Resolves #87

revert Update dependency aiohttp to ~=3.10.0 (#84)

This PR contains the following updates:

| Package | Update | Change |
|---|---|---|
| [aiohttp](https://github.com/aio-libs/aiohttp) | minor | `~=3.9.1` -> `~=3.10.0` |

---

### Release Notes

<details>
<summary>aio-libs/aiohttp (aiohttp)</summary>

### [`v3.10.0`](https://github.com/aio-libs/aiohttp/blob/HEAD/CHANGES.rst#3100-2024-07-30)

[Compare Source](https://github.com/aio-libs/aiohttp/compare/v3.9.5...v3.10.0)

\========================

## Bug fixes

-   Fixed server response headers for `Content-Type` and `Content-Encoding` for
    static compressed files -- by :user:`steverep`.

    Server will now respond with a `Content-Type` appropriate for the compressed
    file (e.g. `"application/gzip"`), and omit the `Content-Encoding` header.
    Users should expect that most clients will no longer decompress such responses
    by default.

    *Related issues and pull requests on GitHub:*
    :issue:`4462`.

-   Fixed duplicate cookie expiration calls in the CookieJar implementation

    *Related issues and pull requests on GitHub:*
    :issue:`7784`.

-   Adjusted `FileResponse` to check file existence and access when preparing the response -- by :user:`steverep`.

    The :py:class:`~aiohttp.web.FileResponse` class was modified to respond with
    403 Forbidden or 404 Not Found as appropriate.  Previously, it would cause a
    server error if the path did not exist or could not be accessed.  Checks for
    existence, non-regular files, and permissions were expected to be done in the
    route handler.  For static routes, this now permits a compressed file to exist
    without its uncompressed variant and still be served.  In addition, this
    changes the response status for files without read permission to 403, and for
    non-regular files from 404 to 403 for consistency.

    *Related issues and pull requests on GitHub:*
    :issue:`8182`.

-   Fixed `AsyncResolver` to match `ThreadedResolver` behavior
    \-- by :user:`bdraco`.

    On system with IPv6 support, the :py:class:`~aiohttp.resolver.AsyncResolver` would not fallback
    to providing A records when AAAA records were not available.
    Additionally, unlike the :py:class:`~aiohttp.resolver.ThreadedResolver`, the :py:class:`~aiohttp.resolver.AsyncResolver`
    did not handle link-local addresses correctly.

    This change makes the behavior consistent with the :py:class:`~aiohttp.resolver.ThreadedResolver`.

    *Related issues and pull requests on GitHub:*
    :issue:`8270`.

-   Fixed `ws_connect` not respecting `receive_timeout`` on WS(S) connection. -- by :user:`arcivanov\`.

    *Related issues and pull requests on GitHub:*
    :issue:`8444`.

-   Removed blocking I/O in the event loop for static resources and refactored
    exception handling -- by :user:`steverep`.

    File system calls when handling requests for static routes were moved to a
    separate thread to potentially improve performance. Exception handling
    was tightened in order to only return 403 Forbidden or 404 Not Found responses
    for expected scenarios; 500 Internal Server Error would be returned for any
    unknown errors.

    *Related issues and pull requests on GitHub:*
    :issue:`8507`.

## Features

-   Added a Request.wait_for_disconnection() method, as means of allowing request handlers to be notified of premature client disconnections.

    *Related issues and pull requests on GitHub:*
    :issue:`2492`.

-   Added 5 new exceptions: :py:exc:`~aiohttp.InvalidUrlClientError`, :py:exc:`~aiohttp.RedirectClientError`,
    :py:exc:`~aiohttp.NonHttpUrlClientError`, :py:exc:`~aiohttp.InvalidUrlRedirectClientError`,
    :py:exc:`~aiohttp.NonHttpUrlRedirectClientError`

    :py:exc:`~aiohttp.InvalidUrlRedirectClientError`, :py:exc:`~aiohttp.NonHttpUrlRedirectClientError`
    are raised instead of :py:exc:`ValueError` or :py:exc:`~aiohttp.InvalidURL` when the redirect URL is invalid. Classes
    :py:exc:`~aiohttp.InvalidUrlClientError`, :py:exc:`~aiohttp.RedirectClientError`,
    :py:exc:`~aiohttp.NonHttpUrlClientError` are base for them.

    The :py:exc:`~aiohttp.InvalidURL` now exposes a `description` property with the text explanation of the error details.

    \-- by :user:`setla`, :user:`AraHaan`, and :user:`bdraco`

    *Related issues and pull requests on GitHub:*
    :issue:`2507`, :issue:`3315`, :issue:`6722`, :issue:`8481`, :issue:`8482`.

-   Added a feature to retry closed connections automatically for idempotent methods. -- by :user:`Dreamsorcerer`

    *Related issues and pull requests on GitHub:*
    :issue:`7297`.

-   Implemented filter_cookies() with domain-matching and path-matching on the keys, instead of testing every single cookie.
    This may break existing cookies that have been saved with `CookieJar.save()`. Cookies can be migrated with this script::

        import pickle
        with file_path.open("rb") as f:
            cookies = pickle.load(f)

        morsels = [(name, m) for c in cookies.values() for name, m in c.items()]
        cookies.clear()
        for name, m in morsels:
            cookies[(m["domain"], m["path"].rstrip("/"))][name] = m

        with file_path.open("wb") as f:
            pickle.dump(cookies, f, pickle.HIGHEST_PROTOCOL)

    *Related issues and pull requests on GitHub:*
    :issue:`7583`, :issue:`8535`.

-   Separated connection and socket timeout errors, from ServerTimeoutError.

    *Related issues and pull requests on GitHub:*
    :issue:`7801`.

-   Implemented happy eyeballs

    *Related issues and pull requests on GitHub:*
    :issue:`7954`.

-   Added server capability to check for static files with Brotli compression via a `.br` extension -- by :user:`steverep`.

    *Related issues and pull requests on GitHub:*
    :issue:`8062`.

## Removals and backward incompatible breaking changes

-   The shutdown logic in 3.9 waited on all tasks, which caused issues with some libraries.
    In 3.10 we've changed this logic to only wait on request handlers. This means that it's
    important for developers to correctly handle the lifecycle of background tasks using a
    library such as `aiojobs`. If an application is using `handler_cancellation=True` then
    it is also a good idea to ensure that any :func:`asyncio.shield` calls are replaced with
    :func:`aiojobs.aiohttp.shield`.

    Please read the updated documentation on these points: \
    https://docs.aiohttp.org/en/stable/web_advanced.html#graceful-shutdown \
    https://docs.aiohttp.org/en/stable/web_advanced.html#web-handler-cancellation

    \-- by :user:`Dreamsorcerer`

    *Related issues and pull requests on GitHub:*
    :issue:`8495`.

## Improved documentation

-   Added documentation for `aiohttp.web.FileResponse`.

    *Related issues and pull requests on GitHub:*
    :issue:`3958`.

-   Improved the docs for the `ssl` params.

    *Related issues and pull requests on GitHub:*
    :issue:`8403`.

## Contributor-facing changes

-   Enabled HTTP parser tests originally intended for 3.9.2 release -- by :user:`pajod`.

    *Related issues and pull requests on GitHub:*
    :issue:`8088`.

## Miscellaneous internal changes

-   Improved URL handler resolution time by indexing resources in the UrlDispatcher.
    For applications with a large number of handlers, this should increase performance significantly.
    \-- by :user:`bdraco`

    *Related issues and pull requests on GitHub:*
    :issue:`7829`.

-   Added `nacl_middleware <https://github.com/CosmicDNA/nacl_middleware>`\_ to the list of middlewares in the third party section of the documentation.

    *Related issues and pull requests on GitHub:*
    :issue:`8346`.

-   Minor improvements to static typing -- by :user:`Dreamsorcerer`.

    *Related issues and pull requests on GitHub:*
    :issue:`8364`.

-   Added a 3.11-specific overloads to `ClientSession`  -- by :user:`max-muoto`.

    *Related issues and pull requests on GitHub:*
    :issue:`8463`.

-   Simplified path checks for `UrlDispatcher.add_static()` method -- by :user:`steverep`.

    *Related issues and pull requests on GitHub:*
    :issue:`8491`.

-   Avoided creating a future on every websocket receive -- by :user:`bdraco`.

    *Related issues and pull requests on GitHub:*
    :issue:`8498`.

-   Updated identity checks for all `WSMsgType` type compares -- by :user:`bdraco`.

    *Related issues and pull requests on GitHub:*
    :issue:`8501`.

-   When using Python 3.12 or later, the writer is no longer scheduled on the event loop if it can finish synchronously. Avoiding event loop scheduling reduces latency and improves performance. -- by :user:`bdraco`.

    *Related issues and pull requests on GitHub:*
    :issue:`8510`.

-   Restored :py:class:`~aiohttp.resolver.AsyncResolver` to be the default resolver. -- by :user:`bdraco`.

    :py:class:`~aiohttp.resolver.AsyncResolver` was disabled by default because
    of IPv6 compatibility issues. These issues have been resolved and
    :py:class:`~aiohttp.resolver.AsyncResolver` is again now the default resolver.

    *Related issues and pull requests on GitHub:*
    :issue:`8522`.

***

</details>

---

### Configuration

📅 **Schedule**: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 **Automerge**: Enabled.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update again.

---

 - [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check this box

---

This PR has been generated by [Renovate Bot](https://github.com/renovatebot/renovate).
<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzNi4zNS4wIiwidXBkYXRlZEluVmVyIjoiMzYuMzUuMCIsInRhcmdldEJyYW5jaCI6ImRldiJ9-->

Reviewed-on: #84
Co-authored-by: Renovate <renovate@git.end-play.xyz>
Co-committed-by: Renovate <renovate@git.end-play.xyz>

.gitignore

@@ -153,8 +153,12 @@ cython_debug/
 #.idea/
 
 # Custom
+cache/
 config.json
+
 *.session
+*.session-wal
+*.session-shm
 *.session-journal
 
 venv

classes/pyroclient.py

@@ -57,7 +57,7 @@ class PyroClient(PyroClient):
             self.config["bot"]["owner"]
         ]
 
-        self.sender_session = ClientSession()
+        self.sender_session: Union[ClientSession, None] = None
 
         self.scopes_placeholders: Dict[str, int] = {
             "owner": self.owner,
@@ -67,6 +67,9 @@ class PyroClient(PyroClient):
     async def start(self):
         await super().start()
 
+        if self.sender_session is None:
+            self.sender_session = ClientSession()
+
         if self.config["reports"]["update"]:
             try:
                 async with ClientSession(
@@ -104,8 +107,8 @@ class PyroClient(PyroClient):
                 logger.warning(
                     "Could not send startup message to bot owner. Perhaps user has not started the bot yet."
                 )
-            except Exception as exp:
-                logger.exception("Update check failed due to %s: %s", exp, format_exc())
+            except Exception as exc:
+                logger.exception("Update check failed due to %s: %s", exc, format_exc())
 
         if self.config["mode"]["post"]:
             if self.config["posting"]["use_interval"]:
@@ -134,14 +137,16 @@ class PyroClient(PyroClient):
         )
 
         await http_session.close()
-        await self.sender_session.close()
+
+        if self.sender_session is not None:
+            await self.sender_session.close()
 
         await super().stop()
 
     async def submit_media(
-        self, id: str
+        self, id: str, purge_caption: bool = False
     ) -> Tuple[Union[Message, None], Union[str, None]]:
-        db_entry = col_submitted.find_one({"_id": ObjectId(id)})
+        db_entry = await col_submitted.find_one({"_id": ObjectId(id)})
         submission = None
 
         if db_entry is None:
@@ -155,8 +160,8 @@ class PyroClient(PyroClient):
                 filepath = await self.download_media(
                     submission, file_name=self.config["locations"]["tmp"] + sep
                 )
-            except Exception as exp:
-                raise SubmissionUnavailableError() from exp
+            except Exception as exc:
+                raise SubmissionUnavailableError() from exc
 
         elif not Path(
             f"{self.config['locations']['data']}/submissions/{db_entry['temp']['uuid']}/{db_entry['temp']['file']}",
@@ -179,7 +184,7 @@ class PyroClient(PyroClient):
                 response = await photo_upload(
                     self.config["posting"]["api"]["album"],
                     client=client,
-                    multipart_data=BodyPhotoUpload(
+                    body=BodyPhotoUpload(
                         File(media_bytes, filepath.name, "image/jpeg")
                     ),
                     ignore_duplicates=self.config["submission"]["allow_duplicates"],
@@ -190,22 +195,20 @@ class PyroClient(PyroClient):
                 response = await video_upload(
                     self.config["posting"]["api"]["album"],
                     client=client,
-                    multipart_data=BodyVideoUpload(
-                        File(media_bytes, filepath.name, "video/*")
-                    ),
+                    body=BodyVideoUpload(File(media_bytes, filepath.name, "video/*")),
                     caption="queue",
                 )
             # elif db_entry["type"] == SubmissionType.ANIMATION.value:
             #     response = await video_upload(
             #         self.config["posting"]["api"]["album"],
             #         client=client,
-            #         multipart_data=BodyVideoUpload(
+            #         body=BodyVideoUpload(
             #             File(media_bytes, filepath.name, "video/*")
             #         ),
             #         caption="queue",
             #     )
-        except UnexpectedStatus as exp:
-            raise SubmissionUnsupportedError(str(filepath)) from exp
+        except UnexpectedStatus as exc:
+            raise SubmissionUnsupportedError(str(filepath)) from exc
 
         response_dict = (
             {}
@@ -226,10 +229,14 @@ class PyroClient(PyroClient):
                     )
             raise SubmissionDuplicatesError(str(filepath), duplicates)
 
-        col_submitted.find_one_and_update(
-            {"_id": ObjectId(id)}, {"$set": {"done": True}}
+        db_update = (
+            {"$set": {"done": True, "caption": None}}
+            if purge_caption
+            else {"$set": {"done": True}}
         )
 
+        await col_submitted.update_one({"_id": ObjectId(id)}, db_update)
+
         try:
             if db_entry["temp"]["uuid"] is not None:
                 rmtree(
@@ -258,12 +265,12 @@ class PyroClient(PyroClient):
             * `PyroUser`: PyroUser object
         """
         if (
-            col_users.find_one(
+            await col_users.find_one(
                 {"id": user.id if isinstance(user, User) else user}
             )  # type: ignore
             is None
         ):
-            col_users.insert_one(
+            await col_users.insert_one(
                 {
                     "id": user.id if isinstance(user, User) else user,
                     "locale": user.language_code if isinstance(user, User) else None,
@@ -273,7 +280,7 @@ class PyroClient(PyroClient):
                 }
             )  # type: ignore
 
-        db_record = col_users.find_one(
+        db_record = await col_users.find_one(
             {"id": user.id if isinstance(user, User) else user}
         )  # type: ignore
 

classes/pyrouser.py

@@ -20,19 +20,19 @@ class PyroUser:
     cooldown: datetime
     subscription: dict
 
-    async def update_locale(self, locale: str):
-        col_users.update_one({"_id": self._id}, {"$set": {"locale": locale}})
+    async def update_locale(self, locale: str) -> None:
+        await col_users.update_one({"_id": self._id}, {"$set": {"locale": locale}})
 
-    async def update_cooldown(self, time: datetime = datetime.now()):
-        col_users.update_one({"_id": self._id}, {"$set": {"cooldown": time}})
+    async def update_cooldown(self, time: datetime = datetime.now()) -> None:
+        await col_users.update_one({"_id": self._id}, {"$set": {"cooldown": time}})
 
     async def block(self) -> None:
         """Ban user from using command and submitting content."""
-        col_users.update_one({"_id": self._id}, {"$set": {"banned": True}})
+        await col_users.update_one({"_id": self._id}, {"$set": {"banned": True}})
 
     async def unblock(self) -> None:
         """Allow user to use command and submit posts again."""
-        col_users.update_one({"_id": self._id}, {"$set": {"banned": False}})
+        await col_users.update_one({"_id": self._id}, {"$set": {"banned": False}})
 
     async def is_limited(self, app: Union[PyroClient, None] = None) -> bool:
         """Check if user is on a cooldown after submitting something.
@@ -41,11 +41,9 @@ class PyroUser:
             `bool`: Must be `True` if on the cooldown and `False` if not
         """
         admins = (
-            app.admins
-            if app is not None
-            else (
-                await config_get("admins", "bot") + [await config_get("owner", "bot")]
-            )
+            await config_get("admins", "bot") + [await config_get("owner", "bot")]
+            if app is None
+            else app.admins
         )
 
         return (datetime.now() - self.cooldown).total_seconds() < (

config_example.json

@@ -83,7 +83,8 @@
             "address_external": "https://photos.domain.com",
             "username": "",
             "password": "",
-            "album": ""
+            "album": "",
+            "timeout": 15.0
         }
     },
     "caption": {

locale/en.json

@@ -32,6 +32,7 @@
         "sub_yes_auto": "✅ Submission automatically accepted",
         "sub_no": "❌ Submission reviewed and declined",
         "sub_dup": "⚠️ Submission automatically declined because database already contains this photo",
+        "sub_deleted": "⚠️ Submission's database record ({0}) is not available.",
         "sub_blocked": "You were blocked and you can't submit media anymore.",
         "sub_unblocked": "You were unblocked and you can now submit media.",
         "sub_by": "\n\nSubmitted by:",

locale/uk.json

@@ -31,6 +31,7 @@
         "sub_yes_auto": "✅ Подання автоматично прийнято",
         "sub_no": "❌ Подання розглянуто та відхилено",
         "sub_dup": "⚠️ Подання автоматично відхилено через наявність цього фото в базі даних",
+        "sub_deleted": "⚠️ Запис подання у базі даних ({0}) недоступний.",
         "sub_blocked": "Вас заблокували, ви більше не можете надсилати медіафайли.",
         "sub_unblocked": "Вас розблокували, тепер ви можете надсилати медіафайли.",
         "sub_by": "\n\nПредставлено:",

modules/api_client.py

@@ -117,16 +117,14 @@ async def authorize(custom_session: Union[ClientSession, None] = None) -> str:
 
 
 unauthorized_client = Client(
-    base_url=sync.config_get("address", "posting", "api"),
-    timeout=5.0,
-    verify_ssl=True,
+    sync.config_get("address", "posting", "api"),
     raise_on_unexpected_status=True,
-    follow_redirects=False,
+    timeout=sync.config_get("timeout", "posting", "api"),
 )
 
 login_token = login(
     client=unauthorized_client,
-    form_data=BodyLoginForAccessTokenTokenPost(
+    body=BodyLoginForAccessTokenTokenPost(
         grant_type="password",
         scope="me albums.list albums.read albums.write photos.list photos.read photos.write videos.list videos.read videos.write",
         username=sync.config_get("username", "posting", "api"),
@@ -141,12 +139,10 @@ if not isinstance(login_token, Token):
     exit()
 
 client = AuthenticatedClient(
-    base_url=sync.config_get("address", "posting", "api"),
-    timeout=5.0,
-    verify_ssl=True,
-    raise_on_unexpected_status=True,
+    sync.config_get("address", "posting", "api"),
     token=login_token.access_token,
-    follow_redirects=False,
+    raise_on_unexpected_status=True,
+    timeout=sync.config_get("timeout", "posting", "api"),
 )
 
 if __name__ == "__main__":

modules/cli.py

@@ -58,8 +58,8 @@ async def cli_create_user() -> None:
         none = input(
             "Alright. If you have email confirmation enabled - please confirm registration by using the link in your email. After that press Enter. Otherwise just press Enter."
         )
-    except Exception as exp:
-        print(f"Could not create a user due to {exp}", flush=True)
+    except Exception as exc:
+        print(f"Could not create a user due to {exc}", flush=True)
         print_exc()
         exit()
     if not args.create_album:
@@ -97,8 +97,8 @@ async def cli_create_album() -> None:
         result_2 = await album_create(client=client, name=name, title=title)
         # asyncio.run(create_album(name, title))
         await config_set("album", name, "posting", "api")
-    except Exception as exp:
-        print(f"Could not create an album due to {exp}", flush=True)
+    except Exception as exc:
+        print(f"Could not create an album due to {exc}", flush=True)
         print_exc()
         exit()
     print("You're done!", flush=True)

modules/custom_filters.py

@@ -0,0 +1,18 @@
+"""Custom message filters"""
+
+from pyrogram import filters
+from pyrogram.types import Message
+
+from classes.pyroclient import PyroClient
+
+
+async def _mode_post_func(_, __: PyroClient, message: Message):
+    return __.config["mode"]["post"]
+
+
+async def _mode_submit_func(_, __: PyroClient, message: Message):
+    return __.config["mode"]["submit"]
+
+
+mode_post = filters.create(_mode_post_func)
+mode_submit = filters.create(_mode_submit_func)

modules/database.py

@@ -1,11 +1,9 @@
 """Module that provides all database columns"""
 
-from pymongo import MongoClient
-from ujson import loads
+from async_pymongo import AsyncClient
+from libbot import sync
 
-with open("config.json", "r", encoding="utf-8") as f:
-    db_config = loads(f.read())["database"]
-    f.close()
+db_config = sync.config_get("database")
 
 if db_config["user"] is not None and db_config["password"] is not None:
     con_string = "mongodb://{0}:{1}@{2}:{3}/{4}".format(
@@ -20,15 +18,9 @@ else:
         db_config["host"], db_config["port"], db_config["name"]
     )
 
-db_client = MongoClient(con_string)
+db_client = AsyncClient(con_string)
 db = db_client.get_database(name=db_config["name"])
 
-collections = db.list_collection_names()
-
-for collection in ["sent", "users", "submitted"]:
-    if collection not in collections:
-        db.create_collection(collection)
-
 col_sent = db.get_collection("sent")
 col_users = db.get_collection("users")
 col_submitted = db.get_collection("submitted")

modules/sender.py

@@ -77,12 +77,12 @@ async def send_content(app: PyroClient, http_session: ClientSession) -> None:
 
                     try:
                         response: File = await func_iter[1](id=media.id, client=client)
-                    except Exception as exp:
+                    except Exception as exc:
                         print_exc()
-                        logger.error("Media is invalid: %s", exp)
+                        logger.error("Media is invalid: %s", exc)
                         if app.config["reports"]["error"]:
                             await app.send_message(
-                                app.owner, f"Media is invalid: {exp}"
+                                app.owner, f"Media is invalid: {exc}"
                             )
                         return
 
@@ -103,11 +103,11 @@ async def send_content(app: PyroClient, http_session: ClientSession) -> None:
                 ).results[0]
                 try:
                     response: File = await func[1](id=media.id, client=client)
-                except Exception as exp:
+                except Exception as exc:
                     print_exc()
-                    logger.error("Media is invalid: %s", exp)
+                    logger.error("Media is invalid: %s", exc)
                     if app.config["reports"]["error"]:
-                        await app.send_message(app.owner, f"Media is invalid: {exp}")
+                        await app.send_message(app.owner, f"Media is invalid: {exc}")
                     return
 
         except (KeyError, AttributeError, TypeError, IndexError):
@@ -152,7 +152,7 @@ async def send_content(app: PyroClient, http_session: ClientSession) -> None:
         ) and func[0] is photo_random:
             image = Image.open(path.join(app.config["locations"]["tmp"], tmp_path))
             width, height = image.size
-            image = image.resize((int(width / 2), int(height / 2)), Image.ANTIALIAS)
+            image = image.resize((int(width / 2), int(height / 2)), Image.LANCZOS)
             if tmp_path.lower().endswith(".jpeg") or tmp_path.lower().endswith(".jpg"):
                 image.save(
                     path.join(app.config["locations"]["tmp"], tmp_path),
@@ -179,7 +179,7 @@ async def send_content(app: PyroClient, http_session: ClientSession) -> None:
 
         del response
 
-        submitted = col_submitted.find_one({"temp.file": media.filename})
+        submitted = await col_submitted.find_one({"temp.file": media.filename})
 
         if submitted is not None and submitted["caption"] is not None:
             caption = submitted["caption"].strip()
@@ -217,19 +217,19 @@ async def send_content(app: PyroClient, http_session: ClientSession) -> None:
                 caption=caption,
                 disable_notification=app.config["posting"]["silent"],
             )
-        except Exception as exp:
+        except Exception as exc:
             logger.error(
-                "Could not send media %s (%s) due to %s", media.filename, media.id, exp
+                "Could not send media %s (%s) due to %s", media.filename, media.id, exc
             )
             if app.config["reports"]["error"]:
                 await app.send_message(
                     app.owner,
-                    app._("post_exception", "message").format(exp, format_exc()),
+                    app._("post_exception", "message").format(exc, format_exc()),
                 )
             # rmtree(path.join(app.config['locations']['tmp'], tmp_dir), ignore_errors=True)
             return
 
-        col_sent.insert_one(
+        await col_sent.insert_one(
             {
                 "date": datetime.now(),
                 "image": media.id,
@@ -253,14 +253,14 @@ async def send_content(app: PyroClient, http_session: ClientSession) -> None:
             str(app.config["posting"]["silent"]),
         )
 
-    except Exception as exp:
+    except Exception as exc:
         logger.error(
-            "Could not send content due to %s. Traceback: %s", exp, format_exc()
+            "Could not send content due to %s. Traceback: %s", exc, format_exc()
         )
         if app.config["reports"]["error"]:
             await app.send_message(
                 app.owner,
-                app._("post_exception", "message").format(exp, format_exc()),
+                app._("post_exception", "message").format(exc, format_exc()),
             )
         try:
             rmtree(

plugins/callbacks/nothing.py

@@ -6,7 +6,7 @@ from classes.pyroclient import PyroClient
 
 
 @Client.on_callback_query(filters.regex("nothing"))
-async def callback_query_nothing(app: PyroClient, clb: CallbackQuery):
-    user = await app.find_user(clb.from_user)
+async def callback_query_nothing(app: PyroClient, callback: CallbackQuery):
+    user = await app.find_user(callback.from_user)
 
-    await clb.answer(text=app._("nothing", "callback", locale=user.locale))
+    await callback.answer(text=app._("nothing", "callback", locale=user.locale))

plugins/callbacks/shutdown.py

@@ -10,11 +10,11 @@ from classes.pyroclient import PyroClient
 
 
 @Client.on_callback_query(filters.regex("shutdown"))
-async def callback_query_nothing(app: PyroClient, clb: CallbackQuery):
-    if clb.from_user.id not in app.admins:
+async def callback_query_nothing(app: PyroClient, callback: CallbackQuery):
+    if callback.from_user.id not in app.admins:
         return
 
-    await clb.answer()
+    await callback.answer()
 
     makedirs(await config_get("cache", "locations"), exist_ok=True)
     await json_write(

plugins/callbacks/submission.py

@@ -21,43 +21,46 @@ logger = logging.getLogger(__name__)
 
 
 @Client.on_callback_query(filters.regex("sub_yes_[\s\S]*"))
-async def callback_query_yes(app: PyroClient, clb: CallbackQuery):
-    user = await app.find_user(clb.from_user)
-    fullclb = str(clb.data).split("_")
+async def callback_query_yes(app: PyroClient, callback: CallbackQuery):
+    user = await app.find_user(callback.from_user)
+    fullcallback = str(callback.data).split("_")
 
-    db_entry = col_submitted.find_one({"_id": ObjectId(fullclb[2])})
+    db_entry = await col_submitted.find_one({"_id": ObjectId(fullcallback[2])})
 
     try:
-        submission = await app.submit_media(fullclb[2])
+        submission = await app.submit_media(
+            fullcallback[2],
+            purge_caption=("caption" not in fullcallback),
+        )
     except SubmissionUnavailableError:
-        await clb.answer(
+        await callback.answer(
             text=app._("sub_msg_unavail", "callback", locale=user.locale),
             show_alert=True,
         )
         return
     except SubmissionUnsupportedError:
-        await clb.answer(
+        await callback.answer(
             text=app._("mime_not_allowed", "message", locale=user.locale).format(
                 ", ".join(app.config["submission"]["mime_types"]), quote=True
             ),
             show_alert=True,
         )
         return
-    except SubmissionDuplicatesError as exp:
-        await clb.answer(
+    except SubmissionDuplicatesError as exc:
+        await callback.answer(
             text=app._("sub_duplicates_found", "callback", locale=user.locale),
             show_alert=True,
         )
-        await clb.message.reply_text(
+        await callback.message.reply_text(
             app._("sub_media_duplicates_list", "message", locale=user.locale).format(
-                "\n • ".join(exp.duplicates)
+                "\n • ".join(exc.duplicates)
             ),
             quote=True,
         )
         logger.info(
             "Submission with ID '%s' could not be accepted because of the duplicates: %s",
-            fullclb[2],
-            str(exp.duplicates),
+            fullcallback[2],
+            str(exc.duplicates),
         )
         return
 
@@ -80,8 +83,8 @@ async def callback_query_yes(app: PyroClient, clb: CallbackQuery):
             ),
         )
 
-    await clb.answer(
-        text=app._("sub_yes", "callback", locale=user.locale).format(fullclb[2]),
+    await callback.answer(
+        text=app._("sub_yes", "callback", locale=user.locale).format(fullcallback[2]),
         show_alert=True,
     )
 
@@ -93,9 +96,9 @@ async def callback_query_yes(app: PyroClient, clb: CallbackQuery):
                     callback_data="nothing",
                 )
             ],
-            clb.message.reply_markup.inline_keyboard[1],
+            callback.message.reply_markup.inline_keyboard[1],
         ]
-        if len(clb.message.reply_markup.inline_keyboard) > 1
+        if len(callback.message.reply_markup.inline_keyboard) > 1
         else [
             [
                 InlineKeyboardButton(
@@ -107,30 +110,44 @@ async def callback_query_yes(app: PyroClient, clb: CallbackQuery):
     )
 
     if await config_get("send_uploaded_id", "submission"):
-        await clb.message.edit_caption(
-            f"{clb.message.caption}\n\nID: `{submission[1]}`"
+        await callback.message.edit_caption(
+            f"{callback.message.caption}\n\nID: `{submission[1]}`"
         )
 
-    await clb.message.edit_reply_markup(
+    await callback.message.edit_reply_markup(
         reply_markup=InlineKeyboardMarkup(edited_markup)
     )
 
     logger.info(
         "Submission with ID '%s' accepted and uploaded with ID '%s'",
-        fullclb[2],
+        fullcallback[2],
+        submission[1],
+    )
+    logger.info(
+        "Submission with ID '%s' accepted and uploaded with ID '%s'",
+        fullcallback[2],
         submission[1],
     )
 
 
 @Client.on_callback_query(filters.regex("sub_no_[\s\S]*"))
-async def callback_query_no(app: PyroClient, clb: CallbackQuery):
-    user = await app.find_user(clb.from_user)
-    fullclb = str(clb.data).split("_")
+async def callback_query_no(app: PyroClient, callback: CallbackQuery):
+    user = await app.find_user(callback.from_user)
+    fullcallback = str(callback.data).split("_")
 
-    db_entry = col_submitted.find_one_and_delete({"_id": ObjectId(fullclb[2])})
+    db_entry = await col_submitted.delete_one({"_id": ObjectId(fullcallback[2])})
+
+    if db_entry.deleted_count == 0:
+        await callback.answer(
+            text=app._("sub_deleted", "callback", locale=user.locale).format(
+                fullcallback[2]
+            ),
+            show_alert=True,
+        )
+        return
 
     if (
-        db_entry["temp"]["uuid"] is not None
+        db_entry.raw_result["temp"]["uuid"] is not None
         and Path(
             f"{app.config['locations']['data']}/submissions/{db_entry['temp']['uuid']}"
         ).exists()
@@ -146,8 +163,8 @@ async def callback_query_no(app: PyroClient, clb: CallbackQuery):
         submission = await app.get_messages(
             db_entry["user"], db_entry["telegram"]["msg_id"]
         )
-    except Exception as exp:
-        await clb.answer(
+    except Exception as exc:
+        await callback.answer(
             text=app._("sub_msg_unavail", "message", locale=user.locale),
             show_alert=True,
         )
@@ -161,8 +178,8 @@ async def callback_query_no(app: PyroClient, clb: CallbackQuery):
         ),
         quote=True,
     )
-    await clb.answer(
-        text=app._("sub_no", "callback", locale=user.locale).format(fullclb[2]),
+    await callback.answer(
+        text=app._("sub_no", "callback", locale=user.locale).format(fullcallback[2]),
         show_alert=True,
     )
 
@@ -174,9 +191,9 @@ async def callback_query_no(app: PyroClient, clb: CallbackQuery):
                     callback_data="nothing",
                 )
             ],
-            clb.message.reply_markup.inline_keyboard[1],
+            callback.message.reply_markup.inline_keyboard[1],
         ]
-        if len(clb.message.reply_markup.inline_keyboard) > 1
+        if len(callback.message.reply_markup.inline_keyboard) > 1
         else [
             [
                 InlineKeyboardButton(
@@ -186,81 +203,83 @@ async def callback_query_no(app: PyroClient, clb: CallbackQuery):
             ]
         ]
     )
-    await clb.message.edit_reply_markup(
+    await callback.message.edit_reply_markup(
         reply_markup=InlineKeyboardMarkup(edited_markup)
     )
     logger.info(
         "Submission with ID '%s' rejected",
-        fullclb[2],
+        fullcallback[2],
     )
 
 
 @Client.on_callback_query(filters.regex("sub_block_[\s\S]*"))
-async def callback_query_block(app: PyroClient, clb: CallbackQuery):
-    user = await app.find_user(clb.from_user)
-    fullclb = str(clb.data).split("_")
+async def callback_query_block(app: PyroClient, callback: CallbackQuery):
+    user = await app.find_user(callback.from_user)
+    fullcallback = str(callback.data).split("_")
 
     await app.send_message(
-        int(fullclb[2]),
+        int(fullcallback[2]),
         app._(
             "sub_blocked",
             "message",
-            locale=(await app.find_user(int(fullclb[2]))).locale,
+            locale=(await app.find_user(int(fullcallback[2]))).locale,
         ),
     )
     await user.block()
 
-    await clb.answer(
-        text=app._("sub_block", "callback", locale=user.locale).format(fullclb[2]),
+    await callback.answer(
+        text=app._("sub_block", "callback", locale=user.locale).format(fullcallback[2]),
         show_alert=True,
     )
 
     edited_markup = [
-        clb.message.reply_markup.inline_keyboard[0],
+        callback.message.reply_markup.inline_keyboard[0],
         [
             InlineKeyboardButton(
                 text=str(app._("sub_unblock", "button", locale=user.locale)),
-                callback_data=f"sub_unblock_{fullclb[2]}",
+                callback_data=f"sub_unblock_{fullcallback[2]}",
             )
         ],
     ]
-    await clb.message.edit_reply_markup(
+    await callback.message.edit_reply_markup(
         reply_markup=InlineKeyboardMarkup(edited_markup)
     )
-    logger.info("User %s has been blocked", fullclb[2])
+    logger.info("User %s has been blocked", fullcallback[2])
 
 
 @Client.on_callback_query(filters.regex("sub_unblock_[\s\S]*"))
-async def callback_query_unblock(app: PyroClient, clb: CallbackQuery):
-    user = await app.find_user(clb.from_user)
-    fullclb = str(clb.data).split("_")
+async def callback_query_unblock(app: PyroClient, callback: CallbackQuery):
+    user = await app.find_user(callback.from_user)
+    fullcallback = str(callback.data).split("_")
 
     await app.send_message(
-        int(fullclb[2]),
+        int(fullcallback[2]),
         app._(
             "sub_unblocked",
             "message",
-            locale=(await app.find_user(int(fullclb[2]))).locale,
+            locale=(await app.find_user(int(fullcallback[2]))).locale,
         ),
     )
 
     await user.unblock()
 
-    await clb.answer(
-        text=app._("sub_unblock", "callback", locale=user.locale).format(fullclb[2]),
+    await callback.answer(
+        text=app._("sub_unblock", "callback", locale=user.locale).format(
+            fullcallback[2]
+        ),
         show_alert=True,
     )
 
     edited_markup = [
-        clb.message.reply_markup.inline_keyboard[0],
+        callback.message.reply_markup.inline_keyboard[0],
         [
             InlineKeyboardButton(
                 text=str(app._("sub_block", "button", locale=user.locale)),
-                callback_data=f"sub_block_{fullclb[2]}",
+                callback_data=f"sub_block_{fullcallback[2]}",
             )
         ],
     ]
-    await clb.message.edit_reply_markup(
+    await callback.message.edit_reply_markup(
         reply_markup=InlineKeyboardMarkup(edited_markup)
     )
-    logger.info("User %s has been unblocked", fullclb[2])
+    logger.info("User %s has been unblocked", fullcallback[2])

plugins/commands/general.py

@@ -15,14 +15,14 @@ from modules.utils import USERS_WITH_CONTEXT
 @Client.on_message(
     ~filters.scheduled & filters.command(["shutdown"], prefixes=["", "/"])
 )
-async def cmd_kill(app: PyroClient, msg: Message):
-    if msg.from_user.id not in app.admins:
+async def cmd_kill(app: PyroClient, message: Message):
+    if message.from_user.id not in app.admins:
         return
 
-    user = await app.find_user(msg.from_user)
+    user = await app.find_user(message.from_user)
 
     if len(USERS_WITH_CONTEXT) > 0:
-        await msg.reply_text(
+        await message.reply_text(
             app._("shutdown_confirm", "message", locale=user.locale).format(
                 len(USERS_WITH_CONTEXT)
             ),

plugins/commands/mode_submit.py

@@ -3,25 +3,32 @@ from pyrogram.client import Client
 from pyrogram.types import Message
 
 from classes.pyroclient import PyroClient
-
-
-@Client.on_message(~filters.scheduled & filters.command(["start"], prefixes="/"))
-async def cmd_start(app: PyroClient, msg: Message):
-    user = await app.find_user(msg.from_user)
-
-    if user.banned:
-        return
-
-    await msg.reply_text(app._("start", "message", locale=user.locale))
+from modules import custom_filters
 
 
 @Client.on_message(
-    ~filters.scheduled & filters.command(["rules", "help"], prefixes="/")
+    custom_filters.mode_submit
+    & ~filters.scheduled
+    & filters.command(["start"], prefixes="/")
 )
-async def cmd_rules(app: PyroClient, msg: Message):
-    user = await app.find_user(msg.from_user)
+async def cmd_start(app: PyroClient, message: Message):
+    user = await app.find_user(message.from_user)
 
     if user.banned:
         return
 
-    await msg.reply_text(app._("rules", "message", locale=user.locale))
+    await message.reply_text(app._("start", "message", locale=user.locale))
+
+
+@Client.on_message(
+    custom_filters.mode_submit
+    & ~filters.scheduled
+    & filters.command(["rules", "help"], prefixes="/")
+)
+async def cmd_rules(app: PyroClient, message: Message):
+    user = await app.find_user(message.from_user)
+
+    if user.banned:
+        return
+
+    await message.reply_text(app._("rules", "message", locale=user.locale))

plugins/commands/photos.py

@@ -37,27 +37,27 @@ logger = logging.getLogger(__name__)
 
 
 @Client.on_message(~filters.scheduled & filters.command(["import"], prefixes=["", "/"]))
-async def cmd_import(app: PyroClient, msg: Message):
-    if msg.from_user.id not in app.admins:
+async def cmd_import(app: PyroClient, message: Message):
+    if message.from_user.id not in app.admins:
         return
 
     global USERS_WITH_CONTEXT
 
-    if msg.from_user.id not in USERS_WITH_CONTEXT:
-        USERS_WITH_CONTEXT.append(msg.from_user.id)
+    if message.from_user.id not in USERS_WITH_CONTEXT:
+        USERS_WITH_CONTEXT.append(message.from_user.id)
     else:
         return
 
-    user = await app.find_user(msg.from_user)
+    user = await app.find_user(message.from_user)
 
-    await msg.reply_text(app._("import_request", "message", locale=user.locale))
+    await message.reply_text(app._("import_request", "message", locale=user.locale))
 
-    answer = await listen_message(app, msg.chat.id, timeout=600)
+    answer = await listen_message(app, message.chat.id, timeout=600)
 
-    USERS_WITH_CONTEXT.remove(msg.from_user.id)
+    USERS_WITH_CONTEXT.remove(message.from_user.id)
 
     if answer is None:
-        await msg.reply_text(
+        await message.reply_text(
             app._("import_ignored", "message", locale=user.locale),
             quote=True,
         )
@@ -86,7 +86,7 @@ async def cmd_import(app: PyroClient, msg: Message):
         return
 
     if disk_usage(getcwd())[2] < (answer.document.file_size) * 3:
-        await msg.reply_text(
+        await message.reply_text(
             app._("import_too_big", "message", locale=user.locale).format(
                 answer.document.file_size // (2**30),
                 disk_usage(getcwd())[2] // (2**30),
@@ -123,16 +123,16 @@ async def cmd_import(app: PyroClient, msg: Message):
                 for name in handle.namelist()
             ]
             _ = await asyncio.gather(*tasks)
-    except Exception as exp:
+    except Exception as exc:
         logger.error(
             "Could not import '%s' due to %s: %s",
             answer.document.file_name,
-            exp,
+            exc,
             format_exc(),
         )
         await answer.reply_text(
             app._("import_unpack_error", "message", locale=user.locale).format(
-                exp, format_exc()
+                exc, format_exc()
             )
         )
         return
@@ -158,21 +158,21 @@ async def cmd_import(app: PyroClient, msg: Message):
             uploaded = await photo_upload(
                 app.config["posting"]["api"]["album"],
                 client=client,
-                multipart_data=BodyPhotoUpload(
+                body=BodyPhotoUpload(
                     File(photo_bytes, Path(filename).name, "image/jpeg")
                 ),
                 ignore_duplicates=app.config["submission"]["allow_duplicates"],
                 compress=False,
                 caption="queue",
             )
-        except UnexpectedStatus as exp:
+        except UnexpectedStatus as exc:
             logger.error(
                 "Could not upload '%s' from '%s': %s",
                 filename,
                 Path(f"{app.config['locations']['tmp']}/{tmp_dir}"),
-                exp,
+                exc,
             )
-            await msg.reply_text(
+            await message.reply_text(
                 app._(
                     "import_upload_error_other",
                     "message",
@@ -193,7 +193,7 @@ async def cmd_import(app: PyroClient, msg: Message):
             )
 
             if len(uploaded_dict["duplicates"]) > 0:
-                await msg.reply_text(
+                await message.reply_text(
                     app._(
                         "import_upload_error_duplicate",
                         "message",
@@ -202,7 +202,7 @@ async def cmd_import(app: PyroClient, msg: Message):
                     disable_notification=True,
                 )
             else:
-                await msg.reply_text(
+                await message.reply_text(
                     app._(
                         "import_upload_error_other",
                         "message",
@@ -235,33 +235,35 @@ async def cmd_import(app: PyroClient, msg: Message):
 
 
 @Client.on_message(~filters.scheduled & filters.command(["export"], prefixes=["", "/"]))
-async def cmd_export(app: PyroClient, msg: Message):
-    if msg.from_user.id not in app.admins:
+async def cmd_export(app: PyroClient, message: Message):
+    if message.from_user.id not in app.admins:
         return
 
 
 @Client.on_message(~filters.scheduled & filters.command(["remove"], prefixes=["", "/"]))
-async def cmd_remove(app: PyroClient, msg: Message):
-    if msg.from_user.id not in app.admins:
+async def cmd_remove(app: PyroClient, message: Message):
+    if message.from_user.id not in app.admins:
         return
 
     global USERS_WITH_CONTEXT
 
-    if msg.from_user.id not in USERS_WITH_CONTEXT:
-        USERS_WITH_CONTEXT.append(msg.from_user.id)
+    if message.from_user.id not in USERS_WITH_CONTEXT:
+        USERS_WITH_CONTEXT.append(message.from_user.id)
     else:
         return
 
-    user = await app.find_user(msg.from_user)
+    user = await app.find_user(message.from_user)
 
-    await msg.reply_text(app._("remove_request", "message", locale=user.locale))
+    await message.reply_text(app._("remove_request", "message", locale=user.locale))
 
-    answer_id = await listen_message(app, msg.chat.id, timeout=600)
+    answer_id = await app.listen.Message(
+        filters.text & ~filters.me, id=filters.user(message.from_user.id), timeout=600
+    )
 
-    USERS_WITH_CONTEXT.remove(msg.from_user.id)
+    USERS_WITH_CONTEXT.remove(message.from_user.id)
 
     if answer_id is None:
-        await msg.reply_text(
+        await message.reply_text(
             app._("remove_ignored", "message", locale=user.locale),
             quote=True,
         )
@@ -271,7 +273,7 @@ async def cmd_remove(app: PyroClient, msg: Message):
         await answer_id.reply_text(app._("remove_abort", "message", locale=user.locale))
         return
 
-    await msg.reply_text(
+    await message.reply_text(
         app._("remove_kind", "message", locale=user.locale),
         reply_markup=ReplyKeyboardMarkup(
             [
@@ -285,14 +287,16 @@ async def cmd_remove(app: PyroClient, msg: Message):
         ),
     )
 
-    USERS_WITH_CONTEXT.append(msg.from_user.id)
+    USERS_WITH_CONTEXT.append(message.from_user.id)
 
-    answer_kind = await listen_message(app, msg.chat.id, timeout=600)
+    answer_kind = await app.listen.Message(
+        filters.text & ~filters.me, id=filters.user(message.from_user.id), timeout=600
+    )
 
-    USERS_WITH_CONTEXT.remove(msg.from_user.id)
+    USERS_WITH_CONTEXT.remove(message.from_user.id)
 
     if answer_kind is None:
-        await msg.reply_text(
+        await message.reply_text(
             app._("remove_ignored", "message", locale=user.locale),
             quote=True,
             reply_markup=ReplyKeyboardRemove(),
@@ -351,6 +355,6 @@ async def cmd_remove(app: PyroClient, msg: Message):
 
 
 @Client.on_message(~filters.scheduled & filters.command(["purge"], prefixes=["", "/"]))
-async def cmd_purge(app: PyroClient, msg: Message):
-    if msg.from_user.id not in app.admins:
+async def cmd_purge(app: PyroClient, message: Message):
+    if message.from_user.id not in app.admins:
         return

plugins/commands/report.py

@@ -4,32 +4,35 @@ from pyrogram.client import Client
 from pyrogram.types import Message, User
 
 from classes.pyroclient import PyroClient
+from modules import custom_filters
 
 
 @Client.on_message(
-    ~filters.scheduled
+    custom_filters.mode_post
+    & ~filters.scheduled
     & filters.chat(sync.config_get("comments", "posting"))
     & filters.reply
     & filters.command(["report"], prefixes=["", "/"])
 )
-async def command_report(app: PyroClient, msg: Message):
-    if msg.reply_to_message.forward_from_chat.id != app.config["posting"]["channel"]:
+async def command_report(app: PyroClient, message: Message):
+    if (
+        message.reply_to_message.forward_from_chat.id
+        != app.config["posting"]["channel"]
+    ):
         return
 
-    user = await app.find_user(msg.from_user)
+    user = await app.find_user(message.from_user)
 
-    await msg.reply_text(
+    await message.reply_text(
         app._(
             "report_sent",
             "message",
-            locale=user.locale if msg.from_user is not None else None,
+            locale=user.locale if message.from_user is not None else None,
         )
     )
 
-    print(msg)
-
-    report_sent = await msg.reply_to_message.forward(app.owner)
-    sender = msg.from_user if msg.from_user is not None else msg.sender_chat
+    report_sent = await message.reply_to_message.forward(app.owner)
+    sender = message.from_user if message.from_user is not None else message.sender_chat
 
     sender_name = sender.first_name if isinstance(sender, User) else sender.title
 

plugins/handlers/submission.py

@@ -13,6 +13,7 @@ from pyrogram.types import InlineKeyboardButton, InlineKeyboardMarkup, Message
 from classes.enums.submission_types import SubmissionType
 from classes.exceptions import SubmissionDuplicatesError, SubmissionUnsupportedError
 from classes.pyroclient import PyroClient
+from modules import custom_filters
 from modules.database import col_submitted
 from modules.utils import USERS_WITH_CONTEXT
 
@@ -20,120 +21,126 @@ logger = logging.getLogger(__name__)
 
 
 @Client.on_message(
-    ~filters.scheduled & filters.private & filters.photo
+    custom_filters.mode_submit & ~filters.scheduled & filters.private & filters.photo
     | filters.video
     # | filters.animation
     | filters.document
 )
-async def get_submission(app: PyroClient, msg: Message):
+async def get_submission(app: PyroClient, message: Message):
     global USERS_WITH_CONTEXT
 
-    if not hasattr(msg.from_user, "id"):
+    if not hasattr(message.from_user, "id"):
         return
 
-    if msg.from_user.id in USERS_WITH_CONTEXT:
+    if message.from_user.id in USERS_WITH_CONTEXT:
         return
 
-    user = await app.find_user(msg.from_user)
+    user = await app.find_user(message.from_user)
     user_owner = await app.find_user(app.owner)
 
     try:
         if user.banned:
             return
 
-        await app.send_chat_action(msg.chat.id, ChatAction.TYPING)
+        await app.send_chat_action(message.chat.id, ChatAction.TYPING)
 
         save_tmp = True
         contents = None
 
         if await user.is_limited():
-            await msg.reply_text(
+            await message.reply_text(
                 app._("sub_cooldown", "message", locale=user.locale).format(
                     app.config["submission"]["timeout"]
                 )
             )
             return
 
-        if msg.document is not None:
+        if message.document is not None:
             logger.info(
                 "User %s is trying to submit a file of type '%s' with name '%s' and size of %s MB",
-                msg.from_user.id,
-                msg.document.mime_type,
-                msg.document.file_name,
-                msg.document.file_size / 1024 / 1024,
+                message.from_user.id,
+                message.document.mime_type,
+                message.document.file_name,
+                message.document.file_size / 1024 / 1024,
             )
-            if msg.document.mime_type not in app.config["submission"]["mime_types"]:
-                await msg.reply_text(
+            if message.document.mime_type not in app.config["submission"]["mime_types"]:
+                await message.reply_text(
                     app._("mime_not_allowed", "message", locale=user.locale).format(
                         ", ".join(app.config["submission"]["mime_types"])
                     ),
                     quote=True,
                 )
                 return
-            if msg.document.file_size > app.config["submission"]["file_size"]:
-                await msg.reply_text(
+            if message.document.file_size > app.config["submission"]["file_size"]:
+                await message.reply_text(
                     app._("document_too_large", "message", locale=user.locale).format(
                         app.config["submission"]["file_size"] / 1024 / 1024
                     ),
                     quote=True,
                 )
                 return
-            if msg.document.file_size > app.config["submission"]["tmp_size"]:
+            if message.document.file_size > app.config["submission"]["tmp_size"]:
                 save_tmp = False
             contents = (
-                msg.document.file_id,
+                message.document.file_id,
                 SubmissionType.DOCUMENT,
-            )  # , msg.document.file_name
+            )  # , message.document.file_name
 
-        if msg.video is not None:
+        if message.video is not None:
             logger.info(
                 "User %s is trying to submit a video with name '%s' and size of %s MB",
-                msg.from_user.id,
-                msg.video.file_name,
-                msg.video.file_size / 1024 / 1024,
+                message.from_user.id,
+                message.video.file_name,
+                message.video.file_size / 1024 / 1024,
             )
-            if msg.video.file_size > app.config["submission"]["file_size"]:
-                await msg.reply_text(
+            if message.video.file_size > app.config["submission"]["file_size"]:
+                await message.reply_text(
                     app._("document_too_large", "message", locale=user.locale).format(
                         app.config["submission"]["file_size"] / 1024 / 1024
                     ),
                     quote=True,
                 )
                 return
-            if msg.video.file_size > app.config["submission"]["tmp_size"]:
+            if message.video.file_size > app.config["submission"]["tmp_size"]:
                 save_tmp = False
-            contents = msg.video.file_id, SubmissionType.VIDEO  # , msg.video.file_name
+            contents = (
+                message.video.file_id,
+                SubmissionType.VIDEO,
+            )  # , message.video.file_name
 
-        # if msg.animation is not None:
+        # if message.animation is not None:
         #     logger.info(
         #         "User %s is trying to submit an animation with name '%s' and size of %s MB",
-        #         msg.from_user.id,
-        #         msg.animation.file_name,
-        #         msg.animation.file_size / 1024 / 1024,
+        #         message.from_user.id,
+        #         message.animation.file_name,
+        #         message.animation.file_size / 1024 / 1024,
         #     )
-        #     if msg.animation.file_size > app.config["submission"]["file_size"]:
-        #         await msg.reply_text(
+        #     if message.animation.file_size > app.config["submission"]["file_size"]:
+        #         await message.reply_text(
         #             app._("document_too_large", "message", locale=user.locale).format(
         #                 str(app.config["submission"]["file_size"] / 1024 / 1024)
         #             ),
         #             quote=True,
         #         )
         #         return
-        #     if msg.animation.file_size > app.config["submission"]["tmp_size"]:
+        #     if message.animation.file_size > app.config["submission"]["tmp_size"]:
         #         save_tmp = False
         #     contents = (
-        #         msg.animation.file_id,
+        #         message.animation.file_id,
         #         SubmissionType.ANIMATION,
-        #     )  # , msg.animation.file_name
+        #     )  # , message.animation.file_name
 
-        if msg.photo is not None:
+        if message.photo is not None:
             logger.info(
                 "User %s is trying to submit a photo with ID '%s' and size of %s MB",
-                msg.from_user.id,
-                msg.photo.file_id,
-                msg.photo.file_size / 1024 / 1024,
+                message.from_user.id,
+                message.photo.file_id,
+                message.photo.file_size / 1024 / 1024,
             )
-            contents = msg.photo.file_id, SubmissionType.PHOTO  # , "please_generate"
+            contents = (
+                message.photo.file_id,
+                SubmissionType.PHOTO,
+            )  # , "please_generate"
 
         if contents is None:
             return
@@ -147,33 +154,37 @@ async def get_submission(app: PyroClient, msg: Message):
                 exist_ok=True,
             )
             downloaded = await app.download_media(
-                msg,
+                message,
                 str(Path(f"{app.config['locations']['data']}/submissions/{tmp_id}"))
                 + sep,
             )
 
-            inserted = col_submitted.insert_one(
+            inserted = await col_submitted.insert_one(
                 {
-                    "user": msg.from_user.id,
+                    "user": message.from_user.id,
                     "date": datetime.now(),
                     "done": False,
                     "type": contents[1].value,
                     "temp": {"uuid": tmp_id, "file": path.basename(str(downloaded))},
-                    "telegram": {"msg_id": msg.id, "file_id": contents[0]},
-                    "caption": str(msg.caption) if msg.caption is not None else None,
+                    "telegram": {"msg_id": message.id, "file_id": contents[0]},
+                    "caption": str(message.caption)
+                    if message.caption is not None
+                    else None,
                 }
             )
 
         else:
-            inserted = col_submitted.insert_one(
+            inserted = await col_submitted.insert_one(
                 {
-                    "user": msg.from_user.id,
+                    "user": message.from_user.id,
                     "date": datetime.now(),
                     "done": False,
                     "type": contents[1].value,
                     "temp": {"uuid": None, "file": None},
-                    "telegram": {"msg_id": msg.id, "file_id": contents[0]},
-                    "caption": str(msg.caption) if msg.caption is not None else None,
+                    "telegram": {"msg_id": message.id, "file_id": contents[0]},
+                    "caption": str(message.caption)
+                    if message.caption is not None
+                    else None,
                 }
             )
 
@@ -186,8 +197,8 @@ async def get_submission(app: PyroClient, msg: Message):
             ]
         ]
 
-        if msg.caption is not None:
-            caption = str(msg.caption)
+        if message.caption is not None:
+            caption = str(message.caption)
             buttons[0].append(
                 InlineKeyboardButton(
                     text=app._("sub_yes_caption", "button", locale=user_owner.locale),
@@ -205,106 +216,108 @@ async def get_submission(app: PyroClient, msg: Message):
         )
         caption += app._("sub_by", "message", locale=user_owner.locale)
 
-        if msg.from_user.first_name is not None:
-            caption += f" {msg.from_user.first_name}"
-        if msg.from_user.last_name is not None:
-            caption += f" {msg.from_user.last_name}"
-        if msg.from_user.username is not None:
-            caption += f" (@{msg.from_user.username})"
-        if msg.from_user.phone_number is not None:
-            caption += f" ({msg.from_user.phone_number})"
+        if message.from_user.first_name is not None:
+            caption += f" {message.from_user.first_name}"
+        if message.from_user.last_name is not None:
+            caption += f" {message.from_user.last_name}"
+        if message.from_user.username is not None:
+            caption += f" (@{message.from_user.username})"
+        if message.from_user.phone_number is not None:
+            caption += f" ({message.from_user.phone_number})"
 
         if (
-            msg.from_user.id in app.admins
+            message.from_user.id in app.admins
             and app.config["submission"]["require_confirmation"]["admins"] is False
         ):
             try:
                 submitted = await app.submit_media(str(inserted.inserted_id))
-                await msg.reply_text(
+                await message.reply_text(
                     app._("sub_yes_auto", "message", locale=user.locale),
                     disable_notification=True,
                     quote=True,
                 )
                 if app.config["submission"]["send_uploaded_id"]:
                     caption += f"\n\nID: `{submitted[1]}`"
-                await msg.copy(app.owner, caption=caption, disable_notification=True)
+                await message.copy(
+                    app.owner, caption=caption, disable_notification=True
+                )
                 return
             except SubmissionUnsupportedError:
-                await msg.reply_text(
+                await message.reply_text(
                     app._("mime_not_allowed", "message", locale=user.locale).format(
                         ", ".join(app.config["submission"]["mime_types"]), quote=True
                     ),
                     quote=True,
                 )
                 return
-            except SubmissionDuplicatesError as exp:
-                await msg.reply_text(
+            except SubmissionDuplicatesError as exc:
+                await message.reply_text(
                     app._(
                         "sub_media_duplicates_list", "message", locale=user.locale
-                    ).format("\n • ".join(exp.duplicates)),
+                    ).format("\n • ".join(exc.duplicates)),
                     quote=True,
                 )
                 return
-            except Exception as exp:
-                await msg.reply_text(format_exc(), quote=True)
+            except Exception as exc:
+                await message.reply_text(exc, quote=True)
                 return
         elif (
-            msg.from_user.id not in app.admins
+            message.from_user.id not in app.admins
             and app.config["submission"]["require_confirmation"]["users"] is False
         ):
             try:
                 submitted = await app.submit_photo(str(inserted.inserted_id))
-                await msg.reply_text(
+                await message.reply_text(
                     app._("sub_yes_auto", "message", locale=user.locale),
                     disable_notification=True,
                     quote=True,
                 )
                 if app.config["submission"]["send_uploaded_id"]:
                     caption += f"\n\nID: `{submitted[1]}`"
-                await msg.copy(app.owner, caption=caption)
+                await message.copy(app.owner, caption=caption)
                 return
             except SubmissionUnsupportedError:
-                await msg.reply_text(
+                await message.reply_text(
                     app._("mime_not_allowed", "message", locale=user.locale).format(
                         ", ".join(app.config["submission"]["mime_types"]), quote=True
                     )
                 )
                 return
-            except SubmissionDuplicatesError as exp:
-                await msg.reply_text(
+            except SubmissionDuplicatesError as exc:
+                await message.reply_text(
                     app._("sub_dup", "message", locale=user.locale), quote=True
                 )
                 return
-            except Exception as exp:
+            except Exception as exc:
                 await app.send_message(
                     app.owner,
                     app._(
                         "sub_error_admin", "message", locale=user_owner.locale
-                    ).format(msg.from_user.id, format_exc()),
+                    ).format(message.from_user.id, format_exc()),
                 )
-                await msg.reply_text("sub_error", quote=True)
+                await message.reply_text("sub_error", quote=True)
                 return
 
-        if msg.from_user.id not in app.admins:
+        if message.from_user.id not in app.admins:
             buttons += [
                 [
                     InlineKeyboardButton(
                         text=app._("sub_block", "button", locale=user_owner.locale),
-                        callback_data=f"sub_block_{msg.from_user.id}",
+                        callback_data=f"sub_block_{message.from_user.id}",
                     )
                 ]
             ]
 
             await user.update_cooldown()
 
-        if msg.from_user.id != app.owner:
-            await msg.reply_text(
+        if message.from_user.id != app.owner:
+            await message.reply_text(
                 app._("sub_sent", "message", locale=user.locale),
                 disable_notification=True,
                 quote=True,
             )
 
-        await msg.copy(
+        await message.copy(
             app.owner, caption=caption, reply_markup=InlineKeyboardMarkup(buttons)
         )
 

plugins/remove_commands.py

@@ -8,6 +8,6 @@ from classes.pyroclient import PyroClient
 @Client.on_message(
     ~filters.scheduled & filters.private & filters.command(["remove_commands"], prefixes=["/"])  # type: ignore
 )
-async def command_remove_commands(app: PyroClient, msg: Message):
-    await msg.reply_text("Okay.")
+async def command_remove_commands(app: PyroClient, message: Message):
+    await message.reply_text("Okay.")
     await app.remove_commands(command_sets=await app.collect_commands())

requirements.txt

@@ -1,15 +1,11 @@
-aiohttp~=3.8.4
-black~=23.3.0
+aiohttp~=3.10.2
+async_pymongo==0.1.6
 convopyro==0.5
-pillow~=10.0.0
-psutil~=5.9.4
-pykeyboard==0.1.5
-pymongo~=4.4.0
-pyrogram==2.0.106
-python_dateutil==2.8.2
+pillow~=10.4.0
+pykeyboard==0.1.7
 pytimeparse~=1.1.8
 tgcrypto==1.2.5
-uvloop==0.17.0
+#uvloop==0.19.0
 --extra-index-url https://git.end-play.xyz/api/packages/profitroll/pypi/simple
-libbot[speed,pyrogram]==1.8
-photosapi_client==0.5.0
+libbot[speed,pyrogram]==3.2.3
+photosapi_client==0.6.0