telegrinder 0.1.dev163__tar.gz → 0.1.dev165__tar.gz

{telegrinder-0.1.dev163 → telegrinder-0.1.dev165}/PKG-INFO

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

{telegrinder-0.1.dev163 → telegrinder-0.1.dev165}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "telegrinder"
-version = "0.1.dev163"
+version = "0.1.dev165"
 description = "Framework for effective and reliable async telegram bot building."
 authors = ["timoniq <tesseradecades@mail.ru>"]
 maintainers = ["luwqz1 <howluwqz1@gmail.com>"]

{telegrinder-0.1.dev163 → telegrinder-0.1.dev165}/telegrinder/__init__.py

@@ -1,3 +1,37 @@
+"""Telegrinder
+
+Framework for effective and reliable telegram bot building.
+
+* Type hinted
+* Customizable and extensible
+* Ready to use scenarios and rules
+* Fast models built on msgspec
+* Both low-level and high-level API
+
+Basic example:
+
+```python
+from telegrinder import API, Message, Telegrinder, Token
+from telegrinder.modules import logger
+from telegrinder.rules import Text
+
+api = API(token=Token("123:token"))
+bot = Telegrinder(api)
+logger.set_level("INFO")
+
+
+@bot.on.message(Text("/start"))
+async def start(message: Message):
+    me = (await api.get_me()).unwrap()
+    await message.answer(
+        f"Hello, {message.from_user.full_name}! I'm {me.full_name}."
+    )
+
+
+bot.run_forever()
+```
+"""
+
 import typing
 
 from .api import ABCAPI, API, APIError, APIResponse, Token
@@ -58,6 +92,7 @@ from .tools import (
     Keyboard,
     KeyboardSetBase,
     KeyboardSetYAML,
+    Lifespan,
     LoopWrapper,
     ParseMode,
     RowButtons,
@@ -123,6 +158,7 @@ __all__ = (
     "Keyboard",
     "KeyboardSetBase",
     "KeyboardSetYAML",
+    "Lifespan",
     "LoopWrapper",
     "Message",
     "MessageCute",

{telegrinder-0.1.dev163 → telegrinder-0.1.dev165}/telegrinder/bot/bot.py

@@ -24,6 +24,15 @@ class Telegrinder(typing.Generic[DispatchT, PollingT, LoopWrapperT]):
         self.dispatch = typing.cast(DispatchT, dispatch or Dispatch())
         self.polling = typing.cast(PollingT, polling or Polling(api))
         self.loop_wrapper = typing.cast(LoopWrapperT, loop_wrapper or LoopWrapper())
+    
+    def __repr__(self) -> str:
+        return "<{}: api={!r}, dispatch={!r}, polling={!r}, loop_wrapper={!r}>".format(
+            self.__class__.__name__,
+            self.api,
+            self.dispatch,
+            self.polling,
+            self.loop_wrapper,
+        )
 
     @property
     def on(self) -> DispatchT:

{telegrinder-0.1.dev163 → telegrinder-0.1.dev165}/telegrinder/bot/cute_types/message.py

@@ -80,7 +80,7 @@ async def execute_method_answer(
         params["link_preview_options"] = compose_link_preview_options(
             **link_preview_options
         )
-
+        
     result = await getattr(message.ctx_api, method_name)(**params)
     return result.map(
         lambda x: (

{telegrinder-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/telegrinder/bot/dispatch/return_manager/abc.py

@@ -43,6 +43,12 @@ class ABCReturnManager(ABC, typing.Generic[EventT]):
 
 
 class BaseReturnManager(ABCReturnManager[EventT]):
+    def __repr__(self) -> str:
+        return "<{}: {}>".format(
+            self.__class__.__name__,
+            ", ".join(x.callback.__name__ + "=" + repr(x) for x in self.managers),
+        )
+
     @property
     def managers(self) -> list[Manager]:
         return [

{telegrinder-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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-0.1.dev163 → telegrinder-0.1.dev165}/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",)