Pytdbot 0.9.3__tar.gz → 0.9.5.dev0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Pytdbot
-Version: 0.9.3
+Version: 0.9.5.dev0
 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.49-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.50-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.3 → pytdbot-0.9.5.dev0}/Pytdbot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Pytdbot
-Version: 0.9.3
+Version: 0.9.5.dev0
 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.49-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.50-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.3 → pytdbot-0.9.5.dev0}/Pytdbot.egg-info/SOURCES.txt

@@ -31,6 +31,9 @@ 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/utils/__init__.py
 pytdbot/utils/asyncio_utils.py
 pytdbot/utils/escape.py

{pytdbot-0.9.3 → pytdbot-0.9.5.dev0}/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.49-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.50-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.3 → pytdbot-0.9.5.dev0}/pytdbot/__init__.py

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

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

@@ -1,6 +1,6 @@
 import asyncio
 import signal
-from importlib import import_module
+from importlib import import_module, reload as reload_module
 from json import dumps
 from logging import DEBUG, getLogger
 from os.path import join as join_path
@@ -102,6 +102,9 @@ class Client(Decorators, Methods):
 
         td_log (:class:`~pytdbot.types.LogStream`, *optional*):
             Log stream. Default is ``None`` (Log to ``stdout``)
+
+        user_bot (``bool``, *optional*):
+            Pass ``True`` if this is a user-bot. Default is ``False``
     """
 
     def __init__(
@@ -172,14 +175,18 @@ class Client(Decorators, Methods):
         self.is_running = None
         self.me: types.User = None
         self.is_authenticated = False
+        self.is_reloading_plugins = False
         self.is_rabbitmq = True if rabbitmq_url else False
         self.options = {}
+        self.allow_outgoing_message_types: tuple = (types.MessagePaymentRefunded,)
 
         self._check_init_args()
 
         self._handlers = {"initializer": [], "finalizer": []}
+        self._current_handlers = {}
         self._results: Dict[str, asyncio.Future] = {}
         self._workers_tasks = None
+        self.__rabbitmq_iterator_task = None
         self.__authorization_state = None
         self.__cache = {"is_coro_filter": {}}
         self.__local_handlers = {
@@ -223,17 +230,72 @@ class Client(Decorators, Methods):
 
         return self.__authorization_state
 
+    async def getServerStats(
+        self,
+    ) -> Union["pytdbot.types.ServerStats", "pytdbot.types.Error"]:
+        """Returns TDLib Server stats"""
+
+        self._check_rabbitmq()
+
+        return await self.invoke({"@type": "getServerStats"})
+
+    async def scheduleEvent(
+        self, data: dict, send_at: int
+    ) -> Union["pytdbot.types.ScheduledEvent", "pytdbot.types.Error"]:
+        """Schedule an event
+
+        Parameters:
+            data (:class:`dict`):
+                The event data to be scheduled
+
+            send_at (:class:`int`):
+                Unix timestamp when the event should be sent
+        """
+
+        self._check_rabbitmq()
+
+        if not isinstance(data, dict):
+            raise ValueError("data must be dict")
+        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}
+        )
+
+    async def cancelScheduledEvent(
+        self, event_id: str
+    ) -> Union["pytdbot.types.Ok", "pytdbot.types.Error"]:
+        """Cancel a scheduled event
+
+        Parameters:
+            event_id (:class:`str`):
+                Event ID to cancel
+        """
+
+        self._check_rabbitmq()
+
+        if not isinstance(event_id, str):
+            raise ValueError("event_id must be str")
+
+        return await self.invoke(
+            {"@type": "cancelScheduledEvent", "event_id": event_id}
+        )
+
     async def start(self) -> None:
         r"""Start pytdbot client"""
 
         if not self.is_running:
             self.logger.info("Starting pytdbot client...")
 
-            if not self.client_manager:
+            if self.is_rabbitmq:
+                await self.__start_rabbitmq()
+            elif not self.client_manager:
                 self.client_manager = ClientManager(
                     self, self.lib_path, self.td_verbosity, loop=self.loop
                 )
                 await self.client_manager.start()
+                self.is_running = True
 
             if isinstance(self.td_log, LogStream) and not self.is_rabbitmq:
                 await self.__send(
@@ -242,21 +304,22 @@ class Client(Decorators, Methods):
 
             if isinstance(self.workers, int):
                 self._workers_tasks = [
-                    self.loop.create_task(self._queue_update_worker())
+                    self.loop.create_task(
+                        self._queue_update_worker()
+                        if not self.is_rabbitmq
+                        else self.__rabbitmq_worker()
+                    )
                     for _ in range(self.workers)
                 ]
                 self.__is_queue_worker = True
 
                 self.logger.info(f"Started with {self.workers} workers")
+            elif self.is_rabbitmq:
+                raise ValueError("workers must be an int when using TDLib Server")
             else:
                 self.__is_queue_worker = False
                 self.logger.info("Started with unlimited updates processes")
 
-            if self.is_rabbitmq:
-                await self.__start_rabbitmq()
-            else:  # client_manager
-                self.is_running = True
-
         self.loop.create_task(
             self.getOption("version")
         )  # Ping TDLib to start processing updates
@@ -268,6 +331,7 @@ class Client(Decorators, Methods):
         filters: pytdbot.filters.Filter = None,
         position: int = None,
         inner_object: bool = False,
+        is_from_plugin: bool = False,
     ) -> None:
         r"""Add an update handler
 
