patchpyro 2.0.5__tar.gz → 2.1.1__tar.gz

patchpyro-2.1.1/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: patchpyro
+Version: 2.1.1
+Summary: A modified pyromod by a.devh.in
+Home-page: https://github.com/adityaprasad502/patchpyro
+Author: Cezar H. & adityaprasad502
+Author-email: plutoniumx502@gmail.com
+License: LGPLv3+
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: COPYING
+License-File: COPYING.lesser
+License-File: NOTICE
+Requires-Dist: kurigram>=2.0.69
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# PatchPyro
+
+A fork of pyromod (renamed as patchpyro) providing conversation patches for Pyrogram-based clients.
+
+## Requirements
+```text
+kurigram>=2.0.69
+python>=3.9
+```
+
+## Installation
+```bash
+pip install patchpyro
+```
+ 
+## Usage
+Import `patchpyro` at least once in your script so you can use the modified Pyrogram in all files of the same process. 
+
+### Example
+```python
+# config.py
+from patchpyro import listen # or import patchpyro.listen
+from pyrogram import Client
+
+listen.thank() # use this if your linter/IDE flags patchpyro as an unused import.
+
+mybot = Client("mysession")
+```
+
+```python
+# any other .py
+from config import mybot
+# no need to import patchpyro again; Pyrogram is already monkeypatched globally (in the same process)
+```
+
+## Available Methods
+Just importing `patchpyro.listen` will automatically do the monkeypatch and you'll get these new methods:
+
+### `Chat.listen`, `User.listen`
+- `await mybot.listen(chat_id, filters=None, timeout=30)`
+- Awaits a new message in the specified chat and returns it.
+- Raises `asyncio.TimeoutError` if timeout (optional parameter) occurs.
+- You can pass Update Filters to the filters parameter just like you do for the update handlers.
+  - E.g. `filters=filters.photo & filters.bot`
+
+### `Chat.ask`, `User.ask`
+- `await mybot.ask(text, chat_id, filters=None, timeout=30)`
+- Same as `.listen()` above, but sends a message before awaiting.
+- You can pass custom parameters to its internal `send_message()` call. Check the example below.
+    
+### `Chat.asker`, `User.asker`
+- `await mybot.asker(chat_id, filters=None, timeout=36)` 
+- Same as `.listen()` but `.asker()` returns `None` instead of raising `asyncio.TimeoutError`.
+- Useful for graceful timeout handling, `.asker()` has a default timeout of 2 minutes (adjustable via `timeout` argument).
+
+## Examples
+
+### `asker()`
+```python
+# ...
+    sendx = await client.send_message(chat_id, "`Send me your name:`")
+    answer = await client.asker(chat_id, filters=None, timeout=60)
+    if not answer: # `None` if timeout reached with no reply.
+        return await sendx.reply_text("How long should I wait? Bye!")
+    await answer.reply_text(f"{answer.text}, That's a cool name!")
+# ...
+```
+
+### `ask()`
+```python
+# ...
+    answer = await client.ask(chat_id, '*Send me your name:*', parse_mode=enums.ParseMode.MARKDOWN)
+    await client.send_message(chat_id, f'Your name is: {answer.text}')
+# ...
+```
+
+## Copyright & License
+This project includes code from:
+- **[kurimod](https://github.com/ohmyarthur/kurimod)**: Monkeypatcher logic and modern async compatibility fixes.
+- **Pyrogram**: Telegram MTProto API Client Library for Python. Copyright (C) 2017-2022 Dan <<https://github.com/delivrance>>
+- **pyromod**: Original conversation patch logic.
+
+Licensed under the terms of the [GNU Lesser General Public License v3 or later (LGPLv3+)](COPYING.lesser)

patchpyro-2.1.1/README.md

@@ -0,0 +1,83 @@
+# PatchPyro
+
+A fork of pyromod (renamed as patchpyro) providing conversation patches for Pyrogram-based clients.
+
+## Requirements
+```text
+kurigram>=2.0.69
+python>=3.9
+```
+
+## Installation
+```bash
+pip install patchpyro
+```
+ 
+## Usage
+Import `patchpyro` at least once in your script so you can use the modified Pyrogram in all files of the same process. 
+
+### Example
+```python
+# config.py
+from patchpyro import listen # or import patchpyro.listen
+from pyrogram import Client
+
+listen.thank() # use this if your linter/IDE flags patchpyro as an unused import.
+
+mybot = Client("mysession")
+```
+
+```python
+# any other .py
+from config import mybot
+# no need to import patchpyro again; Pyrogram is already monkeypatched globally (in the same process)
+```
+
+## Available Methods
+Just importing `patchpyro.listen` will automatically do the monkeypatch and you'll get these new methods:
+
+### `Chat.listen`, `User.listen`
+- `await mybot.listen(chat_id, filters=None, timeout=30)`
+- Awaits a new message in the specified chat and returns it.
+- Raises `asyncio.TimeoutError` if timeout (optional parameter) occurs.
+- You can pass Update Filters to the filters parameter just like you do for the update handlers.
+  - E.g. `filters=filters.photo & filters.bot`
+
+### `Chat.ask`, `User.ask`
+- `await mybot.ask(text, chat_id, filters=None, timeout=30)`
+- Same as `.listen()` above, but sends a message before awaiting.
+- You can pass custom parameters to its internal `send_message()` call. Check the example below.
+    
+### `Chat.asker`, `User.asker`
+- `await mybot.asker(chat_id, filters=None, timeout=36)` 
+- Same as `.listen()` but `.asker()` returns `None` instead of raising `asyncio.TimeoutError`.
+- Useful for graceful timeout handling, `.asker()` has a default timeout of 2 minutes (adjustable via `timeout` argument).
+
+## Examples
+
+### `asker()`
+```python
+# ...
+    sendx = await client.send_message(chat_id, "`Send me your name:`")
+    answer = await client.asker(chat_id, filters=None, timeout=60)
+    if not answer: # `None` if timeout reached with no reply.
+        return await sendx.reply_text("How long should I wait? Bye!")
+    await answer.reply_text(f"{answer.text}, That's a cool name!")
+# ...
+```
+
+### `ask()`
+```python
+# ...
+    answer = await client.ask(chat_id, '*Send me your name:*', parse_mode=enums.ParseMode.MARKDOWN)
+    await client.send_message(chat_id, f'Your name is: {answer.text}')
+# ...
+```
+
+## Copyright & License
+This project includes code from:
+- **[kurimod](https://github.com/ohmyarthur/kurimod)**: Monkeypatcher logic and modern async compatibility fixes.
+- **Pyrogram**: Telegram MTProto API Client Library for Python. Copyright (C) 2017-2022 Dan <<https://github.com/delivrance>>
+- **pyromod**: Original conversation patch logic.
+
+Licensed under the terms of the [GNU Lesser General Public License v3 or later (LGPLv3+)](COPYING.lesser)

{patchpyro-2.0.5/patchpyro/listen → patchpyro-2.1.1/patchpyro}/__init__.py

@@ -1,6 +1,5 @@
-"""
-patchpyro - A monkeypatcher add-on for Pyrogram
-Copyright (C) 2026 Aditya Prasad S <https://github.com/adityaprasad502>
+"""patchpyro - A monkeypatcher add-on for Pyrogram
+Copyright (C) 2026 Aditya Prasad S <https://github.com/adityaprasad502>.
 
 This file is part of patchpyro and was forked from usernein/pyromod.
 
@@ -18,4 +17,8 @@ You should have received a copy of the GNU General Public License
 along with patchpyro.  If not, see <https://www.gnu.org/licenses/>.
 """
 
-from .listen import Chat, Client, MessageHandler, User
+
+__version__ = "2.1.1"
+# change in setup.py aswell
+
+from . import listen

patchpyro-2.0.5/patchpyro/utils/utils.py → patchpyro-2.1.1/patchpyro/listen/__init__.py

@@ -1,6 +1,5 @@
-"""
-patchpyro - A monkeypatcher add-on for Pyrogram
-Copyright (C) 2026 Aditya Prasad S <https://github.com/adityaprasad502>
+"""patchpyro - A monkeypatcher add-on for Pyrogram
+Copyright (C) 2026 Aditya Prasad S <https://github.com/adityaprasad502>.
 
 This file is part of patchpyro and was forked from usernein/pyromod.
 
@@ -19,20 +18,11 @@ along with patchpyro.  If not, see <https://www.gnu.org/licenses/>.
 """
 
 
-def patch(obj):
-    def is_patchable(item):
-        return getattr(item[1], "patchable", False)
-
-    def wrapper(container):
-        for name, func in filter(is_patchable, container.__dict__.items()):
-            old = getattr(obj, name, None)
-            setattr(obj, f"old{name}", old)
-            setattr(obj, name, func)
-        return container
-
-    return wrapper
-
+from .listen import Chat, Client, MessageHandler, User
+def thank() -> None:
+    """A dummy function to prevent patchpyro.listen from being removed by formatters and linters."""
+    from patchpyro import __version__
+    import logging
+    logging.debug(f"Thank you for using patchpyro v{__version__}!")
 
-def patchable(func):
-    func.patchable = True
-    return func
+__all__ = ["Chat", "Client", "MessageHandler", "User", "thank"]

patchpyro-2.1.1/patchpyro/listen/listen.py

@@ -0,0 +1,186 @@
+"""patchpyro - A monkeypatcher add-on for Pyrogram
+Copyright (C) 2026 Aditya Prasad S <https://github.com/adityaprasad502>.
+
+This file is part of patchpyro and was forked from usernein/pyromod.
+Additional patching logic was adapted from kurimod (C) Dias Arthur.
+
+patchpyro is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+patchpyro is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with patchpyro.  If not, see <https://www.gnu.org/licenses/>.
+"""
+
+import asyncio
+import functools
+from contextlib import suppress
+from inspect import iscoroutinefunction
+
+import pyrogram
+import pyrogram.client
+import pyrogram.handlers.message_handler
+import pyrogram.types.user_and_chats.chat
+import pyrogram.types.user_and_chats.user
+
+from patchpyro.utils import patch_into, should_patch
+
+
+class ListenerCanceled(Exception):
+    pass
+
+
+pyrogram.errors.ListenerCanceled = ListenerCanceled
+
+
+@patch_into(pyrogram.client.Client)
+class Client:
+    @should_patch()
+    def __init__(self, *args, **kwargs) -> None:
+        self.listening = {}
+        self.using_mod = True
+
+        self.old__init__(*args, **kwargs)
+
+    @should_patch()
+    async def listen(
+        self,
+        chat_id: int | str,
+        filters: pyrogram.filters.Filter | None = None,
+        timeout: int | None = None,
+    ) -> pyrogram.types.Message:
+        if not isinstance(chat_id, int):
+            chat = await self.get_chat(chat_id)
+            chat_id = chat.id
+
+        # Cancel existing listener in this chat if any
+        self.cancel_listener(chat_id)
+
+        loop = asyncio.get_running_loop()
+        future = loop.create_future()
+        future.add_done_callback(functools.partial(self.clear_listener, chat_id))
+        self.listening[chat_id] = {"future": future, "filters": filters}
+
+        return await asyncio.wait_for(future, timeout)
+
+    @should_patch()
+    async def ask(
+        self,
+        chat_id: int | str,
+        text: str,
+        filters: pyrogram.filters.Filter | None = None,
+        timeout: int | None = None,
+        *args,
+        **kwargs,
+    ) -> pyrogram.types.Message:
+        request = await self.send_message(chat_id, text, *args, **kwargs)
+        response = await self.listen(chat_id, filters, timeout)
+        response.request = request
+        return response
+
+    @should_patch()
+    async def asker(
+        self,
+        chat_id: int | str,
+        filters: pyrogram.filters.Filter | None = None,
+        timeout: int = 119,
+    ) -> pyrogram.types.Message | None:
+        try:
+            return await self.listen(chat_id, filters, timeout)
+        except asyncio.TimeoutError:
+            return None
+
+    @should_patch()
+    def clear_listener(self, chat_id: int, future: asyncio.Future) -> None:
+        with suppress(KeyError):
+            if (
+                chat_id in self.listening
+                and future == self.listening[chat_id]["future"]
+            ):
+                self.listening.pop(chat_id, None)
+
+    @should_patch()
+    def cancel_listener(self, chat_id: int) -> None:
+        listener = self.listening.get(chat_id)
+        if not listener or listener["future"].done():
+            return
+
+        if not listener["future"].done():
+            listener["future"].set_exception(ListenerCanceled())
+        self.clear_listener(chat_id, listener["future"])
+
+
+@patch_into(pyrogram.handlers.message_handler.MessageHandler)
+class MessageHandler:
+    @should_patch()
+    def __init__(self, callback: callable, filters=None) -> None:
+        self.user_callback = callback
+        self.old__init__(self.resolve_listener, filters)
+
+    @should_patch()
+    async def resolve_listener(self, client: "pyrogram.Client", message: pyrogram.types.Message, *args) -> None:
+        listener = client.listening.get(message.chat.id)
+        if listener and not listener["future"].done():
+            listener["future"].set_result(message)
+            raise pyrogram.StopPropagation
+
+        if listener and listener["future"].done():
+            client.clear_listener(message.chat.id, listener["future"])
+
+        await self.user_callback(client, message, *args)
+
+    @should_patch()
+    async def check(self, client: "pyrogram.Client", update: pyrogram.types.Message):
+        listener = client.listening.get(update.chat.id)
+
+        if listener and not listener["future"].done():
+            filters = listener["filters"]
+            if callable(filters):
+                if iscoroutinefunction(filters.__call__):
+                    return await filters(client, update)
+                loop = asyncio.get_running_loop()
+                return await loop.run_in_executor(None, filters, client, update)
+            return True
+
+        if callable(self.filters):
+            if iscoroutinefunction(self.filters.__call__):
+                return await self.filters(client, update)
+            loop = asyncio.get_running_loop()
+            return await loop.run_in_executor(None, self.filters, client, update)
+        return True
+
+
+@patch_into(pyrogram.types.user_and_chats.chat.Chat)
+class Chat(pyrogram.types.Chat):
+    @should_patch()
+    async def listen(self, *args, **kwargs) -> pyrogram.types.Message:
+        return await self._client.listen(self.id, *args, **kwargs)
+
+    @should_patch()
+    async def ask(self, *args, **kwargs) -> pyrogram.types.Message:
+        return await self._client.ask(self.id, *args, **kwargs)
+
+    @should_patch()
+    def cancel_listener(self) -> None:
+        return self._client.cancel_listener(self.id)
+
+
+@patch_into(pyrogram.types.user_and_chats.user.User)
+class User(pyrogram.types.User):
+    @should_patch()
+    async def listen(self, *args, **kwargs) -> pyrogram.types.Message:
+        return await self._client.listen(self.id, *args, **kwargs)
+
+    @should_patch()
+    async def ask(self, *args, **kwargs) -> pyrogram.types.Message:
+        return await self._client.ask(self.id, *args, **kwargs)
+
+    @should_patch()
+    def cancel_listener(self) -> None:
+        return self._client.cancel_listener(self.id)

{patchpyro-2.0.5 → patchpyro-2.1.1}/patchpyro/utils/__init__.py

@@ -1,6 +1,5 @@
-"""
-patchpyro - A monkeypatcher add-on for Pyrogram
-Copyright (C) 2026 Aditya Prasad S <https://github.com/adityaprasad502>
+"""patchpyro - A monkeypatcher add-on for Pyrogram
+Copyright (C) 2026 Aditya Prasad S <https://github.com/adityaprasad502>.
 
 This file is part of patchpyro and was forked from usernein/pyromod.
 
@@ -18,4 +17,6 @@ You should have received a copy of the GNU General Public License
 along with patchpyro.  If not, see <https://www.gnu.org/licenses/>.
 """
 
-from .utils import patch, patchable
+from .utils import patch, patch_into, patchable, should_patch
+
+__all__ = ["patch", "patch_into", "patchable", "should_patch"]

patchpyro-2.1.1/patchpyro/utils/utils.py

@@ -0,0 +1,90 @@
+"""patchpyro - A monkeypatcher add-on for Pyrogram
+Copyright (C) 2026 Aditya Prasad S <https://github.com/adityaprasad502>.
+
+This file is part of patchpyro and was forked from usernein/pyromod.
+Additional patching logic was adapted from kurimod (C) Dias Arthur.
+
+patchpyro is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+patchpyro is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with patchpyro.  If not, see <https://www.gnu.org/licenses/>.
+"""
+from collections.abc import Callable
+from contextlib import asynccontextmanager, contextmanager
+from inspect import iscoroutinefunction
+from typing import TypeVar
+
+from pyrogram.sync import async_to_sync
+
+T = TypeVar("T")
+
+
+def patch(target_class):
+    def is_patchable(item):
+        func = item[1]
+        return getattr(func, "should_patch", False) or getattr(func, "patchable", False)
+
+    def wrapper(container: type[T]) -> T:
+        for name, func in filter(is_patchable, container.__dict__.items()):
+            old = getattr(target_class, name, None)
+            if old is not None:
+                setattr(target_class, "old" + name, old)
+
+            tempConf = {
+                i: getattr(func, i, False)
+                for i in ["is_property", "is_static", "is_context"]
+            }
+
+            if not iscoroutinefunction(func):
+                async_to_sync(container, name)
+                func = getattr(container, name)
+
+            for tKey, tValue in tempConf.items():
+                setattr(func, tKey, tValue)
+
+            if func.is_property:
+                func = property(func)
+            elif func.is_static:
+                func = staticmethod(func)
+            elif func.is_context:
+                if iscoroutinefunction(func.__call__):
+                    func = asynccontextmanager(func)
+                else:
+                    func = contextmanager(func)
+
+            setattr(target_class, name, func)
+        return container
+
+    return wrapper
+
+
+def patchable(
+    func: Callable | None = None,
+    *,
+    is_property: bool = False,
+    is_static: bool = False,
+    is_context: bool = False,
+) -> Callable:
+    def wrapper(f: Callable) -> Callable:
+        f.should_patch = True
+        f.patchable = True
+        f.is_property = is_property
+        f.is_static = is_static
+        f.is_context = is_context
+        return f
+
+    if func is not None:
+        return wrapper(func)
+    return wrapper
+
+
+patch_into = patch
+should_patch = patchable

patchpyro-2.1.1/patchpyro.egg-info/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: patchpyro
+Version: 2.1.1
+Summary: A modified pyromod by a.devh.in
+Home-page: https://github.com/adityaprasad502/patchpyro
+Author: Cezar H. & adityaprasad502
+Author-email: plutoniumx502@gmail.com
+License: LGPLv3+
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: COPYING
+License-File: COPYING.lesser
+License-File: NOTICE
+Requires-Dist: kurigram>=2.0.69
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# PatchPyro
+
+A fork of pyromod (renamed as patchpyro) providing conversation patches for Pyrogram-based clients.
+
+## Requirements
+```text
+kurigram>=2.0.69
+python>=3.9
+```
+
+## Installation
+```bash
+pip install patchpyro
+```
+ 
+## Usage
+Import `patchpyro` at least once in your script so you can use the modified Pyrogram in all files of the same process. 
+
+### Example
+```python
+# config.py
+from patchpyro import listen # or import patchpyro.listen
+from pyrogram import Client
+
+listen.thank() # use this if your linter/IDE flags patchpyro as an unused import.
+
+mybot = Client("mysession")
+```
+
+```python
+# any other .py
+from config import mybot
+# no need to import patchpyro again; Pyrogram is already monkeypatched globally (in the same process)
+```
+
+## Available Methods
+Just importing `patchpyro.listen` will automatically do the monkeypatch and you'll get these new methods:
+
+### `Chat.listen`, `User.listen`
+- `await mybot.listen(chat_id, filters=None, timeout=30)`
+- Awaits a new message in the specified chat and returns it.
+- Raises `asyncio.TimeoutError` if timeout (optional parameter) occurs.
+- You can pass Update Filters to the filters parameter just like you do for the update handlers.
+  - E.g. `filters=filters.photo & filters.bot`
+
+### `Chat.ask`, `User.ask`
+- `await mybot.ask(text, chat_id, filters=None, timeout=30)`
+- Same as `.listen()` above, but sends a message before awaiting.
+- You can pass custom parameters to its internal `send_message()` call. Check the example below.
+    
+### `Chat.asker`, `User.asker`
+- `await mybot.asker(chat_id, filters=None, timeout=36)` 
+- Same as `.listen()` but `.asker()` returns `None` instead of raising `asyncio.TimeoutError`.
+- Useful for graceful timeout handling, `.asker()` has a default timeout of 2 minutes (adjustable via `timeout` argument).
+
+## Examples
+
+### `asker()`
+```python
+# ...
+    sendx = await client.send_message(chat_id, "`Send me your name:`")
+    answer = await client.asker(chat_id, filters=None, timeout=60)
+    if not answer: # `None` if timeout reached with no reply.
+        return await sendx.reply_text("How long should I wait? Bye!")
+    await answer.reply_text(f"{answer.text}, That's a cool name!")
+# ...
+```
+
+### `ask()`
+```python
+# ...
+    answer = await client.ask(chat_id, '*Send me your name:*', parse_mode=enums.ParseMode.MARKDOWN)
+    await client.send_message(chat_id, f'Your name is: {answer.text}')
+# ...
+```
+
+## Copyright & License
+This project includes code from:
+- **[kurimod](https://github.com/ohmyarthur/kurimod)**: Monkeypatcher logic and modern async compatibility fixes.
+- **Pyrogram**: Telegram MTProto API Client Library for Python. Copyright (C) 2017-2022 Dan <<https://github.com/delivrance>>
+- **pyromod**: Original conversation patch logic.
+
+Licensed under the terms of the [GNU Lesser General Public License v3 or later (LGPLv3+)](COPYING.lesser)

{patchpyro-2.0.5 → patchpyro-2.1.1}/setup.py

@@ -2,7 +2,7 @@ import re
 
 import setuptools
 
-with open("README.md", "r") as fp:
+with open("README.md") as fp:
     long_description = fp.read()
 
 requirements = ["kurigram>=2.0.69"]

patchpyro-2.0.5/PKG-INFO

@@ -1,113 +0,0 @@
-Metadata-Version: 2.4
-Name: patchpyro
-Version: 2.0.5
-Summary: A modified pyromod by a.devh.in
-Home-page: https://github.com/adityaprasad502/patchpyro
-Author: Cezar H. & adityaprasad502
-Author-email: plutoniumx502@gmail.com
-License: LGPLv3+
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: COPYING
-License-File: COPYING.lesser
-License-File: NOTICE
-Requires-Dist: kurigram>=2.0.69
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# PatchPyro
-### This is a fork of pyromod (renamed as patchpyro) for personal usecases.
-
-### Remember that this fork contains only conversation patch.
-
-# Requirements:
- ~~~python
- kurigram>=2.0.69
- python>=3.9
- ~~~
-
- # Installation:
-```
-python -m pip install patchpyro
-```
- 
-# Usage:
-Import `patchpyro` at least one time in your script, so you'll be able to use modified pyrogram in all files of the same proccess. 
-Example:
-
-```python
-# config.py
-from patchpyro import listen # or import patchpyro.listen
-from pyrogram import Client
-
-patchpyro.thank() # use this if ur linters/ide is removing patchpyro as unused import.
-
-mybot = Client("mysession")
-```
-
-```python
-# any other .py
-from config import mybot
-# no need to import patchpyro again pyrogram is already monkeypatched globally (at the same proccess)
-```
-
-## `patchpyro.listen`
-Just import it, it will automatically do the monkeypatch and you'll get these new methods:
-
-- Available bound methods::
-  - `Chat.listen, User.listen`
-
-    - `await mybot.listen(chat_id, filters=None, timeout=30)`
-    - raises `asyncio.TimeoutError` if timeout (optional parameter)
-    - Awaits for a new message in the specified chat and returns it.
-    - You can pass Update Filters to the filters parameter just like you do for the update handlers.
-    - E.g. `filters=filters.photo & filters.bot`
-  - `Chat.ask, User.ask`
-
-    - `await mybot.ask(text, chat_id, filters=None, timeout=30)`
-    - Same of `.listen()` above, but sends a message before awaiting.
-    - You can pass custom parameters to its send_message() call. Check the example below.
-    
-  - `Chat.asker, User.asker`
-     - `await mybot.asker(chat_id, filters=None, timeout=36)` 
-     - same as `.listen()` but `.asker()` returns `None` instead of raising `asyncio.TimeoutError`.
-     - Found useful in some cases for me, `.asker()` has a default timeout of 2 minutes. 
-     - You can adjust it by passing as a argument. Refer the example code given below.
-
-# Examples:
-### For .asker():
-```python
-...
-    sendx = await client.send_message(chat_id, "`Send me your name:`")
-    answer = await client.asker(chat_id, filters=None, timeout=60)
-    if not answer: # `None` if timeout if no reply received.
-        return await sendx.reply_text("How long should I wait?, Eh! Bye!")
-    await answer.reply_text(f"{answer.text}, That's a cool name!")
-...
-```
-### For .ask():
-```python
-...
-    answer = await client.ask(chat_id, '*Send me your name:*', parse_mode=enums.ParseMode.MARKDOWN)
-    await client.send_message(chat_id, f'Your name is: {answer.text}')
-...
-```
-
-
-### Copyright & License
-This project may include snippets of Pyrogram code
-- Pyrogram - Telegram MTProto API Client Library for Python. Copyright (C) 2017-2022 Dan <<https://github.com/delivrance>>
-
-Licensed under the terms of the [GNU Lesser General Public License v3 or later (LGPLv3+)](COPYING.lesser)

patchpyro-2.0.5/README.md

@@ -1,84 +0,0 @@
-# PatchPyro
-### This is a fork of pyromod (renamed as patchpyro) for personal usecases.
-
-### Remember that this fork contains only conversation patch.
-
-# Requirements:
- ~~~python
- kurigram>=2.0.69
- python>=3.9
- ~~~
-
- # Installation:
-```
-python -m pip install patchpyro
-```
- 
-# Usage:
-Import `patchpyro` at least one time in your script, so you'll be able to use modified pyrogram in all files of the same proccess. 
-Example:
-
-```python
-# config.py
-from patchpyro import listen # or import patchpyro.listen
-from pyrogram import Client
-
-patchpyro.thank() # use this if ur linters/ide is removing patchpyro as unused import.
-
-mybot = Client("mysession")
-```
-
-```python
-# any other .py
-from config import mybot
-# no need to import patchpyro again pyrogram is already monkeypatched globally (at the same proccess)
-```
-
-## `patchpyro.listen`
-Just import it, it will automatically do the monkeypatch and you'll get these new methods:
-
-- Available bound methods::
-  - `Chat.listen, User.listen`
-
-    - `await mybot.listen(chat_id, filters=None, timeout=30)`
-    - raises `asyncio.TimeoutError` if timeout (optional parameter)
-    - Awaits for a new message in the specified chat and returns it.
-    - You can pass Update Filters to the filters parameter just like you do for the update handlers.
-    - E.g. `filters=filters.photo & filters.bot`
-  - `Chat.ask, User.ask`
-
-    - `await mybot.ask(text, chat_id, filters=None, timeout=30)`
-    - Same of `.listen()` above, but sends a message before awaiting.
-    - You can pass custom parameters to its send_message() call. Check the example below.
-    
-  - `Chat.asker, User.asker`
-     - `await mybot.asker(chat_id, filters=None, timeout=36)` 
-     - same as `.listen()` but `.asker()` returns `None` instead of raising `asyncio.TimeoutError`.
-     - Found useful in some cases for me, `.asker()` has a default timeout of 2 minutes. 
-     - You can adjust it by passing as a argument. Refer the example code given below.
-
-# Examples:
-### For .asker():
-```python
-...
-    sendx = await client.send_message(chat_id, "`Send me your name:`")
-    answer = await client.asker(chat_id, filters=None, timeout=60)
-    if not answer: # `None` if timeout if no reply received.
-        return await sendx.reply_text("How long should I wait?, Eh! Bye!")
-    await answer.reply_text(f"{answer.text}, That's a cool name!")
-...
-```
-### For .ask():
-```python
-...
-    answer = await client.ask(chat_id, '*Send me your name:*', parse_mode=enums.ParseMode.MARKDOWN)
-    await client.send_message(chat_id, f'Your name is: {answer.text}')
-...
-```
-
-
-### Copyright & License
-This project may include snippets of Pyrogram code
-- Pyrogram - Telegram MTProto API Client Library for Python. Copyright (C) 2017-2022 Dan <<https://github.com/delivrance>>
-
-Licensed under the terms of the [GNU Lesser General Public License v3 or later (LGPLv3+)](COPYING.lesser)

patchpyro-2.0.5/patchpyro/__init__.py

@@ -1,28 +0,0 @@
-"""
-patchpyro - A monkeypatcher add-on for Pyrogram
-Copyright (C) 2026 Aditya Prasad S <https://github.com/adityaprasad502>
-
-This file is part of patchpyro and was forked from usernein/pyromod.
-
-patchpyro is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-patchpyro is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with patchpyro.  If not, see <https://www.gnu.org/licenses/>.
-"""
-
-
-__version__ = "2.0.5"
-# change in setup.py aswell
-
-def thank():
-    "A dummy function to prevent patchpyro from being removed by formatters and linters. It does nothing, just prints a message to the console to indicate that patchpyro is not an unused import."
-    # print("Thank you for using patchpyro! If you see this message. author: a.devh.in, version: " + __version__)
-    print("PatchPyro " + __version__ + " is imported! Thank you for using it! Author: a.devh.in")

patchpyro-2.0.5/patchpyro/listen/listen.py

@@ -1,151 +0,0 @@
-"""
-patchpyro - A monkeypatcher add-on for Pyrogram
-Copyright (C) 2026 Aditya Prasad S <https://github.com/adityaprasad502>
-
-This file is part of patchpyro and was forked from usernein/pyromod.
-
-patchpyro is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-patchpyro is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with patchpyro.  If not, see <https://www.gnu.org/licenses/>.
-"""
-
-import asyncio
-import functools
-from contextlib import suppress
-
-import pyrogram
-
-from ..utils import patch, patchable
-
-loop = asyncio.get_event_loop()
-
-
-class ListenerCanceled(Exception):
-    pass
-
-
-pyrogram.errors.ListenerCanceled = ListenerCanceled
-
-
-@patch(pyrogram.client.Client)
-class Client:
-    @patchable
-    def __init__(self, *args, **kwargs):
-        self.listening = {}
-        self.using_mod = True
-
-        self.old__init__(*args, **kwargs)
-
-    @patchable
-    async def listen(self, chat_id, filters=None, timeout=None):
-        if type(chat_id) != int:
-            chat = await self.get_chat(chat_id)
-            chat_id = chat.id
-
-        future = loop.create_future()
-        future.add_done_callback(functools.partial(self.clear_listener, chat_id))
-        self.listening.update({chat_id: {"future": future, "filters": filters}})
-        return await asyncio.wait_for(future, timeout)
-
-    @patchable
-    async def ask(self, chat_id, text, filters=None, timeout=None, *args, **kwargs):
-        request = await self.send_message(chat_id, text, *args, **kwargs)
-        response = await self.listen(chat_id, filters, timeout)
-        response.request = request
-        return response
-
-    @patchable
-    async def asker(self, chat_id, filters=None, timeout=119):
-        try:
-            response = await self.listen(chat_id, filters, timeout)
-        except asyncio.TimeoutError:
-            response = None
-        return response
-
-    @patchable
-    def clear_listener(self, chat_id, future):
-        with suppress(KeyError):
-            if (
-                chat_id in self.listening
-                and future == self.listening[chat_id]["future"]
-            ):
-                self.listening.pop(chat_id, None)
-
-    @patchable
-    def cancel_listener(self, chat_id):
-        listener = self.listening.get(chat_id)
-        if not listener or listener["future"].done():
-            return
-
-        listener["future"].set_exception(ListenerCanceled())
-        self.clear_listener(chat_id, listener["future"])
-
-
-@patch(pyrogram.handlers.message_handler.MessageHandler)
-class MessageHandler:
-    @patchable
-    def __init__(self, callback: callable, filters=None):
-        self.user_callback = callback
-        self.old__init__(self.resolve_listener, filters)
-
-    @patchable
-    async def resolve_listener(self, client, message, *args):
-        listener = client.listening.get(message.chat.id)
-        if listener and not listener["future"].done():
-            listener["future"].set_result(message)
-        else:
-            if listener and listener["future"].done():
-                client.clear_listener(message.chat.id, listener["future"])
-            await self.user_callback(client, message, *args)
-
-    @patchable
-    async def check(self, client, update):
-        listener = client.listening.get(update.chat.id)
-
-        if listener and not listener["future"].done():
-            return (
-                await listener["filters"](client, update)
-                if callable(listener["filters"])
-                else True
-            )
-
-        return await self.filters(client, update) if callable(self.filters) else True
-
-
-@patch(pyrogram.types.user_and_chats.chat.Chat)
-class Chat(pyrogram.types.Chat):
-    @patchable
-    def listen(self, *args, **kwargs):
-        return self._client.listen(self.id, *args, **kwargs)
-
-    @patchable
-    def ask(self, *args, **kwargs):
-        return self._client.ask(self.id, *args, **kwargs)
-
-    @patchable
-    def cancel_listener(self):
-        return self._client.cancel_listener(self.id)
-
-
-@patch(pyrogram.types.user_and_chats.user.User)
-class User(pyrogram.types.User):
-    @patchable
-    def listen(self, *args, **kwargs):
-        return self._client.listen(self.id, *args, **kwargs)
-
-    @patchable
-    def ask(self, *args, **kwargs):
-        return self._client.ask(self.id, *args, **kwargs)
-
-    @patchable
-    def cancel_listener(self):
-        return self._client.cancel_listener(self.id)

patchpyro-2.0.5/patchpyro.egg-info/PKG-INFO

@@ -1,113 +0,0 @@
-Metadata-Version: 2.4
-Name: patchpyro
-Version: 2.0.5
-Summary: A modified pyromod by a.devh.in
-Home-page: https://github.com/adityaprasad502/patchpyro
-Author: Cezar H. & adityaprasad502
-Author-email: plutoniumx502@gmail.com
-License: LGPLv3+
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: COPYING
-License-File: COPYING.lesser
-License-File: NOTICE
-Requires-Dist: kurigram>=2.0.69
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# PatchPyro
-### This is a fork of pyromod (renamed as patchpyro) for personal usecases.
-
-### Remember that this fork contains only conversation patch.
-
-# Requirements:
- ~~~python
- kurigram>=2.0.69
- python>=3.9
- ~~~
-
- # Installation:
-```
-python -m pip install patchpyro
-```
- 
-# Usage:
-Import `patchpyro` at least one time in your script, so you'll be able to use modified pyrogram in all files of the same proccess. 
-Example:
-
-```python
-# config.py
-from patchpyro import listen # or import patchpyro.listen
-from pyrogram import Client
-
-patchpyro.thank() # use this if ur linters/ide is removing patchpyro as unused import.
-
-mybot = Client("mysession")
-```
-
-```python
-# any other .py
-from config import mybot
-# no need to import patchpyro again pyrogram is already monkeypatched globally (at the same proccess)
-```
-
-## `patchpyro.listen`
-Just import it, it will automatically do the monkeypatch and you'll get these new methods:
-
-- Available bound methods::
-  - `Chat.listen, User.listen`
-
-    - `await mybot.listen(chat_id, filters=None, timeout=30)`
-    - raises `asyncio.TimeoutError` if timeout (optional parameter)
-    - Awaits for a new message in the specified chat and returns it.
-    - You can pass Update Filters to the filters parameter just like you do for the update handlers.
-    - E.g. `filters=filters.photo & filters.bot`
-  - `Chat.ask, User.ask`
-
-    - `await mybot.ask(text, chat_id, filters=None, timeout=30)`
-    - Same of `.listen()` above, but sends a message before awaiting.
-    - You can pass custom parameters to its send_message() call. Check the example below.
-    
-  - `Chat.asker, User.asker`
-     - `await mybot.asker(chat_id, filters=None, timeout=36)` 
-     - same as `.listen()` but `.asker()` returns `None` instead of raising `asyncio.TimeoutError`.
-     - Found useful in some cases for me, `.asker()` has a default timeout of 2 minutes. 
-     - You can adjust it by passing as a argument. Refer the example code given below.
-
-# Examples:
-### For .asker():
-```python
-...
-    sendx = await client.send_message(chat_id, "`Send me your name:`")
-    answer = await client.asker(chat_id, filters=None, timeout=60)
-    if not answer: # `None` if timeout if no reply received.
-        return await sendx.reply_text("How long should I wait?, Eh! Bye!")
-    await answer.reply_text(f"{answer.text}, That's a cool name!")
-...
-```
-### For .ask():
-```python
-...
-    answer = await client.ask(chat_id, '*Send me your name:*', parse_mode=enums.ParseMode.MARKDOWN)
-    await client.send_message(chat_id, f'Your name is: {answer.text}')
-...
-```
-
-
-### Copyright & License
-This project may include snippets of Pyrogram code
-- Pyrogram - Telegram MTProto API Client Library for Python. Copyright (C) 2017-2022 Dan <<https://github.com/delivrance>>
-
-Licensed under the terms of the [GNU Lesser General Public License v3 or later (LGPLv3+)](COPYING.lesser)