Pytdbot 0.10.0.dev0__py3-none-any.whl → 0.10.0.dev2__py3-none-any.whl

pytdbot/__init__.py

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

pytdbot/client.py

@@ -5,6 +5,7 @@ import signal
 from collections.abc import Callable
 from importlib import import_module
 from importlib import reload as reload_module
+from inspect import iscoroutinefunction
 from json import dumps
 from logging import DEBUG, getLogger
 from os.path import join as join_path
@@ -28,7 +29,6 @@ from .utils import (
     create_extra_id,
     dict_to_obj,
     get_bot_id_from_token,
-    get_running_loop,
     json_dumps,
     json_loads,
     obj_to_dict,
@@ -88,9 +88,6 @@ class Client(Decorators, Methods):
         use_message_database (``bool``, *optional*):
             If set to true, the library will maintain a cache of chats and messages. Implies use_chat_info_database. Default is ``True``
 
-        loop (:py:class:`asyncio.AbstractEventLoop`, *optional*):
-            Event loop. Default is ``None`` (auto-detect)
-
         options (``dict``, *optional*):
             Pass key-value dictionary to set TDLib options. Check the list of available options at https://core.telegram.org/tdlib/options
 
@@ -131,7 +128,6 @@ class Client(Decorators, Methods):
         use_file_database: bool = True,
         use_chat_info_database: bool = True,
         use_message_database: bool = True,
-        loop: asyncio.AbstractEventLoop | None = None,
         options: dict | None = None,
         workers: int = 5,
         queue_size: int = 1000,
@@ -220,15 +216,15 @@ class Client(Decorators, Methods):
         }
         self.__is_queue_worker = False
         self.__is_closing = False
+        self.__idle_event: asyncio.Event = None
+        self.__closed_event: asyncio.Event = None
 
         # RabbitMQ
         self.__rqueues = None
         self.__rconnection = None
         self.__rchannel = None
 
-        self.loop = (
-            loop if isinstance(loop, asyncio.AbstractEventLoop) else get_running_loop()
-        )
+        self.loop = None
 
         if plugins is not None:
             self._load_plugins()
@@ -324,6 +320,10 @@ class Client(Decorators, Methods):
         if not self.is_running:
             self.logger.info("Starting pytdbot client...")
 
+            self.loop = asyncio.get_running_loop()
+            self.__idle_event = asyncio.Event()
+            self.__closed_event = asyncio.Event()
+
             if self.is_rabbitmq:
                 await self.__start_rabbitmq()
             elif not self.client_manager:
@@ -611,12 +611,13 @@ class Client(Decorators, Methods):
 
         return await self.invoke(kwargs)
 
-    def run(self) -> None:
+    async def run(self) -> None:
         r"""Start the client and block until the client is stopped
 
         Example:
             .. code-block:: python
 
+                import asyncio
                 from pytdbot import Client
 
                 client = Client(...)
@@ -625,19 +626,22 @@ class Client(Decorators, Methods):
                 async def new_message(c,update):
                     await update.reply_text('Hello!')
 
-                client.run()
+                asyncio.run(client.run())
         """
 
+        await self.start()
+
         self._register_signal_handlers()
 
-        self.loop.run_until_complete(self.start())
-        self.loop.run_until_complete(self.idle())
+        await self.idle()
 
     async def idle(self):
-        r"""Idle and wait until the client is stopped."""
+        r"""Idle and wait until the client is stopped"""
 
