Pytdbot 0.9.4__tar.gz → 0.9.5.dev0__tar.gz

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

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

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

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

{pytdbot-0.9.4 → 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.4 → pytdbot-0.9.5.dev0}/pytdbot/__init__.py

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

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

@@ -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__(
@@ -183,6 +186,7 @@ class Client(Decorators, Methods):
         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 = {
@@ -226,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(
@@ -245,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
@@ -535,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")
@@ -567,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
@@ -696,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)
@@ -884,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
         ):
@@ -955,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(
@@ -968,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,
         }
@@ -986,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))
 
@@ -1026,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.4 → 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.4 → pytdbot-0.9.5.dev0}/pytdbot/types/__init__.py

@@ -1,6 +1,9 @@
 __all__ = [
     "TlObject",
     "Plugins",
+    "ServerStats",
+    "ScheduledEvent",
+    "UpdateScheduledEvent",
     "AuthenticationCodeType",
     "EmailAddressAuthentication",
     "EmailAddressResetState",
@@ -3901,5 +3904,6 @@ from .td_types import (
     Updates,
 )
 from .plugins import Plugins
+from .tdserver import ServerStats, ScheduledEvent, UpdateScheduledEvent
 
 TDLIB_VERSION = "1.8.50"

pytdbot-0.9.5.dev0/pytdbot/types/tdserver/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ("ServerStats", "ScheduledEvent", "UpdateScheduledEvent")
+from .schedule import ScheduledEvent, UpdateScheduledEvent
+from .stats import ServerStats

pytdbot-0.9.5.dev0/pytdbot/types/tdserver/schedule.py

@@ -0,0 +1,96 @@
+import pytdbot
+from typing import Literal, Union
+
+
+class ScheduledEvent:
+    r"""Describes a scheduled event
+
+    Parameters:
+        event_id (:class:`str`):
+            Unique identifier of the scheduled event
+
+        send_at (:class:`int`):
+            Point in time \(Unix timestamp\) when the scheduled event will be sent
+    """
+
+    def __init__(
+        self,
+        event_id: str = "",
+        send_at: int = 0,
+    ) -> None:
+        self.event_id = event_id
+        r"""Unique identifier of the scheduled event"""
+        self.send_at = send_at
+        r"""Point in time \(Unix timestamp\) when the scheduled event will be sent"""
+
+    def __str__(self):
+        return str(pytdbot.utils.obj_to_json(self, indent=4))
+
+    def getType(self) -> Literal["scheduledEvent"]:
+        return "scheduledEvent"
+
+    def getClass(self) -> Literal["ScheduledEvent"]:
+        return "ScheduledEvent"
+
+    def to_dict(self) -> dict:
+        return {
+            "@type": self.getType(),
+            "event_id": self.event_id,
+            "send_at": self.send_at,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Union["ScheduledEvent", None]:
+        if data:
+            data_class = cls()
+            data_class.event_id = data.get("event_id", None)
+            data_class.send_at = data.get("send_at", None)
+
+        return data_class
+
+
+class UpdateScheduledEvent:
+    r"""A scheduled event
+
+    Parameters:
+        event_id (:class:`str`):
+            Unique identifier of the scheduled event
+
+        data (:class:`dict`):
+            Event data
+    """
+
+    def __init__(
+        self,
+        event_id: str = "",
+        data: dict = None,
+    ) -> None:
+        self.event_id = event_id
+        r"""Unique identifier of the scheduled event"""
+        self.data = data
+        r"""Event data"""
+
+    def __str__(self):
+        return str(pytdbot.utils.obj_to_json(self, indent=4))
+
+    def getType(self) -> Literal["updateScheduledEvent"]:
+        return "updateScheduledEvent"
+
+    def getClass(self) -> Literal["UpdateScheduledEvent"]:
+        return "UpdateScheduledEvent"
+
+    def to_dict(self) -> dict:
+        return {
+            "@type": self.getType(),
+            "event_id": self.event_id,
+            "data": self.data,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Union["UpdateScheduledEvent", None]:
+        if data:
+            data_class = cls()
+            data_class.event_id = data.get("event_id", None)
+            data_class.data = data.get("data", None)
+
+        return data_class

pytdbot-0.9.5.dev0/pytdbot/types/tdserver/stats.py

@@ -0,0 +1,65 @@
+import pytdbot
+from typing import Literal, Union
+
+
+class ServerStats:
+    r"""Describes TDLib Server stats
+
+    Parameters:
+        my_id (:class:`int`):
+            Identifier of the current user
+
+        uptime (:class:`int`):
+            Server uptime in seconds
+
+        updates_count (:class:`int`):
+            Total number of received updates
+
+        requests_count (:class:`int`):
+            Total number of sent requests
+    """
+
+    def __init__(
+        self,
+        my_id: int = 0,
+        uptime: int = 0,
+        updates_count: int = 0,
+        requests_count: int = 0,
+    ) -> None:
+        self.my_id = my_id
+        r"""Identifier of the current user"""
+        self.uptime = uptime
+        r"""Server uptime in seconds"""
+        self.updates_count = updates_count
+        r"""Total number of received updates"""
+        self.requests_count = requests_count
+        r"""Total number of sent requests"""
+
+    def __str__(self):
+        return str(pytdbot.utils.obj_to_json(self, indent=4))
+
+    def getType(self) -> Literal["serverStats"]:
+        return "serverStats"
+
+    def getClass(self) -> Literal["ServerStats"]:
+        return "ServerStats"
+
+    def to_dict(self) -> dict:
+        return {
+            "@type": self.getType(),
+            "my_id": self.my_id,
+            "uptime": self.uptime,
+            "updates_count": self.updates_count,
+            "requests_count": self.requests_count,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> Union["ServerStats", None]:
+        if data:
+            data_class = cls()
+            data_class.my_id = data.get("my_id", None)
+            data_class.uptime = data.get("uptime", None)
+            data_class.updates_count = data.get("updates_count", None)
+            data_class.requests_count = data.get("requests_count", None)
+
+        return data_class

{pytdbot-0.9.4 → pytdbot-0.9.5.dev0}/pytdbot/utils/__init__.py

@@ -26,6 +26,8 @@ __all__ = [
     "pre",
     "pre_code",
     "quote",
+    "rtl",
+    "ltr",
 ]
 
 from .asyncio_utils import get_running_loop
@@ -52,4 +54,6 @@ from .text_format import (
     pre,
     pre_code,
     quote,
+    rtl,
+    ltr,
 )

{pytdbot-0.9.4 → pytdbot-0.9.5.dev0}/pytdbot/utils/text_format.py

@@ -15,7 +15,7 @@ def bold(text: str, html: bool = True, escape: bool = True) -> str:
             Whether escape special characters to the given text or not. Default is ``True``
 
     Returns:
-        py:class:`str`: The formated text
+        :py:class:`str`: The formated text
     """
 
     if html:
@@ -38,7 +38,7 @@ def italic(text: str, html: bool = True, escape: bool = True) -> str:
             Whether escape special characters to the given text or not. Default is ``True``
 
     Returns:
-        py:class:`str`: The formated text
+        :py:class:`str`: The formated text
     """
 
     if html:
@@ -61,7 +61,7 @@ def underline(text: str, html: bool = True, escape: bool = True) -> str:
             Whether escape special characters to the given text or not. Default is ``True``
 
     Returns:
-        py:class:`str`: The formated text
+        :py:class:`str`: The formated text
     """
 
     if html:
@@ -84,7 +84,7 @@ def strikethrough(text: str, html: bool = True, escape: bool = True) -> str:
             Whether escape special characters to the given text or not. Default is ``True``
 
     Returns:
-        py:class:`str`: The formated text
+        :py:class:`str`: The formated text
     """
 
     if html:
@@ -107,7 +107,7 @@ def spoiler(text: str, html: bool = True, escape: bool = True) -> str:
             Whether escape special characters to the given text or not. Default is ``True``
 
     Returns:
-        py:class:`str`: The formated text
+        :py:class:`str`: The formated text
     """
 
     if html:
@@ -133,7 +133,7 @@ def hyperlink(text: str, url: str, html: bool = True, escape: bool = True) -> st
             Whether escape special characters to the given text or not. Default is ``True``
 
     Returns:
-        py:class:`str`: The formated text
+        :py:class:`str`: The formated text
     """
 
     assert isinstance(url, str), "url must be str"
@@ -163,7 +163,7 @@ def mention(text: str, user_id: str, html: bool = True, escape: bool = True) ->
             Whether escape special characters to the given text or not. Default is ``True``
 
     Returns:
-        py:class:`str`: The formated text
+        :py:class:`str`: The formated text
     """
 
     if html:
@@ -186,7 +186,7 @@ def custom_emoji(emoji: str, custom_emoji_id: int, html: bool = True) -> str:
             If ``True``, returns HTML format, if ``False`` returns MarkdownV2. Default is ``True``
 
     Returns:
-        py:class:`str`: The formated text
+        :py:class:`str`: The formated text
     """
 
     if html:
@@ -209,7 +209,7 @@ def code(text: str, html: bool = True, escape: bool = True) -> str:
             Whether escape special characters to the given text or not. Default is ``True``
 
     Returns:
-        py:class:`str`: The formated text
+        :py:class:`str`: The formated text
     """
 
     if html:
@@ -232,7 +232,7 @@ def pre(text: str, html: bool = True, escape: bool = True) -> str:
             Whether escape special characters to the given text or not. Default is ``True``
 
     Returns:
-        py:class:`str`: The formated text
+        :py:class:`str`: The formated text
     """
 
     if html:
@@ -258,7 +258,7 @@ def pre_code(text: str, language: str, html: bool = True, escape: bool = True) -
             Whether escape special characters to the given text or not. Default is ``True``
 
     Returns:
-        py:class:`str`: The formated text
+        :py:class:`str`: The formated text
     """
 
     assert isinstance(language, str), "text must be str"
@@ -288,10 +288,42 @@ def quote(text: str, expandable: bool = False, html: bool = True, escape: bool =
             Whether escape special characters to the given text or not. Default is ``True``
 
     Returns:
-        py:class:`str`: The formated text
+        :py:class:`str`: The formated text
     """
 
     if html:
         return f"<blockquote{' expandable' if expandable else ''}>{text if escape is False else escape_html(str(text))}</blockquote>"
 
     return f"{'**' if expandable else ''}>{text if escape is False else escape_markdown(str(text))}"
+
+
+rtl_mark = "\u200f"
+ltr_mark = "\u200e"
+
+
+def rtl(text: str) -> str:
+    r"""Add RTL (Right-to-Left) mark to the given text
+
+    Parameters:
+        text (``str``):
+            The text to convert
+
+    Returns:
+        :py:class:`str`: The formated text
+    """
+
+    return f"{rtl_mark}{text}"
+
+
+def ltr(text: str) -> str:
+    r"""Add LTR (Left-to-Right) mark to the given text
+
+    Parameters:
+        text (``str``):
+            The text to convert
+
+    Returns:
+        :py:class:`str`: The formated text
+    """
+
+    return f"{ltr_mark}{text}"