telegrinder 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

telegrinder/bot/cute_types/update.py

@@ -1,8 +1,5 @@
-import typing
-
 from fntypes.co import Nothing, Some
 
-from telegrinder.api.api import API
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
 from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
@@ -14,12 +11,8 @@ from telegrinder.model import UNSET, From, field
 from telegrinder.msgspec_utils import Option
 from telegrinder.types.objects import *
 
-EventModel = typing.TypeVar("EventModel", bound=Model)
-
 
 class UpdateCute(BaseCute[Update], Update, kw_only=True):
-    api: API
-
     message: Option[MessageCute] = field(
         default=UNSET,
         converter=From[MessageCute | None],
@@ -103,7 +96,7 @@ class UpdateCute(BaseCute[Update], Update, kw_only=True):
     """Optional. New incoming pre-checkout query. Contains full information
     about checkout."""
 
-    def get_event(self, event_model: type[EventModel]) -> Option[EventModel]:
+    def get_event[T: Model](self, event_model: type[T], /) -> Option[T]:
         if isinstance(self.incoming_update, event_model):
             return Some(self.incoming_update)
         return Nothing()

telegrinder/bot/cute_types/utils.py

@@ -1,6 +1,6 @@
 import typing
 
-from telegrinder.model import get_params
+from telegrinder.types.methods_utils import get_params
 from telegrinder.types.objects import (
     InputFile,
     InputMediaAnimation,

telegrinder/bot/dispatch/__init__.py

@@ -1,4 +1,5 @@
 from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.bot.dispatch.action import action
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.dispatch import Dispatch, TelegrinderContext
 from telegrinder.bot.dispatch.handler import (
@@ -25,13 +26,12 @@ from telegrinder.bot.dispatch.return_manager import (
     register_manager,
 )
 from telegrinder.bot.dispatch.view import (
-    ABCStateView,
     ABCView,
-    BaseStateView,
     BaseView,
     CallbackQueryView,
     ChatJoinRequestView,
     ChatMemberView,
+    ErrorView,
     InlineQueryView,
     MessageView,
     PreCheckoutQueryView,
@@ -47,25 +47,24 @@ from telegrinder.bot.dispatch.waiter_machine import (
     MESSAGE_IN_CHAT,
     Hasher,
     ShortState,
-    StateViewHasher,
     WaiterMachine,
-    clear_wm_storage_worker,
 )
 
 __all__ = (
+    "CALLBACK_QUERY_FOR_MESSAGE",
+    "CALLBACK_QUERY_FROM_CHAT",
+    "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
+    "MESSAGE_FROM_USER",
+    "MESSAGE_FROM_USER_IN_CHAT",
+    "MESSAGE_IN_CHAT",
     "ABCDispatch",
     "ABCHandler",
     "ABCMiddleware",
     "ABCReturnManager",
-    "ABCStateView",
     "ABCView",
     "AudioReplyHandler",
     "BaseReturnManager",
-    "BaseStateView",
     "BaseView",
-    "CALLBACK_QUERY_FOR_MESSAGE",
-    "CALLBACK_QUERY_FROM_CHAT",
-    "CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE",
     "CallbackQueryReturnManager",
     "CallbackQueryView",
     "ChatJoinRequestView",
@@ -73,13 +72,11 @@ __all__ = (
     "Context",
     "Dispatch",
     "DocumentReplyHandler",
+    "ErrorView",
     "FuncHandler",
     "Hasher",
     "InlineQueryReturnManager",
     "InlineQueryView",
-    "MESSAGE_FROM_USER",
-    "MESSAGE_FROM_USER_IN_CHAT",
-    "MESSAGE_IN_CHAT",
     "Manager",
     "MediaGroupReplyHandler",
     "MessageReplyHandler",
@@ -90,15 +87,13 @@ __all__ = (
     "PreCheckoutQueryView",
     "RawEventView",
     "ShortState",
-    "StateViewHasher",
     "StickerReplyHandler",
     "TelegrinderContext",
     "VideoReplyHandler",
     "ViewBox",
     "WaiterMachine",
+    "action",
     "check_rule",
-    "clear_wm_storage_worker",
-    "clear_wm_storage_worker",
     "process_inner",
     "register_manager",
 )

telegrinder/bot/dispatch/abc.py

@@ -10,9 +10,6 @@ from fntypes.option import Option
 from telegrinder.api.api import API
 from telegrinder.types.objects import Update
 
-if typing.TYPE_CHECKING:
-    from telegrinder.bot.dispatch.view.abc import ABCView
-
 
 class PathExistsError(BaseException):
     pass
@@ -20,7 +17,7 @@ class PathExistsError(BaseException):
 
 class ABCDispatch(ABC):
     @abstractmethod
-    async def feed(self, event: Update, api: API[typing.Any]) -> bool:
+    async def feed(self, event: Update, api: API) -> bool:
         pass
 
     @abstractmethod
@@ -31,26 +28,30 @@ class ABCDispatch(ABC):
     def get_view[T](self, of_type: type[T]) -> Option[T]:
         pass
 
-    @abstractmethod
-    def get_views(self) -> dict[str, "ABCView"]:
-        pass
-
     def load_many(self, *externals: typing.Self) -> None:
         for external in externals:
             self.load(external)
 
-    def load_from_dir(self, directory: str | pathlib.Path) -> bool:
+    def load_from_dir(
+        self,
+        directory: str | pathlib.Path,
+        *,
+        recursive: bool = False,
+    ) -> bool:
         """Loads dispatchers from a directory containing Python modules where global variables
         are declared with instances of dispatch.
         Returns True if dispatchers were found, otherwise False.
         """
+
         directory = pathlib.Path(directory)
 
         if not directory.exists():
             raise PathExistsError(f"Path {str(directory)!r} does not exists.")
 
         dps: list[typing.Self] = []
-        for root, _, files in os.walk(directory):
+        files_iter = os.walk(directory) if recursive else [(directory, [], os.listdir(directory))]
+
+        for root, _, files in files_iter:
             for f in files:
                 if f.endswith(".py") and f != "__init__.py":
                     module_path = os.path.join(root, f)
@@ -66,7 +67,7 @@ class ABCDispatch(ABC):
                     spec.loader.exec_module(module)
 
                     for obj in module.__dict__.values():
-                        if isinstance(obj, self.__class__):
+                        if isinstance(obj, type(self)):
                             dps.append(obj)
 
         self.load_many(*dps)

telegrinder/bot/dispatch/action.py

@@ -0,0 +1,104 @@
+import inspect
+import typing
+
+from fntypes.co import Error, Ok, Result, unwrapping
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules.abc import ABCRule
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.func import FuncHandler
+from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.modules import logger
+from telegrinder.node.base import get_nodes
+from telegrinder.node.composer import compose_nodes
+from telegrinder.tools.aio import maybe_awaitable, next_generator, stop_generator
+from telegrinder.tools.magic.function import bundle
+from telegrinder.types.objects import Update
+
+type When = ABCRule
+type Handler = typing.Callable[..., typing.Any]
+type ActionFunction = typing.Callable[..., ActionFunctionResult]
+type ActionFunctionResult = typing.Union[
+    typing.AsyncGenerator[typing.Any, typing.Any],
+    typing.Awaitable[typing.Any],
+    typing.Generator[typing.Any, typing.Any, typing.Any],
+    typing.Any,
+]
+
+
+@unwrapping
+async def run_action_function[T: Handler](
+    func_handler: FuncHandler[T],
+    function: ActionFunction,
+    api: API,
+    update: Update,
+    context: Context,
+) -> Result[typing.Any, str]:
+    data = {API: api, Update: update}
+    node_col = (
+        (
+            await compose_nodes(
+                nodes=get_nodes(function),
+                ctx=context,
+                data=data,
+            )
+        )
+        .map_err(lambda error: error.message)
+        .unwrap()
+    )
+
+    temp_ctx = context.copy()
+    bundle_function = bundle(function, {Context: temp_ctx, **data}, start_idx=0, typebundle=True)
+    bundle_function &= bundle(
+        function,
+        context | ({} if node_col is None else node_col.values),
+        start_idx=0,
+    )
+    result = bundle_function()
+
+    try:
+        if inspect.isasyncgen(result) or inspect.isgenerator(result):
+            value = await next_generator(result)
+            handler_result = await func_handler.run(api, update, context)
+            await stop_generator(result, value)
+            return handler_result
+
+        await maybe_awaitable(result)
+        return await func_handler.run(api, update, context)
+    finally:
+        context |= temp_ctx
+        await node_col.close_all()
+
+
+def action[T: Handler](
+    function: ActionFunction,
+    *,
+    when: When | None = None,
+) -> typing.Callable[[T], T]:
+    def decorator(handler: T, /) -> T:
+        func_handler = FuncHandler(function=handler)
+
+        async def action_wrapper(api: API, update: Update, context: Context) -> typing.Any:
+            if when and not await check_rule(api, when, update, context):
+                logger.debug("When action rule `{!r}` failed.", when)
+                result = await func_handler.run(api, update, context)
+            else:
+                result = await run_action_function(func_handler, function, api, update, context)
+
+            match result:
+                case Ok(value):
+                    return value
+                case Error(error):
+                    logger.debug(error)
+                    return None
+
+        action_wrapper.__name__ = f"<action for {handler.__name__}>"
+        action_wrapper.__qualname__ = f"<action for {handler.__qualname__}>"
+        return action_wrapper  # type: ignore
+
+    return decorator
+
+
+__all__ = ("action",)

telegrinder/bot/dispatch/context.py

@@ -4,45 +4,30 @@ import enum
 import typing
 from reprlib import recursive_repr
 
-from telegrinder.types.objects import Update
+from fntypes import Some
+from fntypes.option import Nothing, Option
 
 if typing.TYPE_CHECKING:
-    from telegrinder.node.composer import NodeCollection
+    from telegrinder.api.api import API
+    from telegrinder.bot.cute_types.update import UpdateCute
+    from telegrinder.types.objects import Update
 
 type Key = str | enum.Enum
 type AnyValue = typing.Any
 
 
 class Context(dict[str, AnyValue]):
-    """Context class like dict & dotdict.
+    """Low level per event context storage."""
 
-    For example:
-    ```python
-    class MyRule(ABCRule[T]):
-        async def check(self, event: T, ctx: Context) -> bool:
-            ctx.me = (await event.ctx_api.get_me()).unwrap()
-            ctx["items"] = [1, 2, 3]
-            return True
-    ```
-    """
-
-    raw_update: Update
-    node_col: NodeCollection | None = None
+    update_cute: Option[UpdateCute] = Nothing()
+    exception_update: Option[BaseException] = Nothing()
 
     def __init__(self, **kwargs: AnyValue) -> None:
-        cls_vars = vars(self.__class__)
-        defaults = {}
-
-        for k in self.__class__.__annotations__:
-            if k in cls_vars:
-                defaults[k] = cls_vars[k]
-                delattr(self.__class__, k)
-
-        dict.__init__(self, **defaults | kwargs)
+        dict.__init__(self, **kwargs)
 
     @recursive_repr()
     def __repr__(self) -> str:
-        return "{}({})".format(self.__class__.__name__, ", ".join(f"{k}={v!r}" for k, v in self.items()))
+        return "{}({})".format(type(self).__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)
@@ -56,12 +41,30 @@ class Context(dict[str, AnyValue]):
     def __setattr__(self, __name: str, __value: AnyValue) -> None:
         self.__setitem__(__name, __value)
 
-    def __getattr__(self, __name: str) -> AnyValue:
+    def __getattribute__(self, __name: str) -> AnyValue:
+        cls = type(self)
+
+        if __name in cls.__annotations__:
+            return self[__name] if __name in self else super().__getattribute__(__name)
+
+        if __name in _CONTEXT_CLASS_ATTRS:
+            return super().__getattribute__(__name)
+
         return self.__getitem__(__name)
 
     def __delattr__(self, __name: str) -> None:
         self.__delitem__(__name)
 
+    def add_update_cute(self, update: Update, bound_api: API, /) -> typing.Self:
+        from telegrinder.bot.cute_types.update import UpdateCute
+
+        self.update_cute = Some(UpdateCute.from_update(update, bound_api))
+        return self
+
+    def add_exception_update(self, exception_update: BaseException, /) -> typing.Self:
+        self.exception_update = Some(exception_update)
+        return self
+
     @staticmethod
     def key_to_str(key: Key) -> str:
         return key if isinstance(key, str) else str(key.value)
@@ -93,4 +96,7 @@ class Context(dict[str, AnyValue]):
         del self[key]
 
 
+_CONTEXT_CLASS_ATTRS = frozenset(Context.__dict__ | dict.__dict__ | object.__dict__)
+
+
 __all__ = ("Context",)

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",