TgrEzLi 0.1.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

TgrEzLi/crypto.py

@@ -0,0 +1,39 @@
+"""Encrypted credential storage (PyCypherLib / PyCypher)."""
+from __future__ import annotations
+
+import os
+
+from PyCypher import Cy
+
+
+class CredentialManager:
+    """Store and load Telegram token + chat dict encrypted with a password (PyCypherLib)."""
+
+    def __init__(self, filename: str = "tgrdata.cy") -> None:
+        self.filename = filename
+
+    def signup(self, token: str, chat_dict: dict[str, str], password: str) -> None:
+        """Create encrypted file with token and chat IDs. Fails if file already exists."""
+
+        if os.path.exists(self.filename):
+            raise FileExistsError("Encrypted file already exists.")
+        lines = [token] + [f"{name}:{cid}" for name, cid in chat_dict.items()]
+        Cy().encLines(self.filename).Lines(lines).P(password)
+
+    def login(self, password: str) -> tuple[str, dict[str, str]]:
+        """Read encrypted file and return (token, chat_dict)."""
+        if not os.path.exists(self.filename):
+            raise FileNotFoundError("Encrypted file not found.")
+        try:
+            lines = Cy().decLines(self.filename).P(password)
+        except Exception as e:
+            raise ValueError("Invalid password or corrupted encrypted file.") from e
+        token = lines[0]
+        chat_dict: dict[str, str] = {}
+        for element in lines[1:]:
+            name, cid = element.split(":", 1)
+            chat_dict[name] = cid
+        return token, chat_dict
+
+
+__all__ = ["CredentialManager"]

TgrEzLi/defaults.py

@@ -0,0 +1,16 @@
+"""Default constants for TgrEzLi."""
+
+# API server
+DEFAULT_API_HOST = "localhost"
+DEFAULT_API_PORT = 9999
+MAX_REQUEST_BODY_BYTES = 1 * 1024 * 1024  # 1 MiB
+
+# Logging
+DEFAULT_LOG_FILE = "TgrEzLi.log"
+DEFAULT_LOGGER_NAME = "TgrEzLi"
+
+# Credentials (crypto)
+DEFAULT_CREDENTIAL_FILE = "tgrdata.cy"
+
+# Banner
+DEFAULT_BANNER_FILLER = "█"

TgrEzLi/handlers.py

@@ -0,0 +1,70 @@
+"""Handler registry and user-callback invocation (threaded)."""
+from __future__ import annotations
+
+import threading
+import traceback
+from typing import Any, Callable
+
+from TgrEzLi.models import clear_context, set_context
+from TgrEzLi.types import TgArgsData, TgCbData, TgCmdData, TgMsgData
+
+
+def call_user_function(
+    logger: Any,
+    func: Callable[[], None],
+    *,
+    TgMsg: TgMsgData | None = None,
+    TgCmd: TgCmdData | None = None,
+    TgCb: TgCbData | None = None,
+    TgArgs: TgArgsData | None = None,
+) -> None:
+    """Run the user handler in a background thread with thread-local context set."""
+    def worker() -> None:
+        try:
+            set_context(TgMsg=TgMsg, TgCmd=TgCmd, TgCb=TgCb, TgArgs=TgArgs)
+            func()
+        except Exception as e:  # noqa: BLE001
+            logger.error("Error in user handler: %s", e)
+            logger.debug(traceback.format_exc())
+        finally:
+            clear_context()
+
+    thread = threading.Thread(target=worker, daemon=True)
+    thread.start()
+
+
+class HandlerRegistry:
+    """Registry for message, command, callback, and API route handlers."""
+
+    __slots__ = ("message_handlers", "command_handlers", "callback_handlers", "api_routes")
+
+    def __init__(self) -> None:
+        self.message_handlers: list[tuple[set[str], Callable[[], None]]] = []
+        self.command_handlers: dict[str, list[tuple[set[str], Callable[[], None]]]] = {}
+        self.callback_handlers: list[tuple[set[str], Callable[[], None]]] = []
+        self.api_routes: dict[str, dict[str, Any]] = {}  # path -> {"args": [...], "func": ...}
+
+    def register_message_handler(self, func: Callable[[], None], chats: set[str]) -> None:
+        name = getattr(func, "__name__", None)
+        if name is not None:
+            self.message_handlers[:] = [(c, f) for c, f in self.message_handlers if getattr(f, "__name__", None) != name]
+        self.message_handlers.append((chats, func))
+
+    def register_command_handler(self, command: str, func: Callable[[], None], chats: set[str]) -> None:
+        name = getattr(func, "__name__", None)
+        lst = self.command_handlers.setdefault(command, [])
+        if name is not None:
+            lst[:] = [(c, f) for c, f in lst if getattr(f, "__name__", None) != name]
+        lst.append((chats, func))
+
+    def register_callback_handler(self, func: Callable[[], None], chats: set[str]) -> None:
+        name = getattr(func, "__name__", None)
+        if name is not None:
+            self.callback_handlers[:] = [(c, f) for c, f in self.callback_handlers if getattr(f, "__name__", None) != name]
+        self.callback_handlers.append((chats, func))
+
+    def register_api_route(self, endpoint: str, args_list: list[str], func: Callable[[], None]) -> None:
+        self.api_routes[endpoint] = {"args": args_list, "func": func}
+
+
+__all__ = ["call_user_function", "HandlerRegistry"]