@@ -287,6 +351,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``
 
+            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``
+
         Raises:
             TypeError
         """
@@ -298,14 +365,38 @@ class Client(Decorators, Methods):
         elif filters is not None and not isinstance(filters, Filter):
             raise TypeError("filters must be instance of pytdbot.filters.Filter")
         else:
-            func = Handler(func, update_type, filters, position, inner_object)
+            handler = Handler(
+                func, update_type, filters, position, inner_object, is_from_plugin
+            )
+
             if update_type not in self._handlers:
                 self._handlers[update_type] = []
+
             if isinstance(position, int):
-                self._handlers[update_type].insert(position, func)
+                self._handlers[update_type].insert(position, handler)
             else:
-                self._handlers[update_type].append(func)
-        self._handlers[update_type].sort(key=lambda x: (x.position is None, x.position))
+                self._handlers[update_type].append(handler)
+
+        self._update_handlers()
+
+    def reload_plugins(self):
+        """Reload all plugins, non-plugin handlers are not ``reloaded``
+        .. note::
+            This is for ``development purposes only`` and should not be used
+            in production environments
+        """
+
+        if self.is_reloading_plugins:
+            return
+
+        self.is_reloading_plugins = True
+        for handlers in self._handlers.values():
+            for handler in handlers.copy():
+                if handler.is_from_plugin:
+                    self.remove_handler(handler.func)
+
+        self._load_plugins(reload_plugins=True)
+        self.is_reloading_plugins = False
 
     def remove_handler(self, func: Callable) -> bool:
         r"""Remove an update handler
@@ -323,13 +414,17 @@ class Client(Decorators, Methods):
 
         if not isinstance(func, Callable):
             raise TypeError("func must be callable")
-        for _, handlers in self._handlers.items():
+
+        removed = False
+        for handlers in self._handlers.values():
             for handler in handlers.copy():
                 if handler.func == func:
                     handlers.remove(handler)
-                    handlers.sort(key=lambda x: (x.position is None, x.position))
-                    return True
-        return False
+                    removed = True
+
+        if removed:
+            self._update_handlers()
+        return removed
 
     async def invoke(
         self,
@@ -500,7 +595,7 @@ class Client(Decorators, Methods):
 
         self.__stop_client()
 
-        if not self.client_manager.start_clients_on_add:
+        if self.client_manager and not self.client_manager.start_clients_on_add:
             await self.client_manager.close()
 
         self.logger.info("Instance closed")
@@ -532,6 +627,9 @@ class Client(Decorators, Methods):
         else:
             self.client_manager.send(self.client_id, request)
 
+    def _check_rabbitmq(self):
+        assert self.is_rabbitmq, "This method is only available for TDLib Server"
+
     def _check_init_args(self):
         if self.user_bot:
             return
@@ -554,7 +652,13 @@ class Client(Decorators, Methods):
         if isinstance(self.workers, int) and self.workers < 1:
             raise ValueError("workers must be greater than 0")
 
-    def _load_plugins(self):
+    def _update_handlers(self):
+        self._current_handlers = {
+            k: tuple(sorted(v, key=lambda x: (x.position is None, x.position)))
+            for k, v in self._handlers.items()
+        }
+
+    def _load_plugins(self, reload_plugins: bool = False):
         count = 0
         handlers = 0
         plugin_paths = sorted(Path(self.plugins.folder).rglob("*.py"))
@@ -578,6 +682,8 @@ class Client(Decorators, Methods):
 
             try:
                 module = import_module(module_path)
+                if reload_plugins:
+                    reload_module(module)
             except Exception:
                 self.logger.exception(f"Failed to import plugin {module_path}")
                 continue
@@ -600,6 +706,7 @@ class Client(Decorators, Methods):
                         handler.filter,
                         handler.position,
                         handler.inner_object,
+                        True,
                     )
                     handlers += 1
                     plugin_handlers_count += 1
