Pytdbot 0.9.1__tar.gz → 0.9.2__tar.gz

{pytdbot-0.9.1 → pytdbot-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: Pytdbot
-Version: 0.9.1
+Version: 0.9.2
 Summary: Easy-to-use asynchronous TDLib wrapper for Python.
 Home-page: https://github.com/pytdbot/client
 Author: AYMEN Mohammed
@@ -23,13 +23,14 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: provides-extra
 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.46-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)
+# 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.47-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.1 → pytdbot-0.9.2}/Pytdbot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: Pytdbot
-Version: 0.9.1
+Version: 0.9.2
 Summary: Easy-to-use asynchronous TDLib wrapper for Python.
 Home-page: https://github.com/pytdbot/client
 Author: AYMEN Mohammed
@@ -23,13 +23,14 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: provides-extra
 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.46-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)
+# 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.47-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.1 → pytdbot-0.9.2}/Pytdbot.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ Pytdbot.egg-info/requires.txt
 Pytdbot.egg-info/top_level.txt
 pytdbot/__init__.py
 pytdbot/client.py
+pytdbot/client_manager.py
 pytdbot/filters.py
 pytdbot/exception/__init__.py
 pytdbot/handlers/__init__.py
@@ -31,6 +32,7 @@ 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/utils/__init__.py
+pytdbot/utils/asyncio_utils.py
 pytdbot/utils/escape.py
 pytdbot/utils/json_utils.py
 pytdbot/utils/obj_encoder.py

{pytdbot-0.9.1 → pytdbot-0.9.2}/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.46-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)
+# 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.47-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.1 → pytdbot-0.9.2}/pytdbot/__init__.py

@@ -1,10 +1,19 @@
 from . import types, utils, filters, exception
 from .tdjson import TdJson
+from .client_manager import ClientManager
 from .client import Client
 
-__all__ = ["types", "utils", "filters", "exception", "TdJson", "Client"]
+__all__ = [
+    "types",
+    "utils",
+    "filters",
+    "exception",
+    "TdJson",
+    "ClientManager",
+    "Client",
+]
 
-__version__ = "0.9.1"
+__version__ = "0.9.2"
 __copyright__ = "Copyright (c) 2022-2025 Pytdbot, AYMENJD"
 __license__ = "MIT License"
 

{pytdbot-0.9.1 → pytdbot-0.9.2}/pytdbot/client.py

@@ -1,45 +1,37 @@
-import signal
-import pytdbot
 import asyncio
-import aio_pika
-
-from platform import python_implementation, python_version
+import signal
+from importlib import import_module
+from json import dumps
+from logging import DEBUG, getLogger
 from os.path import join as join_path
 from pathlib import Path
-from importlib import import_module
-
-from typing import Callable, Union, Dict
-from logging import getLogger, DEBUG
+from platform import python_implementation, python_version
+from threading import current_thread, main_thread
+from typing import Callable, Dict, Union
 
+import aio_pika
 from deepdiff import DeepDiff
-from concurrent.futures import ThreadPoolExecutor
-from threading import current_thread, main_thread
-from json import dumps
 
-from .tdjson import TdJson
-from .handlers import Decorators, Handler
-from .methods import Methods
-from .types import Plugins, LogStream
+import pytdbot
+
 from . import types
+from .client_manager import ClientManager
+from .exception import AuthorizationError, StopHandlers
 from .filters import Filter
-from .exception import StopHandlers, AuthorizationError
+from .handlers import Decorators, Handler
+from .methods import Methods
+from .types import LogStream, Plugins
 from .utils import (
     create_extra_id,
-    json_loads,
-    json_dumps,
+    dict_to_obj,
     get_bot_id_from_token,
+    get_running_loop,
+    json_dumps,
+    json_loads,
     obj_to_dict,
-    dict_to_obj,
 )
 
 
