telegrinder 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

telegrinder/bot/dispatch/dispatch.py

@@ -3,13 +3,13 @@ from __future__ import annotations
 import dataclasses
 
 import typing_extensions as typing
-from fntypes import Nothing, Option, Some
-from vbml.patcher import Patcher
+from fntypes.option import Nothing, Option, Some
+from vbml.patcher.abc import ABCPatcher
 
-from telegrinder.api.api import API, HTTPClient
+from telegrinder.api.api import API
 from telegrinder.bot.dispatch.abc import ABCDispatch
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.handler.func import ErrorHandlerT, Func, FuncHandler
+from telegrinder.bot.dispatch.handler.func import FuncHandler, Function
 from telegrinder.bot.dispatch.middleware.abc import run_middleware
 from telegrinder.bot.dispatch.middleware.global_middleware import GlobalMiddleware
 from telegrinder.bot.dispatch.view.abc import ABCView
@@ -17,6 +17,7 @@ from telegrinder.bot.dispatch.view.box import (
     CallbackQueryView,
     ChatJoinRequestView,
     ChatMemberView,
+    ErrorView,
     InlineQueryView,
     MessageView,
     PreCheckoutQueryView,
@@ -24,23 +25,20 @@ from telegrinder.bot.dispatch.view.box import (
     ViewBox,
 )
 from telegrinder.modules import logger
-from telegrinder.tools.error_handler.error_handler import ErrorHandler
+from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, NodeScope
 from telegrinder.tools.global_context import TelegrinderContext
-from telegrinder.types.enums import UpdateType
 from telegrinder.types.objects import Update
 
 if typing.TYPE_CHECKING:
     from telegrinder.bot.cute_types.base import BaseCute
-    from telegrinder.bot.cute_types.update import UpdateCute
     from telegrinder.bot.rules.abc import ABCRule
+    from telegrinder.node.composer import Composer
 
 T = typing.TypeVar("T", default=typing.Any)
 R = typing.TypeVar("R", covariant=True, default=typing.Any)
 Event = typing.TypeVar("Event", bound="BaseCute")
 P = typing.ParamSpec("P", default=...)
 
-DEFAULT_DATACLASS: typing.Final[type[Update]] = Update
-
 
 @dataclasses.dataclass(repr=False, kw_only=True)
 class Dispatch(
@@ -53,9 +51,9 @@ class Dispatch(
         MessageView,
         PreCheckoutQueryView,
         RawEventView,
+        ErrorView,
     ],
     typing.Generic[
-        HTTPClient,
         CallbackQueryView,
         ChatJoinRequestView,
         ChatMemberView,
@@ -63,9 +61,10 @@ class Dispatch(
         MessageView,
         PreCheckoutQueryView,
         RawEventView,
+        ErrorView,
     ],
 ):
-    _global_context: TelegrinderContext = dataclasses.field(
+    global_context: TelegrinderContext = dataclasses.field(
         init=False,
         default_factory=TelegrinderContext,
     )
@@ -77,156 +76,82 @@ class Dispatch(
         return "Dispatch(%s)" % ", ".join(f"{k}={v!r}" for k, v in self.get_views().items())
 
     @property
-    def global_context(self) -> TelegrinderContext:
-        return self._global_context
-
-    @property
-    def patcher(self) -> Patcher:
+    def patcher(self) -> ABCPatcher:
         """Alias `patcher` to get `vbml.Patcher` from the global context."""
         return self.global_context.vbml_patcher
 
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler["UpdateCute", Func[P, R], ErrorHandler[UpdateCute]]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        dataclass: type[T],
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler["UpdateCute", Func[P, R], ErrorHandler[T]]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        update_type: UpdateType,
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler["UpdateCute", Func[P, R], ErrorHandler[UpdateCute]]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        dataclass: type[T],
-        update_type: UpdateType,
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler["UpdateCute", Func[P, R], ErrorHandler[T]]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        error_handler: ErrorHandlerT,
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler["UpdateCute", Func[P, R], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        update_type: UpdateType,
-        error_handler: ErrorHandlerT,
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler["UpdateCute", Func[P, R], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        dataclass: type[T],
-        error_handler: ErrorHandlerT,
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[T, Func[P, R], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        dataclass: type[T],
-        update_type: UpdateType,
-        error_handler: ErrorHandlerT,
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[T, Func[P, R], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def handle(
-        self,
-        *rules: "ABCRule",
-        update_type: UpdateType | None = None,
-        dataclass: type[T] = DEFAULT_DATACLASS,
-        error_handler: typing.Literal[None] = None,
-        final: bool = True,
-    ) -> typing.Callable[[Func[P, R]], FuncHandler[T, Func[P, R], ErrorHandler[T]]]: ...
-
-    def handle(
-        self,
-        *rules: "ABCRule",
-        update_type: UpdateType | None = None,
-        dataclass: type[typing.Any] = DEFAULT_DATACLASS,
-        error_handler: ErrorHandlerT | None = None,
-        final: bool = True,
-    ) -> typing.Callable[..., typing.Any]:
-        def wrapper(func):
-            handler = FuncHandler(
-                func,
-                list(rules),
-                final=final,
-                dataclass=dataclass,
-                error_handler=error_handler or ErrorHandler(),
-                update_type=update_type,
+    @property
+    def composer(self) -> Composer:
+        """Alias `composer` to get `telegrinder.node.composer.Composer` from the global context."""
+        return self.global_context.composer.unwrap()
+
+    def handle[T: Function](self, *rules: ABCRule, final: bool = True) -> typing.Callable[[T], T]:
+        def wrapper(func: T, /) -> T:
+            self.raw_event.handlers.append(
+                FuncHandler(
+                    function=func,
+                    rules=list(rules),
+                    final=final,
+                ),
             )
-            self.raw_event.handlers.append(handler)
-            return handler
+            return func
 
         return wrapper
 
-    async def feed(self, event: Update, api: API[HTTPClient]) -> bool:
-        logger.debug(
-            "Processing update (update_id={}, update_type={!r})",
-            event.update_id,
-            event.update_type.name,
-        )
-        context = Context(raw_update=event)
+    async def feed(self, event: Update, api: API) -> bool:
+        logger.info("New Update(id={}, type={!r})", event.update_id, event.update_type)
+        processed = False
+        context = Context().add_update_cute(event, api)
+        start_time = self.global_context.loop_wrapper.loop.time()
 
         if (
             await run_middleware(
                 self.global_middleware.pre,
                 api,
-                event,  # type: ignore
-                raw_event=event,
-                ctx=context,
-                adapter=self.global_middleware.adapter,
+                event,
+                context,
+                required_nodes=self.global_middleware.pre_required_nodes,
             )
             is False
         ):
-            return False
+            return processed
 
         for view in self.get_views().values():
             if await view.check(event):
                 logger.debug(
-                    "Update (update_id={}, update_type={!r}) matched view {!r}.",
+                    "Processing update (id={}, type={!r}) with view {!r} by bot (id={})",
                     event.update_id,
-                    event.update_type.name,
+                    event.update_type,
                     view,
+                    api.id,
                 )
-                if await view.process(event, api, context):
-                    return True
+
+                try:
+                    if await view.process(event, api, context):
+                        processed = True
+                        break
+                except BaseException as exception:
+                    if not await self.error.process(event, api, context.add_exception_update(exception)):
+                        raise exception
+                finally:
+                    for session in context.get(CONTEXT_STORE_NODES_KEY, {}).values():
+                        await session.close(scopes=(NodeScope.PER_EVENT,))
 
         await run_middleware(
             self.global_middleware.post,
             api,
             event,
-            raw_event=event,
-            ctx=context,
-            adapter=self.global_middleware.adapter,
+            context,
+            required_nodes=self.global_middleware.post_required_nodes,
         )
-
-        return False
+        logger.debug(
+            "Update (id={}, type={!r}) processed in {} ms by bot (id={})",
+            event.update_id,
+            event.update_type,
+            int((self.global_context.loop_wrapper.loop.time() - start_time) * 1000),
+            api.id,
+        )
+        return processed
 
     def load(self, external: typing.Self) -> None:
         views_external = external.get_views()
@@ -246,7 +171,9 @@ class Dispatch(
 
     def get_views(self) -> dict[str, ABCView]:
         """Get all views."""
-        return {name: view for name, view in self.__dict__.items() if isinstance(view, ABCView)}
+        return {
+            name: view for name, view in self.__dict__.items() if isinstance(view, ABCView) and name != "error"
+        }
 
     __call__ = handle
 

telegrinder/bot/dispatch/handler/__init__.py

@@ -1,5 +1,6 @@
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
 from telegrinder.bot.dispatch.handler.audio_reply import AudioReplyHandler
+from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
 from telegrinder.bot.dispatch.handler.document_reply import DocumentReplyHandler
 from telegrinder.bot.dispatch.handler.func import FuncHandler
 from telegrinder.bot.dispatch.handler.media_group_reply import MediaGroupReplyHandler
@@ -11,6 +12,7 @@ from telegrinder.bot.dispatch.handler.video_reply import VideoReplyHandler
 __all__ = (
     "ABCHandler",
     "AudioReplyHandler",
+    "BaseReplyHandler",
     "DocumentReplyHandler",
     "FuncHandler",
     "MediaGroupReplyHandler",

telegrinder/bot/dispatch/handler/abc.py

@@ -1,22 +1,24 @@
 import typing
 from abc import ABC, abstractmethod
 
+from fntypes.result import Result
+
 from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.tools.adapter.abc import ABCAdapter
 from telegrinder.types.objects import Update
 
 
-class ABCHandler[Event](ABC):
+class ABCHandler(ABC):
     final: bool
-    adapter: ABCAdapter[Update, Event] | None = None
-
-    @abstractmethod
-    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
-        pass
 
     @abstractmethod
-    async def run(self, api: API, event: Event, ctx: Context) -> typing.Any:
+    async def run(
+        self,
+        api: API,
+        event: Update,
+        context: Context,
+        check: bool = True,
+    ) -> Result[typing.Any, typing.Any]:
         pass
 
 

telegrinder/bot/dispatch/handler/audio_reply.py

@@ -1,6 +1,5 @@
 import typing
 
-from telegrinder.api.api import API
 from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
@@ -31,8 +30,8 @@ class AudioReplyHandler(BaseReplyHandler):
             **default_params,
         )
 
-    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
-        method = event.answer_audio if not self.as_reply else event.reply_audio
+    async def handle(self, message: MessageCute) -> None:
+        method = message.answer_audio if not self.as_reply else message.reply_audio
         await method(
             audio=self.audio,
             parse_mode=self.parse_mode,

telegrinder/bot/dispatch/handler/base.py

@@ -1,24 +1,14 @@
 import abc
 import typing
 
-from fntypes.result import Result
-
-from telegrinder.api.api import API
-from telegrinder.api.error import APIError
-from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.handler.abc import ABCHandler
-from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.bot.dispatch.handler.func import FuncHandler
 from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.modules import logger
-from telegrinder.types.objects import Update
 
-type APIMethod = typing.Callable[
-    typing.Concatenate[MessageCute, ...], typing.Awaitable[Result[typing.Any, APIError]]
-]
 
+class BaseReplyHandler(FuncHandler, abc.ABC):
+    final: bool
 
-class BaseReplyHandler(ABCHandler[MessageCute], abc.ABC):
     def __init__(
         self,
         *rules: ABCRule,
@@ -27,30 +17,17 @@ class BaseReplyHandler(ABCHandler[MessageCute], abc.ABC):
         preset_context: Context | None = None,
         **default_params: typing.Any,
     ) -> None:
-        self.rules = list(rules)
         self.as_reply = as_reply
-        self.final = final
         self.default_params = default_params
-        self.preset_context = preset_context or Context()
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__qualname__}>"
-
-    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
-        ctx = Context(raw_update=event) if ctx is None else ctx
-        temp_ctx = ctx.copy()
-        temp_ctx |= self.preset_context
-
-        for rule in self.rules:
-            if not await check_rule(api, rule, event, ctx):
-                logger.debug("Rule {!r} failed!", rule)
-                return False
-
-        ctx |= temp_ctx
-        return True
+        super().__init__(
+            function=self.handle,
+            rules=list(rules),
+            final=final,
+            preset_context=preset_context or Context(),
+        )
 
     @abc.abstractmethod
-    async def run(self, api: API, event: MessageCute, ctx: Context) -> typing.Any:
+    async def handle(self, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
         pass
 
 

telegrinder/bot/dispatch/handler/document_reply.py

@@ -1,6 +1,5 @@
 import typing
 
-from telegrinder.api.api import API
 from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
@@ -31,8 +30,8 @@ class DocumentReplyHandler(BaseReplyHandler):
             **default_params,
         )
 
-    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
-        method = event.answer_document if not self.as_reply else event.reply_document
+    async def handle(self, message: MessageCute) -> None:
+        method = message.answer_document if not self.as_reply else message.reply_document
         await method(
             document=self.document,
             parse_mode=self.parse_mode,

telegrinder/bot/dispatch/handler/func.py

@@ -1,128 +1,96 @@
+from __future__ import annotations
+
 import dataclasses
+import typing
+from collections import deque
 from functools import cached_property
 
-import typing_extensions as typing
+from fntypes.result import Error, Ok, Result
 
 from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
 from telegrinder.bot.dispatch.process import check_rule
 from telegrinder.modules import logger
-from telegrinder.node.base import NodeType, get_nodes
-from telegrinder.node.composer import NodeCollection, compose_nodes
-from telegrinder.tools.adapter.abc import ABCAdapter
-from telegrinder.tools.adapter.dataclass import DataclassAdapter
-from telegrinder.tools.error_handler import ABCErrorHandler, ErrorHandler
-from telegrinder.tools.magic import get_annotations, magic_bundle
-from telegrinder.types.enums import UpdateType
+from telegrinder.node.base import IsNode, get_nodes
+from telegrinder.node.composer import compose_nodes
+from telegrinder.tools.fullname import fullname
+from telegrinder.tools.magic.function import bundle
 from telegrinder.types.objects import Update
 
-from .abc import ABCHandler
-
 if typing.TYPE_CHECKING:
     from telegrinder.bot.rules.abc import ABCRule
-    from telegrinder.node.composer import NodeCollection
 
-Function = typing.TypeVar("Function", bound="Func[..., typing.Any]")
-Event = typing.TypeVar("Event")
-ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
-
-type Func[**Rest, Result] = typing.Callable[Rest, typing.Coroutine[typing.Any, typing.Any, Result]]
+type Function = typing.Callable[..., typing.Coroutine[typing.Any, typing.Any, typing.Any]]
 
 
 @dataclasses.dataclass(repr=False, slots=True)
-class FuncHandler(ABCHandler[Event], typing.Generic[Event, Function, ErrorHandlerT]):
-    function: Function
-    rules: list["ABCRule"]
-    adapter: ABCAdapter[Update, Event] | None = dataclasses.field(default=None, kw_only=True)
+class FuncHandler[T: Function](ABCHandler):
+    function: T
+    rules: dataclasses.InitVar[typing.Iterable[ABCRule] | None] = None
     final: bool = dataclasses.field(default=True, kw_only=True)
-    dataclass: type[typing.Any] | None = dataclasses.field(default=dict[str, typing.Any], kw_only=True)
-    error_handler: ErrorHandlerT = dataclasses.field(
-        default_factory=lambda: typing.cast(ErrorHandlerT, ErrorHandler()),
-        kw_only=True,
-    )
     preset_context: Context = dataclasses.field(default_factory=lambda: Context(), kw_only=True)
-    update_type: UpdateType | None = dataclasses.field(default=None, kw_only=True)
-
-    def __post_init__(self) -> None:
-        self.dataclass = typing.get_origin(self.dataclass) or self.dataclass
 
-        if self.dataclass is not None and self.adapter is None:
-            self.adapter = DataclassAdapter(self.dataclass, self.update_type)
+    def __post_init__(self, rules: typing.Iterable[ABCRule] | None) -> None:
+        self.check_rules = deque(rules or ())
 
     @property
     def __call__(self) -> Function:
         return self.function
 
     def __repr__(self) -> str:
-        return "<{}: {}={!r} with rules={!r}, dataclass={!r}, error_handler={!r}>".format(
-            self.__class__.__name__,
-            "final function" if self.final else "function",
-            self.function.__qualname__,
-            self.rules,
-            self.dataclass,
-            self.error_handler,
-        )
+        return fullname(self.function)
 
     @cached_property
-    def required_nodes(self) -> dict[str, type[NodeType]]:
+    def required_nodes(self) -> dict[str, IsNode]:
         return get_nodes(self.function)
 
-    def get_name_event_param(self, event: Event) -> str | None:
-        event_class = self.dataclass or event.__class__
-        for k, v in get_annotations(self.function).items():
-            if isinstance(v := typing.get_origin(v) or v, type) and v is event_class:
-                self.func_event_param = k
-                return k
-        return None
-
-    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
-        if self.update_type is not None and self.update_type != event.update_type:
-            return False
-
-        logger.debug("Checking handler {!r}...", self)
-        ctx = Context(raw_update=event) if ctx is None else ctx
-        temp_ctx = ctx.copy()
+    async def run(
+        self,
+        api: API,
+        event: Update,
+        context: Context,
+        check: bool = True,
+    ) -> Result[typing.Any, str]:
+        logger.debug("Checking rules and composing nodes for handler `{!r}`...", self)
+
+        temp_ctx = context.copy()
         temp_ctx |= self.preset_context.copy()
-        update = event
 
-        for rule in self.rules:
-            if not await check_rule(api, rule, update, temp_ctx):
-                logger.debug("Rule {!r} failed!", rule)
-                return False
+        if check:
+            for rule in self.check_rules:
+                if not await check_rule(api, rule, event, temp_ctx):
+                    return Error(f"Rule {rule!r} failed.")
 
-        nodes = self.required_nodes
+        context |= temp_ctx
+        data = {Update: event, API: api}
         node_col = None
-        if nodes:
-            result = await compose_nodes(nodes, ctx, data={Update: update, API: api})
-            if not result:
-                logger.debug(f"Cannot compose nodes for handler, error: {str(result.error)}")
-                return False
-
-            node_col = result.value
-            temp_ctx |= node_col.values
 
-        logger.debug("All checks passed for handler.")
-        temp_ctx["node_col"] = node_col
-        ctx |= temp_ctx
-        return True
+        if self.required_nodes:
+            match await compose_nodes(self.required_nodes, context, data=data):
+                case Ok(value):
+                    node_col = value
+                case Error(compose_error):
+                    return Error(f"Cannot compose nodes for handler `{self}`, error: {compose_error.message}")
 
-    async def run(
-        self,
-        api: API,
-        event: Event,
-        ctx: Context,
-        node_col: "NodeCollection | None" = None,
-    ) -> typing.Any:
-        logger.debug(f"Running handler {self!r}...")
+        logger.debug("All good, running handler `{!r}`", self)
 
+        temp_ctx = context.copy()
         try:
-            if event_param := self.get_name_event_param(event):
-                ctx = Context(**{event_param: event, **ctx})
-            return await self(**magic_bundle(self.function, ctx, start_idx=0))
-        except BaseException as exception:
-            return await self.error_handler.run(exception, event, api, ctx)
+            bundle_function = bundle(
+                self.function,
+                {**data, Context: temp_ctx},
+                typebundle=True,
+                start_idx=0,
+            )
+            bundle_function &= bundle(
+                self.function, context | ({} if node_col is None else node_col.values), start_idx=0
+            )
+            return Ok(await bundle_function())
         finally:
-            if node_col := ctx.node_col:
+            context |= temp_ctx
+
+            if node_col is not None:
                 await node_col.close_all()
 
 

telegrinder/bot/dispatch/handler/media_group_reply.py

@@ -1,6 +1,5 @@
 import typing
 
-from telegrinder.api.api import API
 from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
@@ -31,8 +30,8 @@ class MediaGroupReplyHandler(BaseReplyHandler):
             **default_params,
         )
 
-    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
-        method = event.answer_media_group if not self.as_reply else event.reply_media_group
+    async def handle(self, message: MessageCute) -> None:
+        method = message.answer_media_group if not self.as_reply else message.reply_media_group
         await method(
             media=self.media,
             parse_mode=self.parse_mode,

telegrinder/bot/dispatch/handler/message_reply.py

@@ -1,6 +1,5 @@
 import typing
 
-from telegrinder.api.api import API
 from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
@@ -28,8 +27,8 @@ class MessageReplyHandler(BaseReplyHandler):
             **default_params,
         )
 
-    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
-        method = event.answer if not self.as_reply else event.reply
+    async def handle(self, message: MessageCute) -> None:
+        method = message.answer if not self.as_reply else message.reply
         await method(text=self.text, parse_mode=self.parse_mode, **self.default_params)