telegrinder 0.1.dev163__py3-none-any.whl → 0.1.dev164__py3-none-any.whl

telegrinder/bot/dispatch/abc.py

@@ -14,7 +14,7 @@ class ABCDispatch(ABC):
         pass
 
     @abstractmethod
-    def load(self, external: typing.Self):
+    def load(self, external: typing.Self) -> None:
         pass
 
 

telegrinder/bot/dispatch/composition.py

@@ -27,12 +27,20 @@ class Composition:
         }
         self.is_blocking = is_blocking
     
+    def __repr__(self) -> str:
+        return "<{}: for function={!r} with nodes={}>".format(
+            ("blocking " if self.is_blocking else "")
+            + self.__class__.__name__,
+            self.func.__name__,
+            self.nodes,
+        )
+    
     async def compose_nodes(self, update: UpdateCute) -> NodeCollection | None:
         nodes: dict[str, NodeSession] = {}
         for name, node_t in self.nodes.items():
             try:
                 nodes[name] = await compose_node(node_t, update)
-            except ComposeError as err:
+            except ComposeError:
                 await NodeCollection(nodes).close_all()
                 return None
         return NodeCollection(nodes)
@@ -45,6 +53,12 @@ class CompositionDispatch(ABCDispatch):
     def __init__(self) -> None:
         self.compositions: list[Composition] = []
     
+    def __repr__(self) -> str:
+        return "<{}: with compositions={!r}>".format(
+            self.__class__.__name__,
+            self.compositions,
+        )
+
     async def feed(self, event: Update, api: ABCAPI) -> bool:
         update = UpdateCute(**event.to_dict(), api=api)
         is_found = False

telegrinder/bot/dispatch/context.py

@@ -1,5 +1,6 @@
 import enum
 import typing
+from reprlib import recursive_repr
 
 from telegrinder.types import Update
 
@@ -33,6 +34,13 @@ class Context(dict[str, AnyValue]):
                 delattr(self.__class__, k)
         dict.__init__(self, **defaults | kwargs)
     
+    @recursive_repr()
+    def __repr__(self) -> str:
+        return "{}({})".format(
+            self.__class__.__name__,
+            ", ".join(f"{k}={v!r}" for k, v in self.items())
+        )
+
     def __setitem__(self, __key: Key, __value: AnyValue) -> None:
         dict.__setitem__(self, self.key_to_str(__key), __value)
     

telegrinder/bot/dispatch/dispatch.py

@@ -6,8 +6,10 @@ from vbml.patcher import Patcher
 
 from telegrinder.api.abc import ABCAPI
 from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.rules import ABCRule
 from telegrinder.modules import logger
+from telegrinder.tools.error_handler.error_handler import ErrorHandler
 from telegrinder.tools.global_context import TelegrinderCtx
 from telegrinder.types import Update
 
@@ -19,6 +21,7 @@ from .view.box import CallbackQueryViewT, InlineQueryViewT, MessageViewT, ViewBo
 T = typing.TypeVar("T")
 R = typing.TypeVar("R")
 P = typing.ParamSpec("P")
+Handler = typing.Callable[typing.Concatenate[T, ...], typing.Coroutine[typing.Any, typing.Any, typing.Any]]
 Event = typing.TypeVar("Event", bound=BaseCute)
 
 DEFAULT_DATACLASS: typing.Final[type[Update]] = Update
@@ -47,17 +50,74 @@ class Dispatch(
     def patcher(self) -> Patcher:
         """Alias `patcher` to get `vbml.Patcher` from the global context"""
         return self.global_context.vbml_patcher
+    
+    @typing.overload
+    def handle(
+        self,
+        *rules: ABCRule[Event],
+    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]:
+        ...
 
+    @typing.overload
     def handle(
         self,
-        *rules: ABCRule,
+        *rules: ABCRule[Event],
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]:
+        ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: ABCRule[Event],
+        dataclass: type[T],
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]:
+        ...
+
+    @typing.overload
+    def handle(  # type: ignore
+        self,
+        *rules: ABCRule[Event],
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandlerT]]:
+        ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: ABCRule[Event],
+        dataclass: type[T],
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandlerT]]:
+        ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: ABCRule[Event],
+        dataclass: type[T] = DEFAULT_DATACLASS,
+        error_handler: typing.Literal[None] = None,
         is_blocking: bool = True,
+    ) -> typing.Callable[[Handler[T]], FuncHandler[Event, Handler[T], ErrorHandler]]:
+        ...
+
+    def handle(  # type: ignore
+        self,
+        *rules: ABCRule,
         dataclass: type[typing.Any] = DEFAULT_DATACLASS,
         error_handler: ErrorHandlerT | None = None,
+        is_blocking: bool = True,
     ):
         def wrapper(func: typing.Callable):
             handler = FuncHandler(
-                func, list(rules), is_blocking, dataclass, error_handler,
+                func,
+                list(rules),
+                is_blocking=is_blocking,
+                dataclass=dataclass,
+                error_handler=error_handler or ErrorHandler(),
             )
             self.default_handlers.append(handler)
             return handler