-def get_running_loop():
-    try:
-        return asyncio.get_running_loop()
-    except RuntimeError:
-        return asyncio.new_event_loop()
-
-
 class Client(Decorators, Methods):
     r"""Pytdbot, a TDLib client
 
@@ -136,6 +128,7 @@ class Client(Decorators, Methods):
         no_updates: bool = False,
         td_verbosity: int = 2,
         td_log: LogStream = None,
+        user_bot: bool = False,
     ) -> None:
         self.__api_id = api_id
         self.__api_hash = api_hash
@@ -164,9 +157,17 @@ class Client(Decorators, Methods):
         self.workers = workers
         self.no_updates = no_updates
         self.queue = asyncio.Queue()
-        self.my_id = get_bot_id_from_token(self.__token)
+        self.user_bot = user_bot
+        self.my_id = (
+            get_bot_id_from_token(self.__token)
+            if isinstance(self.__token, str)
+            else None
+        )
+        self.client_id = None
+        self.client_manager = None
         self.logger = getLogger(f"{__name__}:{self.my_id or 0}")
         self.td_verbosity = td_verbosity
+        self.td_log = td_log
         self.connection_state: str = None
         self.is_running = None
         self.me: types.User = None
@@ -178,8 +179,6 @@ class Client(Decorators, Methods):
 
         self._handlers = {"initializer": [], "finalizer": []}
         self._results: Dict[str, asyncio.Future] = {}
-        self._tdjson = None if self.is_rabbitmq else TdJson(lib_path, td_verbosity)
-        self.__listen_loop_task = None
         self._workers_tasks = None
         self.__authorization_state = None
         self.__cache = {"is_coro_filter": {}}
@@ -191,9 +190,14 @@ class Client(Decorators, Methods):
             "updateOption": self.__handle_update_option,
             "updateUser": self.__handle_update_user,
         }
-        self.__login = False
+        self.__is_queue_worker = False
         self.__is_closing = False
 
+        # RabbitMQ
+        self.__rqueues = None
+        self.__rconnection = None
+        self.__rchannel = None
+
         self.loop = (
             loop if isinstance(loop, asyncio.AbstractEventLoop) else get_running_loop()
         )
@@ -201,16 +205,10 @@ class Client(Decorators, Methods):
         if plugins is not None:
             self._load_plugins()
 
-        if isinstance(td_log, LogStream) and not self.is_rabbitmq:
-            self._tdjson.execute(
-                {"@type": "setLogStream", "log_stream": obj_to_dict(td_log)}
-            )
-
         self.logger.info(f"Pytdbot v{pytdbot.VERSION}")
 
     async def __aenter__(self):
         await self.start()
-        await self.login()
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
@@ -225,21 +223,27 @@ class Client(Decorators, Methods):
 
         return self.__authorization_state
 
-    async def start(self, login: bool = True) -> None:
-        r"""Start pytdbot client
-
-        Parameters:
-            login (``bool``, *optional*):
-                Login after start. Default is ``True``
-        """
+    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:
+                self.client_manager = ClientManager(
+                    self, self.lib_path, self.td_verbosity, loop=self.loop
+                )
+                await self.client_manager.start()
+
+            if isinstance(self.td_log, LogStream) and not self.is_rabbitmq:
+                await self.__send(
+                    {"@type": "setLogStream", "log_stream": obj_to_dict(self.td_log)}
+                )
+
             if isinstance(self.workers, int):
                 self._workers_tasks = [
                     self.loop.create_task(self._queue_update_worker())
-                    for x in range(self.workers)
+                    for _ in range(self.workers)
                 ]
                 self.__is_queue_worker = True
 
@@ -249,45 +253,13 @@ class Client(Decorators, Methods):
                 self.logger.info("Started with unlimited updates processes")
 
             if self.is_rabbitmq:
-                await self.__startRabbitMQ()
-            else:
-                self.__listen_loop_task = self.loop.create_task(self.__listen_loop())
-
-        if login:
-            await self.login()
-
-    async def login(self) -> None:
-        r"""Login to Telegram."""
-
-        if not self.__token or (self.is_authenticated or self.is_rabbitmq):
-            return
-
-        self.__login = True
-
-        await self.getOption("version")  # Ping TDLib to start authorization process
-
-        while self.authorization_state != "authorizationStateReady":
-            await asyncio.sleep(0.1)
-            if self.authorization_state == "authorizationStateClosed":
-                return
-
-        if not self.is_running:
-            return
-
-        self.me = await self.getMe()
-        if isinstance(self.me, types.Error):
-            self.logger.error(f"Get me error: {self.me.message}")
-
-        self.is_authenticated = True
+                await self.__start_rabbitmq()
+            else:  # client_manager
+                self.is_running = True
 
-        self.logger.info(
-            "Logged in as {} {}".format(
-                self.me.first_name,
-                str(self.me.id)
-                if not self.me.usernames
-                else "@" + self.me.usernames.editable_username,
-            )
-        )
+        self.loop.create_task(
+            self.getOption("version")
+        )  # Ping TDLib to start processing updates
 
     def add_handler(
         self,
@@ -351,13 +323,11 @@ class Client(Decorators, Methods):
 
         if not isinstance(func, Callable):
             raise TypeError("func must be callable")
-        for update_type in self._handlers:
-            for handler in self._handlers[update_type]:
+        for _, handlers in self._handlers.items():
+            for handler in handlers.copy():
                 if handler.func == func:
-                    self._handlers[update_type].remove(handler)
-                    self._handlers[update_type].sort(
-                        key=lambda x: (x.position is None, x.position)
-                    )
+                    handlers.remove(handler)
+                    handlers.sort(key=lambda x: (x.position is None, x.position))
                     return True
         return False
 
@@ -466,7 +436,7 @@ class Client(Decorators, Methods):
 
         return await self.invoke(kwargs)
 
-    def run(self, login: bool = True) -> None:
+    def run(self) -> None:
         r"""Start the client and block until the client is stopped
 
         Example:
