telegrinder 0.1.dev20__py3-none-any.whl → 0.1.dev158__py3-none-any.whl

telegrinder/tools/kb_set/yaml.py

@@ -1,21 +1,33 @@
-from .base import KeyboardSetBase, KeyboardSetError
-from telegrinder.tools.keyboard import Keyboard, InlineKeyboard
-import typing
-import re
 import os
+import re
+import typing
+
 import yaml
 
+from telegrinder.tools.keyboard import InlineKeyboard, Keyboard
+
+from .base import KeyboardSetBase, KeyboardSetError
+
+PathLike = str | os.PathLike[str]
+
 
 class KeyboardSetYAML(KeyboardSetBase):
-    __config__: str
+    __config__: PathLike
 
     @classmethod
     def load(cls) -> None:
         config_path = getattr(cls, "__config__", "keyboards.yaml")
         if not os.path.exists(config_path):
-            raise FileNotFoundError(f"Config file for {cls.__name__} is undefined")
+            raise FileNotFoundError(f"Config file for {cls.__name__!r} is undefined.")
 
-        config = yaml.load(open(config_path, "r", encoding="utf-8"), yaml.Loader)
+        config = yaml.load(
+            open(  # noqa: SIM115
+                str(config_path),
+                mode="r",
+                encoding="UTF-8",
+            ),
+            yaml.Loader,
+        ) 
         for name, hint in typing.get_type_hints(cls).items():
             g = re.match(r"(?:kb_|keyboard_)(.+)", name.lower())
             if not g:
@@ -23,12 +35,9 @@ class KeyboardSetYAML(KeyboardSetBase):
 
             short_name = g.group(1)
             if short_name not in config:
-                raise KeyboardSetError(
-                    f"Keyboard {short_name!r} is undefined in config"
-                )
+                raise KeyboardSetError(f"Keyboard {short_name!r} is undefined in config.")
 
             kb_config = config[short_name]
-
             if (
                 not isinstance(kb_config, dict)
                 or "buttons" not in kb_config
@@ -36,18 +45,20 @@ class KeyboardSetYAML(KeyboardSetBase):
             ):
                 raise KeyboardSetError(
                     "Keyboard should be dict with field buttons which must be a list, "
-                    "check documentation"
+                    "check documentation."
                 )
-
+            
             buttons = kb_config.pop("buttons")
-            new_keyboard: typing.Union[Keyboard, InlineKeyboard] = hint(**kb_config)
-
+            new_keyboard: Keyboard | InlineKeyboard = hint(**kb_config)
             for button in buttons:
                 if not button:
                     new_keyboard.row()
                     continue
                 if "text" not in button:
-                    raise KeyboardSetError("text is required")
-                new_keyboard.add(new_keyboard.BUTTON(**button))
+                    raise KeyboardSetError("Text is required in button.")
+                new_keyboard.add(new_keyboard.BUTTON(**button))  # type: ignore
 
             setattr(cls, name, new_keyboard)
+
+
+__all__ = ("KeyboardSetYAML",)

telegrinder/tools/keyboard.py

@@ -1,47 +1,45 @@
+import dataclasses
 import typing
-from typing import List, Optional
-from dataclasses import dataclass
 from abc import ABC, abstractmethod
-from telegrinder.types.objects import InlineKeyboardMarkup, ReplyKeyboardMarkup
+from types import NoneType
 
-from .buttons import Button, InlineButton, ABCButton
+from fntypes.option import Nothing, Some
 
+from telegrinder.msgspec_utils import Option
+from telegrinder.types.objects import (
+    InlineKeyboardMarkup,
+    ReplyKeyboardMarkup,
+    ReplyKeyboardRemove,
+)
 
-AnyMarkup = typing.Union[InlineKeyboardMarkup, ReplyKeyboardMarkup]
+from .buttons import Button, ButtonT, InlineButton, RowButtons
 
+DictStrAny = dict[str, typing.Any]
+AnyMarkup = InlineKeyboardMarkup | ReplyKeyboardMarkup
 
-@dataclass
-class KeyboardModel:
-    resize_keyboard: bool
-    one_time_keyboard: bool
-    selective: bool
-    keyboard: List[List[dict]]
 
+def keyboard_remove(*, selective: bool | None = None) -> ReplyKeyboardRemove:
+    return ReplyKeyboardRemove(
+        remove_keyboard=True,
+        selective=Nothing() if selective is None else Some(selective),
+    )
 
-class ABCMarkup(ABC, KeyboardModel):
-    BUTTON: typing.Type[ABCButton]
 