@@ -77,11 +137,12 @@ class Dispatch(
                 return True
 
         loop = asyncio.get_running_loop()
+        ctx = Context()
         found = False
         for handler in self.default_handlers:
-            if await handler.check(api, event):
+            if await handler.check(api, event, ctx):
                 found = True
-                loop.create_task(handler.run(event))
+                loop.create_task(handler.run(event, ctx))
                 if handler.is_blocking:
                     break
         return found
@@ -94,30 +155,6 @@ class Dispatch(
             ), f"View {name!r} is undefined in external dispatch."
             view.load(view_external[name])
             setattr(external, name, view)
-    
-    @classmethod
-    def to_handler(
-        cls,
-        *rules: ABCRule[BaseCute],
-        is_blocking: bool = True,
-        error_handler: ErrorHandlerT | None = None,
-    ):
-        def wrapper(
-            func: typing.Callable[typing.Concatenate[T, P], typing.Awaitable[R]]
-        ) -> FuncHandler[
-            BaseCute,
-            typing.Callable[typing.Concatenate[T, P], typing.Awaitable[R]],
-            ErrorHandlerT,
-        ]:
-            return FuncHandler(
-                func,
-                list(rules),
-                is_blocking=is_blocking,
-                dataclass=None,
-                error_handler=error_handler,
-            )
-
-        return wrapper
 
 
 __all__ = ("Dispatch",)

telegrinder/bot/dispatch/handler/abc.py

@@ -11,15 +11,13 @@ T = typing.TypeVar("T", bound=Model)
 
 class ABCHandler(ABC, typing.Generic[T]):
     is_blocking: bool
-    ctx: Context
 
     @abstractmethod
-    async def run(self, event: T) -> typing.Any:
+    async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
         pass
 
     @abstractmethod
-    async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
+    async def run(self, event: T, ctx: Context) -> typing.Any:
         pass
 
-
 __all__ = ("ABCHandler",)

telegrinder/bot/dispatch/handler/func.py

@@ -1,3 +1,5 @@
+import dataclasses
+
 import typing_extensions as typing
 
 from telegrinder.api.abc import ABCAPI
@@ -13,46 +15,50 @@ from .abc import ABCHandler
 if typing.TYPE_CHECKING:
     from telegrinder.bot.rules import ABCRule
 
-F = typing.TypeVar("F", bound=typing.Callable[typing.Concatenate[typing.Any, ...], typing.Awaitable])
+F = typing.TypeVar("F", bound=typing.Callable[typing.Concatenate[typing.Any, ...], typing.Awaitable[typing.Any]])
 EventT = typing.TypeVar("EventT", bound=BaseCute)
 ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
 
 
+@dataclasses.dataclass(repr=False)
 class FuncHandler(ABCHandler[EventT], typing.Generic[EventT, F, ErrorHandlerT]):
-    def __init__(
-        self,
-        func: F,
-        rules: list["ABCRule[EventT]"],
-        is_blocking: bool = True,
-        dataclass: type[typing.Any] | None = dict,
-        error_handler: ErrorHandlerT | None = None,
-    ):
-        self.func = func
-        self.is_blocking = is_blocking
-        self.rules = rules
-        self.dataclass = dataclass
-        self.error_handler: ErrorHandlerT = error_handler or ErrorHandler()  # type: ignore
-        self.ctx = Context()
-    
-    @property
-    def on_error(self):
-        return self.error_handler.register_catcher
+    func: F
+    rules: list["ABCRule[EventT]"]
+    _: dataclasses.KW_ONLY
+    is_blocking: bool = dataclasses.field(default=True)
+    dataclass: type[typing.Any] | None = dataclasses.field(default=dict)
+    error_handler: ErrorHandlerT = dataclasses.field(
+        default_factory=lambda: typing.cast(ErrorHandlerT, ErrorHandler()),
+    )
+    preset_context: Context = dataclasses.field(default_factory=lambda: Context())
+
+    def __repr__(self) -> str:
+        return "<{}: {}={!r} with rules={!r}, dataclass={!r}, error_handler={!r}>".format(
+            self.__class__.__name__,
+            "blocking function" if self.is_blocking else "function",
+            self.func.__name__,
+            self.rules,
+            self.dataclass,
+            self.error_handler,
+        )
     
     async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
         ctx = ctx or Context()
-        preset_ctx = self.ctx.copy()
-        self.ctx |= ctx
+        temp_ctx = ctx.copy()
+        temp_ctx |= self.preset_context
+
         for rule in self.rules:
-            if not await check_rule(api, rule, event, self.ctx):
+            if not await check_rule(api, rule, event, temp_ctx):
                 logger.debug("Rule {!r} failed!", rule)
-                self.ctx = preset_ctx
                 return False
+        
+        ctx |= temp_ctx
         return True
 
-    async def run(self, event: EventT) -> typing.Any:
+    async def run(self, event: EventT, ctx: Context) -> typing.Any:
         if self.dataclass is not None:
             event = self.dataclass(**event.to_dict())
-        return (await self.error_handler.run(self.func, event, event.api, self.ctx)).unwrap()
+        return (await self.error_handler.run(self.func, event, event.api, ctx)).unwrap()
 
 
 __all__ = ("FuncHandler",)

telegrinder/bot/dispatch/handler/message_reply.py

@@ -7,7 +7,7 @@ from telegrinder.bot.dispatch.process import check_rule
 from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.modules import logger
 from telegrinder.msgspec_utils import Nothing
-from telegrinder.types.objects import Update
+from telegrinder.types.objects import ReplyParameters, Update
 
 from .abc import ABCHandler
 
@@ -17,29 +17,41 @@ class MessageReplyHandler(ABCHandler[MessageCute]):
         self,
         text: str,
         *rules: ABCRule[MessageCute],
-        as_reply: bool = False,
         is_blocking: bool = True,
-    ):
+        as_reply: bool = False,
+    ) -> None:
         self.text = text
         self.rules = list(rules)
         self.as_reply = as_reply
         self.is_blocking = is_blocking
-        self.dataclass = MessageCute
-        self.ctx = Context()
+        self.preset_context = Context()
+    
+    def __repr__(self) -> str:
+        return "<{}: with rules={!r}, {}: {!r}>".format(
+            ("blocking " if self.is_blocking else "")
+            + self.__class__.__name__,
+            self.rules,
+            "answer text as reply" if self.as_reply else "answer text",
+            self.text,
+        )
 
     async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
         ctx = ctx or Context()
-        self.ctx |= ctx
+        temp_ctx = ctx.copy()
+        temp_ctx |= self.preset_context
+
         for rule in self.rules:
