telegrinder 0.1.dev166__py3-none-any.whl → 0.1.dev168__py3-none-any.whl

telegrinder/node/attachment.py

@@ -14,21 +14,15 @@ from .message import MessageNode
 class Attachment(DataNode):
     attachment_type: typing.Literal["audio", "document", "photo", "poll", "video"]
     _: dataclasses.KW_ONLY
-    audio: Option[telegrinder.types.Audio] = dataclasses.field(
-        default_factory=lambda: Nothing()
-    )
+    audio: Option[telegrinder.types.Audio] = dataclasses.field(default_factory=lambda: Nothing())
     document: Option[telegrinder.types.Document] = dataclasses.field(
         default_factory=lambda: Nothing()
     )
     photo: Option[list[telegrinder.types.PhotoSize]] = dataclasses.field(
         default_factory=lambda: Nothing()
     )
-    poll: Option[telegrinder.types.Poll] = dataclasses.field(
-        default_factory=lambda: Nothing()
-    )
-    video: Option[telegrinder.types.Video] = dataclasses.field(
-        default_factory=lambda: Nothing()
-    )
+    poll: Option[telegrinder.types.Poll] = dataclasses.field(default_factory=lambda: Nothing())
+    video: Option[telegrinder.types.Video] = dataclasses.field(default_factory=lambda: Nothing())
 
     @classmethod
     async def compose(cls, message: MessageNode) -> "Attachment":
@@ -44,31 +38,41 @@ class Photo(DataNode):
 
     @classmethod
     async def compose(cls, attachment: Attachment) -> typing.Self:
-        return cls(attachment.photo.expect(ComposeError("Attachment is not an photo")))
+        if not attachment.photo:
+            raise ComposeError("Attachment is not an photo")
+        return cls(attachment.photo.unwrap())
 
 
 class Video(ScalarNode, telegrinder.types.Video):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Video:
-        return attachment.video.expect(ComposeError("Attachment is not an video"))
+        if not attachment.video:
+            raise ComposeError("Attachment is not an video")
+        return attachment.video.unwrap()
 
 
 class Audio(ScalarNode, telegrinder.types.Audio):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Audio:
-        return attachment.audio.expect(ComposeError("Attachment is not an audio"))
+        if not attachment.audio:
+            raise ComposeError("Attachment is not an audio")
+        return attachment.audio.unwrap()
 
 
 class Document(ScalarNode, telegrinder.types.Document):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Document:
-        return attachment.document.expect(ComposeError("Attachment is not an document"))
+        if not attachment.document:
+            raise ComposeError("Attachment is not an document")
+        return attachment.document.unwrap()
 
 
 class Poll(ScalarNode, telegrinder.types.Poll):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Poll:
-        return attachment.poll.expect(ComposeError("Attachment is not an poll"))
+        if not attachment.poll:
+            raise ComposeError("Attachment is not an poll")
+        return attachment.poll.unwrap()
 
 
 __all__ = (

telegrinder/node/base.py

@@ -3,8 +3,7 @@ import inspect
 import typing
 
 ComposeResult: typing.TypeAlias = (
-    typing.Coroutine[typing.Any, typing.Any, typing.Any]
-    | typing.AsyncGenerator[typing.Any, None]
+    typing.Coroutine[typing.Any, typing.Any, typing.Any] | typing.AsyncGenerator[typing.Any, None]
 )
 
 
@@ -16,9 +15,7 @@ class Node(abc.ABC):
 
     @classmethod
     @abc.abstractmethod
-    def compose(
-        cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any
-    ) -> ComposeResult:
+    def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
         pass
 
     @classmethod
@@ -52,18 +49,14 @@ class DataNode(Node, abc.ABC):
     @typing.dataclass_transform()
     @classmethod
     @abc.abstractmethod
-    async def compose(
-        cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any
-    ) -> ComposeResult:
+    async def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
         pass
 
 
 class ScalarNodeProto(Node, abc.ABC):
     @classmethod
     @abc.abstractmethod
-    async def compose(
-        cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any
-    ) -> ComposeResult:
+    async def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
         pass
 
 

telegrinder/node/composer.py

@@ -27,9 +27,7 @@ class NodeSession:
             self.generator = None
 
     def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}: {self.value}" + (
