telegrinder 0.1.dev165__py3-none-any.whl → 0.1.dev167__py3-none-any.whl

telegrinder/msgspec_utils.py

@@ -15,15 +15,14 @@ else:
 
     datetime = type("datetime", (dt,), {})
 
-
     class OptionMeta(type):
         def __instancecheck__(cls, __instance: typing.Any) -> bool:
             return isinstance(__instance, fntypes.option.Some | fntypes.option.Nothing)
 
-
     class Option(typing.Generic[Value], metaclass=OptionMeta):
         pass
 
+
 T = typing.TypeVar("T")
 Ts = typing.TypeVarTuple("Ts")
 
@@ -51,13 +50,13 @@ def msgspec_convert(obj: typing.Any, t: type[T]) -> Result[T, msgspec.Validation
 def option_dec_hook(tp: type[Option[typing.Any]], obj: typing.Any) -> Option[typing.Any]:
     if obj is None:
         return Nothing
-    value_type, = typing.get_args(tp) or (typing.Any,)
+    (value_type,) = typing.get_args(tp) or (typing.Any,)
     return msgspec_convert({"value": obj}, fntypes.option.Some[value_type]).unwrap()
 
 
 def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
     union_types = typing.get_args(tp)
-    
+
     if isinstance(obj, dict):
         struct_fields_match_sums: dict[type[msgspec.Struct], int] = {
             m: sum(1 for k in obj if k in m.__struct_fields__)
@@ -68,14 +67,20 @@ def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
         reverse = False
 
         if len(set(struct_fields_match_sums.values())) != len(struct_fields_match_sums.values()):
-            struct_fields_match_sums = {m: len(m.__struct_fields__) for m in struct_fields_match_sums}
+            struct_fields_match_sums = {
+                m: len(m.__struct_fields__) for m in struct_fields_match_sums
+            }
             reverse = True
 
         union_types = (
-            *sorted(struct_fields_match_sums, key=lambda k: struct_fields_match_sums[k], reverse=reverse),
+            *sorted(
+                struct_fields_match_sums,
+                key=lambda k: struct_fields_match_sums[k],
+                reverse=reverse,
+            ),
             *union_types,
         )
-    
+
     for t in union_types:
         match msgspec_convert(obj, t):
             case Ok(value):
@@ -92,7 +97,7 @@ def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
 class Decoder:
     """Class `Decoder` for `msgspec` module with decode hook
     for objects with the specified type.
-    
+
     ```
     import enum
 
@@ -122,7 +127,7 @@ class Decoder:
             Variative: variative_dec_hook,
             datetime: lambda t, obj: t.fromtimestamp(obj),
         }
-    
+
     def __repr__(self) -> str:
         return "<{}: dec_hooks={!r}>".format(
             self.__class__.__name__,
@@ -132,9 +137,9 @@ class Decoder:
     def add_dec_hook(self, t: T):  # type: ignore
         def decorator(func: DecHook[T]) -> DecHook[T]:
             return self.dec_hooks.setdefault(get_origin(t), func)  # type: ignore
-        
+
         return decorator
-    
+
     def dec_hook(self, tp: type[typing.Any], obj: object) -> object:
         origin_type = t if isinstance((t := get_origin(tp)), type) else type(t)
         if origin_type not in self.dec_hooks:
@@ -143,7 +148,7 @@ class Decoder:
                 "You can implement decode hook for this type."
             )
         return self.dec_hooks[origin_type](tp, obj)
-    
+
     def convert(
         self,
         obj: object,
@@ -163,14 +168,12 @@ class Decoder:
             builtin_types=builtin_types,
             str_keys=str_keys,
         )
-    
+
     @typing.overload
-    def decode(self, buf: str | bytes) -> typing.Any:
-        ...
-    
+    def decode(self, buf: str | bytes) -> typing.Any: ...
+
     @typing.overload
-    def decode(self, buf: str | bytes, *, strict: bool = True) -> typing.Any:
-        ...
+    def decode(self, buf: str | bytes, *, strict: bool = True) -> typing.Any: ...
 
     @typing.overload
     def decode(
@@ -179,8 +182,7 @@ class Decoder:
         *,
         type: type[T],
         strict: bool = True,
-    ) -> T:
-        ...
+    ) -> T: ...
 
     def decode(
         self,
@@ -199,7 +201,7 @@ class Decoder:
 
 class Encoder:
     """Class `Encoder` for `msgspec` module with encode hooks for objects.
-    
+
     ```
     from datetime import datetime as dt
 
@@ -231,9 +233,9 @@ class Encoder:
         def decorator(func: EncHook[T]) -> EncHook[T]:
             encode_hook = self.enc_hooks.setdefault(get_origin(t), func)
             return func if encode_hook is not func else encode_hook
-        
+
         return decorator
-    
+
     def enc_hook(self, obj: object) -> object:
         origin_type = get_origin(obj.__class__)
         if origin_type not in self.enc_hooks:
@@ -244,16 +246,13 @@ class Encoder:
         return self.enc_hooks[origin_type](obj)
 
     @typing.overload
-    def encode(self, obj: typing.Any) -> str:
-        ...
-    
+    def encode(self, obj: typing.Any) -> str: ...
+
     @typing.overload
-    def encode(self, obj: typing.Any, *, as_str: typing.Literal[True]) -> str:
-        ...
+    def encode(self, obj: typing.Any, *, as_str: typing.Literal[True]) -> str: ...
 
     @typing.overload
-    def encode(self, obj: typing.Any, *, as_str: typing.Literal[False]) -> bytes:
-        ...
+    def encode(self, obj: typing.Any, *, as_str: typing.Literal[False]) -> bytes: ...
 
     def encode(self, obj: typing.Any, *, as_str: bool = True) -> str | bytes:
         buf = msgspec.json.encode(obj, enc_hook=self.enc_hook)
@@ -267,14 +266,14 @@ encoder: typing.Final[Encoder] = Encoder()
 __all__ = (
     "Decoder",
     "Encoder",
-    "Option",
     "Nothing",
+    "Option",
+    "datetime",
+    "decoder",
+    "encoder",
     "get_origin",
-    "repr_type",
     "msgspec_convert",
     "option_dec_hook",
+    "repr_type",
     "variative_dec_hook",
-    "datetime",
-    "decoder",
-    "encoder",
 )

telegrinder/node/__init__.py

@@ -10,22 +10,22 @@ from .tools import generate
 from .update import UpdateNode
 
 __all__ = (
-    "Node",
-    "DataNode",
-    "ScalarNode",
     "Attachment",
-    "Photo",
-    "Video",
-    "Text",
     "Audio",
-    "UpdateNode",
-    "compose_node",
     "ComposeError",
+    "ContainerNode",
+    "DataNode",
     "MessageNode",
-    "Source",
-    "NodeSession",
+    "Node",
     "NodeCollection",
-    "ContainerNode",
-    "generate",
+    "NodeSession",
+    "Photo",
     "RuleContext",
+    "ScalarNode",
+    "Source",
+    "Text",
+    "UpdateNode",
+    "Video",
+    "compose_node",
+    "generate",
 )

telegrinder/node/attachment.py

@@ -15,8 +15,12 @@ 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())
-    document: Option[telegrinder.types.Document] = dataclasses.field(default_factory=lambda: Nothing())
-    photo: Option[list[telegrinder.types.PhotoSize]] = 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())
 
@@ -34,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

@@ -2,11 +2,12 @@ import abc
 import inspect
 import typing
 
-ComposeResult: typing.TypeAlias = typing.Coroutine[typing.Any, typing.Any, typing.Any] | typing.AsyncGenerator[typing.Any, None]
+ComposeResult: typing.TypeAlias = (
+    typing.Coroutine[typing.Any, typing.Any, typing.Any] | typing.AsyncGenerator[typing.Any, None]
+)
 
 
-class ComposeError(BaseException):
-    ...
+class ComposeError(BaseException): ...
 
 
 class Node(abc.ABC):
@@ -24,7 +25,7 @@ class Node(abc.ABC):
     @classmethod
     def get_sub_nodes(cls) -> dict[str, type[typing.Self]]:
         parameters = inspect.signature(cls.compose).parameters
-        
+
         sub_nodes = {}
         for name, param in parameters.items():
             if param.annotation is inspect._empty:
@@ -32,11 +33,11 @@ class Node(abc.ABC):
             node = param.annotation
             sub_nodes[name] = node
         return sub_nodes
-    
+
     @classmethod
     def as_node(cls) -> type[typing.Self]:
         return cls
-    
+
     @classmethod
     def is_generator(cls) -> bool:
         return inspect.isasyncgenfunction(cls.compose)
@@ -64,9 +65,9 @@ SCALAR_NODE = type("ScalarNode", (), {"node": "scalar"})
 
 if typing.TYPE_CHECKING:
 
-    class ScalarNode(ScalarNodeProto, abc.ABC): 
+    class ScalarNode(ScalarNodeProto, abc.ABC):
         pass
-    
+
 else:
 
     def create_node(cls, bases, dct):
@@ -75,8 +76,8 @@ else:
 
     def create_class(name, bases, dct):
         return type(
-            "Scalar", 
-            (SCALAR_NODE,), 
+            "Scalar",
+            (SCALAR_NODE,),
             {"as_node": classmethod(lambda cls: create_node(cls, bases, dct))},
         )
 
@@ -85,9 +86,9 @@ else:
 
 
 __all__ = (
-    "ScalarNode",
-    "SCALAR_NODE",
+    "ComposeError",
     "DataNode",
     "Node",
-    "ComposeError",
+    "SCALAR_NODE",
+    "ScalarNode",
 )

telegrinder/node/composer.py

@@ -6,7 +6,7 @@ from telegrinder.node import Node
 
 class NodeSession:
     def __init__(
-        self, 
+        self,
         value: typing.Any,
         subnodes: dict[str, typing.Self],
         generator: typing.AsyncGenerator[typing.Any, None] | None = None,
@@ -14,11 +14,11 @@ class NodeSession:
         self.value = value
         self.subnodes = subnodes
         self.generator = generator
-    
+
     async def close(self, with_value: typing.Any | None = None) -> None:
         for subnode in self.subnodes.values():
             await subnode.close()
-        
+
         if self.generator is None:
             return
         try:
@@ -36,7 +36,7 @@ class NodeCollection:
 
     def values(self) -> dict[str, typing.Any]:
         return {name: session.value for name, session in self.sessions.items()}
-    
+
     async def close_all(self, with_value: typing.Any | None = None) -> None:
         for session in self.sessions.values():
             await session.close(with_value)
@@ -64,7 +64,7 @@ async def compose_node(
     else:
         generator = None
         value = await _node.compose(**context.values())  # type: ignore
-    
+
     return NodeSession(value, context.sessions, generator)
 
 

telegrinder/node/container.py

@@ -13,7 +13,7 @@ class ContainerNode(Node):
     @classmethod
     def get_sub_nodes(cls) -> dict[str, type["Node"]]:
         return {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
-    
+
     @classmethod
     def link_nodes(cls, linked_nodes: list[type[Node]]) -> type["ContainerNode"]:
         return type("_ContainerNode", (cls,), {"linked_nodes": linked_nodes})

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/rule.py

@@ -26,7 +26,7 @@ class RuleContext(dict):
     @classmethod
     def as_node(cls) -> type[typing.Self]:
         return cls
-    
+
     @classmethod
     def get_sub_nodes(cls) -> dict:
         return {"update": UpdateNode}
@@ -37,16 +37,16 @@ class RuleContext(dict):
 
     def __new__(cls, *rules: ABCRule) -> type[Node]:
         return type("_RuleNode", (cls,), {"dataclass": dict, "rules": rules})  # type: ignore
-    
+
     def __class_getitem__(cls, item: tuple[ABCRule, ...]) -> typing.Self:
         if not isinstance(item, tuple):
             item = (item,)
         return cls(*item)
-    
+
     @staticmethod
     def generate_dataclass(cls_: type["RuleContext"]):  # noqa: ANN205
         return dataclasses.dataclass(type(cls_.__name__, (object,), dict(cls_.__dict__)))
-    
+
     def __init_subclass__(cls) -> None:
         if cls.__name__ == "_RuleNode":
             return

telegrinder/node/source.py

@@ -21,9 +21,13 @@ class Source(DataNode):
             chat=message.chat,
             thread_id=message.message_thread_id.unwrap_or_none(),
         )
-    
+
     async def send(self, text: str) -> Message:
-        result = await self.api.send_message(self.chat.id, message_thread_id=self.thread_id, text=text)
+        result = await self.api.send_message(
+            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/node/tools/generator.py

@@ -20,7 +20,7 @@ def error_on_none(value: T | None) -> T:
 
 
 def generate(
-    subnodes: tuple[type[Node], ...], 
+    subnodes: tuple[type[Node], ...],
     func: typing.Callable[..., typing.Any],
     casts: tuple[typing.Callable, ...] = (cast_false_to_none, error_on_none),
 ) -> type[ContainerNode]:

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
@@ -98,8 +99,9 @@ __all__ = (
     "Keyboard",
     "KeyboardSetBase",
     "KeyboardSetYAML",
-    "Link",
     "Lifespan",
+    "Link",
+    "LimitedDict",
     "LoopWrapper",
     "Mention",
     "ParseMode",

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

@@ -4,10 +4,9 @@ from abc import ABC, abstractmethod
 from fntypes.result import Result
 
 from telegrinder.api import ABCAPI
-from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.context import Context
 
-EventT = typing.TypeVar("EventT", bound=BaseCute)
+EventT = typing.TypeVar("EventT")
 Handler = typing.Callable[typing.Concatenate[EventT, ...], typing.Awaitable[typing.Any]]
 
 

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

@@ -57,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,
                 )
@@ -71,7 +70,7 @@ class Catcher(typing.Generic[EventT]):
             )
         logger.debug("Failed to match exception {!r}!", exception.__class__.__name__)
         return Error(exception)
-    
+
     def match_exception(self, exception: BaseException) -> bool:
         for exc in self.exceptions:
             if isinstance(exc, type) and type(exception) is exc:
@@ -84,10 +83,11 @@ class Catcher(typing.Generic[EventT]):
 class ErrorHandler(ABCErrorHandler[EventT]):
     def __init__(self, catcher: Catcher[EventT] | None = None, /) -> None:
         self.catcher = catcher
-    
+
     def __repr__(self) -> str:
         return (
-            "<ErrorHandler: exceptions_handled=[{}], catcher={!r}>".format(
+            "<{}: exceptions_handled=[{}], catcher={!r}>".format(
+                self.__class__.__name__,
                 ", ".join(
                     e.__name__ if isinstance(e, type) else repr(e)
                     for e in self.catcher.exceptions
@@ -95,7 +95,7 @@ class ErrorHandler(ABCErrorHandler[EventT]):
                 self.catcher,
             )
             if self.catcher is not None
-            else "<ErrorHandler: No catcher>"
+            else "<{}: No catcher>".format(self.__class__.__name__)
         )
 
     def __call__(
@@ -106,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.
         """
@@ -121,8 +122,9 @@ class ErrorHandler(ABCErrorHandler[EventT]):
                     ignore_errors=ignore_errors,
                 )
             return func
+
         return decorator
-    
+
     async def process(
         self,
         handler: Handler[EventT],
@@ -135,23 +137,25 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         try:
             return await self.catcher(handler, event, api, ctx)
         except BaseException as exc:
-            return Error(CatcherError(
-                exc,
-                "Exception {!r} was occurred during the running catcher {!r}.".format(
-                    repr(exc), self.catcher.func.__name__
+            return Error(
+                CatcherError(
+                    exc,
+                    "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)
 
     async def run(
@@ -160,16 +164,22 @@ 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):
-                    return self.process_catcher_error(exc)              
+                    return self.process_catcher_error(exc)
                 if self.catcher.ignore_errors:
                     return Ok(None)
                 return err