-            if not await check_rule(api, rule, event, self.ctx):
+            if not await check_rule(api, rule, event, ctx):
                 logger.debug("Rule {!r} failed!", rule)
                 return False
+
+        ctx |= temp_ctx
         return True
 
-    async def run(self, event: MessageCute) -> typing.Any:
+    async def run(self, event: MessageCute, _: Context) -> typing.Any:
         await event.answer(
             text=self.text,
-            reply_to_message_id=(event.message_id if self.as_reply else Nothing),
+            reply_parameters=ReplyParameters(event.message_id) if self.as_reply else None,
         )
 
 

telegrinder/bot/dispatch/middleware/abc.py

@@ -11,7 +11,7 @@ class ABCMiddleware(ABC, typing.Generic[T]):
     async def pre(self, event: T, ctx: Context) -> bool:
         ...
 
-    async def post(self, event: T, responses: list[typing.Any], ctx: Context):
+    async def post(self, event: T, responses: list[typing.Any], ctx: Context) -> None:
         ...
 
 

telegrinder/bot/dispatch/process.py

@@ -17,7 +17,7 @@ if typing.TYPE_CHECKING:
     from telegrinder.bot.rules.abc import ABCRule
 
 T = typing.TypeVar("T", bound=BaseCute)
-_ = typing.Any
+_: typing.TypeAlias = typing.Any
 
 
 async def process_inner(
@@ -36,15 +36,17 @@ async def process_inner(
 
     found = False
     responses = []
+    ctx_copy = ctx.copy()
+
     for handler in handlers:
         if await handler.check(event.api, raw_event, ctx):
             found = True
-            handler.ctx |= ctx
-            response = await handler.run(event)
+            response = await handler.run(event, ctx)
             responses.append(response)
             await return_manager.run(response, event, ctx)
             if handler.is_blocking:
                 break
+            ctx = ctx_copy
 
     for middleware in middlewares:
         await middleware.post(event, responses, ctx)

telegrinder/bot/dispatch/return_manager/callback_query.py

@@ -1,3 +1,5 @@
+import typing
+
 from telegrinder.bot.cute_types import CallbackQueryCute
 from telegrinder.bot.dispatch.context import Context
 
@@ -12,7 +14,7 @@ class CallbackQueryReturnManager(BaseReturnManager[CallbackQueryCute]):
     
     @register_manager(dict)
     @staticmethod
-    async def dict_manager(value: dict, event: CallbackQueryCute, ctx: Context) -> None:
+    async def dict_manager(value: dict[str, typing.Any], event: CallbackQueryCute, ctx: Context) -> None:
         await event.answer(**value)
 
 

telegrinder/bot/dispatch/return_manager/inline_query.py

@@ -1,3 +1,5 @@
+import typing
+
 from telegrinder.bot.cute_types import InlineQueryCute
 from telegrinder.bot.dispatch.context import Context
 
@@ -7,7 +9,7 @@ from .abc import BaseReturnManager, register_manager
 class InlineQueryReturnManager(BaseReturnManager[InlineQueryCute]):         
     @register_manager(dict)
     @staticmethod
-    async def dict_manager(value: dict, event: InlineQueryCute, ctx: Context) -> None:
+    async def dict_manager(value: dict[str, typing.Any], event: InlineQueryCute, ctx: Context) -> None:
         await event.answer(**value)
 
 

telegrinder/bot/dispatch/return_manager/message.py

@@ -1,5 +1,8 @@
+import typing
+
 from telegrinder.bot.cute_types import MessageCute
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.tools.formatting import HTMLFormatter
 
 from .abc import BaseReturnManager, register_manager
 
@@ -18,8 +21,13 @@ class MessageReturnManager(BaseReturnManager[MessageCute]):
     
     @register_manager(dict)
     @staticmethod
-    async def dict_manager(value: dict, event: MessageCute, ctx: Context) -> None:
+    async def dict_manager(value: dict[str, typing.Any], event: MessageCute, ctx: Context) -> None:
         await event.answer(**value)
 
+    @register_manager(HTMLFormatter)
+    @staticmethod
+    async def htmlformatter_manager(value: HTMLFormatter, event: MessageCute, ctx: Context) -> None:
+        await event.answer(value, parse_mode=HTMLFormatter.PARSE_MODE)
+
 
 __all__ = ("MessageReturnManager",)

telegrinder/bot/dispatch/view/abc.py

@@ -6,16 +6,18 @@ from fntypes.co import Nothing, Some
 from telegrinder.api.abc import ABCAPI
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
-from telegrinder.bot.dispatch.handler.func import ErrorHandlerT, FuncHandler
+from telegrinder.bot.dispatch.handler.func import FuncHandler
 from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
 from telegrinder.bot.dispatch.process import process_inner
 from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
 from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.model import Model
 from telegrinder.msgspec_utils import Option
+from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
 from telegrinder.types.objects import Update
 
 EventType = typing.TypeVar("EventType", bound=BaseCute)
+ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler)
 MiddlewareT = typing.TypeVar("MiddlewareT", bound=ABCMiddleware)
 
 FuncType: typing.TypeAlias = typing.Callable[
@@ -74,20 +76,44 @@ class BaseView(ABCView, typing.Generic[EventType]):
                 return getattr(update, update_type.value)
             case _:
                 return Nothing()
+    
+    @typing.overload
+    def __call__(
+        self,
+        *rules: ABCRule[EventType],
+    ) -> typing.Callable[[FuncType[EventType]], FuncHandler[EventType, FuncType[EventType], ErrorHandler]]:
+        ...
+    
+    @typing.overload
+    def __call__(
+        self,
+        *rules: ABCRule[EventType],
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[FuncType[EventType]], FuncHandler[EventType, FuncType[EventType], ErrorHandlerT]]:
+        ...
 
+    @typing.overload
     def __call__(
         self,
         *rules: ABCRule[EventType],
+        error_handler: typing.Literal[None] = None,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[FuncType[EventType]], FuncHandler[EventType, FuncType[EventType], ErrorHandler]]:
+        ...
+
+    def __call__(  # type: ignore
+        self,
+        *rules: ABCRule[EventType],
+        error_handler: ABCErrorHandler | None = None,
         is_blocking: bool = True,
-        error_handler: ErrorHandlerT | None = None,
     ):
         def wrapper(func: FuncType[EventType]):
-            func_handler = FuncHandler[EventType, FuncType[EventType], ErrorHandlerT](
+            func_handler = FuncHandler(
                 func,
                 [*self.auto_rules, *rules],
-                is_blocking,
+                is_blocking=is_blocking,
                 dataclass=None,
-                error_handler=error_handler,
             )
             self.handlers.append(func_handler)
             return func_handler

telegrinder/bot/dispatch/view/box.py

@@ -30,7 +30,8 @@ class ViewBox(typing.Generic[CallbackQueryViewT, InlineQueryViewT, MessageViewT]
 
     def get_views(self) -> dict[str, ABCView]:
         return {
-            name: view for name, view in self.__dict__.items()
+            name: view
+            for name, view in self.__dict__.items()
             if isinstance(view, ABCView)
         }
 

telegrinder/bot/dispatch/view/inline_query.py

@@ -12,7 +12,7 @@ class InlineQueryView(BaseStateView[InlineQueryCute]):
         self.return_manager = InlineQueryReturnManager()
 
     def get_state_key(self, event: InlineQueryCute) -> int | None:
-        return event.from_.id
+        return event.from_user.id
 
 
 __all__ = ("InlineQueryView",)

telegrinder/bot/dispatch/view/message.py

@@ -12,7 +12,7 @@ class MessageView(BaseStateView[MessageCute]):
         self.return_manager = MessageReturnManager()
 
     def get_state_key(self, event: MessageCute) -> int | None:
-        return event.chat.id
+        return event.chat_id
 
 
 __all__ = ("MessageView",)

telegrinder/bot/dispatch/waiter_machine/machine.py

@@ -19,12 +19,18 @@ if typing.TYPE_CHECKING:
 class WaiterMachine:
     def __init__(self) -> None:
         self.storage: Storage = {}
+    
+    def __repr__(self) -> str:
+        return "<{}: storage={!r}>".format(
+            self.__class__.__name__,
+            self.storage,
+        )
 
     async def drop(
         self,
         state_view: "ABCStateView[EventModel]",
         id: Identificator,
-        **context,
+        **context: typing.Any,
     ) -> None:
         view_name = state_view.__class__.__name__
         if view_name not in self.storage:
@@ -60,9 +66,9 @@ class WaiterMachine:
         *rules: ABCRule[EventModel],
         default: Behaviour = None,
         on_drop: Behaviour = None,
-        expiration: datetime.timedelta | int | None = None,
+        expiration: datetime.timedelta | int | float | None = None,
     ) -> tuple[EventModel, Context]:
-        if isinstance(expiration, int):
+        if isinstance(expiration, int | float):
             expiration = datetime.timedelta(seconds=expiration)
 
         api: ABCAPI
@@ -77,9 +83,9 @@ class WaiterMachine:
 
         short_state = ShortState(
             key,
-            ctx_api=api,
-            event=event,
-            rules=rules,
+            api,
+            event,
+            rules,
             expiration=expiration,
             default_behaviour=default,
             on_drop_behaviour=on_drop,
@@ -104,13 +110,13 @@ class WaiterMachine:
         view: "ABCStateView[EventModel]",
         behaviour: Behaviour,
         event: asyncio.Event | EventModel,
-        **context,
+        **context: typing.Any,
     ) -> None:
         if behaviour is None:
             return
         # TODO: add behaviour check
         # TODO: support view as a behaviour
-        await behaviour.run(event)
+        await behaviour.run(event, context)  # type: ignore
 
 
 __all__ = ("WaiterMachine",)

telegrinder/bot/dispatch/waiter_machine/middleware.py

@@ -38,32 +38,34 @@ class WaiterMiddleware(ABCMiddleware[EventType]):
         if key is None:
             raise RuntimeError("Unable to get state key.")
 
-        short_state: typing.Optional["ShortState"] = self.machine.storage[view_name].get(key)
+        short_state: typing.Optional["ShortState[EventType]"] = self.machine.storage[view_name].get(key)
         if not short_state:
             return True
 
         if (
-            short_state.expiration is not None
-            and datetime.datetime.now() >= short_state.expiration
+            short_state.expiration_date is not None
+            and datetime.datetime.now() >= short_state.expiration_date
         ):
             await self.machine.drop(self.view, short_state.key)
             return True
         
         handler = FuncHandler(
-            self.pass_runtime, list(short_state.rules), dataclass=None
+            self.pass_runtime,
+            list(short_state.rules),
+            dataclass=None,
         )
-        handler.ctx.set("short_state", short_state)
+        handler.preset_context.set("short_state", short_state)
         result = await handler.check(event.ctx_api, ctx.raw_update, ctx)
 
         if result is True:
-            await handler.run(event)
+            await handler.run(event, ctx)
 
         elif short_state.default_behaviour is not None:
             await self.machine.call_behaviour(
                 self.view,
                 short_state.default_behaviour,
                 event,
-                **handler.ctx,
+                **handler.preset_context,
             )
 
         return False

telegrinder/bot/dispatch/waiter_machine/short_state.py

@@ -1,8 +1,9 @@
 import asyncio
+import dataclasses
 import datetime
 import typing
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import ABCAPI
 from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
 from telegrinder.bot.rules.abc import ABCRule
@@ -14,24 +15,22 @@ EventModel = typing.TypeVar("EventModel", bound=BaseCute)
 Behaviour: typing.TypeAlias = ABCHandler | None
 
 
+@dataclasses.dataclass
 class ShortState(typing.Generic[EventModel]):
-    def __init__(
-        self,
-        key: "Identificator",
-        ctx_api: ABCAPI,
-        event: asyncio.Event,
-        rules: tuple[ABCRule[EventModel], ...],
-        expiration: datetime.timedelta | None = None,
-        default_behaviour: Behaviour | None = None,
-        on_drop_behaviour: Behaviour | None = None,
-    ) -> None:
-        self.key = key
-        self.ctx_api = ctx_api
-        self.event = event
-        self.rules = rules
-        self.default_behaviour = default_behaviour
-        self.expiration = (datetime.datetime.now() + expiration) if expiration else None
-        self.on_drop_behaviour = on_drop_behaviour
+    key: "Identificator"
+    ctx_api: ABCAPI
+    event: asyncio.Event
+    rules: tuple[ABCRule[EventModel], ...]
+    _: dataclasses.KW_ONLY
+    expiration: dataclasses.InitVar[datetime.timedelta | None] = dataclasses.field(default=None)
+    default_behaviour: Behaviour | None = dataclasses.field(default=None)
+    on_drop_behaviour: Behaviour | None = dataclasses.field(default=None)
+    expiration_date: datetime.datetime | None = dataclasses.field(init=False)
+
+    def __post_init__(self, expiration: datetime.timedelta | None = None) -> None:
+        self.expiration_date = (
+            datetime.datetime.now() - expiration
+        ) if expiration is not None else None
 
 
 __all__ = ("ShortState",)

telegrinder/bot/rules/text.py

@@ -14,7 +14,7 @@ class TextMessageRule(MessageRule, ABC, requires=[HasText()]):
 
 
 class Text(TextMessageRule):
-    def __init__(self, texts: str | list[str], ignore_case: bool = False):
+    def __init__(self, texts: str | list[str], *, ignore_case: bool = False) -> None:
         if not isinstance(texts, list):
             texts = [texts]
         self.texts = texts if not ignore_case else list(map(str.lower, texts))

telegrinder/bot/scenario/checkbox.py

@@ -45,6 +45,21 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         self.max_in_row = max_in_row
         self.random_code = secrets.token_hex(8)
         self.waiter_machine = waiter_machine
+    
+    def __repr__(self) -> str:
+        return (
+            "<{}@{!r}: (choices={!r}, max_in_row={}) with waiter_machine={!r}, ready_text={!r} "
+            "for chat_id={} with message={!r}>"
+        ).format(
+            self.__class__.__name__,
+            self.random_code,
+            self.choices,
+            self.max_in_row,
+            self.waiter_machine,
+            self.ready,
+            self.chat_id,
+            self.msg,
+        )
 
     def get_markup(self) -> InlineKeyboardMarkup:
         kb = InlineKeyboard()
@@ -70,6 +85,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         name: str,
         default_text: str,
         picked_text: str,
+        *,
         is_picked: bool = False,
     ) -> typing.Self:
         self.choices.append(

telegrinder/node/base.py

@@ -6,7 +6,7 @@ ComposeResult: typing.TypeAlias = typing.Coroutine[typing.Any, typing.Any, typin
 
 
 class ComposeError(BaseException):
-    pass
+    ...
 
 
 class Node(abc.ABC):

telegrinder/node/composer.py

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

telegrinder/tools/error_handler/abc.py

@@ -13,12 +13,12 @@ Handler = typing.Callable[typing.Concatenate[EventT, ...], typing.Awaitable[typi
 
 class ABCErrorHandler(ABC, typing.Generic[EventT]):
     @abstractmethod
-    def register_catcher(
+    def __call__(
         self,
         *args: typing.Any,
         **kwargs: typing.Any,
     ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
-        ...
+        """Decorator for registering callback as an error handler."""
 
     @abstractmethod
     async def run(
@@ -28,7 +28,7 @@ class ABCErrorHandler(ABC, typing.Generic[EventT]):
         api: ABCAPI,
         ctx: Context,
     ) -> Result[typing.Any, typing.Any]:
-        ...
+        """Run error handler."""
 
 
 __all__ = ("ABCErrorHandler",)

telegrinder/tools/error_handler/error_handler.py

@@ -97,27 +97,8 @@ class ErrorHandler(ABCErrorHandler[EventT]):
             if self.catcher is not None
             else "<ErrorHandler: No catcher>"
         )
-    
-    async def __call__(
-        self,
-        handler: Handler[EventT],
-        event: EventT,
-        api: ABCAPI,
-        ctx: Context,
-    ) -> Result[typing.Any, BaseException]:
-        assert self.catcher is not None
 
-        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__
-                )
-            ))
-    
-    def register_catcher(
+    def __call__(
         self,
         *exceptions: type[BaseException] | BaseException,
         logging: bool = False,
@@ -142,6 +123,25 @@ class ErrorHandler(ABCErrorHandler[EventT]):
             return func
         return decorator
     
+    async def process(
+        self,
+        handler: Handler[EventT],
+        event: EventT,
+        api: ABCAPI,
+        ctx: Context,
+    ) -> Result[typing.Any, BaseException]:
+        assert self.catcher is not None
+
+        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__
+                )
+            ))
+        
     def process_catcher_error(self, error: CatcherError) -> Result[None, str]:
         assert self.catcher is not None
         
@@ -164,7 +164,7 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         if not self.catcher:
             return Ok(await handler(event, **magic_bundle(handler, ctx)))  # type: ignore
         
-        match await self(handler, event, api, ctx):
+        match await self.process(handler, event, api, ctx):
             case Ok(_) as ok:
                 return ok
             case Error(exc) as err:

{telegrinder-0.1.dev163.dist-info → telegrinder-0.1.dev164.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.1.dev163
+Version: 0.1.dev164
 Summary: Framework for effective and reliable async telegram bot building.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT

{telegrinder-0.1.dev163.dist-info → telegrinder-0.1.dev164.dist-info}/RECORD

@@ -14,32 +14,32 @@ telegrinder/bot/cute_types/message.py,sha256=xYlbHfKP1kbVpUXOLed8yCuxW8v1cD7lV6N
 telegrinder/bot/cute_types/update.py,sha256=VakZ2FwapOJvpEBIyzuiT8eftHHzBS-uPXrAUROQxOg,752
 telegrinder/bot/cute_types/utils.py,sha256=Gp7zHUn5gEfxFItIYbzkaj6wxWoPNe7hM9abHkn3Jug,16349
 telegrinder/bot/dispatch/__init__.py,sha256=o10t98PY1BuIGaJcloxfbgUYp0bf5ZqAaBQScIaV3VQ,1322
-telegrinder/bot/dispatch/abc.py,sha256=3bOKEFJTKarwqWTDqhscVw2U5FBllJ-TyId-aUPzb7c,454
-telegrinder/bot/dispatch/composition.py,sha256=0UbXqTxcs0X_DGB5COR6n_9RZBIhn83O2-1UNVoZQ8E,2558
-telegrinder/bot/dispatch/context.py,sha256=Uk_GFN3wlLuS5BGgBaLfLxU8xBp_yB4fPJcuzEd1ti4,2093
-telegrinder/bot/dispatch/dispatch.py,sha256=UyzqfsYTfr-gXo12NbJcYLi6Y8ZorRYEE3H0DU1bT8s,3818
+telegrinder/bot/dispatch/abc.py,sha256=YX184RfqSTMtxrt6qyNRu9uhlPHJLEJY3RKsLfBV7nw,462
+telegrinder/bot/dispatch/composition.py,sha256=EcIgiFJm1v7y8uaumrvBl-43vl8pABbjYLdgVNp4M-s,2973
+telegrinder/bot/dispatch/context.py,sha256=ozsL1oy5BGjXADzVT-qhe8YohMxc-ORQKfUaKNbYm-Q,2322
+telegrinder/bot/dispatch/dispatch.py,sha256=NSPLNAUu2q2-73JXLPAatF5cej1ySZykeiHaQD4XFhE,5048
 telegrinder/bot/dispatch/handler/__init__.py,sha256=mzchbArrm0eoTEeVKHYrtJX4WSfW5t6T4xDU3-mtYaA,169
-telegrinder/bot/dispatch/handler/abc.py,sha256=ffa9zmIcaIkIuQk8JKBty2pf53woH6hzIkQb0wmqA3k,573
-telegrinder/bot/dispatch/handler/func.py,sha256=B2rUH5Adm5RI4bE-49cbf5FCYTxsw2M3cJ-2GMctC0o,2085
-telegrinder/bot/dispatch/handler/message_reply.py,sha256=pfFINSLwTsx9buHwVW1ahVRWYQZn0QKyIazkO8D5MVo,1425
+telegrinder/bot/dispatch/handler/abc.py,sha256=Qi7MDVlUdvMZYqYis3HuSoSW6KF23q3nqfvQ8FM5sEw,569
+telegrinder/bot/dispatch/handler/func.py,sha256=IvDWA3ybQUcxXBOeEwteKeIVKp9-Lj9EEfKf2IIVQ40,2369
+telegrinder/bot/dispatch/handler/message_reply.py,sha256=rpBRDHuJ4PdCUKq0CtFWgs7jCS4PlcgYoPFr6QOYpgw,1827
 telegrinder/bot/dispatch/middleware/__init__.py,sha256=qDuTt2ZZKX9UMjPdw5xaaNZdMI-i3P4Px2T8qbYCMJw,61
-telegrinder/bot/dispatch/middleware/abc.py,sha256=RWmr1agbvCabsh-m1WeQORi-Lrkt1xRBidKkugzA41Y,421
-telegrinder/bot/dispatch/process.py,sha256=Z4iNCwqZQyBogGxFzeNK7Pbk3ldH_e0Z95AE9sm5R-0,2267
+telegrinder/bot/dispatch/middleware/abc.py,sha256=mF_G22pes-qJg6wqK9Tf71sduODXSyPjWyPT1hAiDo0,429
+telegrinder/bot/dispatch/process.py,sha256=J9MYuP-soXXa0eFjJ-5wE_bNEFmr4SukJzdajDSTfAw,2313
 telegrinder/bot/dispatch/return_manager/__init__.py,sha256=-4h9nU-vdyPgv7bqKi1fAlfzNOKTO9m9FtdTZOhrmuc,447
 telegrinder/bot/dispatch/return_manager/abc.py,sha256=dGPwsIUJW_6SRsNxSiWS69xOOwSOATzMP2a7FoD90sA,3150
-telegrinder/bot/dispatch/return_manager/callback_query.py,sha256=FV_bVdJRbtVNRvf_CvL1V5EFZqS83VqZQOWUi1x3pxk,624
-telegrinder/bot/dispatch/return_manager/inline_query.py,sha256=erJ54AXSG_1lACnzmP1CIQYT4RkHT4Ml5PeRD1bkHK4,452
-telegrinder/bot/dispatch/return_manager/message.py,sha256=eXjQEm1qBv5W9MfvdAfleytarR7UY_Ksnpv4EAaMfQY,824
+telegrinder/bot/dispatch/return_manager/callback_query.py,sha256=LIkXTGGyEnAHY-L_F82sbtzQtjvOHBi2GeL2eiWsEFc,656
+telegrinder/bot/dispatch/return_manager/inline_query.py,sha256=-GRnPcdnNamtKL0IbbxCynyO3Dimk9Uz-_-wegfr1h4,484
+telegrinder/bot/dispatch/return_manager/message.py,sha256=MNML9jGAAkmza1bwUOQVn9l2FmFqGHP4npub6TM_vqs,1139
 telegrinder/bot/dispatch/view/__init__.py,sha256=iMReW_At2YzenjUGOgrVnOcHLVJAIQAfI9DdQElZdcM,379
-telegrinder/bot/dispatch/view/abc.py,sha256=YJ_FI1SkF2bMg6yFjz2JuvwE7j_Qv6_jky-Ytfe_1Ow,4685
-telegrinder/bot/dispatch/view/box.py,sha256=Le7HbD9Obl-P_5nnmwptKkv8VBNlBAfWmlPWFnerUos,1240
+telegrinder/bot/dispatch/view/abc.py,sha256=E6fB_WRsX3y1i84_DwTYNhFyLUyOc0ougihvoxQSuFE,5564
+telegrinder/bot/dispatch/view/box.py,sha256=rek4a2cxO6VTPRVXoz9KJsb0kU_rAYX2SlN-7LCZvsM,1252
 telegrinder/bot/dispatch/view/callback_query.py,sha256=iL6DbB8ucXGvlv0w8eyMeZ94S1xz181pIn2yvYK1N_8,636
-telegrinder/bot/dispatch/view/inline_query.py,sha256=ZcT1iCE8uRQ_PeaXGcOsXrMmIl2ow0YTTtDzuQ2kgjU,527
-telegrinder/bot/dispatch/view/message.py,sha256=U80vO8tFtVsMfZHMA_LU9HunLB7nw0vbgEBltyZaSzk,498
+telegrinder/bot/dispatch/view/inline_query.py,sha256=hRwrgfhgS5YF0E6eUrR8FuWVHUMlnA758kG7V049lkE,531
+telegrinder/bot/dispatch/view/message.py,sha256=XX-_UmVf3_12-8I4TuH7utMRKxRcVKpWknXKhnGEx44,498
 telegrinder/bot/dispatch/waiter_machine/__init__.py,sha256=RUuq-J1qZMeREL8omM8kxEfgAz3-7h3B9NhzSjLTMqA,190
-telegrinder/bot/dispatch/waiter_machine/machine.py,sha256=IhbbDDzRFQQFjOcq1Pzh8tSFE90o3LmxIqe0fnyMM80,3412
-telegrinder/bot/dispatch/waiter_machine/middleware.py,sha256=MExbbYO9Bs_fBv1UTr28mOT3iozwY-H9Yg_7Z-B4Y5U,2483
-telegrinder/bot/dispatch/waiter_machine/short_state.py,sha256=tmvoeJNA7c4h30khkljt3tAGp_8LUt6lONN9C3OPuSg,1124
+telegrinder/bot/dispatch/waiter_machine/machine.py,sha256=RHq0x6XOl7xcT3nZICIpkaDgVibiLLIEak_mYt5jnTw,3610
+telegrinder/bot/dispatch/waiter_machine/middleware.py,sha256=6i_E2VPX71wYFnjESsUoCq1PaL4T6uaSXIWTgsTu874,2556
+telegrinder/bot/dispatch/waiter_machine/short_state.py,sha256=2jYjr5RM2DknakcdbTc_xvH8FCrKKvDI8tsUwG0I5Hg,1200
 telegrinder/bot/polling/__init__.py,sha256=OqfIFPS_V6UrCg-vCv9pkMFzTKdNbDP2faBfATs_TGg,94
 telegrinder/bot/polling/abc.py,sha256=-5BpX55SJfDlEJWt15yOXWCizQRrgeY5oiA5eHkm1Nw,434
 telegrinder/bot/polling/polling.py,sha256=GPXXlAhI81PZVUMGXsPd4j67GO19zozMRJaVNAgsBMg,4280
@@ -64,10 +64,10 @@ telegrinder/bot/rules/message_entities.py,sha256=_lWHCNymbV1Sv-f2Q8Ca3SOxqIPSHVy
 telegrinder/bot/rules/regex.py,sha256=wqGEEiFqe5t_RwX9KjVCtg0wRZfwqo1ktGvNBo9JaKE,1191
 telegrinder/bot/rules/rule_enum.py,sha256=BUd78f7fEa0hfu1Paa384_Q-r0lB-ZWWukqkrFXdn58,2083
 telegrinder/bot/rules/start.py,sha256=5ok581Ww56g27rE4QkrykbBZ-ER-SnATQNzMGut2PHA,1183
-telegrinder/bot/rules/text.py,sha256=LaY8A2KUYDZpIllYTRSXXCwWfDN6dnFFmdvXM1nCKvA,1147
+telegrinder/bot/rules/text.py,sha256=FUynYklF7VCFwOXj-cFCXWOA2N5Ul9BV9Wolbi5X72c,1158
 telegrinder/bot/scenario/__init__.py,sha256=Ehe2uH-eQ-vRBPxIzdmE23B-FBOAa9YQyndmb6K8C5E,166
 telegrinder/bot/scenario/abc.py,sha256=3AZYRjZlkbDtyFbsKdZ6BefzWYlJ0DOrGwh8jI3nzv4,474
-telegrinder/bot/scenario/checkbox.py,sha256=H5XuhAwwvyJbMdVpRLDzCXg2VKDU029OnDbgcANB3IE,3738
+telegrinder/bot/scenario/checkbox.py,sha256=IIpC6F1JTtnH3D49R9xrXXrBd7A6klWzpDRCeBHwGg8,4202
 telegrinder/bot/scenario/choice.py,sha256=-NYyzgfGI0njVuT-EY0j3jS4tPlsKOEkZaUagtns7dE,1442
 telegrinder/client/__init__.py,sha256=ZiS1Wb_l_kv3FHzEEi1oXtFLwlA_HXmWOzeN0xA3E7Y,104
 telegrinder/client/abc.py,sha256=OxsTX_PLYBEeFT9zpidFUzAbQL9BM7rQqru7zdn5DiQ,1611
@@ -78,8 +78,8 @@ telegrinder/msgspec_json.py,sha256=phfyhUvYYZUGEcI6RAyRx9lnARPK_Fqtw3Q0MEJnuUk,2
 telegrinder/msgspec_utils.py,sha256=ZA_qj36FabalE65J82j_Hp34umHhUFbNIOt8CBYbqvA,7987
 telegrinder/node/__init__.py,sha256=01XTe8GPUBp5LXayDshihTxre7ejf99NYte20d08JLM,706
 telegrinder/node/attachment.py,sha256=vMnD2tWQQQ6PFuXEIq2ZdL91xcBxiwlAkMkqJqseLlk,2587
-telegrinder/node/base.py,sha256=iszAnP2pD3REDpUfufbVyJmg0rkXt2-ByeG6LgmS7Zc,2221
-telegrinder/node/composer.py,sha256=f6l8qLjewu6lJTcxAucKyiQ4t-4d614YF6ssk9kYCZg,2225
+telegrinder/node/base.py,sha256=rEYPjLQ5EqahyIvH9ktlk_iOiym2NGK2wzh9akVIs6I,2220
+telegrinder/node/composer.py,sha256=OQj3WpY5EJ2UyFa5BWw70-AvXBny9jcuOVMRbrgOQWg,2226
 telegrinder/node/container.py,sha256=sECP3TyC6AaNcJqKOfrL1T7-N8fkZzP2vB84kku6Jxg,636
 telegrinder/node/message.py,sha256=2IW6DjF0KqH2_TZbZ-MXNsDioQRVPg9TUt86aQos0Kk,415
 telegrinder/node/rule.py,sha256=VGmS4lJAFCoR0hCZSLn56fonMt0FhOGyZ1BQn_1vgeg,1724
@@ -92,9 +92,9 @@ telegrinder/rules.py,sha256=BFB8RFwKKxqs9HFfo_p0RfulQNonPZAX8cHpmnG7qCU,39
 telegrinder/tools/__init__.py,sha256=EssNbs2XHkoL-tRMB_nk5pQsgdDLg2zb0nSUY8liXIM,2878
 telegrinder/tools/buttons.py,sha256=qMvtpawzkjdqopqE7o9C0k-no1dGJVy5gjFX4SiOE6A,2430
 telegrinder/tools/error_handler/__init__.py,sha256=WmYWZCNhhSk32j4lIOltEwzoYUx086TGTbOF5h3Ps7s,207
-telegrinder/tools/error_handler/abc.py,sha256=1w-X7dncSyO5ouv6r_LAnywFRGYz7SgA79eNfTqMG3M,881
+telegrinder/tools/error_handler/abc.py,sha256=ymQGDXgnIkfjMMBsLeNcpekQ-p7lj9kSSTLFWqpZ8Ok,952
 telegrinder/tools/error_handler/error.py,sha256=jVp3J4pMkkL20QHvDtlid9hKtAc66jZIcpsecB3-f98,188
-telegrinder/tools/error_handler/error_handler.py,sha256=LIAQNSTb14AhKhvhddhW4EQCwBpyNjAZJZSfcy4Fsas,5993
+telegrinder/tools/error_handler/error_handler.py,sha256=GpGNkEHZAv_4awk96tpJwcnm_YdI3MAfWVILS49jNQ4,5992
 telegrinder/tools/formatting/__init__.py,sha256=_oxb-4y_vyIgALlO2rfaa-azqicySpHHIcaYBrVPdSg,1609
 telegrinder/tools/formatting/html.py,sha256=-tvN1zJK_Q7evil3-XgRdvsdYsOgaG9eX2KsIQkt0m8,8718
 telegrinder/tools/formatting/links.py,sha256=ABglEz8EA6XitSM5xJt2FU78ffUdXVNbziJUjoUjKnI,1074
@@ -121,7 +121,7 @@ telegrinder/types/__init__.py,sha256=pvPKWDXq9PBiIOCW8dFcJMqgr1kAqodPhwT-u8I4kug
 telegrinder/types/enums.py,sha256=9ZYiz_KRP1o7jB5If6730YLDfLt_-wKVK8UFs5a6CVI,18330
 telegrinder/types/methods.py,sha256=CbeuZgtH5IIH1cKZlMWVkTnNAFqQLOYLw-_DeWHKKhk,186385
 telegrinder/types/objects.py,sha256=znpGLbPrFu5GCUf4j6p_XA7iCVaxYqUZN1UqBEpr5FY,214803
-telegrinder-0.1.dev163.dist-info/LICENSE,sha256=J9ngGsqHCNNjpm3xYPT7EnlzsnjhfqNXej5mJFjM6lw,1094
-telegrinder-0.1.dev163.dist-info/METADATA,sha256=Njdjq7FipuHi822K2gkEmCd2HnEh5Y624RlBtzaM0_s,2892
-telegrinder-0.1.dev163.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-telegrinder-0.1.dev163.dist-info/RECORD,,
+telegrinder-0.1.dev164.dist-info/LICENSE,sha256=J9ngGsqHCNNjpm3xYPT7EnlzsnjhfqNXej5mJFjM6lw,1094
+telegrinder-0.1.dev164.dist-info/METADATA,sha256=iaWGLP29CV1O042MEqTS25vDC7FsqUSB9Zh5cE62gGc,2892
+telegrinder-0.1.dev164.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+telegrinder-0.1.dev164.dist-info/RECORD,,

{telegrinder-0.1.dev163.dist-info → telegrinder-0.1.dev164.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any