@@ -652,7 +759,7 @@ class Client(Decorators, Methods):
             if update_handler:
                 self.loop.create_task(update_handler(update))
 
-            if self.__is_queue_worker:
+            if not self.is_rabbitmq and self.__is_queue_worker:
                 self.queue.put_nowait(update)
             else:
                 await self._handle_update(update)
@@ -665,7 +772,7 @@ class Client(Decorators, Methods):
     async def __run_initializers(self, update):
         inner_object = self.get_inner_object(update)
 
-        for initializer in self._handlers["initializer"]:
+        for initializer in self._current_handlers["initializer"]:
             try:
                 handler_value = inner_object if initializer.inner_object else update
 
@@ -687,7 +794,7 @@ class Client(Decorators, Methods):
     async def __run_handlers(self, update):
         inner_object = self.get_inner_object(update)
 
-        for handler in self._handlers[update.getType()]:
+        for handler in self._current_handlers[update.getType()]:
             try:
                 handler_value = inner_object if handler.inner_object else update
 
@@ -708,7 +815,7 @@ class Client(Decorators, Methods):
     async def __run_finalizers(self, update):
         inner_object = self.get_inner_object(update)
 
-        for finalizer in self._handlers["finalizer"]:
+        for finalizer in self._current_handlers["finalizer"]:
             try:
                 handler_value = inner_object if finalizer.inner_object else update
 
@@ -728,10 +835,13 @@ class Client(Decorators, Methods):
                 self.logger.exception(f"Finalizer {finalizer} failed")
 
     async def _handle_update(self, update):
-        if update.getType() in self._handlers:
+        if update.getType() in self._current_handlers:
             if (
                 not self.user_bot
                 and isinstance(update, types.UpdateNewMessage)
+                and not isinstance(
+                    update.message.content, self.allow_outgoing_message_types
+                )
                 and update.message.is_outgoing
             ):
                 return
@@ -837,7 +947,9 @@ class Client(Decorators, Methods):
                 f"{str(self.me.id) if not self.me.usernames else '@' + self.me.usernames.editable_username}"
             )
 
-        if (
+        if self.authorization_state == "authorizationStateClosing":
+            self.__is_closing = True
+        elif (
             self.authorization_state == "authorizationStateClosed"
             and self.__is_closing is False
         ):
@@ -908,6 +1020,8 @@ class Client(Decorators, Methods):
         )
         self.__rchannel = await self.__rconnection.channel()
 