TgrEzLi/logger.py

@@ -0,0 +1,65 @@
+"""Logger for TgrEzLi: ezlog for console, optional file append when save_log is True."""
+from __future__ import annotations
+
+from datetime import datetime
+
+from ezlog import EzLog
+
+from TgrEzLi.defaults import DEFAULT_LOG_FILE
+
+
+def _format_msg(msg: str, *args: object) -> str:
+    return msg % args if args else msg
+
+
+class TgrezliLogger:
+    """Adapter: EzLog for console output and optional file append (save_log)."""
+
+    def __init__(
+        self,
+        save_log: bool = True,
+        log_file: str | None = DEFAULT_LOG_FILE,
+    ) -> None:
+        self._ez = EzLog()
+        self._save_log = save_log
+        self._log_file = log_file or None
+
+    def set_save_log(self, flag: bool) -> None:
+        """Enable or disable writing log lines to the file."""
+        self._save_log = flag
+
+    def _write_file(self, level: str, msg: str) -> None:
+        if not self._save_log or not self._log_file:
+            return
+        try:
+            line = f"[{datetime.now():%Y-%m-%d %H:%M:%S}] [{level}] TgrEzLi - {msg}\n"
+            with open(self._log_file, "a", encoding="utf-8") as f:
+                f.write(line)
+        except OSError:
+            pass
+
+    def info(self, msg: str, *args: object) -> None:
+        formatted = _format_msg(msg, *args)
+        self._ez.info(formatted)
+        self._write_file("INFO", formatted)
+
+    def debug(self, msg: str, *args: object) -> None:
+        formatted = _format_msg(msg, *args)
+        self._ez.d(formatted)
+        self._write_file("DEBUG", formatted)
+
+    def error(self, msg: str, *args: object) -> None:
+        formatted = _format_msg(msg, *args)
+        self._ez.error(formatted)
+        self._write_file("ERROR", formatted)
+
+
+def get_default_logger(
+    save_log: bool = True,
+    log_file: str | None = DEFAULT_LOG_FILE,
+) -> TgrezliLogger:
+    """Return a logger that uses ezlog for console and optionally appends to a file."""
+    return TgrezliLogger(save_log=save_log, log_file=log_file)
+
+
+__all__ = ["TgrezliLogger", "get_default_logger"]

TgrEzLi/models.py

@@ -0,0 +1,82 @@
+"""Data payloads and thread-local proxies for handler context (TgMsg, TgCmd, TgCb, TgArgs)."""
+from __future__ import annotations
+
+import threading
+from typing import Any
+
+from TgrEzLi.types import TgArgsData, TgCbData, TgCmdData, TgMsgData
+
+# Thread-local storage for current handler payload
+_local: threading.local = threading.local()
+
+
+def _get_proxy(attr: str, label: str) -> Any:
+    obj = getattr(_local, attr, None)
+    if obj is None:
+        raise AttributeError(f"{label} is not available in this context (use inside a handler).")
+    return obj
+
+
+class TgMsgProxy:
+    """Proxy to current message payload; use only inside onMessage handlers."""
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(_get_proxy("TgMsg", "TgMsg"), name)
+
+
+class TgCmdProxy:
+    """Proxy to current command payload; use only inside onCommand handlers."""
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(_get_proxy("TgCmd", "TgCmd"), name)
+
+
+class TgCbProxy:
+    """Proxy to current callback payload; use only inside onCallback handlers."""
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(_get_proxy("TgCb", "TgCb"), name)
+
+
+class TgArgsProxy:
+    """Proxy to current API request body; use only inside onApiReq handlers."""
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(_get_proxy("TgArgs", "TgArgs"), name)
+
+
+def set_context(TgMsg: TgMsgData | None = None, TgCmd: TgCmdData | None = None,
+                TgCb: TgCbData | None = None, TgArgs: TgArgsData | None = None) -> None:
+    """Set thread-local context (used by handlers module)."""
+    _local.TgMsg = TgMsg
+    _local.TgCmd = TgCmd
+    _local.TgCb = TgCb
+    _local.TgArgs = TgArgs
+
+
+def clear_context() -> None:
+    """Clear thread-local context."""
+    _local.TgMsg = None
+    _local.TgCmd = None
+    _local.TgCb = None
+    _local.TgArgs = None
+
+
+# Public proxies (singletons)
+TgMsg = TgMsgProxy()
+TgCmd = TgCmdProxy()
+TgCb = TgCbProxy()
+TgArgs = TgArgsProxy()
+
+__all__ = [
+    "TgMsgData",
+    "TgCmdData",
+    "TgCbData",
+    "TgArgsData",
+    "TgMsg",
+    "TgCmd",
+    "TgCb",
+    "TgArgs",
+    "set_context",
+    "clear_context",
+]