-            "ACTIVE>" if self.generator else ">"
-        )
+        return f"<{self.__class__.__name__}: {self.value}" + ("ACTIVE>" if self.generator else ">")
 
 
 class NodeCollection:

telegrinder/node/message.py

@@ -9,8 +9,10 @@ from .update import UpdateNode
 class MessageNode(ScalarNode, MessageCute):
     @classmethod
     async def compose(cls, update: UpdateNode) -> typing.Self:
+        if not update.message:
+            raise ComposeError
         return cls(
-            **update.message.expect(ComposeError).to_dict(),
+            **update.message.unwrap().to_dict(),
             api=update.api,
         )
 

telegrinder/node/source.py

@@ -24,7 +24,9 @@ class Source(DataNode):
 
     async def send(self, text: str) -> Message:
         result = await self.api.send_message(
-            self.chat.id, message_thread_id=self.thread_id, text=text
+            chat_id=self.chat.id,
+            message_thread_id=self.thread_id,
+            text=text,
         )
         return result.unwrap()
 

telegrinder/node/text.py

@@ -7,7 +7,9 @@ from .message import MessageNode
 class Text(ScalarNode, str):
     @classmethod
     async def compose(cls, message: MessageNode) -> typing.Self:
-        return cls(message.text.expect(ComposeError("Message has no text")))
+        if not message.text:
+            raise ComposeError("Message has no text")
+        return cls(message.text.unwrap())
 
 
 __all__ = ("Text",)

telegrinder/tools/__init__.py

@@ -66,6 +66,7 @@ from .keyboard import (
     Keyboard,
     RowButtons,
 )
+from .limited_dict import LimitedDict
 from .loop_wrapper import ABCLoopWrapper, DelayedTask, Lifespan, LoopWrapper
 from .magic import magic_bundle, resolve_arg_names
 from .parse_mode import ParseMode
@@ -99,6 +100,7 @@ __all__ = (
     "KeyboardSetBase",
     "KeyboardSetYAML",
     "Lifespan",
+    "LimitedDict",
     "Link",
     "LoopWrapper",
     "Mention",

telegrinder/tools/buttons.py

@@ -63,15 +63,13 @@ class InlineButton(BaseButton):
     url: str | None = None
     login_url: dict[str, typing.Any] | LoginUrl | None = None
     pay: bool | None = None
-    callback_data: (
-        str | dict[str, typing.Any] | DataclassInstance | msgspec.Struct | None
-    ) = None
+    callback_data: str | dict[str, typing.Any] | DataclassInstance | msgspec.Struct | None = None
     callback_game: dict[str, typing.Any] | CallbackGame | None = None
     switch_inline_query: str | None = None
     switch_inline_query_current_chat: str | None = None
-    switch_inline_query_chosen_chat: (
-        dict[str, typing.Any] | SwitchInlineQueryChosenChat | None
-    ) = None
+    switch_inline_query_chosen_chat: dict[str, typing.Any] | SwitchInlineQueryChosenChat | None = (
+        None
+    )
     web_app: dict[str, typing.Any] | WebAppInfo | None = None
 
 

telegrinder/tools/error_handler/abc.py

@@ -16,9 +16,7 @@ class ABCErrorHandler(ABC, typing.Generic[EventT]):
         self,
         *args: typing.Any,
         **kwargs: typing.Any,
-    ) -> typing.Callable[
-        [typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]
-    ]:
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
         """Decorator for registering callback as an error handler."""
 
     @abstractmethod

telegrinder/tools/error_handler/error.py

@@ -1,10 +1,7 @@
-import typing
-
-
-class CatcherError(TypeError):
-    def __init__(self, exc: typing.Any, error: str) -> None:
+class CatcherError(BaseException):
+    def __init__(self, exc: BaseException, message: str) -> None:
         self.exc = exc