+        self.logger.info("Connected to TDLib server via RabbitMQ")
+
         updates_queue = await self.__get_updates_queue()
 
         notify_queue = await self.__rchannel.declare_queue(
@@ -921,7 +1035,7 @@ class Client(Decorators, Methods):
 
         self.__rqueues = {
             "updates": updates_queue,
-            "requests": await self.__rchannel.get_queue(self.my_id + "_requests"),
+            "requests": await self.__rchannel.get_queue(f"{self.my_id}_requests"),
             "notify": notify_queue,
             "responses": responses_queue,
         }
@@ -939,10 +1053,35 @@ class Client(Decorators, Methods):
             await self.process_update(obj_to_dict(update))
 
         if not self.no_updates:
-            await self.__rqueues["updates"].consume(self.__on_update, no_ack=True)
+            self.__rabbitmq_iterator_task = self.loop.create_task(
+                self.__rabbitmq_iterator()
+            )
 
         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 for message in iterator:
+                await self.queue.put(message)
+
+    async def __rabbitmq_worker(self):
+        while self.is_running:
+            message: aio_pika.IncomingMessage = await self.queue.get()
+
+            try:
+                update = json_loads(message.body)
+                if self.__is_closing and not isinstance(
+                    update, types.UpdateAuthorizationState
+                ):
+                    await message.nack(requeue=True)
+                    continue
+
+                await self.process_update(update)
+            except Exception:
+                self.logger.exception("Error processing message")
+
+            await message.ack()  # ack after processing
+
     async def __handle_rabbitmq_message(self, message: aio_pika.IncomingMessage):
         await self.process_update(json_loads(message.body))
 
@@ -979,6 +1118,9 @@ class Client(Decorators, Methods):
         self.is_authenticated = False
         self.is_running = False
 
+        if self.__rabbitmq_iterator_task:
+            self.__rabbitmq_iterator_task.cancel()
+
         if self.__is_queue_worker:
             for worker_task in self._workers_tasks:
                 worker_task.cancel()

{pytdbot-0.9.3 → pytdbot-0.9.5.dev0}/pytdbot/handlers/decorators.py

@@ -134,3 +134,48 @@ class Decorators(Updates):
             return func
 
         return decorator
+
+    def on_updateScheduledEvent(
+        self: "pytdbot.Client" = None,
+        filters: "pytdbot.filters.Filter" = None,
+        position: int = None,
+        inner_object: bool = False,
+    ) -> None:
+        r"""A scheduled event has been triggered
+
+        Parameters:
+            filters (:class:`~pytdbot.filters.Filter`, *optional*):
+                An update filter
+
+            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``
+
+        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(
+                        "updateScheduledEvent", func, filters, position, inner_object
+                    )
+                else:
+                    raise TypeError("Handler must be async")
+            elif isinstance(self, pytdbot.filters.Filter):
+                func._handler = Handler(
+                    func, "updateScheduledEvent", self, position, inner_object
+                )
+            else:
+                func._handler = Handler(
+                    func, "updateScheduledEvent", filters, position, inner_object
+                )
+
+            return func
+
+        return decorator

{pytdbot-0.9.3 → pytdbot-0.9.5.dev0}/pytdbot/handlers/handler.py

@@ -15,18 +15,20 @@ class Handler:
         filter: Filter = None,
         position: int = None,
         inner_object: bool = False,
+        is_from_plugin: bool = False,
     ) -> None:
         self.func = func
         self.update_type = update_type
         self.filter = filter
         self.position = position
         self.inner_object = inner_object
+        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})"
+        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})"
 
     def __repr__(self) -> str:
         return str(self)

{pytdbot-0.9.3 → pytdbot-0.9.5.dev0}/pytdbot/handlers/td_updates.py

@@ -1947,6 +1947,82 @@ class Updates:
 
         return decorator
 
+    def on_updateDirectMessagesChatTopic(
+        self: "pytdbot.Client" = None,
+        filters: "pytdbot.filters.Filter" = None,
+        position: int = None,
+    ) -> Callable:
+        r"""Basic information about a topic in a channel direct messages chat administered by the current user has changed\. This update is guaranteed to come before the topic identifier is returned to the application
+
+        Parameters:
+            filters (:class:`pytdbot.filters.Filter`, *optional*):
+                An update filter
+
+            position (``int``, *optional*):
+                The function position in handlers list. Default is ``None`` (append)
+
+        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(
+                        "updateDirectMessagesChatTopic", func, filters, position
+                    )
+                else:
+                    raise TypeError("Handler must be async")
+            elif isinstance(self, pytdbot.filters.Filter):
+                func._handler = Handler(
+                    func, "updateDirectMessagesChatTopic", self, position
+                )
+            else:
+                func._handler = Handler(
+                    func, "updateDirectMessagesChatTopic", filters, position
+                )
+            return func
+
+        return decorator
+
+    def on_updateTopicMessageCount(
+        self: "pytdbot.Client" = None,
+        filters: "pytdbot.filters.Filter" = None,
+        position: int = None,
+    ) -> Callable:
+        r"""Number of messages in a topic has changed; for Saved Messages and channel direct messages chat topics only
+
+        Parameters:
+            filters (:class:`pytdbot.filters.Filter`, *optional*):
+                An update filter
+
+            position (``int``, *optional*):
+                The function position in handlers list. Default is ``None`` (append)
+
+        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("updateTopicMessageCount", func, filters, position)
+                else:
+                    raise TypeError("Handler must be async")
+            elif isinstance(self, pytdbot.filters.Filter):
+                func._handler = Handler(func, "updateTopicMessageCount", self, position)
+            else:
+                func._handler = Handler(
+                    func, "updateTopicMessageCount", filters, position
+                )
+            return func
+
+        return decorator
+
     def on_updateQuickReplyShortcut(
         self: "pytdbot.Client" = None,
         filters: "pytdbot.filters.Filter" = None,