TgrEzLi/requests.py

@@ -0,0 +1,49 @@
+"""HTTP client for sending requests to the embedded API server (TReq)."""
+from __future__ import annotations
+
+import requests
+
+
+class TgrezliRequestError(Exception):
+    """Raised when a TReq request fails (network or HTTP error)."""
+
+
+class TReq:
+    """Fluent client for POST requests to the TgrEzLi API server."""
+
+    def __init__(self, endpoint: str, host: str = "localhost", port: int = 9999, timeout_sec: float = 30.0) -> None:
+        self.endpoint = endpoint if endpoint.startswith("/") else f"/{endpoint}"
+        self._host = host
+        self._port = port
+        self._timeout = timeout_sec
+        self._body: dict = {}
+
+    def host(self, host: str) -> TReq:
+        self._host = host
+        return self
+
+    def port(self, port: int) -> TReq:
+        self._port = port
+        return self
+
+    def timeout(self, seconds: float) -> TReq:
+        self._timeout = seconds
+        return self
+
+    def arg(self, name: str, value: object) -> TReq:
+        self._body[name] = value
+        return self
+
+    def body(self, body_dict: dict) -> TReq:
+        self._body = dict(body_dict)
+        return self
+
+    def send(self) -> requests.Response:
+        url = f"http://{self._host}:{self._port}{self.endpoint}"
+        try:
+            return requests.post(url, json=self._body, timeout=self._timeout)
+        except requests.RequestException as e:
+            raise TgrezliRequestError(f"Request to {url} failed: {e}") from e
+
+
+__all__ = ["TReq", "TgrezliRequestError"]

TgrEzLi/types.py

@@ -0,0 +1,119 @@
+"""Type definitions and data structures for TgrEzLi."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+# --- Config ---
+
+
+@dataclass(frozen=False)
+class TgrezliConfig:
+    """Runtime configuration for TEL (log, API server)."""
+
+    save_log: bool = True
+    log_file: str = "TgrEzLi.log"
+    api_host: str = "localhost"
+    api_port: int = 9999
+
+
+# --- Handler payloads (internal; passed from core to user via thread-local) ---
+
+
+@dataclass
+class TgMsgData:
+    """Payload for onMessage handlers."""
+
+    text: str
+    msg_id: int | None
+    chat_id: str
+    user_id: int | None
+    user_name: str | None
+    timestamp: Any
+    raw_update: Any
+
+    @property
+    def msgId(self) -> int | None:
+        return self.msg_id
+
+    @property
+    def chatId(self) -> str:
+        return self.chat_id
+
+    @property
+    def userId(self) -> int | None:
+        return self.user_id
+
+    @property
+    def userName(self) -> str | None:
+        return self.user_name
+
+
+@dataclass
+class TgCmdData:
+    """Payload for onCommand handlers."""
+
+    command: str
+    args: str
+    msg_id: int | None
+    chat_id: str
+    user_id: int | None
+    user_name: str | None
+    timestamp: Any
+    raw_update: Any
+
+    @property
+    def msgId(self) -> int | None:
+        return self.msg_id
+
+    @property
+    def chatId(self) -> str:
+        return self.chat_id
+
+    @property
+    def userId(self) -> int | None:
+        return self.user_id
+
+    @property
+    def userName(self) -> str | None:
+        return self.user_name
+
+
+@dataclass
+class TgCbData:
+    """Payload for onCallback handlers."""
+
+    text: str | None
+    value: str
+    msg_id: int | None
+    chat_id: str
+    user_id: int | None
+    user_name: str | None
+    timestamp: Any
+    raw_update: Any
+
+    @property
+    def msgId(self) -> int | None:
+        return self.msg_id
+
+    @property
+    def chatId(self) -> str:
+        return self.chat_id
+
+    @property
+    def userId(self) -> int | None:
+        return self.user_id
+
+    @property
+    def userName(self) -> str | None:
+        return self.user_name
+
+
+@dataclass
+class TgArgsData:
+    """Payload for onApiReq handlers (POST body)."""
+
+    _data: dict[str, Any]
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)