telegrinder 0.1.dev164__py3-none-any.whl → 0.1.dev166__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,14 +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
-    generic_args = typing.get_args(tp)
-    value_type: typing.Any | type[typing.Any] = typing.Any if not generic_args else generic_args[0]
+    (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,15 +66,23 @@ def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
         union_types = tuple(t for t in union_types if t not in struct_fields_match_sums)
         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}
+        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
+            }
             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):
@@ -93,7 +99,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
 
@@ -124,12 +130,18 @@ class Decoder:
             datetime: lambda t, obj: t.fromtimestamp(obj),
         }
 
+    def __repr__(self) -> str:
+        return "<{}: dec_hooks={!r}>".format(
+            self.__class__.__name__,
+            self.dec_hooks,
+        )
+
     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:
@@ -138,7 +150,7 @@ class Decoder:
                 "You can implement decode hook for this type."
             )
         return self.dec_hooks[origin_type](tp, obj)
-    
+
     def convert(
         self,
         obj: object,
@@ -158,14 +170,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(
@@ -174,8 +184,7 @@ class Decoder:
         *,
         type: type[T],
         strict: bool = True,
-    ) -> T:
-        ...
+    ) -> T: ...
 
     def decode(
         self,
@@ -194,7 +203,7 @@ class Decoder:
 
 class Encoder:
     """Class `Encoder` for `msgspec` module with encode hooks for objects.
-    
+
     ```
     from datetime import datetime as dt
 
@@ -216,13 +225,19 @@ class Encoder:
             datetime: lambda date: int(date.timestamp()),
         }
 
+    def __repr__(self) -> str:
+        return "<{}: enc_hooks={!r}>".format(
+            self.__class__.__name__,
+            self.enc_hooks,
+        )
+
     def add_dec_hook(self, t: type[T]):
         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:
@@ -233,16 +248,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)
@@ -256,14 +268,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

@@ -14,11 +14,21 @@ 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())
-    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())
+    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()
+    )
 
     @classmethod
     async def compose(cls, message: MessageNode) -> "Attachment":

telegrinder/node/base.py

@@ -2,11 +2,13 @@ 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):
@@ -14,7 +16,9 @@ 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
@@ -24,7 +28,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 +36,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)
@@ -48,14 +52,18 @@ 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
 
 
@@ -64,9 +72,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 +83,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 +93,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:
@@ -27,7 +27,9 @@ class NodeSession:
             self.generator = None
 
     def __repr__(self) -> str:
-        return f"<NodeSession: {self.value}" + ("ACTIVE>" if self.generator else ">")
+        return f"<{self.__class__.__name__}: {self.value}" + (
+            "ACTIVE>" if self.generator else ">"
+        )
 
 
 class NodeCollection:
@@ -36,7 +38,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 +66,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/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,11 @@ 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(
+            self.chat.id, message_thread_id=self.thread_id, text=text
+        )
         return result.unwrap()
 
 

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,7 +66,7 @@ from .keyboard import (
     Keyboard,
     RowButtons,
 )
-from .loop_wrapper import ABCLoopWrapper, DelayedTask, LoopWrapper
+from .loop_wrapper import ABCLoopWrapper, DelayedTask, Lifespan, LoopWrapper
 from .magic import magic_bundle, resolve_arg_names
 from .parse_mode import ParseMode
 
@@ -98,6 +98,7 @@ __all__ = (
     "Keyboard",
     "KeyboardSetBase",
     "KeyboardSetYAML",
+    "Lifespan",
     "Link",
     "LoopWrapper",
     "Mention",

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]]
 
 
@@ -17,7 +16,9 @@ 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_handler.py

@@ -13,7 +13,9 @@ 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)
@@ -71,7 +73,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 +86,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 +98,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__(
@@ -121,8 +124,9 @@ class ErrorHandler(ABCErrorHandler[EventT]):
                     ignore_errors=ignore_errors,
                 )
             return func
+
         return decorator
-    
+
     async def process(
         self,
         handler: Handler[EventT],
@@ -135,23 +139,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 {!r} was occurred during the running catcher {!r}.".format(
+                        repr(exc), self.catcher.func.__name__
+                    ),
                 )
-            ))
-        
+            )
+
     def process_catcher_error(self, error: CatcherError) -> Result[None, str]:
         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)
-        
+
         return Ok(None)
 
     async def run(
@@ -163,13 +169,13 @@ class ErrorHandler(ABCErrorHandler[EventT]):
     ) -> Result[typing.Any, typing.Any]:
         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:
                 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