python-telegram 2.0.0__py3-none-macosx_11_0_arm64.whl

telegram/tdjson.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import ctypes.util
+import importlib.resources
+import json
+import logging
+import os
+import platform
+from ctypes import CDLL, CFUNCTYPE, c_char_p, c_double, c_int, c_longlong, c_void_p
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+TDLIB_PATH_ENV_VAR = "PYTHON_TELEGRAM_TDLIB_PATH"
+
+_OVERRIDES_HINT = (
+    "Only the linux x86_64, linux aarch64, macOS arm64 and macOS x86_64 wheels bundle a "
+    "libtdjson; the sdist never does. Install tdlib system-wide so ctypes can find it, or "
+    f"point python-telegram at your own build with the {TDLIB_PATH_ENV_VAR} environment "
+    "variable or the TDJson(library_path=...) argument."
+)
+
+
+class ClientDestroyedError(RuntimeError):
+    """Raised when a TDJson client is used after it has been stopped"""
+
+
+class TDLibNotFoundError(OSError):
+    """
+    Raised when no libtdjson can be found or loaded.
+
+    Subclasses OSError because that is what ctypes.CDLL raises, so callers that
+    already handle a failed load keep working.
+    """
+
+
+def _bundled_lib_path() -> Path:
+    name = "libtdjson.dylib" if platform.system().lower() == "darwin" else "libtdjson.so"
+
+    return Path(str(importlib.resources.files("telegram").joinpath(f"lib/{name}")))
+
+
+def _resolve_tdjson_library() -> tuple[str, str]:
+    """Returns the path of the libtdjson to load and the name of the source it came from."""
+    env_path = os.environ.get(TDLIB_PATH_ENV_VAR)
+
+    if env_path:
+        return env_path, "env"
+
+    system_library = ctypes.util.find_library("tdjson")
+
+    if system_library is not None:
+        return system_library, "system"
+
+    bundled = _bundled_lib_path()
+
+    if bundled.is_file():
+        return str(bundled), "bundled"
+
+    raise TDLibNotFoundError(
+        f"No libtdjson found for {platform.system()} {platform.machine()}. "
+        f"{TDLIB_PATH_ENV_VAR} is not set, ctypes.util.find_library('tdjson') found nothing, "
+        f"and there is no bundled binary at {bundled}. {_OVERRIDES_HINT}"
+    )
+
+
+class TDJson:
+    def __init__(self, library_path: str | None = None, verbosity: int = 2) -> None:
+        if library_path is None:
+            library_path, source = _resolve_tdjson_library()
+        else:
+            source = "library_path"
+
+        logger.info('Using shared library "%s" (found via: %s)', library_path, source)
+
+        self._build_client(library_path, verbosity)
+
+    def __del__(self) -> None:
+        if hasattr(self, "_td_json_client_destroy"):
+            self.stop()
+
+    def _build_client(self, library_path: str, verbosity: int) -> None:
+        try:
+            self._tdjson = CDLL(library_path)
+        except OSError as error:
+            raise TDLibNotFoundError(
+                f"Failed to load libtdjson from {library_path} on "
+                f"{platform.system()} {platform.machine()}: {error}. {_OVERRIDES_HINT}"
+            ) from error
+
+        # load TDLib functions from shared library
+        self._td_json_client_create = self._tdjson.td_json_client_create
+        self._td_json_client_create.restype = c_void_p
+        self._td_json_client_create.argtypes = []
+
+        self.td_json_client: int | None = self._td_json_client_create()
+
+        self._td_json_client_receive = self._tdjson.td_json_client_receive
+        self._td_json_client_receive.restype = c_char_p
+        self._td_json_client_receive.argtypes = [c_void_p, c_double]
+
+        self._td_json_client_send = self._tdjson.td_json_client_send
+        self._td_json_client_send.restype = None
+        self._td_json_client_send.argtypes = [c_void_p, c_char_p]
+
+        self._td_json_client_execute = self._tdjson.td_json_client_execute
+        self._td_json_client_execute.restype = c_char_p
+        self._td_json_client_execute.argtypes = [c_void_p, c_char_p]
+
+        self._td_json_client_destroy = self._tdjson.td_json_client_destroy
+        self._td_json_client_destroy.restype = None
+        self._td_json_client_destroy.argtypes = [c_void_p]
+
+        self._td_set_log_file_path = self._tdjson.td_set_log_file_path
+        self._td_set_log_file_path.restype = c_int
+        self._td_set_log_file_path.argtypes = [c_char_p]
+
+        self._td_set_log_max_file_size = self._tdjson.td_set_log_max_file_size
+        self._td_set_log_max_file_size.restype = None
+        self._td_set_log_max_file_size.argtypes = [c_longlong]
+
+        self._td_set_log_verbosity_level = self._tdjson.td_set_log_verbosity_level
+        self._td_set_log_verbosity_level.restype = None
+        self._td_set_log_verbosity_level.argtypes = [c_int]
+
+        self._td_set_log_verbosity_level(verbosity)
+
+        fatal_error_callback_type = CFUNCTYPE(None, c_char_p)
+
+        self._td_set_log_fatal_error_callback = self._tdjson.td_set_log_fatal_error_callback
+        self._td_set_log_fatal_error_callback.restype = None
+        self._td_set_log_fatal_error_callback.argtypes = [fatal_error_callback_type]
+
+        # initialize TDLib log with desired parameters
+        def on_fatal_error_callback(error_message: str) -> None:
+            logger.error("TDLib fatal error: %s", error_message)
+
+        self._c_on_fatal_error_callback = fatal_error_callback_type(on_fatal_error_callback)
+        self._td_set_log_fatal_error_callback(self._c_on_fatal_error_callback)
+
+    def _get_client(self) -> int:
+        """
+        Returns the client handle, or raises if the client has been destroyed.
+
+        tdlib dereferences this handle, so passing a destroyed (NULL) one
+        crashes the whole process instead of raising.
+        """
+        if self.td_json_client is None:
+            raise ClientDestroyedError("The tdlib client is stopped and cannot be used anymore")
+
+        return self.td_json_client
+
+    def send(self, query: dict[Any, Any]) -> None:
+        dumped_query = json.dumps(query).encode("utf-8")
+        self._td_json_client_send(self._get_client(), dumped_query)
+        logger.debug("[me ==>] Sent %s", dumped_query)
+
+    def receive(self) -> None | dict[Any, Any]:
+        result_str = self._td_json_client_receive(self._get_client(), 1.0)
+
+        if result_str:
+            result: dict[Any, Any] = json.loads(result_str.decode("utf-8"))
+            logger.debug("[me <==] Received %s", result)
+
+            return result
+
+        return None
+
+    def td_execute(self, query: dict[Any, Any]) -> dict[Any, Any] | Any:
+        dumped_query = json.dumps(query).encode("utf-8")
+        result_str = self._td_json_client_execute(self._get_client(), dumped_query)
+
+        if result_str:
+            result: dict[Any, Any] = json.loads(result_str.decode("utf-8"))
+
+            return result
+
+        return None
+
+    def stop(self) -> None:
+        if self.td_json_client is None:
+            return
+        self._td_json_client_destroy(self.td_json_client)
+        self.td_json_client = None

