Pytdbot 0.9.6.dev0__tar.gz → 0.9.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Pytdbot
-Version: 0.9.6.dev0
+Version: 0.9.7
 Summary: Easy-to-use asynchronous TDLib wrapper for Python.
 Home-page: https://github.com/pytdbot/client
 Author: AYMEN Mohammed
@@ -30,7 +30,7 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# Pytdbot [![Version](https://img.shields.io/pypi/v/Pytdbot?style=flat&logo=pypi)](https://pypi.org/project/Pytdbot) [![TDLib version](https://img.shields.io/badge/TDLib-v1.8.51-blue?logo=telegram)](https://github.com/tdlib/td) [![Downloads](https://static.pepy.tech/personalized-badge/pytdbot?period=month&units=none&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/pytdbot) [![Telegram Chat](https://img.shields.io/badge/Pytdbot%20chat-blue?logo=telegram&label=Telegram)](https://t.me/pytdbotchat)
+# Pytdbot [![Version](https://img.shields.io/pypi/v/Pytdbot?style=flat&logo=pypi)](https://pypi.org/project/Pytdbot) [![TDLib version](https://img.shields.io/badge/TDLib-v1.8.55-blue?logo=telegram)](https://github.com/tdlib/td) [![Downloads](https://static.pepy.tech/personalized-badge/pytdbot?period=month&units=none&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/pytdbot) [![Telegram Chat](https://img.shields.io/badge/Pytdbot%20chat-blue?logo=telegram&label=Telegram)](https://t.me/pytdbotchat)
 
 Pytdbot (Python TDLib) is an asynchronous [**TDLib**](https://github.com/tdlib/td) wrapper for **Telegram** users/bots written in **Python**.
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Pytdbot
-Version: 0.9.6.dev0
+Version: 0.9.7
 Summary: Easy-to-use asynchronous TDLib wrapper for Python.
 Home-page: https://github.com/pytdbot/client
 Author: AYMEN Mohammed
@@ -30,7 +30,7 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# Pytdbot [![Version](https://img.shields.io/pypi/v/Pytdbot?style=flat&logo=pypi)](https://pypi.org/project/Pytdbot) [![TDLib version](https://img.shields.io/badge/TDLib-v1.8.51-blue?logo=telegram)](https://github.com/tdlib/td) [![Downloads](https://static.pepy.tech/personalized-badge/pytdbot?period=month&units=none&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/pytdbot) [![Telegram Chat](https://img.shields.io/badge/Pytdbot%20chat-blue?logo=telegram&label=Telegram)](https://t.me/pytdbotchat)
+# Pytdbot [![Version](https://img.shields.io/pypi/v/Pytdbot?style=flat&logo=pypi)](https://pypi.org/project/Pytdbot) [![TDLib version](https://img.shields.io/badge/TDLib-v1.8.55-blue?logo=telegram)](https://github.com/tdlib/td) [![Downloads](https://static.pepy.tech/personalized-badge/pytdbot?period=month&units=none&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/pytdbot) [![Telegram Chat](https://img.shields.io/badge/Pytdbot%20chat-blue?logo=telegram&label=Telegram)](https://t.me/pytdbotchat)
 
 Pytdbot (Python TDLib) is an asynchronous [**TDLib**](https://github.com/tdlib/td) wrapper for **Telegram** users/bots written in **Python**.
 

{pytdbot-0.9.6.dev0 → pytdbot-0.9.7}/Pytdbot.egg-info/SOURCES.txt

@@ -23,14 +23,13 @@ pytdbot/methods/td_functions.py
 pytdbot/tdjson/__init__.py
 pytdbot/tdjson/tdjson.py
 pytdbot/types/__init__.py
+pytdbot/types/td_types.py
+pytdbot/types/bound_methods/__init__.py
+pytdbot/types/bound_methods/callback_query.py
+pytdbot/types/bound_methods/chatActions.py
+pytdbot/types/bound_methods/file.py
+pytdbot/types/bound_methods/message.py
 pytdbot/types/plugins/__init__.py
-pytdbot/types/td_types/__init__.py
-pytdbot/types/td_types/types.py
-pytdbot/types/td_types/bound_methods/__init__.py
-pytdbot/types/td_types/bound_methods/callback_query.py
-pytdbot/types/td_types/bound_methods/chatActions.py
-pytdbot/types/td_types/bound_methods/file.py
-pytdbot/types/td_types/bound_methods/message.py
 pytdbot/types/tdserver/__init__.py
 pytdbot/types/tdserver/schedule.py
 pytdbot/types/tdserver/stats.py

{pytdbot-0.9.6.dev0 → pytdbot-0.9.7}/README.md

@@ -1,4 +1,4 @@
-# Pytdbot [![Version](https://img.shields.io/pypi/v/Pytdbot?style=flat&logo=pypi)](https://pypi.org/project/Pytdbot) [![TDLib version](https://img.shields.io/badge/TDLib-v1.8.51-blue?logo=telegram)](https://github.com/tdlib/td) [![Downloads](https://static.pepy.tech/personalized-badge/pytdbot?period=month&units=none&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/pytdbot) [![Telegram Chat](https://img.shields.io/badge/Pytdbot%20chat-blue?logo=telegram&label=Telegram)](https://t.me/pytdbotchat)
+# Pytdbot [![Version](https://img.shields.io/pypi/v/Pytdbot?style=flat&logo=pypi)](https://pypi.org/project/Pytdbot) [![TDLib version](https://img.shields.io/badge/TDLib-v1.8.55-blue?logo=telegram)](https://github.com/tdlib/td) [![Downloads](https://static.pepy.tech/personalized-badge/pytdbot?period=month&units=none&left_color=grey&right_color=brightgreen&left_text=Downloads)](https://pepy.tech/project/pytdbot) [![Telegram Chat](https://img.shields.io/badge/Pytdbot%20chat-blue?logo=telegram&label=Telegram)](https://t.me/pytdbotchat)
 
 Pytdbot (Python TDLib) is an asynchronous [**TDLib**](https://github.com/tdlib/td) wrapper for **Telegram** users/bots written in **Python**.
 

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

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

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

@@ -94,6 +94,9 @@ class Client(Decorators, Methods):
         workers (``int``, *optional*):
             Number of workers to handle updates. Default is ``5``. If set to ``None``, updates will be immediately handled instead of being queued, which can impact performance.
 
+        default_handlers_timeout (``float``, *optional*):
+            Default timeout for handlers. If set, each handler will be awaited with this timeout (ignored if ``timeout`` is set when registering handler). Default is ``None`` (no timeout)
+
         no_updates (``bool``, *optional*):
             Whether the client should handle updates or not. Applicable only when using [TDLib Server](https://github.com/pytdbot/tdlib-server). Default is ``False``
 
@@ -128,11 +131,14 @@ class Client(Decorators, Methods):
         loop: asyncio.AbstractEventLoop = None,
         options: dict = None,
         workers: int = 5,
+        queue_size: int = 1000,
+        default_handlers_timeout: float = None,
         no_updates: bool = False,
         load_messages_before_reply: bool = False,
         td_verbosity: int = 2,
         td_log: LogStream = None,
         user_bot: bool = False,
+        server_ack: bool = True,
     ) -> None:
         self.__api_id = api_id
         self.__api_hash = api_hash
@@ -159,10 +165,13 @@ class Client(Decorators, Methods):
         self.use_message_database = use_message_database
         self.td_options = options
         self.workers = workers
+        self.queue_size = queue_size
+        self.default_handlers_timeout = default_handlers_timeout
         self.no_updates = no_updates
         self.load_messages_before_reply = load_messages_before_reply
         self.queue = asyncio.Queue()
         self.user_bot = user_bot
+        self.server_ack = server_ack
         self.my_id = (
             get_bot_id_from_token(self.__token)
             if isinstance(self.__token, str)
@@ -248,11 +257,14 @@ class Client(Decorators, Methods):
         return await self.invoke({"@type": "getServerStats"})
 
     async def scheduleEvent(
-        self, payload: str, send_at: int
+        self, name: str, payload: str, send_at: int
     ) -> Union["pytdbot.types.ScheduledEvent", "pytdbot.types.Error"]:
         """Schedule an event
 
         Parameters:
+            name (:class:`str`):
+                Event name
+
             payload (:class:`str`):
                 The event payload to be scheduled
 
@@ -262,13 +274,20 @@ class Client(Decorators, Methods):
 
         self._check_rabbitmq()
 
+        if not isinstance(name, str):
+            raise ValueError("name must be str")
         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", "payload": payload, "send_at": send_at}
+            {
+                "@type": "scheduleEvent",
+                "name": name,
+                "payload": payload,
+                "send_at": send_at,
+            }
         )
 
     async def cancelScheduledEvent(
@@ -339,6 +358,7 @@ class Client(Decorators, Methods):
         filters: pytdbot.filters.Filter = None,
         position: int = None,
         inner_object: bool = False,
+        timeout: float = None,
         is_from_plugin: bool = False,
     ) -> None:
         r"""Add an update handler
@@ -359,6 +379,9 @@ class Client(Decorators, Methods):
             inner_object (``bool``, *optional*):
                 Wether to pass an inner object of update or not; for example ``UpdateNewMessage.message``. Default is ``False``
 
+            timeout (``float``, *optional*):
+                Max execution time for the handler before it timeout. If ``None``, ``Client.default_handlers_timeout`` is preferred. Default is ``None``
+
             is_from_plugin (``bool``, *optional*):
                 Wether this handler is from a loaded plugin (this can help reloading plugin during runtime; for development only). Default is ``False``
 
@@ -379,7 +402,13 @@ class Client(Decorators, Methods):
             raise TypeError("filters must be instance of pytdbot.filters.Filter")
 
         handler = Handler(
-            func, update_type, filters, position, inner_object, is_from_plugin
+            func=func,
+            update_type=update_type,
+            filter=filters,
+            position=position,
+            inner_object=inner_object,
+            timeout=timeout,
+            is_from_plugin=is_from_plugin,
         )
 
         if update_type not in self._handlers:
@@ -736,12 +765,13 @@ class Client(Decorators, Methods):
             for handler in handlers_to_load:
                 if asyncio.iscoroutinefunction(handler.func):
                     self.add_handler(
-                        handler.update_type,
-                        handler.func,
-                        handler.filter,
-                        handler.position,
-                        handler.inner_object,
-                        True,
+                        update_type=handler.update_type,
+                        func=handler.func,
+                        filters=handler.filter,
+                        position=handler.position,
+                        inner_object=handler.inner_object,
+                        timeout=handler.timeout,
+                        is_from_plugin=True,
                     )
                     handlers += 1
                     plugin_handlers_count += 1
@@ -820,7 +850,22 @@ class Client(Decorators, Methods):
                     elif not filter_function(self, handler_value):
                         continue
 
-                await initializer(self, handler_value)
+                if (
+                    self.default_handlers_timeout is None
+                    and initializer.timeout is None
+                ):
+                    await initializer(self, handler_value)
+                else:
+                    timeout = initializer.timeout or self.default_handlers_timeout
+                    try:
+                        await asyncio.wait_for(
+                            initializer(self, handler_value),
+                            timeout=timeout,
+                        )
+                    except asyncio.TimeoutError:
+                        self.logger.warning(
+                            f"Initializer {initializer} timed out after {timeout} seconds"
+                        )
             except StopHandlers as e:
                 raise e
             except Exception:
@@ -841,7 +886,18 @@ class Client(Decorators, Methods):
                     elif not filter_function(self, handler_value):
                         continue
 
-                await handler(self, handler_value)
+                if self.default_handlers_timeout is None and handler.timeout is None:
+                    await handler(self, handler_value)
+                else:
+                    timeout = handler.timeout or self.default_handlers_timeout
+                    try:
+                        await asyncio.wait_for(
+                            handler(self, handler_value), timeout=timeout
+                        )
+                    except asyncio.TimeoutError:
+                        self.logger.warning(
+                            f"Handler {handler} timed out after {timeout} seconds"
+                        )
             except StopHandlers as e:
                 raise e
             except Exception:
@@ -863,7 +919,19 @@ class Client(Decorators, Methods):
                     elif not filter_function(self, handler_value):
                         continue
 
-                await finalizer(self, handler_value)
+                if self.default_handlers_timeout is None and finalizer.timeout is None:
+                    await finalizer(self, handler_value)
+                else:
+                    try:
+                        timeout = finalizer.timeout or self.default_handlers_timeout
+                        await asyncio.wait_for(
+                            finalizer(self, handler_value),
+                            timeout=timeout,
+                        )
+                    except asyncio.TimeoutError:
+                        self.logger.warning(
+                            f"Finalizer {finalizer} timed out after {timeout} seconds"
+                        )
             except StopHandlers as e:
                 raise e
             except Exception:
@@ -904,6 +972,9 @@ class Client(Decorators, Methods):
             `AuthorizationError`
         """
 
+        if self.is_rabbitmq:
+            return
+
         if isinstance(self.__database_encryption_key, str):
             self.__database_encryption_key = self.__database_encryption_key.encode(
                 "utf-8"
@@ -1060,12 +1131,12 @@ class Client(Decorators, Methods):
         updates_queue = await self.__get_updates_queue()
 
         notify_queue = await self.__rchannel.declare_queue(
-            f"notify_{self._rabbitmq_instance_id}", exclusive=True
+            f"{self.my_id}_notify_{self._rabbitmq_instance_id}", exclusive=True
         )
         await notify_queue.bind(await self.__rchannel.get_exchange("broadcast"))
 
         responses_queue = await self.__rchannel.declare_queue(
-            f"res_{self._rabbitmq_instance_id}", exclusive=True
+            f"{self.my_id}_res_{self._rabbitmq_instance_id}", exclusive=True
         )
 
         self.__rqueues = {
@@ -1095,13 +1166,22 @@ class Client(Decorators, Methods):
         await self.__rqueues["notify"].consume(self.__on_update, no_ack=True)
 
     async def __rabbitmq_iterator(self):
-        async with self.__rqueues["updates"].iterator() as iterator:
+        async with self.__rqueues["updates"].iterator(
+            no_ack=not self.server_ack
+        ) as iterator:
             async for message in iterator:
-                await self.queue.put(message)
+                if self.queue.qsize() > self.queue_size:
+                    await message.nack(requeue=True)
+                    continue
+
+                self.queue.put_nowait(message)
 
     async def __rabbitmq_worker(self):
         while self.is_running:
-            message: aio_pika.IncomingMessage = await self.queue.get()
+            try:
+                message: aio_pika.IncomingMessage = self.queue.get_nowait()
+            except asyncio.QueueEmpty:
+                message: aio_pika.IncomingMessage = await self.queue.get()
 
             try:
                 update = json_loads(message.body)
@@ -1138,7 +1218,8 @@ class Client(Decorators, Methods):
 
     async def __handle_authorization_state_wait_phone_number(self):
         if (
-            self.authorization_state != "authorizationStateWaitPhoneNumber"
+            self.is_rabbitmq
+            or self.authorization_state != "authorizationStateWaitPhoneNumber"
             or not self.__token
         ):
             return

{pytdbot-0.9.6.dev0 → pytdbot-0.9.7}/pytdbot/handlers/decorators.py

@@ -18,6 +18,7 @@ class Decorators(Updates):
         filters: "pytdbot.filters.Filter" = None,
         position: int = None,
         inner_object: bool = False,
+        timeout: float = None,
     ) -> None:
         r"""A decorator to initialize an event object before running other handlers
 
@@ -31,6 +32,9 @@ class Decorators(Updates):
             inner_object (``bool``, *optional*):
                 Wether to pass an inner object of update or not; for example ``UpdateNewMessage.message``. Default is ``False``
 
+            timeout (``float``, *optional*):
+                Max execution time for the initializer before it timeout. Default is ``None``
+
         Raises:
             :py:class:`TypeError`
         """
@@ -41,17 +45,32 @@ class Decorators(Updates):
             elif isinstance(self, pytdbot.Client):
                 if iscoroutinefunction(func):
                     self.add_handler(
-                        "initializer", func, filters, position, inner_object
+                        update_type="initializer",
+                        func=func,
+                        filters=filters,
+                        position=position,
+                        inner_object=inner_object,
+                        timeout=timeout,
                     )
                 else:
                     raise TypeError("Handler must be async")
             elif isinstance(self, pytdbot.filters.Filter):
                 func._handler = Handler(
-                    func, "initializer", self, position, inner_object
+                    func=func,
+                    update_type="initializer",
+                    filter=self,
+                    position=position,
+                    inner_object=inner_object,
+                    timeout=timeout,
                 )
             else:
                 func._handler = Handler(
-                    func, "initializer", filters, position, inner_object
+                    func=func,
+                    update_type="initializer",
+                    filter=filters,
+                    position=position,
+                    inner_object=inner_object,
+                    timeout=timeout,
                 )
 
             return func
@@ -63,6 +82,7 @@ class Decorators(Updates):
         filters: "pytdbot.filters.Filter" = None,
         position: int = None,
         inner_object: bool = False,
+        timeout: float = None,
     ) -> None:
         r"""A decorator to finalize an event object after running all handlers
 
@@ -76,6 +96,9 @@ class Decorators(Updates):
             inner_object (``bool``, *optional*):
                 Wether to pass an inner object of update or not; for example ``UpdateNewMessage.message``. Default is ``False``
 
+            timeout (``float``, *optional*):
+                Max execution time for the finalizer before it timeout. Default is ``None``
+
         Raises:
             :py:class:`TypeError`
         """
@@ -85,14 +108,33 @@ class Decorators(Updates):
                 return func
             elif isinstance(self, pytdbot.Client):
                 if iscoroutinefunction(func):
-                    self.add_handler("finalizer", func, filters, position, inner_object)
+                    self.add_handler(
+                        update_type="finalizer",
+                        func=func,
+                        filters=filters,
+                        position=position,
+                        inner_object=inner_object,
+                        timeout=timeout,
+                    )
                 else:
                     raise TypeError("Handler must be async")
             elif isinstance(self, pytdbot.filters.Filter):
-                func._handler = Handler(func, "finalizer", self, position, inner_object)
+                func._handler = Handler(
+                    func=func,
+                    update_type="finalizer",
+                    filter=self,
+                    position=position,
+                    inner_object=inner_object,
+                    timeout=timeout,
+                )
             else:
                 func._handler = Handler(
-                    func, "finalizer", filters, position, inner_object
+                    func=func,
+                    update_type="finalizer",
+                    filter=filters,
+                    position=position,
+                    inner_object=inner_object,
+                    timeout=timeout,
                 )
             return func
 
@@ -102,6 +144,7 @@ class Decorators(Updates):
         self: "pytdbot.Client" = None,
         filters: "pytdbot.filters.Filter" = None,
         position: int = None,
+        timeout: float = None,
     ) -> None:
         r"""A decorator to handle ``updateNewMessage`` but with ``Message`` object.
 
@@ -112,6 +155,9 @@ class Decorators(Updates):
             position (``int``, *optional*):
                 The function position in handlers list. Default is ``None`` (append)
 
+            timeout (``float``, *optional*):
+                Max execution time for the handler before it timeout. Default is ``None``
+
         Raises:
             :py:class:`TypeError`
         """
@@ -121,14 +167,33 @@ class Decorators(Updates):
                 return func
             elif isinstance(self, pytdbot.Client):
                 if iscoroutinefunction(func):
-                    self.add_handler("updateNewMessage", func, filters, position, True)
+                    self.add_handler(
+                        update_type="updateNewMessage",
+                        func=func,
+                        filters=filters,
+                        position=position,
+                        inner_object=True,
+                        timeout=timeout,
+                    )
                 else:
                     raise TypeError("Handler must be async")
             elif isinstance(self, pytdbot.filters.Filter):
-                func._handler = Handler(func, "updateNewMessage", self, position, True)
+                func._handler = Handler(
+                    func=func,
+                    update_type="updateNewMessage",
+                    filter=self,
+                    position=position,
+                    inner_object=True,
+                    timeout=timeout,
+                )
             else:
                 func._handler = Handler(
-                    func, "updateNewMessage", filters, position, True
+                    func=func,
+                    update_type="updateNewMessage",
+                    filter=filters,
+                    position=position,
+                    inner_object=True,
+                    timeout=timeout,
                 )
 
             return func
@@ -139,7 +204,7 @@ class Decorators(Updates):
         self: "pytdbot.Client" = None,
         filters: "pytdbot.filters.Filter" = None,
         position: int = None,
-        inner_object: bool = False,
+        timeout: float = None,
     ) -> None:
         r"""A scheduled event has been triggered
 
@@ -150,8 +215,8 @@ class Decorators(Updates):
             position (``int``, *optional*):
                 The function position in handlers list. Default is ``None`` (append)
 
-            inner_object (``bool``, *optional*):
-                Wether to pass an inner object of update or not; for example ``UpdateNewMessage.message``. Default is ``False``
+            timeout (``float``, *optional*):
+                Max execution time for the handler before it timeout. Default is ``None``
 
         Raises:
             :py:class:`TypeError`
@@ -163,17 +228,32 @@ class Decorators(Updates):
             elif isinstance(self, pytdbot.Client):
                 if iscoroutinefunction(func):
                     self.add_handler(
-                        "updateScheduledEvent", func, filters, position, inner_object
+                        update_type="updateScheduledEvent",
+                        func=func,
+                        filters=filters,
+                        position=position,
+                        inner_object=False,
+                        timeout=timeout,
                     )
                 else:
                     raise TypeError("Handler must be async")
             elif isinstance(self, pytdbot.filters.Filter):
                 func._handler = Handler(
-                    func, "updateScheduledEvent", self, position, inner_object
+                    func=func,
+                    update_type="updateScheduledEvent",
+                    filter=self,
+                    position=position,
+                    inner_object=False,
+                    timeout=timeout,
                 )
             else:
                 func._handler = Handler(
-                    func, "updateScheduledEvent", filters, position, inner_object
+                    func=func,
+                    update_type="updateScheduledEvent",
+                    filter=filters,
+                    position=position,
+                    inner_object=False,
+                    timeout=timeout,
                 )
 
             return func

{pytdbot-0.9.6.dev0 → pytdbot-0.9.7}/pytdbot/handlers/handler.py

@@ -15,6 +15,7 @@ class Handler:
         filter: Filter = None,
         position: int = None,
         inner_object: bool = False,
+        timeout: float = None,
         is_from_plugin: bool = False,
     ) -> None:
         self.func = func
@@ -22,13 +23,14 @@ class Handler:
         self.filter = filter
         self.position = position
         self.inner_object = inner_object
+        self.timeout = timeout
         self.is_from_plugin = is_from_plugin
 
     def __call__(self, client: "pytdbot.Client", update: "pytdbot.types.Update"):
         return self.func(client, update)
 
     def __str__(self) -> str:
-        return f"Handler(func={self.func}, update_type={self.update_type}, filter={self.filter}, position={self.position}, inner_object={self.inner_object}, is_from_plugin={self.is_from_plugin})"
+        return f"Handler(func={self.func}, update_type={self.update_type}, filter={self.filter}, position={self.position}, inner_object={self.inner_object}, timeout={self.timeout}, is_from_plugin={self.is_from_plugin})"
 
     def __repr__(self) -> str:
         return str(self)