@@ -481,15 +451,11 @@ class Client(Decorators, Methods):
                     await update.reply_text('Hello!')
 
                 client.run()
-
-        Parameters:
-            login (``bool``, *optional*):
-                Login after start. Default is ``True``
         """
 
         self._register_signal_handlers()
 
-        self.loop.run_until_complete(self.start(login))
+        self.loop.run_until_complete(self.start())
         self.loop.run_until_complete(self.idle())
 
     async def idle(self):
@@ -534,6 +500,9 @@ class Client(Decorators, Methods):
 
         self.__stop_client()
 
+        if not self.client_manager.start_clients_on_add:
+            await self.client_manager.close()
+
         self.logger.info("Instance closed")
 
         return True
@@ -552,11 +521,7 @@ class Client(Decorators, Methods):
         return result
 
     async def __send(self, request: dict) -> None:
-        if not self.is_rabbitmq:
-            self._tdjson.send(
-                request
-            )  # tdjson.send is non-blocking method, So we don't need run_in_executor. This improves performance
-        else:
+        if self.is_rabbitmq:
             await self.__rchannel.default_exchange.publish(
                 aio_pika.Message(
                     json_dumps(request, encode=True),
@@ -564,8 +529,13 @@ class Client(Decorators, Methods):
                 ),
                 routing_key=self.__rqueues["requests"].name,
             )
+        else:
+            self.client_manager.send(self.client_id, request)
 
     def _check_init_args(self):
+        if self.user_bot:
+            return
+
         if not self.is_rabbitmq:
             if not isinstance(self.__api_id, int):
                 raise TypeError("api_id must be an int")
@@ -657,31 +627,7 @@ class Client(Decorators, Methods):
             self.__cache["is_coro_filter"][func] = is_coro
             return is_coro
 
-    async def __listen_loop(self):
-        if self.is_rabbitmq:
-            return
-
-        with ThreadPoolExecutor(1, "pytdbot_listener") as thread:
-            try:
-                self.is_running = True
-                self.logger.info("Listening to updates...")
-
-                while self.is_running:
-                    update = await self.loop.run_in_executor(
-                        thread,
-                        self._tdjson.receive,
-                        1.0,  # Seconds
-                    )
-                    if update is None:
-                        continue
-                    self.loop.create_task(self._process_update(update))
-
-            except Exception:
-                self.logger.exception("Exception in __listen_loop")
-            finally:
-                self.is_running = False
-
-    async def _process_update(self, update):
+    async def process_update(self, update):
         if not update:
             self.logger.warning("Received None update")
             return
@@ -784,7 +730,8 @@ class Client(Decorators, Methods):
     async def _handle_update(self, update):
         if update.getType() in self._handlers:
             if (
-                isinstance(update, types.UpdateNewMessage)
+                not self.user_bot
+                and isinstance(update, types.UpdateNewMessage)
                 and update.message.is_outgoing
             ):
                 return
@@ -872,13 +819,23 @@ class Client(Decorators, Methods):
             f"Authorization state changed to {self.authorization_state.removeprefix('authorizationState')}"
         )
 
-        if self.__login:
-            if self.authorization_state == "authorizationStateWaitTdlibParameters":
-                await self._set_options()
-                await self.set_td_parameters()
-            elif self.authorization_state == "authorizationStateWaitPhoneNumber":
-                self._print_welcome()
-                await self.__handle_authorization_state_wait_phone_number()
+        if self.authorization_state == "authorizationStateWaitTdlibParameters":
+            await self._set_options()
+            await self.set_td_parameters()
+        elif self.authorization_state == "authorizationStateWaitPhoneNumber":
+            self._print_welcome()
+            await self.__handle_authorization_state_wait_phone_number()
+        elif self.authorization_state == "authorizationStateReady":
+            self.is_authenticated = True
+
+            self.me = await self.getMe()
+            if isinstance(self.me, types.Error):
+                self.logger.error(f"Get me error: {self.me.message}")
+
+            self.logger.info(
+                f"Logged in as {self.me.first_name} "
+                f"{str(self.me.id) if not self.me.usernames else '@' + self.me.usernames.editable_username}"
+            )
 
         if (
             self.authorization_state == "authorizationStateClosed"
@@ -942,7 +899,7 @@ class Client(Decorators, Methods):
             f"Could not connect to TDLib Server after {delay * retries} seconds timeout"
         )
 
-    async def __startRabbitMQ(self):
+    async def __start_rabbitmq(self):
         self.__rconnection = await aio_pika.connect_robust(
             self.__rabbitmq_url,
             client_properties={
@@ -979,19 +936,7 @@ class Client(Decorators, Methods):
         for update in res.updates:
             # when using obj_to_dict the key "@client_id" won't exists
             # since it's not part of the object
-            await self._process_update(obj_to_dict(update))
-
-        self.me = await self.getMe()
-        self.is_authenticated = True
-
-        self.logger.info(
-            "Logged in as {} {}".format(
-                self.me.first_name,
-                str(self.me.id)
-                if not self.me.usernames
-                else "@" + self.me.usernames.editable_username,
-            )
-        )
+            await self.process_update(obj_to_dict(update))
 
         if not self.no_updates:
             await self.__rqueues["updates"].consume(self.__on_update, no_ack=True)
@@ -999,20 +944,16 @@ class Client(Decorators, Methods):
         await self.__rqueues["notify"].consume(self.__on_update, no_ack=True)
 
     async def __handle_rabbitmq_message(self, message: aio_pika.IncomingMessage):
-        await self._process_update(json_loads(message.body))
+        await self.process_update(json_loads(message.body))
 
     async def __on_update(self, update):
         self.loop.create_task(self.__handle_rabbitmq_message(update))
 
     async def __handle_update_user(self, update: types.UpdateUser):
-        if self.is_authenticated and update.user.id == self.me.id:
+        if self.is_authenticated and self.me and update.user.id == self.me.id:
             self.logger.info(
-                "Updating {} ({}) info".format(
-                    self.me.first_name,
-                    str(self.me.id)
-                    if not self.me.usernames
-                    else "@" + self.me.usernames.editable_username,
-                )
+                f"Updating {self.me.first_name} "
+                f"({str(self.me.id) if not self.me.usernames else '@' + self.me.usernames.editable_username}) info"
             )
 
             try:
@@ -1042,28 +983,25 @@ class Client(Decorators, Methods):
             for worker_task in self._workers_tasks:
                 worker_task.cancel()
 
-        if self.__listen_loop_task:
-            self.__listen_loop_task.cancel()
-
     def _register_signal_handlers(self):
         def _handle_signal():
             self.loop.create_task(self.stop())
-            for sig in {
+            for sig in (
                 signal.SIGINT,
                 signal.SIGTERM,
                 signal.SIGABRT,
                 signal.SIGSEGV,
-            }:
+            ):
                 self.loop.remove_signal_handler(sig)
 
         if current_thread() is main_thread():
             try:
-                for sig in {
+                for sig in (
                     signal.SIGINT,
                     signal.SIGTERM,
                     signal.SIGABRT,
                     signal.SIGSEGV,
-                }:
+                ):
                     self.loop.add_signal_handler(sig, _handle_signal)
             except NotImplementedError:  # Windows dosen't support add_signal_handler
                 pass
@@ -1082,12 +1020,12 @@ def deepdiff(self, d1, d2):
 
     deep = DeepDiff(d1, d2, ignore_order=True, view="tree")
 
-    for parent in deep.keys():
-        for diff in deep[parent]:
+    for parent, diffs in deep.items():
+        for diff in diffs:
             difflist = diff.path(output_format="list")
-            key = ".".join(str(v) for v in difflist)
+            key = ".".join(map(str, difflist))
 
-            if parent in {"dictionary_item_added", "values_changed"}:
+            if parent in ("dictionary_item_added", "values_changed"):
                 self.logger.info(f"{key} changed to {diff.t2}")
             elif parent == "dictionary_item_removed":
                 self.logger.info(f"{key} removed")