-    def __init__(
-        self,
-        resize_keyboard: bool = True,
-        one_time_keyboard: bool = False,
-        selective: Optional[bool] = None,
-    ):
-        self.keyboard = [[]]
-        self.resize_keyboard = resize_keyboard
-        self.one_time_keyboard = one_time_keyboard
-        self.selective = selective
+@dataclasses.dataclass
+class KeyboardModel:
+    resize_keyboard: bool | Option[bool]
+    one_time_keyboard: bool | Option[bool]
+    selective: bool | Option[bool]
+    is_persistent: bool | Option[bool]
+    keyboard: list[list[dict[str, typing.Any]]]
 
-    @abstractmethod
-    def add(self, button) -> "ABCMarkup":
-        pass
 
-    @abstractmethod
-    def row(self) -> "ABCMarkup":
-        pass
+class ABCMarkup(ABC, typing.Generic[ButtonT]):
+    BUTTON: type[ButtonT]
+    keyboard: list[list[dict[str, typing.Any]]]
 
     @abstractmethod
-    def dict(self) -> dict:
+    def dict(self) -> DictStrAny:
         pass
 
     @abstractmethod
@@ -52,6 +50,26 @@ class ABCMarkup(ABC, KeyboardModel):
     def empty(cls) -> AnyMarkup:
         return cls().get_markup()
 
+    def add(self, row_or_button: RowButtons[ButtonT] | ButtonT) -> typing.Self:
+        if not len(self.keyboard):
+            self.row()
+        
+        if isinstance(row_or_button, RowButtons):
+            self.keyboard[-1].extend(row_or_button.get_data())
+            if row_or_button.auto_row:
+                self.row()
+            return self
+
+        self.keyboard[-1].append(row_or_button.get_data())
+        return self
+
+    def row(self) -> typing.Self:
+        if len(self.keyboard) and not len(self.keyboard[-1]):
+            raise RuntimeError("Last row is empty!")
+
+        self.keyboard.append([])
+        return self
+
     def format(self, **format_data: typing.Dict[str, str]) -> "ABCMarkup":
         copy_keyboard = self.__class__()
         for row in self.keyboard:
@@ -62,54 +80,58 @@ class ABCMarkup(ABC, KeyboardModel):
             copy_keyboard.row()
         return copy_keyboard
 
-    def merge(self, other: "ABCMarkup") -> "ABCMarkup":
+    def merge(self, other: typing.Self) -> typing.Self:
         self.keyboard.extend(other.keyboard)
         return self
 
 
-class Keyboard(ABCMarkup):
+class Keyboard(ABCMarkup[Button], KeyboardModel):
     BUTTON = Button
 
-    def row(self) -> "Keyboard":
-        if len(self.keyboard) and not len(self.keyboard[-1]):
-            raise RuntimeError("Last row is empty!")
-
-        self.keyboard.append([])
-        return self
-
-    def add(self, button: Button) -> "Keyboard":
-        if not len(self.keyboard):
-            self.row()
-
-        self.keyboard[-1].append(button.get_data())
-        return self
+    def __init__(
+        self,
+        *,
+        resize_keyboard: bool = True,
+        one_time_keyboard: bool = False,
+        selective: bool = False,
+        is_persistent: bool = False,
+    ):
+        self.keyboard = [[]]
+        self.resize_keyboard = resize_keyboard
+        self.one_time_keyboard = one_time_keyboard
+        self.selective = selective
+        self.is_persistent = is_persistent
 
-    def dict(self) -> dict:
-        return {k: v for k, v in self.__dict__.items() if v is not None}
+    def dict(self) -> DictStrAny:
+        self.keyboard = [row for row in self.keyboard if row]
+        return {
+            k: v.unwrap() if v and isinstance(v, Some) else v
+            for k, v in self.__dict__.items()
+            if type(v) not in (NoneType, Nothing)
+        }
 
     def get_markup(self) -> ReplyKeyboardMarkup:
         return ReplyKeyboardMarkup(**self.dict())
 
 
-class InlineKeyboard(ABCMarkup):
+class InlineKeyboard(ABCMarkup[InlineButton]):
     BUTTON = InlineButton
 
-    def row(self) -> "InlineKeyboard":
-        if len(self.keyboard) and not len(self.keyboard[-1]):
-            raise RuntimeError("Last row is empty!")
-
-        self.keyboard.append([])
-        return self
-
-    def add(self, button: InlineButton) -> "InlineKeyboard":
-        if not len(self.keyboard):
-            self.row()
-
-        self.keyboard[-1].append(button.get_data())
-        return self
+    def __init__(self) -> None:
+        self.keyboard = [[]]
 
-    def dict(self) -> dict:
+    def dict(self) -> DictStrAny:
+        self.keyboard = [row for row in self.keyboard if row]
         return dict(inline_keyboard=self.keyboard)
 
     def get_markup(self) -> InlineKeyboardMarkup:
         return InlineKeyboardMarkup(**self.dict())