-        self.error = error
+        self.message = message
 
 
 __all__ = ("CatcherError",)

telegrinder/tools/error_handler/error_handler.py

@@ -13,9 +13,7 @@ from .error import CatcherError
 
 F = typing.TypeVar("F", bound="FuncCatcher")
 ExceptionT = typing.TypeVar("ExceptionT", bound=BaseException, contravariant=True)
-FuncCatcher = typing.Callable[
-    typing.Concatenate[ExceptionT, ...], typing.Awaitable[typing.Any]
-]
+FuncCatcher = typing.Callable[typing.Concatenate[ExceptionT, ...], typing.Awaitable[typing.Any]]
 
 
 @dataclasses.dataclass(frozen=True, repr=False)
@@ -59,8 +57,7 @@ class Catcher(typing.Generic[EventT]):
     ) -> Result[typing.Any, BaseException]:
         if self.match_exception(exception):
             logger.debug(
-                "Catcher {!r} caught an exception in handler {!r}, "
-                "running catcher...".format(
+                "Catcher {!r} caught an exception in handler {!r}, " "running catcher...".format(
                     self.func.__name__,
                     handler_name,
                 )
@@ -109,7 +106,8 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         ignore_errors: bool = False,
     ):
         """Register the catcher.
-        :param logging: Error logging in stderr.
+
+        :param logging: Logging the result of the catcher at the level 'DEBUG'.
         :param raise_exception: Raise an exception if the catcher hasn't started.
         :param ignore_errors: Ignore errors that may occur.
         """
@@ -142,21 +140,21 @@ class ErrorHandler(ABCErrorHandler[EventT]):
             return Error(
                 CatcherError(
                     exc,
-                    "Exception {!r} was occurred during the running catcher {!r}.".format(
+                    "Exception {} was occurred during the running catcher {!r}.".format(
                         repr(exc), self.catcher.func.__name__
                     ),
                 )
             )
 
-    def process_catcher_error(self, error: CatcherError) -> Result[None, str]:
+    def process_catcher_error(self, error: CatcherError) -> Result[None, BaseException]:
         assert self.catcher is not None
 
         if self.catcher.raise_exception:
             raise error.exc from None
-        if not self.catcher.ignore_errors:
-            return Error(error.error)
         if self.catcher.logging:
-            logger.error(error.error)
+            logger.error(error.message)
+        if not self.catcher.ignore_errors:
+            return Error(error.exc)
 
         return Ok(None)
 
@@ -166,12 +164,18 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         event: EventT,
         api: ABCAPI,
         ctx: Context,
-    ) -> Result[typing.Any, typing.Any]:
+    ) -> Result[typing.Any, BaseException]:
         if not self.catcher:
             return Ok(await handler(event, **magic_bundle(handler, ctx)))  # type: ignore
 
         match await self.process(handler, event, api, ctx):
-            case Ok(_) as ok:
+            case Ok(value) as ok:
+                if self.catcher.logging:
+                    logger.debug(
+                        "Catcher {!r} returned a value: {!r}",
+                        self.catcher.func.__name__,
+                        value,
+                    )
                 return ok
             case Error(exc) as err:
                 if isinstance(exc, CatcherError):

telegrinder/tools/formatting/html.py

@@ -49,9 +49,7 @@ class StringFormatter(string.Formatter):
             )
         return fmt
 
-    def get_spec_formatter(
-        self, value: SpecialFormat
-    ) -> typing.Callable[..., "TagFormat"]:
+    def get_spec_formatter(self, value: SpecialFormat) -> typing.Callable[..., "TagFormat"]:
         return globals()[value.__formatter_name__]
 
     def check_formats(self, value: typing.Any, fmts: list[str]) -> "TagFormat":
@@ -241,9 +239,7 @@ def start_bot_link(bot_id: str | int, data: str, string: str | None = None) -> T
     return link(get_start_bot_link(bot_id, data), string)
 
 
-def start_group_link(
-    bot_id: str | int, data: str, string: str | None = None
-) -> TagFormat:
+def start_group_link(bot_id: str | int, data: str, string: str | None = None) -> TagFormat:
     return link(get_start_group_link(bot_id, data), string)
 
 