telegram/text.py

@@ -0,0 +1,46 @@
+"""Since telegram.text is based on a third-party module telegram-text,
+you can find more examples of how to use markup components on
+telegram-text.alinsky.tech or github.com/SKY-ALIN/telegram-text
+"""
+
+from telegram_text import (
+    Bold,
+    Chain,
+    Code,
+    Hashtag,
+    InlineCode,
+    InlineUser,
+    Italic,
+    Link,
+    OrderedList,
+    PlainText,
+    Spoiler,
+    Strikethrough,
+    Text,
+    TOMLSection,
+    Underline,
+    UnorderedList,
+    User,
+)
+from telegram_text.bases import Element
+
+__all__ = [
+    "Bold",
+    "Chain",
+    "Code",
+    "Element",
+    "Hashtag",
+    "InlineCode",
+    "InlineUser",
+    "Italic",
+    "Link",
+    "OrderedList",
+    "PlainText",
+    "Spoiler",
+    "Strikethrough",
+    "TOMLSection",
+    "Text",
+    "Underline",
+    "UnorderedList",
+    "User",
+]

telegram/utils.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import logging
+import threading
+import uuid
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from telegram.client import Telegram
+
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncResult:
+    """
+    tdlib is asynchronous, and this class helps you get results back.
+    After each API call, you receive AsyncResult object, which you can use to get results back.
+    """
+
+    def __init__(self, client: Telegram, result_id: str | None = None) -> None:
+        self.client = client
+
+        if result_id:
+            self.id = result_id
+        else:
+            self.id = uuid.uuid4().hex
+
+        self.request: dict[Any, Any] | None = None
+        self.ok_received = False
+        self.error = False
+        self.error_info: dict[Any, Any] | None = None
+        self.update: dict[Any, Any] | None = None
+        self._ready = threading.Event()
+
+    def __str__(self) -> str:
+        return f"AsyncResult <{self.id}>"
+
+    def wait(self, timeout: float | None = None, raise_exc: bool = False) -> None:
+        """
+        Blocking method to wait for the result
+        """
+        result = self._ready.wait(timeout=timeout)
+        if result is False:
+            raise TimeoutError()
+        if raise_exc and self.error:
+            raise RuntimeError(f"Telegram error: {self.error_info}")
+
+    def parse_update(self, update: dict[Any, Any]) -> bool:
+        update_type = update.get("@type")
+
+        logger.debug("update id=%s type=%s received", self.id, update_type)
+
+        if update_type == "ok":
+            self.ok_received = True
+            if self.id == "updateAuthorizationState":
+                # For updateAuthorizationState commands tdlib sends
+                # @type: ok responses
+                # but we want to wait longer to receive the new authorization state
+                return False
+        elif update_type == "error":
+            self.error = True
+            self.error_info = update
+        else:
+            self.update = update
+
+        self._ready.set()
+
+        return True

telegram/worker.py

@@ -0,0 +1,51 @@
+import logging
+import threading
+from queue import Empty, Queue
+
+logger = logging.getLogger(__name__)
+
+
+class BaseWorker:
+    """
+    Base worker class.
+    Each worker must implement the run method to start listening to the queue
+    and calling handler functions
+    """
+
+    def __init__(self, queue: Queue):
+        self._is_enabled = True
+        self._queue = queue
+
+    def run(self) -> None:
+        raise NotImplementedError()
+
+    def stop(self) -> None:
+        raise NotImplementedError()
+
+
+class SimpleWorker(BaseWorker):
+    """Simple one-thread worker"""
+
+    def run(self) -> None:
+        self._thread = threading.Thread(target=self._run_thread)
+        self._thread.daemon = True
+        self._thread.start()
+
+    def _run_thread(self) -> None:
+        logger.info("[SimpleWorker] started")
+
+        while self._is_enabled:
+            try:
+                handler, update = self._queue.get(timeout=0.5)
+            except Empty:
+                continue
+
+            try:
+                handler(update)
+            except Exception:
+                logger.exception("Error in update handler %s", handler)
+            self._queue.task_done()
+
+    def stop(self) -> None:
+        self._is_enabled = False
+        self._thread.join()