+
+
+__all__ = (
+    "ABCMarkup",
+    "InlineKeyboard",
+    "Keyboard",
+    "KeyboardModel",
+    "keyboard_remove",
+)

telegrinder/tools/loop_wrapper/__init__.py

@@ -0,0 +1,4 @@
+from .abc import ABCLoopWrapper
+from .loop_wrapper import DelayedTask, LoopWrapper
+
+__all__ = ("ABCLoopWrapper", "DelayedTask", "LoopWrapper")

telegrinder/tools/loop_wrapper/abc.py

@@ -0,0 +1,18 @@
+import typing
+from abc import ABC, abstractmethod
+
+CoroutineTask = typing.Coroutine[typing.Any, typing.Any, typing.Any]
+CoroutineFunc = typing.Callable[..., CoroutineTask]
+
+
+class ABCLoopWrapper(ABC):
+    @abstractmethod
+    def add_task(self, task: CoroutineFunc | CoroutineTask) -> None:
+        ...
+
+    @abstractmethod
+    def run_event_loop(self) -> None:
+        ...
+
+
+__all__ = ("ABCLoopWrapper",)

telegrinder/tools/loop_wrapper/loop_wrapper.py

@@ -0,0 +1,132 @@
+import asyncio
+import contextlib
+import dataclasses
+import typing
+
+from telegrinder.modules import logger
+
+from .abc import ABCLoopWrapper, CoroutineFunc, CoroutineTask
+
+
+@dataclasses.dataclass
+class DelayedTask:
+    handler: CoroutineFunc
+    seconds: float
+    repeat: bool = dataclasses.field(default=False, kw_only=True)
+    _cancelled: bool = dataclasses.field(default=False, init=False, repr=False)
+
+    @property
+    def is_cancelled(self) -> bool:
+        return self._cancelled
+
+    async def __call__(self, *args, **kwargs) -> None:
+        while not self.is_cancelled:
+            await asyncio.sleep(self.seconds)
+            if self.is_cancelled:
+                break
+            await self.handler(*args, **kwargs)
+            if not self.repeat:
+                break
+
+    def cancel(self) -> None:
+        if not self._cancelled:
+            self._cancelled = True
+
+
+class LoopWrapper(ABCLoopWrapper):
+    def __init__(self, tasks: list[CoroutineTask] | None = None):
+        self.on_startup: list[CoroutineTask] = []
+        self.on_shutdown: list[CoroutineTask] = []
+        self.tasks = tasks or []
+        self._loop = asyncio.new_event_loop()
+        
+    def run_event_loop(self) -> None:
+        if not self.tasks:
+            logger.warning("You run loop with 0 tasks!")
+
+        for startup_task in self.on_startup:
+            self._loop.run_until_complete(startup_task)
+        for task in self.tasks:
+            self._loop.create_task(task)
+        
+        self.tasks.clear()
+        tasks = asyncio.all_tasks(self._loop)
+        try:
+            while tasks:
+                tasks_results, _ = self._loop.run_until_complete(
+                    asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)
+                )
+                for task_result in tasks_results:
+                    try:
+                        task_result.result()
+                    except BaseException as ex:
+                        logger.exception(ex)
+                tasks = asyncio.all_tasks(self._loop)
+        except KeyboardInterrupt:
+            print()  # blank print for ^C
+            logger.info("KeyboardInterrupt")
+            self.complete_tasks(tasks)
+        finally:
+            for shutdown_task in self.on_shutdown:
+                self._loop.run_until_complete(shutdown_task)
+            if self._loop.is_running():
+                self._loop.close()
+        
+    def add_task(self, task: CoroutineFunc | CoroutineTask | DelayedTask):
+        if asyncio.iscoroutinefunction(task) or isinstance(task, DelayedTask):
+            task = task()
+        elif not asyncio.iscoroutine(task):
+            raise TypeError("Task should be coroutine or coroutine function.")
+
+        if self._loop and self._loop.is_running():
+            self._loop.create_task(task)
+        else:
+            self.tasks.append(task)
+    
+    def complete_tasks(self, tasks: set[asyncio.Task[typing.Any]]) -> None:
+        tasks = tasks | asyncio.all_tasks(self._loop)
+        task_to_cancel = asyncio.gather(*tasks, return_exceptions=True)
+        task_to_cancel.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            self._loop.run_until_complete(task_to_cancel)
+
+    def timer(
+        self,
+        *,
+        days: int = 0,
+        hours: int = 0,
+        minutes: int = 0,
+        seconds: float = 0,
+    ) -> typing.Callable[[typing.Callable], DelayedTask]:
+        seconds += minutes * 60
+        seconds += hours * 60 * 60
+        seconds += days * 24 * 60 * 60
+
+        def decorator(func: typing.Callable) -> DelayedTask:
+            delayed_task = DelayedTask(func, seconds, repeat=False)
+            self.add_task(delayed_task)
+            return delayed_task
+
+        return decorator
+
+    def interval(
+        self,
+        *,
+        days: int = 0,
+        hours: int = 0,
+        minutes: int = 0,
+        seconds: float = 0,
+    ) -> typing.Callable[[typing.Callable], DelayedTask]:
+        seconds += minutes * 60
+        seconds += hours * 60 * 60
+        seconds += days * 24 * 60 * 60
+
+        def decorator(func: typing.Callable) -> DelayedTask:
+            delayed_task = DelayedTask(func, seconds, repeat=True)
+            self.add_task(delayed_task)
+            return delayed_task
+
+        return decorator
+
+
+__all__ = ("DelayedTask", "LoopWrapper")