telegrinder/tools/formatting/links.py

@@ -29,9 +29,7 @@ def get_invite_chat_link(invite_link: str) -> str:
 
 
 def user_open_message_link(user_id: int, message: str | None = None) -> str:
-    return f"tg://openmessage?user_id={user_id}" + (
-        "" if not message else f"&msg?text={message}"
-    )
+    return f"tg://openmessage?user_id={user_id}" + ("" if not message else f"&msg?text={message}")
 
 
 __all__ = (

telegrinder/tools/global_context/abc.py

@@ -36,9 +36,7 @@ class GlobalCtxVar(typing.Generic[T]):
     @classmethod
     def collect(cls, name: str, ctx_value: T | CtxVariable[T]) -> typing.Self:
         ctx_value = (
-            CtxVar(ctx_value)
-            if not isinstance(ctx_value, CtxVar | GlobalCtxVar)
-            else ctx_value
+            CtxVar(ctx_value) if not isinstance(ctx_value, CtxVar | GlobalCtxVar) else ctx_value
         )
         params = ctx_value.__dict__
         params["name"] = name

telegrinder/tools/global_context/global_context.py

@@ -15,10 +15,8 @@ F = typing.TypeVar("F", bound=typing.Callable)
 CtxValueT = typing.TypeVar("CtxValueT", default=typing.Any)
 
 if typing.TYPE_CHECKING:
-
     _: typing.TypeAlias = None
 else:
-
     _ = lambda: None
 
 
@@ -51,14 +49,10 @@ def root_protection(func: F) -> F:
 
     @wraps(func)
     def wrapper(self: "GlobalContext", name: str, /, *args) -> typing.Any:
-        if self.is_root_attribute(name) and name in (
-            self.__dict__ | self.__class__.__dict__
-        ):
+        if self.is_root_attribute(name) and name in (self.__dict__ | self.__class__.__dict__):
             root_attr = self.get_root_attribute(name).unwrap()
             if all((not root_attr.can_be_rewritten, not root_attr.can_be_read)):
-                raise AttributeError(
-                    f"Unable to set, get, delete root attribute {name!r}."
-                )
+                raise AttributeError(f"Unable to set, get, delete root attribute {name!r}.")
             if func.__name__ == "__setattr__" and not root_attr.can_be_rewritten:
                 raise AttributeError(f"Unable to set root attribute {name!r}.")
             if func.__name__ == "__getattr__" and not root_attr.can_be_read:
@@ -106,9 +100,7 @@ class Storage:
     )
 
     def __repr__(self) -> str:
-        return "<ContextStorage: %s>" % ", ".join(
-            "ctx @" + repr(x) for x in self._storage
-        )
+        return "<ContextStorage: %s>" % ", ".join("ctx @" + repr(x) for x in self._storage)
 
     @property
     def storage(self) -> dict[str, "GlobalContext"]:
@@ -132,7 +124,9 @@ class Storage:
     order_default=True,
     field_specifiers=(ctx_var,),
 )
