Pytdbot 0.8.4.dev2__tar.gz → 0.8.4.dev3__tar.gz

{Pytdbot-0.8.4.dev2 → Pytdbot-0.8.4.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Pytdbot
-Version: 0.8.4.dev2
+Version: 0.8.4.dev3
 Summary: Easy-to-use asynchronous TDLib wrapper for Python.
 Home-page: https://github.com/pytdbot/client
 Author: AYMEN Mohammed
@@ -36,10 +36,11 @@ Pytdbot (Python TDLib) is an asynchronous [**TDLib**](https://github.com/tdlib/t
 ### Installation
 > For better performance, it's recommended to install [orjson](https://github.com/ijl/orjson#install) or [ujson](https://github.com/ultrajson/ultrajson#ultrajson).
 
+You can install Pytdbot using pip:
 ```bash
 pip install pytdbot
 ```
-From github (dev version)
+To install the development version from Github, use the following command:
 ```bash
 pip install git+https://github.com/pytdbot/client.git
 ```

{Pytdbot-0.8.4.dev2 → Pytdbot-0.8.4.dev3}/Pytdbot.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: Pytdbot
-Version: 0.8.4.dev2
+Version: 0.8.4.dev3
 Summary: Easy-to-use asynchronous TDLib wrapper for Python.
 Home-page: https://github.com/pytdbot/client
 Author: AYMEN Mohammed
@@ -36,10 +36,11 @@ Pytdbot (Python TDLib) is an asynchronous [**TDLib**](https://github.com/tdlib/t
 ### Installation
 > For better performance, it's recommended to install [orjson](https://github.com/ijl/orjson#install) or [ujson](https://github.com/ultrajson/ultrajson#ultrajson).
 
+You can install Pytdbot using pip:
 ```bash
 pip install pytdbot
 ```
-From github (dev version)
+To install the development version from Github, use the following command:
 ```bash
 pip install git+https://github.com/pytdbot/client.git
 ```

{Pytdbot-0.8.4.dev2 → Pytdbot-0.8.4.dev3}/README.md

@@ -20,10 +20,11 @@ Pytdbot (Python TDLib) is an asynchronous [**TDLib**](https://github.com/tdlib/t
 ### Installation
 > For better performance, it's recommended to install [orjson](https://github.com/ijl/orjson#install) or [ujson](https://github.com/ultrajson/ultrajson#ultrajson).
 
+You can install Pytdbot using pip:
 ```bash
 pip install pytdbot
 ```
-From github (dev version)
+To install the development version from Github, use the following command:
 ```bash
 pip install git+https://github.com/pytdbot/client.git
 ```

{Pytdbot-0.8.4.dev2 → Pytdbot-0.8.4.dev3}/pytdbot/__init__.py

@@ -2,7 +2,7 @@ from . import types, utils, filters, exception
 from .tdjson import TdJson
 from .client import Client
 
-__version__ = "0.8.4dev2"
+__version__ = "0.8.4dev3"
 __copyright__ = "Copyright (c) 2022-2023 AYMEN Mohammed ~ https://github.com/AYMENJD"
 __license__ = "MIT License"
 

{Pytdbot-0.8.4.dev2 → Pytdbot-0.8.4.dev3}/pytdbot/client.py

@@ -12,8 +12,7 @@ from typing import Callable, Union
 from logging import getLogger, DEBUG
 from base64 import b64encode
 from deepdiff import DeepDiff
-from concurrent.futures import ThreadPoolExecutor
-from threading import current_thread, main_thread
+from threading import current_thread, main_thread, Thread
 from json import dumps
 
 from .tdjson import TdJson
@@ -94,7 +93,7 @@ class Client(Decorators, Methods):
             If any request is rate limited (flood waited) the client will repeat the request after sleeping the required amount of seconds returned by the error. If the ``retry after`` value is higher than ``sleep_threshold`` the error is returned. Defaults to ``None`` (Disabled)
 
         workers (``int``, *optional*):
-            Number of workers for handling updates. Defaults to ``5``
+            Number of workers to handle updates. Defaults to ``5``. If set to ``None``, updates will be immediately handled instead of being queued, which can impact performance.
 
         td_verbosity (``int``, *optional*):
             Verbosity level of TDLib. Defaults to ``2``
@@ -140,7 +139,7 @@ class Client(Decorators, Methods):
         self.default_parse_mode = (
             default_parse_mode
             if isinstance(default_parse_mode, str)
-            and default_parse_mode in ["markdown", "markdownv2", "html"]
+            and default_parse_mode in ("markdown", "markdownv2", "html")
             else None
         )
         self.system_language_code = system_language_code
@@ -169,9 +168,9 @@ class Client(Decorators, Methods):
         self._handlers = {"initializer": [], "finalizer": []}
         self._results = {}
         self._tdjson = TdJson(lib_path, td_verbosity)
-        self._executor = ThreadPoolExecutor(5, "Pytdbot")
-        self._workers_tasks = None
         self._retry_after_prefex = "Too Many Requests: retry after "
+        self._workers_tasks = None
+        self.__listen_loop_thread = Thread(target=self.__listen_loop, daemon=True)
         self.__authorization_state = None
         self.__authorization = None
         self.__cache = {"is_coro_filter": {}}
@@ -218,14 +217,19 @@ class Client(Decorators, Methods):
         if not self.is_running:
             logger.info("Starting pytdbot client...")
 
-            self._workers_tasks = [
-                self.loop.create_task(self._update_worker(x + 1))
-                for x in range(self.workers)
-            ]
+            if isinstance(self.workers, int):
+                self._workers_tasks = [
+                    self.loop.create_task(self._queue_update_worker())
+                    for x in range(self.workers)
+                ]
+                self.__is_queue_worker = True
 
-            logger.info("Started with %s workers", self.workers)
+                logger.info("Started with %s workers", self.workers)
+            else:
+                self.__is_queue_worker = False
+                logger.info("Started with unlimited updates processes")
 
-            self.loop.create_task(self.__listen_loop())
+            self.__listen_loop_thread.start()
 
         if login:
             await self.login()
@@ -238,7 +242,7 @@ class Client(Decorators, Methods):
 
         self.__login = True
 
-        await self.getOption("version")  # Ping TDLib to start authorization proccess
+        await self.getOption("version")  # Ping TDLib to start authorization process
 
         while self.authorization_state != "authorizationStateReady":
             await asyncio.sleep(0.1)
@@ -503,12 +507,7 @@ class Client(Decorators, Methods):
     def __send(self, request: dict) -> None:
         return self._tdjson.send(
             request
-        )  # tdjson.send is asynchronous, So we don't need run_in_executor. This improves performance
-
-    async def __receive(self, timeout: float = 2.0) -> dict:
-        return await self.loop.run_in_executor(
-            self._executor, self._tdjson.receive, timeout
-        )
+        )  # tdjson.send is non-blocking method, So we don't need run_in_executor. This improves performance
 
     def _check_init_args(self):
         if not isinstance(self.__api_id, int):
@@ -523,14 +522,12 @@ class Client(Decorators, Methods):
             raise TypeError("files_directory must be str")
         elif not isinstance(self.td_verbosity, int):
             raise TypeError("td_verbosity must be int")
-        elif not isinstance(self.workers, int):
-            raise TypeError("workers must be int")
         elif type(Update) is not type(self.update_class):
             raise TypeError(
                 "update_class must be instance of class pytdbot.types.Update"
             )
 
-        if self.workers < 1:
+        if isinstance(self.workers, int) and self.workers < 1:
             raise ValueError("workers must be greater than 0")
 
     def get_retry_after_time(self, error_message: str) -> int:
@@ -589,13 +586,13 @@ class Client(Decorators, Methods):
             self.__cache["is_coro_filter"][func] = is_coro
             return is_coro
 
-    async def __listen_loop(self):
+    def __listen_loop(self):
         try:
             self.is_running = True
             logger.info("Listening to updates...")
 
             while self.is_running:
-                update = await self.__receive(100000.0)  # seconds
+                update = self._tdjson.receive(100000.0)  # seconds
                 if update is None:
                     continue
                 self._process_update(update)
@@ -624,19 +621,36 @@ class Client(Decorators, Methods):
                 logger.error(f"{update['@extra']['option']}: {update['message']}")
         else:
             if update["@type"] == "updateAuthorizationState":
-                self.loop.create_task(self.__handle_authorization_state(update))
+                asyncio.run_coroutine_threadsafe(
+                    self.__handle_authorization_state(update), loop=self.loop
+                )
             elif update["@type"] == "updateMessageSendSucceeded":
-                self.loop.create_task(self.__handle_update_message_succeeded(update))
+                asyncio.run_coroutine_threadsafe(
+                    self.__handle_update_message_succeeded(update), loop=self.loop
+                )
             elif update["@type"] == "updateMessageSendFailed":
-                self.loop.create_task(self.__handle_update_message_failed(update))
+                asyncio.run_coroutine_threadsafe(
+                    self.__handle_update_message_failed(update), loop=self.loop
+                )
             elif update["@type"] == "updateConnectionState":
-                self.loop.create_task(self.__handle_connection_state(update))
+                asyncio.run_coroutine_threadsafe(
+                    self.__handle_connection_state(update), loop=self.loop
+                )
             elif update["@type"] == "updateOption":
-                self.loop.create_task(self.__handle_update_option(update))
+                asyncio.run_coroutine_threadsafe(
+                    self.__handle_update_option(update), loop=self.loop
+                )
             elif update["@type"] == "updateUser":
-                self.loop.create_task(self.__handle_update_user(update))
+                asyncio.run_coroutine_threadsafe(
+                    self.__handle_update_user(update), loop=self.loop
+                )
 
-            self.queue.put_nowait(update)
+            if self.__is_queue_worker:
+                self.queue.put_nowait(update)
+            else:
+                asyncio.run_coroutine_threadsafe(
+                    self._handle_update(update), loop=self.loop
+                )
 
     async def __run_initializers(self, update):
         for initializer in self._handlers["initializer"]:
@@ -692,39 +706,35 @@ class Client(Decorators, Methods):
             except Exception:
                 logger.exception(f"Finalizer {finalizer} failed")
 
-    async def _update_worker(self, worker_id: int):
-        self.is_running = True
-        while self.is_running:
-            try:
-                update = await self.queue.get()
-                if "@type" not in update:
-                    continue
+    async def _handle_update(self, update):
+        if (
+            logger.root.level >= DEBUG
+        ):  # dumping all updates can create performance issues
+            logger.debug(
+                f"Received: {dumps(update, indent=4)}",
+            )
 
-                if (
-                    logger.root.level >= DEBUG
-                ):  # dumping all updates can create performance issues
-                    logger.debug(
-                        f"w{worker_id}: Received: {dumps(update, indent=4)}",
-                    )
+        if update["@type"] in self._handlers:
+            update = self.update_class(self, update)
+            if (
+                update["@type"] == "updateNewMessage"
+                and update["message"]["is_outgoing"]
+                and "sending_state" in update["message"]
+            ):
+                return
 
-                if update["@type"] in self._handlers:
-                    update = self.update_class(self, update)
-                    if (
-                        update["@type"] == "updateNewMessage"
-                        and update["message"]["is_outgoing"]
-                        and "sending_state" in update["message"]
-                    ):
-                        continue
+            try:
+                await self.__run_initializers(update)
+                await self.__run_handlers(update)
+            except StopHandlers:
+                pass
+            finally:
+                await self.__run_finalizers(update)
 
-                    try:
-                        await self.__run_initializers(update)
-                        await self.__run_handlers(update)
-                    except StopHandlers:
-                        pass
-                    finally:
-                        await self.__run_finalizers(update)
-            except Exception:
-                logger.exception("Exception in _update_worker")
+    async def _queue_update_worker(self):
+        self.is_running = True
+        while self.is_running:
+            await self._handle_update(await self.queue.get())
 
     async def set_td_paramaters(self):
         """Make a call to :meth:`~pytdbot.Client.setTdlibParameters` with the current client init parameters
@@ -1014,8 +1024,7 @@ class Client(Decorators, Methods):
             print(f"Your 2FA password hint is: {self.__authorization['password_hint']}")
 
         while self.is_running:
-            password = await self.loop.run_in_executor(
-                self._executor,
+            password = await asyncio.to_thread(
                 getpass,
                 "Enter your 2FA password {}: ".format(
                     "(empty to recover)"
@@ -1074,10 +1083,9 @@ class Client(Decorators, Methods):
         self.is_authenticated = False
         self.is_running = False
 
-        for worker_task in self._workers_tasks:
-            worker_task.cancel()
-
-        self._executor.shutdown(wait=False, cancel_futures=True)
+        if self.__is_queue_worker:
+            for worker_task in self._workers_tasks:
+                worker_task.cancel()
 
     def _register_signal_handlers(self):
         def _handle_signal():
@@ -1103,7 +1111,7 @@ class Client(Decorators, Methods):
                 pass
 
     def __ainput(self, prompt: str):
-        return self.loop.run_in_executor(self._executor, input, prompt)
+        return asyncio.to_thread(input, prompt)
 
     def _print_welcome(self):
         print(f"Welcome to Pytdbot (v{pytdbot.__version__}). {pytdbot.__copyright__}")