telegrinder/tools/magic.py

@@ -1,41 +1,66 @@
+import enum
 import inspect
 import types
 import typing
 
-AnyMock = type("Any", (object,), {"__str__": lambda _: "Any"})
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules.abc import ABCRule
 
+    T = typing.TypeVar("T", bound=ABCRule)
 
-class VarUnset(BaseException):
-    def __init__(self, name: str, t: typing.Any, handler: types.FunctionType):
-        self.name = name
-        self.t = t
-        self.handler = handler
+FuncType = types.FunctionType | typing.Callable
+TRANSLATIONS_KEY = "_translations"
 
-    def __repr__(self):
-        return (
-            f"Handler {self.handler.__name__} requires variable {self.name} of type {self.t} "
-            "which was not set in the context"
-        )
 
-    def __str__(self):
-        return self.__repr__()
+def resolve_arg_names(func: FuncType, start_idx: int = 1) -> tuple[str, ...]:
+    return func.__code__.co_varnames[start_idx : func.__code__.co_argcount]
 
 
-def resolve_arg_names(func: types.FunctionType) -> typing.Tuple[str, ...]:
-    return func.__code__.co_varnames[1 : func.__code__.co_argcount]
-
-
-def get_default_args(func: types.FunctionType) -> typing.Dict[str, typing.Any]:
+def get_default_args(func: FuncType) -> dict[str, typing.Any]:
     fspec = inspect.getfullargspec(func)
     return dict(zip(fspec.args[::-1], (fspec.defaults or ())[::-1]))
 
 
+def to_str(s: str | enum.Enum) -> str:
+    if isinstance(s, enum.Enum):
+        return str(s.value)
+    return s
+
+
 def magic_bundle(
-    handler: types.FunctionType, kw: typing.Dict[str, typing.Any]
-) -> typing.Dict[str, typing.Any]:
-    names = resolve_arg_names(handler)
+    handler: FuncType, 
+    kw: dict[str | enum.Enum, typing.Any],
+    *,
+    start_idx: int = 1,
+    bundle_ctx: bool = True,
+) -> dict[str, typing.Any]:
+    names = resolve_arg_names(handler, start_idx=start_idx)
     args = get_default_args(handler)
-    args.update({k: v for k, v in kw.items() if k in names})
-    if "ctx" in names:
+    args.update({to_str(k): v for k, v in kw.items() if to_str(k) in names})
+    if "ctx" in names and bundle_ctx:
         args["ctx"] = kw
     return args
+
+
+def get_cached_translation(rule: "T", locale: str) -> typing.Optional["T"]:
+    translations = getattr(rule, TRANSLATIONS_KEY, {})
+    if not translations or locale not in translations:
+        return None
+    return translations[locale]
+
+
+def cache_translation(base_rule: "T", locale: str, translated_rule: "T") -> None:
+    translations = getattr(base_rule, TRANSLATIONS_KEY, {})
+    setattr(base_rule, TRANSLATIONS_KEY, {locale: translated_rule, **translations})
+
+
+__all__ = (
+    "TRANSLATIONS_KEY",
+    "cache_translation",
+    "get_cached_translation",
+    "get_default_args",
+    "get_default_args",
+    "magic_bundle",
+    "resolve_arg_names",
+    "to_str",
+)

telegrinder/tools/parse_mode.py

@@ -3,5 +3,4 @@ class ParseMode:
     HTML = "HTML"
 
 
-def get_mention_link(user_id: int) -> str:
-    return f"tg://user?id={user_id}"
+__all__ = ("ParseMode",)

telegrinder/types/__init__.py

@@ -1 +1,2 @@
+from telegrinder.types.enums import *
 from telegrinder.types.objects import *