Pytdbot 0.9.5__tar.gz → 0.9.6.dev0__tar.gz

{pytdbot-0.9.5 → pytdbot-0.9.6.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Pytdbot
-Version: 0.9.5
+Version: 0.9.6.dev0
 Summary: Easy-to-use asynchronous TDLib wrapper for Python.
 Home-page: https://github.com/pytdbot/client
 Author: AYMEN Mohammed

{pytdbot-0.9.5 → pytdbot-0.9.6.dev0}/Pytdbot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Pytdbot
-Version: 0.9.5
+Version: 0.9.6.dev0
 Summary: Easy-to-use asynchronous TDLib wrapper for Python.
 Home-page: https://github.com/pytdbot/client
 Author: AYMEN Mohammed

{pytdbot-0.9.5 → pytdbot-0.9.6.dev0}/pytdbot/__init__.py

@@ -13,7 +13,7 @@ __all__ = [
     "Client",
 ]
 
-__version__ = "0.9.5"
+__version__ = "0.9.6.dev0"
 __copyright__ = "Copyright (c) 2022-2025 Pytdbot, AYMENJD"
 __license__ = "MIT License"
 

{pytdbot-0.9.5 → pytdbot-0.9.6.dev0}/pytdbot/client.py

@@ -7,7 +7,7 @@ from os.path import join as join_path
 from pathlib import Path
 from platform import python_implementation, python_version
 from threading import current_thread, main_thread
-from typing import Callable, Dict, Union
+from typing import Callable, Dict, Type, Union
 
 import aio_pika
 from deepdiff import DeepDiff
@@ -129,6 +129,7 @@ class Client(Decorators, Methods):
         options: dict = None,
         workers: int = 5,
         no_updates: bool = False,
+        load_messages_before_reply: bool = False,
         td_verbosity: int = 2,
         td_log: LogStream = None,
         user_bot: bool = False,
@@ -159,6 +160,7 @@ class Client(Decorators, Methods):
         self.td_options = options
         self.workers = workers
         self.no_updates = no_updates
+        self.load_messages_before_reply = load_messages_before_reply
         self.queue = asyncio.Queue()
         self.user_bot = user_bot
         self.my_id = (
@@ -179,6 +181,12 @@ class Client(Decorators, Methods):
         self.is_rabbitmq = True if rabbitmq_url else False
         self.options = {}
         self.allow_outgoing_message_types: tuple = (types.MessagePaymentRefunded,)
+        self.get_message_methods = {
+            "getmessage",
+            "getmessagelocally",
+            "getrepliedmessage",
+            "getcallbackquerymessage",
+        }  # TODO: improve this
 
         self._check_init_args()
 
@@ -240,13 +248,13 @@ class Client(Decorators, Methods):
         return await self.invoke({"@type": "getServerStats"})
 
     async def scheduleEvent(
-        self, data: dict, send_at: int
+        self, payload: str, send_at: int
     ) -> Union["pytdbot.types.ScheduledEvent", "pytdbot.types.Error"]:
         """Schedule an event
 
         Parameters:
-            data (:class:`dict`):
-                The event data to be scheduled
+            payload (:class:`str`):
+                The event payload to be scheduled
 
             send_at (:class:`int`):
                 Unix timestamp when the event should be sent
@@ -254,13 +262,13 @@ class Client(Decorators, Methods):
 
         self._check_rabbitmq()
 
-        if not isinstance(data, dict):
-            raise ValueError("data must be dict")
+        if not isinstance(payload, str):
+            raise ValueError("payload must be str")
         if not isinstance(send_at, (int, float)):
             raise ValueError("send_at must be int")
 
         return await self.invoke(
-            {"@type": "scheduleEvent", "data": data, "send_at": send_at}
+            {"@type": "scheduleEvent", "payload": payload, "send_at": send_at}
         )
 
     async def cancelScheduledEvent(
@@ -326,7 +334,7 @@ class Client(Decorators, Methods):
 
     def add_handler(
         self,
-        update_type: str,
+        update_type: Union[Type["pytdbot.types.Update"], str],
         func: Callable,
         filters: pytdbot.filters.Filter = None,
         position: int = None,
@@ -336,7 +344,7 @@ class Client(Decorators, Methods):
         r"""Add an update handler
 
         Parameters:
-            update_type (``str``):
+            update_type (``str`` || :class:`~pytdbot.types.Update`):
                 An update type
 
             func (``Callable``):
@@ -359,23 +367,28 @@ class Client(Decorators, Methods):
         """
 
         if not isinstance(update_type, str):
-            raise TypeError("update_type must be str")
-        elif not isinstance(func, Callable):
+            if issubclass(update_type, types.Update):
+                update_type = update_type.getType()
+            else:
+                raise TypeError(
+                    "update_type must be str or subclass of pytdbot.types.Update"
+                )
+        if not isinstance(func, Callable):
             raise TypeError("func must be callable")
-        elif filters is not None and not isinstance(filters, Filter):
+        if filters is not None and not isinstance(filters, Filter):
             raise TypeError("filters must be instance of pytdbot.filters.Filter")
-        else:
-            handler = Handler(
-                func, update_type, filters, position, inner_object, is_from_plugin
-            )
 
-            if update_type not in self._handlers:
-                self._handlers[update_type] = []
+        handler = Handler(
+            func, update_type, filters, position, inner_object, is_from_plugin
+        )
 
-            if isinstance(position, int):
-                self._handlers[update_type].insert(position, handler)
-            else:
-                self._handlers[update_type].append(handler)
+        if update_type not in self._handlers:
+            self._handlers[update_type] = []
+
+        if isinstance(position, int):
+            self._handlers[update_type].insert(position, handler)
+        else:
+            self._handlers[update_type].append(handler)
 
         self._update_handlers()
 
@@ -451,56 +464,78 @@ class Client(Decorators, Methods):
         """
 
         request = obj_to_dict(request)
-
         request["@extra"] = {"id": create_extra_id()}
-
-        future = self._create_request_future(request)
+        request_method = request["@type"].lower()
 
         if (
             self.logger.root.level >= DEBUG or self.logger.level >= DEBUG
         ):  # dumping all requests may create performance issues
             self.logger.debug(f"Sending: {dumps(request, indent=4)}")
 
-        is_chat_attempted_load = request["@type"].lower() == "getchat"
+        is_chat_attempted_load = request_method == "getchat"
+        is_message_attempted_load = request_method in self.get_message_methods
 
         while True:
             future = self._create_request_future(request)
             await self.__send(request)
             result = await future
 
-            if isinstance(result, types.Error):
-                if result.code == 400:
-                    if result.message.startswith(
-                        "Failed to parse JSON object as TDLib request:"
-                    ):
-                        raise ValueError(result.message)
+            if not isinstance(result, types.Error):
+                break
+
+            error_code = result.code
+            error_message = result.message
+
+            if error_message.startswith(
+                "Failed to parse JSON object as TDLib request:"
+            ):
+                raise ValueError(error_message)
 
-                    if not is_chat_attempted_load and (
-                        result.message == "Chat not found" and "chat_id" in request
-                    ):
-                        is_chat_attempted_load = True
+            if error_code != 400:
+                break
 
-                        chat_id = request["chat_id"]
+            chat_id = request.get("chat_id")
+            message_id = request.get("message_id")
 
-                        self.logger.debug(f"Attempt to load chat {chat_id}")
+            if not is_message_attempted_load and (
+                error_message == "Message not found" and (chat_id and message_id)
+            ):
+                is_message_attempted_load = True
 
-                        load_chat = await self.getChat(chat_id)
+                self.logger.debug(f"Attempt to load message {message_id} in {chat_id}")
 
-                        if not isinstance(load_chat, types.Error):
-                            self.logger.debug(f"Chat {chat_id} is loaded")
+                message = await self.getMessage(chat_id=chat_id, message_id=message_id)
+                if message:
+                    self.logger.debug(f"Message {message_id} in {chat_id} is loaded")
+                    continue
+                else:
+                    self.logger.debug(
+                        f"Failed to load message {message_id} in {chat_id}"
+                    )
 
-                            reply_to_message_id = (request.get("reply_to") or {}).get(
-                                "message_id", 0
-                            )
+            if not is_chat_attempted_load and (
+                error_message == "Chat not found" and chat_id
+            ):
+                is_chat_attempted_load = True
 
-                            # if the request is a reply to another message
-                            # load the replied message to avoid "Message not found"
-                            if reply_to_message_id > 0:
-                                await self.getMessage(chat_id, reply_to_message_id)
+                self.logger.debug(f"Attempt to load chat {chat_id}")
 
-                            continue
+                chat = await self.getChat(chat_id)
+                if not isinstance(chat, types.Error):
+                    self.logger.debug(f"Chat {chat_id} is loaded")
+
+                    reply_to_message_id = (request.get("reply_to") or {}).get(
+                        "message_id", 0
+                    )
 
-                        self.logger.error(f"Couldn't load chat {chat_id}")
+                    # if the request is a reply to another message
+                    # load the replied message to avoid "Message not found"
+                    if reply_to_message_id > 0:
+                        await self.getMessage(chat_id, reply_to_message_id)
+
+                    continue
+                else:
+                    self.logger.error(f"Couldn't load chat {chat_id}")
 
             break
 

{pytdbot-0.9.5 → pytdbot-0.9.6.dev0}/pytdbot/methods/methods.py

@@ -1027,7 +1027,7 @@ class Methods(TDLibFunctions):
         return await self.sendMessageWithContent(
             chat_id=chat_id,
             content=InputMessageVoiceNote(
-                voice=voice,
+                voice_note=voice,
                 waveform=waveform,
                 duration=duration,
                 caption=caption,
@@ -1389,6 +1389,11 @@ class Methods(TDLibFunctions):
                 message_id=reply_to_message_id, quote=quote
             )
 
+        if self.load_messages_before_reply and isinstance(
+            reply_to, InputMessageReplyToMessage
+        ):
+            await self.getMessage(chat_id=chat_id, message_id=reply_to.message_id)
+
         res = await self.sendMessage(
             chat_id=chat_id,
             message_thread_id=message_thread_id,