-        while self.is_running:
-            await asyncio.sleep(1)
+        if not self.__idle_event:
+            self.__idle_event = asyncio.Event()
+
+        await self.__idle_event.wait()
 
     async def stop(self) -> bool:
         r"""Stop the client
@@ -666,8 +670,7 @@ class Client(Decorators, Methods):
         }:
             await self.close()
 
-        while self.authorization_state != "authorizationStateClosed":
-            await asyncio.sleep(0.1)
+        await self.__closed_event.wait()
 
         if self.is_rabbitmq:
             await self.__rchannel.close()
@@ -679,6 +682,7 @@ class Client(Decorators, Methods):
             await self.client_manager.close()
 
         self.logger.info("Instance closed")
+        self.__idle_event.set()
 
         return True
 
@@ -778,7 +782,7 @@ class Client(Decorators, Methods):
             ]
 
             for handler in handlers_to_load:
-                if asyncio.iscoroutinefunction(handler.func):
+                if iscoroutinefunction(handler.func):
                     self.add_handler(
                         update_type=handler.update_type,
                         func=handler.func,
@@ -810,39 +814,45 @@ class Client(Decorators, Methods):
         if func in self.__cache["is_coro_filter"]:
             return self.__cache["is_coro_filter"][func]
         else:
-            is_coro = asyncio.iscoroutinefunction(func)
+            is_coro = iscoroutinefunction(func)
             self.__cache["is_coro_filter"][func] = is_coro
             return is_coro
 
-    async def process_update(self, update):
+    async def process_update(self, update: dict) -> None:
         if not update:
             self.logger.warning("Received None update")
             return
 
-        if (
-            self.logger.root.level >= DEBUG or self.logger.level >= DEBUG
-        ):  # dumping all results may create performance issues
-            self.logger.debug(f"Received: {dumps(update, indent=4)}")
+        is_debug = self.logger.isEnabledFor(DEBUG)
 
-        if "@extra" in update:
-            if result := self._results.pop(update["@extra"]["id"], None):
-                obj = dict_to_obj(update, self)
+        if extra := update.get("@extra"):
+            result_id = extra["id"]
 
-                result.set_result(obj)
-            elif update["@type"] == "error" and "option" in update["@extra"]:
-                self.logger.error(f"{update['@extra']['option']}: {update['message']}")
+            if is_debug:
+                self.logger.debug(
+                    f"Received result for {result_id}: {dumps(update, indent=4)}"
+                )
 
-        else:
-            update_handler = self.__local_handlers.get(update["@type"])
-            update = dict_to_obj(update, self)
+            if result_id and (result := self._results.pop(result_id, None)):
+                result.set_result(dict_to_obj(update, self))
 
-            if update_handler:
-                self.loop.create_task(update_handler(update))
+            elif update["@type"] == "error" and "option" in extra:
+                self.logger.error(f"{extra['option']}: {update['message']}")
 
-            if not self.is_rabbitmq and self.__is_queue_worker:
-                self.queue.put_nowait(update)
-            else:
-                await self._handle_update(update)
+            return
+
+        if is_debug:
+            self.logger.debug(f"Received: {dumps(update, indent=4)}")
+
+        update_obj = dict_to_obj(update, self)
+
+        if handler := self.__local_handlers.get(update.get("@type")):
+            self.loop.create_task(handler(update_obj))
+
+        if not self.is_rabbitmq and self.__is_queue_worker:
+            self.queue.put_nowait(update_obj)
+        else:
+            await self._handle_update(update_obj)
 
     def get_inner_object(self, update: types.TlObject):
         if isinstance(update, types.UpdateNewMessage):
@@ -1073,11 +1083,10 @@ class Client(Decorators, Methods):
 
         if self.authorization_state == "authorizationStateClosing":
             self.__is_closing = True
-        elif (
-            self.authorization_state == "authorizationStateClosed"
-            and self.__is_closing is False
-        ):
-            await self.stop()
+        elif self.authorization_state == "authorizationStateClosed":
+            self.__closed_event.set()
+            if self.__is_closing is False:
+                await self.stop()
 
     async def __handle_connection_state(self, update: types.UpdateConnectionState):
         self.connection_state: str = update.state.getType()
@@ -1099,7 +1108,9 @@ class Client(Decorators, Methods):
         m_id = f"{update.message.chat_id}:{update.old_message_id}"
 
         if result := self._results.pop(m_id, None):
-            result.set_result(update.error)
+            result.set_result(
+                update.error if not update.message.media_album_id else update.message
+            )
 
     async def __handle_update_option(self, update: types.UpdateOption):
         if isinstance(update.value, types.OptionValueBoolean):

pytdbot/filters.py

@@ -50,7 +50,7 @@ def create(func: Callable) -> Filter:
             async def photo_handler(c,update):
                 await update.reply_text('I got a photo!')
 
-            client.run()
+            asyncio.run(client.run())
 
     Parameters:
         func (``Callable``):

pytdbot/handlers/td_updates.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from asyncio import iscoroutinefunction
 from collections.abc import Callable
+from inspect import iscoroutinefunction
 from logging import getLogger
 
 import pytdbot
@@ -2433,6 +2433,65 @@ class Updates:
 
         return decorator
 
+    def on_updateChatUnreadPollVoteCount(
+        self: pytdbot.Client | None = None,
+        filters: pytdbot.filters.Filter | None = None,
+        position: int | None = None,
+        timeout: float | None = None,
+    ) -> Callable:
+        r"""The chat unread\_poll\_vote\_count has changed
+
+        Parameters:
+            filters (:class:`pytdbot.filters.Filter`, *optional*):
+                An update filter
+
+            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`
+        """
+
+        def decorator(func: Callable) -> Callable:
+            if hasattr(func, "_handler"):
+                return func
+            elif isinstance(self, pytdbot.Client):
+                if iscoroutinefunction(func):
+                    self.add_handler(
+                        update_type="updateChatUnreadPollVoteCount",
+                        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=func,
+                    update_type="updateChatUnreadPollVoteCount",
+                    filter=self,
+                    position=position,
+                    inner_object=False,
+                    timeout=timeout,
+                )
+            else:
+                func._handler = Handler(
+                    func=func,
+                    update_type="updateChatUnreadPollVoteCount",
+                    filter=filters,
+                    position=position,
+                    inner_object=False,
+                    timeout=timeout,
+                )
+            return func
+
+        return decorator
+
     def on_updateChatVideoChat(
         self: pytdbot.Client | None = None,
         filters: pytdbot.filters.Filter | None = None,
@@ -8864,6 +8923,65 @@ class Updates:
 
         return decorator
 
+    def on_updateTextCompositionStyles(
+        self: pytdbot.Client | None = None,
+        filters: pytdbot.filters.Filter | None = None,
+        position: int | None = None,
+        timeout: float | None = None,
+    ) -> Callable:
+        r"""The styles supported for text composition have changed
+
+        Parameters:
+            filters (:class:`pytdbot.filters.Filter`, *optional*):
+                An update filter
+
+            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`
+        """
+
+        def decorator(func: Callable) -> Callable:
+            if hasattr(func, "_handler"):
+                return func
+            elif isinstance(self, pytdbot.Client):
+                if iscoroutinefunction(func):
+                    self.add_handler(
+                        update_type="updateTextCompositionStyles",
+                        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=func,
+                    update_type="updateTextCompositionStyles",
+                    filter=self,
+                    position=position,
+                    inner_object=False,
+                    timeout=timeout,
+                )
+            else:
+                func._handler = Handler(
+                    func=func,
+                    update_type="updateTextCompositionStyles",
+                    filter=filters,
+                    position=position,
+                    inner_object=False,
+                    timeout=timeout,
+                )
+            return func
+
+        return decorator
+
     def on_updateSuggestedActions(
         self: pytdbot.Client | None = None,
         filters: pytdbot.filters.Filter | None = None,
@@ -9985,6 +10103,65 @@ class Updates:
 
         return decorator
 
+    def on_updateManagedBot(
+        self: pytdbot.Client | None = None,
+        filters: pytdbot.filters.Filter | None = None,
+        position: int | None = None,
+        timeout: float | None = None,
+    ) -> Callable:
+        r"""A bot that can be managed by the current bot was created or updated; for bots only
+
+        Parameters:
+            filters (:class:`pytdbot.filters.Filter`, *optional*):
+                An update filter
+
+            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`
+        """
+
+        def decorator(func: Callable) -> Callable:
+            if hasattr(func, "_handler"):
+                return func
+            elif isinstance(self, pytdbot.Client):
+                if iscoroutinefunction(func):
+                    self.add_handler(
+                        update_type="updateManagedBot",
+                        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=func,
+                    update_type="updateManagedBot",
+                    filter=self,
+                    position=position,
+                    inner_object=False,
+                    timeout=timeout,
+                )
+            else:
+                func._handler = Handler(
+                    func=func,
+                    update_type="updateManagedBot",
+                    filter=filters,
+                    position=position,
+                    inner_object=False,
+                    timeout=timeout,
+                )
+            return func
+
+        return decorator
+
     def on_updateChatMember(
         self: pytdbot.Client | None = None,
         filters: pytdbot.filters.Filter | None = None,