telegrinder 0.3.4.post1__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/tools/global_context/telegrinder_ctx.py

@@ -1,5 +1,4 @@
 import re
-import typing
 
 import vbml
 
@@ -16,12 +15,13 @@ class TelegrinderContext(GlobalContext):
     ctx1 = TelegrinderContext()
     ctx2 = GlobalContext("telegrinder")  # same, but without the type-hints
     assert ctx1 == ctx2  # ok
-    ```"""
+    ```
+    """
 
     __ctx_name__ = "telegrinder"
 
     vbml_pattern_flags: re.RegexFlag | None = None
-    vbml_patcher: typing.ClassVar[vbml.Patcher] = ctx_var(vbml.Patcher(), const=True)
+    vbml_patcher: vbml.Patcher = ctx_var(default=vbml.Patcher(), frozen=True)
 
 
 __all__ = ("TelegrinderContext",)

telegrinder/tools/i18n/middleware/abc.py

@@ -1,4 +1,3 @@
-import typing
 from abc import abstractmethod
 
 from telegrinder.bot.cute_types.base import BaseCute
@@ -6,18 +5,16 @@ from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.middleware import ABCMiddleware
 from telegrinder.tools.i18n import ABCI18n, I18nEnum
 
-T = typing.TypeVar("T", bound=BaseCute)
 
-
-class ABCTranslatorMiddleware(ABCMiddleware[T]):
+class ABCTranslatorMiddleware[Event: BaseCute](ABCMiddleware[Event]):
     def __init__(self, i18n: ABCI18n) -> None:
         self.i18n = i18n
 
     @abstractmethod
-    async def get_locale(self, event: T) -> str:
+    async def get_locale(self, event: Event) -> str:
         pass
 
-    async def pre(self, event: T, ctx: Context) -> bool:
+    async def pre(self, event: Event, ctx: Context) -> bool:
         ctx[I18nEnum.I18N] = self.i18n.get_translator_by_locale(await self.get_locale(event))
         return True
 

telegrinder/tools/input_file_directory.py

@@ -0,0 +1,30 @@
+import dataclasses
+import pathlib
+
+from telegrinder.types.objects import InputFile
+
+
+@dataclasses.dataclass
+class InputFileDirectory:
+    directory: pathlib.Path
+    storage: dict[str, InputFile] = dataclasses.field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        self.storage = self._load_files()
+
+    def _load_files(self) -> dict[str, InputFile]:
+        files = {}
+
+        for path in self.directory.rglob("*"):
+            if path.is_file():
+                relative_path = path.relative_to(self.directory)
+                files[str(relative_path)] = InputFile(path.name, path.read_bytes())
+
+        return files
+
+    def get(self, filename: str, /) -> InputFile:
+        assert filename in self.storage, f"File {filename!r} not found."
+        return self.storage[filename]
+
+
+__all__ = ("InputFileDirectory",)

telegrinder/tools/keyboard.py

@@ -1,20 +1,20 @@
 import dataclasses
 import typing
 from abc import ABC, abstractmethod
-from types import NoneType
 
-from fntypes.option import Nothing, Some
+from fntypes.option import Some
 
+from telegrinder.model import is_none
 from telegrinder.types.objects import (
     InlineKeyboardMarkup,
     ReplyKeyboardMarkup,
     ReplyKeyboardRemove,
 )
 
-from .buttons import Button, InlineButton, KeyboardButton, RowButtons
+from .buttons import BaseButton, Button, InlineButton, RowButtons
 
-DictStrAny: typing.TypeAlias = dict[str, typing.Any]
-AnyMarkup: typing.TypeAlias = InlineKeyboardMarkup | ReplyKeyboardMarkup
+type DictStrAny = dict[str, typing.Any]
+type AnyMarkup = InlineKeyboardMarkup | ReplyKeyboardMarkup
 
 
 def copy_keyboard(keyboard: list[list[DictStrAny]]) -> list[list[DictStrAny]]:
@@ -30,7 +30,7 @@ class KeyboardModel:
     keyboard: list[list[DictStrAny]]
 
 
-class ABCMarkup(ABC, typing.Generic[KeyboardButton]):
+class ABCMarkup[KeyboardButton: BaseButton](ABC):
     BUTTON: type[KeyboardButton]
     keyboard: list[list[DictStrAny]]
 
@@ -46,8 +46,8 @@ class ABCMarkup(ABC, typing.Generic[KeyboardButton]):
     def get_empty_markup(cls) -> AnyMarkup:
         return cls().get_markup()
 
-    def add(self, row_or_button: RowButtons[KeyboardButton] | KeyboardButton) -> typing.Self:
-        if not len(self.keyboard):
+    def add(self, row_or_button: RowButtons[KeyboardButton] | KeyboardButton, /) -> typing.Self:
+        if not self.keyboard:
             self.row()
 
         if isinstance(row_or_button, RowButtons):
@@ -99,7 +99,7 @@ class Keyboard(ABCMarkup[Button], KeyboardModel):
         return {
             k: v.unwrap() if v and isinstance(v, Some) else v
             for k, v in dataclasses.asdict(self).items()
-            if type(v) not in (NoneType, Nothing)
+            if not is_none(v)
         }
 
     def get_markup(self) -> ReplyKeyboardMarkup:

telegrinder/tools/lifespan.py

@@ -0,0 +1,105 @@
+import asyncio
+import dataclasses
+import datetime
+import typing
+
+type CoroutineTask[T] = typing.Coroutine[typing.Any, typing.Any, T]
+type CoroutineFunc[**P, T] = typing.Callable[P, CoroutineTask[T]]
+type Task[**P, T] = CoroutineFunc[P, T] | CoroutineTask[T] | DelayedTask[typing.Callable[P, CoroutineTask[T]]]
+
+
+def run_tasks(
+    tasks: list[CoroutineTask[typing.Any]],
+    /,
+) -> None:
+    loop = asyncio.get_event_loop()
+    while tasks:
+        loop.run_until_complete(tasks.pop(0))
+
+
+def to_coroutine_task[**P, T](task: Task[P, T], /) -> CoroutineTask[T]:
+    if asyncio.iscoroutinefunction(task) or isinstance(task, DelayedTask):
+        task = task()
+    elif not asyncio.iscoroutine(task):
+        raise TypeError("Task should be coroutine or coroutine function.")
+    return task
+
+
+@dataclasses.dataclass(slots=True)
+class DelayedTask[Handler: CoroutineFunc[..., typing.Any]]:
+    handler: Handler
+    seconds: float | datetime.timedelta
+    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
+
+    @property
+    def delay(self) -> float:
+        return self.seconds if isinstance(self.seconds, int | float) else self.seconds.total_seconds()
+
+    async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+        while not self.is_cancelled:
+            await asyncio.sleep(self.delay)
+            if self.is_cancelled:
+                break
+            try:
+                await self.handler(*args, **kwargs)
+            finally:
+                if not self.repeat:
+                    break
+
+    def cancel(self) -> None:
+        if not self._cancelled:
+            self._cancelled = True
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class Lifespan:
+    startup_tasks: list[CoroutineTask[typing.Any]] = dataclasses.field(default_factory=lambda: [])
+    shutdown_tasks: list[CoroutineTask[typing.Any]] = dataclasses.field(default_factory=lambda: [])
+
+    def on_startup[**P, T](self, task: Task[P, T], /) -> Task[P, T]:
+        self.startup_tasks.append(to_coroutine_task(task))
+        return task
+
+    def on_shutdown[**P, T](self, task: Task[P, T], /) -> Task[P, T]:
+        self.shutdown_tasks.append(to_coroutine_task(task))
+        return task
+
+    def start(self) -> None:
+        run_tasks(self.startup_tasks)
+
+    def shutdown(self) -> None:
+        run_tasks(self.shutdown_tasks)
+
+    def __enter__(self) -> None:
+        self.start()
+
+    def __exit__(self) -> None:
+        self.shutdown()
+
+    async def __aenter__(self) -> None:
+        for task in self.startup_tasks:
+            await task
+
+    async def __aexit__(self, *args) -> None:
+        for task in self.shutdown_tasks:
+            await task
+
+    def __add__(self, other: typing.Self, /) -> typing.Self:
+        return self.__class__(
+            startup_tasks=self.startup_tasks + other.startup_tasks,
+            shutdown_tasks=self.shutdown_tasks + other.shutdown_tasks,
+        )
+
+
+__all__ = (
+    "CoroutineTask",
+    "DelayedTask",
+    "Lifespan",
+    "run_tasks",
+    "to_coroutine_task",
+)

telegrinder/tools/limited_dict.py

@@ -1,22 +1,17 @@
-import typing
 from collections import UserDict, deque
 
-KT = typing.TypeVar("KT")
-VT = typing.TypeVar("VT")
 
-
-class LimitedDict(UserDict[KT, VT]):
+class LimitedDict[Key, Value](UserDict[Key, Value]):
     def __init__(self, *, maxlimit: int = 1000) -> None:
         super().__init__()
         self.maxlimit = maxlimit
-        self.queue: deque[KT] = deque(maxlen=maxlimit)
+        self.queue: deque[Key] = deque(maxlen=maxlimit)
 
-    def set(self, key: KT, value: VT, /) -> VT | None:
+    def set(self, key: Key, value: Value, /) -> Value | None:
         """Set item in the dictionary.
         Returns a value that was deleted when the limit in the dictionary
         was reached, otherwise None.
         """
-
         deleted_item = None
         if len(self.queue) >= self.maxlimit:
             deleted_item = self.pop(self.queue.popleft(), None)
@@ -25,10 +20,10 @@ class LimitedDict(UserDict[KT, VT]):
         super().__setitem__(key, value)
         return deleted_item
 
-    def __setitem__(self, key: KT, value: VT, /) -> None:
+    def __setitem__(self, key: Key, value: Value, /) -> None:
         self.set(key, value)
 
-    def __delitem__(self, key: KT) -> None:
+    def __delitem__(self, key: Key) -> None:
         if key in self.queue:
             self.queue.remove(key)
         return super().__delitem__(key)

telegrinder/tools/loop_wrapper/abc.py

@@ -3,13 +3,18 @@ from abc import ABC, abstractmethod
 
 
 class ABCLoopWrapper(ABC):
+    @property
     @abstractmethod
-    def add_task(self, task: typing.Any) -> None:
+    def is_running(self) -> bool:
         pass
 
     @abstractmethod
-    def run_event_loop(self) -> None:
+    def add_task(self, task: typing.Any, /) -> None:
         pass
 
+    @abstractmethod
+    def run_event_loop(self) -> typing.NoReturn:
+        raise NotImplementedError
+
 
 __all__ = ("ABCLoopWrapper",)

telegrinder/tools/loop_wrapper/loop_wrapper.py

@@ -1,84 +1,19 @@
 import asyncio
 import contextlib
-import dataclasses
 import datetime
 import typing
 
 from telegrinder.modules import logger
-from telegrinder.tools.loop_wrapper.abc import ABCLoopWrapper
-
-T = typing.TypeVar("T")
-P = typing.ParamSpec("P")
-CoroFunc = typing.TypeVar("CoroFunc", bound="CoroutineFunc[..., typing.Any]")
-
-CoroutineTask: typing.TypeAlias = typing.Coroutine[typing.Any, typing.Any, T]
-CoroutineFunc: typing.TypeAlias = typing.Callable[P, CoroutineTask[T]]
-Task: typing.TypeAlias = (
-    "CoroutineFunc[P, T] | CoroutineTask[T] | DelayedTask[typing.Callable[P, CoroutineTask[T]]]"
+from telegrinder.tools.lifespan import (
+    CoroutineFunc,
+    CoroutineTask,
+    DelayedTask,
+    Lifespan,
+    Task,
+    to_coroutine_task,
 )
-
-
-def run_tasks(
-    tasks: list[CoroutineTask[typing.Any]],
-    loop: asyncio.AbstractEventLoop,
-) -> None:
-    while tasks:
-        loop.run_until_complete(tasks.pop(0))
-
-
-def to_coroutine_task(task: Task) -> CoroutineTask[typing.Any]:
-    if asyncio.iscoroutinefunction(task) or isinstance(task, DelayedTask):
-        task = task()
-    elif not asyncio.iscoroutine(task):
-        raise TypeError("Task should be coroutine or coroutine function.")
-    return task
-
-
-@dataclasses.dataclass(slots=True)
-class DelayedTask(typing.Generic[CoroFunc]):
-    handler: CoroFunc
-    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: typing.Any, **kwargs: typing.Any) -> None:
-        while not self.is_cancelled:
-            await asyncio.sleep(self.seconds)
-            if self.is_cancelled:
-                break
-            try:
-                await self.handler(*args, **kwargs)
-            finally:
-                if not self.repeat:
-                    break
-
-    def cancel(self) -> None:
-        if not self._cancelled:
-            self._cancelled = True
-
-
-@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
-class Lifespan:
-    startup_tasks: list[CoroutineTask[typing.Any]] = dataclasses.field(default_factory=lambda: [])
-    shutdown_tasks: list[CoroutineTask[typing.Any]] = dataclasses.field(default_factory=lambda: [])
-
-    def on_startup(self, task: Task, /) -> Task:
-        self.startup_tasks.append(to_coroutine_task(task))
-        return task
-
-    def on_shutdown(self, task: Task, /) -> Task:
-        self.shutdown_tasks.append(to_coroutine_task(task))
-        return task
-
-    def start(self, loop: asyncio.AbstractEventLoop, /) -> None:
-        run_tasks(self.startup_tasks, loop)
-
-    def shutdown(self, loop: asyncio.AbstractEventLoop, /) -> None:
-        run_tasks(self.shutdown_tasks, loop)
+from telegrinder.tools.loop_wrapper.abc import ABCLoopWrapper
+from telegrinder.tools.magic import cancel_future
 
 
 class LoopWrapper(ABCLoopWrapper):
@@ -87,15 +22,20 @@ class LoopWrapper(ABCLoopWrapper):
         *,
         tasks: list[CoroutineTask[typing.Any]] | None = None,
         lifespan: Lifespan | None = None,
-        event_loop: asyncio.AbstractEventLoop | None = None,
     ) -> None:
         self.tasks: list[CoroutineTask[typing.Any]] = tasks or []
         self.lifespan = lifespan or Lifespan()
-        self._loop = event_loop
+        self._loop: asyncio.AbstractEventLoop | None = None
+
+    @property
+    def is_running(self) -> bool:
+        if self._loop is None:
+            return False
+        return self._loop.is_running()
 
     @property
     def loop(self) -> asyncio.AbstractEventLoop:
-        assert self._loop is not None
+        assert self._loop is not None, "Loop is not set."
         return self._loop
 
     def __repr__(self) -> str:
@@ -106,15 +46,22 @@ class LoopWrapper(ABCLoopWrapper):
             self.lifespan,
         )
 
-    def run_event_loop(self) -> None:
+    async def _run_tasks(self) -> None:
+        async with asyncio.TaskGroup() as tg:
+            while self.tasks:
+                tg.create_task(self.tasks.pop(0))
+
+    def run_event_loop(self) -> typing.NoReturn:  # type: ignore
         if not self.tasks:
-            logger.warning("You run loop with 0 tasks!")
+            logger.warning("Run loop without tasks!")
 
-        self._loop = asyncio.new_event_loop() if self._loop is None else self._loop
-        self.lifespan.start(self._loop)
+        try:
+            self._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            self._loop = asyncio.get_event_loop()
 
-        while self.tasks:
-            self._loop.create_task(self.tasks.pop(0))
+        self.lifespan.start()
+        self._loop.create_task(self._run_tasks())
 
         tasks = asyncio.all_tasks(self._loop)
         try:
@@ -125,19 +72,19 @@ class LoopWrapper(ABCLoopWrapper):
                 for task_result in tasks_results:
                     try:
                         task_result.result()
-                    except BaseException as ex:
-                        logger.exception(ex)
+                    except BaseException:
+                        logger.exception("Traceback message below:")
                 tasks = asyncio.all_tasks(self._loop)
         except KeyboardInterrupt:
             print()  # blank print for ^C
             logger.info("Caught KeyboardInterrupt, cancellation...")
             self.complete_tasks(tasks)
         finally:
-            self.lifespan.shutdown(self._loop)
+            self.lifespan.shutdown()
             if self._loop.is_running():
                 self._loop.close()
 
-    def add_task(self, task: Task) -> None:
+    def add_task(self, task: Task[..., typing.Any], /) -> None:
         task = to_coroutine_task(task)
 
         if self._loop is not None and self._loop.is_running():
@@ -145,12 +92,10 @@ class LoopWrapper(ABCLoopWrapper):
         else:
             self.tasks.append(task)
 
-    def complete_tasks(self, tasks: set[asyncio.Task[typing.Any]]) -> None:
+    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)
+        with contextlib.suppress(asyncio.CancelledError, asyncio.InvalidStateError):
+            self.loop.run_until_complete(cancel_future(asyncio.gather(*tasks, return_exceptions=True)))
 
     @typing.overload
     def timer(self, *, seconds: datetime.timedelta) -> typing.Callable[..., typing.Any]: ...
@@ -180,7 +125,7 @@ class LoopWrapper(ABCLoopWrapper):
         seconds += hours * 60 * 60
         seconds += days * 24 * 60 * 60
 
-        def decorator(func: CoroFunc) -> CoroFunc:
+        def decorator[Func: CoroutineFunc[..., typing.Any]](func: Func) -> Func:
             self.add_task(DelayedTask(func, seconds, repeat=False))
             return func
 
@@ -214,11 +159,11 @@ class LoopWrapper(ABCLoopWrapper):
         seconds += hours * 60 * 60
         seconds += days * 24 * 60 * 60
 
-        def decorator(func: CoroFunc) -> CoroFunc:
+        def decorator[Func: CoroutineFunc[..., typing.Any]](func: Func) -> Func:
             self.add_task(DelayedTask(func, seconds, repeat=True))
             return func
 
         return decorator
 
 
-__all__ = ("DelayedTask", "Lifespan", "LoopWrapper", "to_coroutine_task")
+__all__ = ("DelayedTask", "LoopWrapper", "to_coroutine_task")