-class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, GlobalCtxVar[CtxValueT]]):
+class GlobalContext(
+    ABCGlobalContext, typing.Generic[CtxValueT], dict[str, GlobalCtxVar[CtxValueT]]
+):
     """GlobalContext.
 
     ```
@@ -208,19 +202,14 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         """Returns True if the names of context stores
         that use self and __value instances are equivalent."""
 
-        return (
-            isinstance(__value, GlobalContext)
-            and self.__ctx_name__ == __value.__ctx_name__
-        )
+        return isinstance(__value, GlobalContext) and self.__ctx_name__ == __value.__ctx_name__
 
     def __setitem__(self, __name: str, __value: CtxValueT | CtxVariable[CtxValueT]):
         if is_dunder(__name):
             raise NameError("Cannot set a context variable with dunder name.")
         var = self.get(__name)
         if var and var.unwrap().const:
-            raise TypeError(
-                f"Unable to set variable {__name!r}, because it's a constant."
-            )
+            raise TypeError(f"Unable to set variable {__name!r}, because it's a constant.")
         dict.__setitem__(self, __name, GlobalCtxVar.collect(__name, __value))
 
     def __getitem__(self, __name: str) -> CtxValueT:
@@ -229,9 +218,7 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
     def __delitem__(self, __name: str):
         var = self.get(__name).unwrap()
         if var.const:
-            raise TypeError(
-                f"Unable to delete variable {__name!r}, because it's a constant."
-            )
+            raise TypeError(f"Unable to delete variable {__name!r}, because it's a constant.")
         dict.__delitem__(self, __name)
 
     @root_protection
@@ -328,9 +315,7 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
         var_value_type: type[T],
     ) -> Option[GlobalCtxVar[T]]: ...
 
-    def pop(
-        self, var_name: str, var_value_type: type[T] = object
-    ) -> Option[GlobalCtxVar[T]]:
+    def pop(self, var_name: str, var_value_type: type[T] = object) -> Option[GlobalCtxVar[T]]:
         """Pop context variable by name."""
 
         val = self.get(var_name, var_value_type)
@@ -398,9 +383,7 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
 
         var = self.get(old_var_name).unwrap()
         if var.const:
-            return Error(
-                f"Unable to rename variable {old_var_name!r}, " "because it's a constant."
-            )
+            return Error(f"Unable to rename variable {old_var_name!r}, " "because it's a constant.")
         del self[old_var_name]
         self[new_var_name] = var.value
         return Ok(_())
@@ -419,9 +402,8 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
             return dict.clear(self)
 
         for name, var in self.dict().items():
-            if var.const:
-                continue
-            del self[name]
+            if not var.const:
+                del self[name]
 
     def delete_ctx(self) -> Result[_, str]:
         """Delete context by `ctx_name`."""

telegrinder/tools/i18n/middleware/base.py

@@ -17,9 +17,7 @@ class ABCTranslatorMiddleware(ABCMiddleware[T]):
         pass
 
     async def pre(self, event: T, ctx: dict) -> bool:
-        ctx[I18nEnum.I18N] = self.i18n.get_translator_by_locale(
-            await self.get_locale(event)
-        )
+        ctx[I18nEnum.I18N] = self.i18n.get_translator_by_locale(await self.get_locale(event))
         return True
 
 

telegrinder/tools/limited_dict.py

@@ -0,0 +1,37 @@
+import typing
+from collections import UserDict, deque
+
+KT = typing.TypeVar("KT")
+VT = typing.TypeVar("VT")
+
+
+class LimitedDict(UserDict[KT, VT]):
+    def __init__(self, *, maxlimit: int = 1000) -> None:
+        super().__init__()
+        self.maxlimit = maxlimit
+        self.queue: deque[KT] = deque(maxlen=maxlimit)
+
+    def set(self, key: KT, value: VT, /) -> VT | 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)
+        if key not in self.queue:
+            self.queue.append(key)
+        super().__setitem__(key, value)
+        return deleted_item
+
+    def __setitem__(self, key: KT, value: VT, /) -> None:
+        self.set(key, value)
+    
+    def __delitem__(self, key: KT) -> None:
+        if key in self.queue:
+            self.queue.remove(key)
+        return super().__delitem__(key)
+
+
+__all__ = ("LimitedDict",)

telegrinder/tools/loop_wrapper/loop_wrapper.py

@@ -17,7 +17,7 @@ Task: typing.TypeAlias = typing.Union[CoroutineFunc, CoroutineTask, "DelayedTask
 
 
 def run_tasks(
-    tasks: list[CoroutineTask[typing.Any]], 
+    tasks: list[CoroutineTask[typing.Any]],
     loop: asyncio.AbstractEventLoop,
 ) -> None:
     while tasks:
@@ -59,12 +59,8 @@ class DelayedTask(typing.Generic[CoroFunc]):
 
 @dataclasses.dataclass(kw_only=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: []
-    )
+    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_or_func: Task) -> Task:
         task_or_func = to_coroutine_task(task_or_func)