telegrinder 0.1.dev20__py3-none-any.whl → 0.1.dev159__py3-none-any.whl

telegrinder/bot/dispatch/__init__.py

@@ -1,5 +1,58 @@
 from .abc import ABCDispatch
-from .dispatch import ABCDispatch, Dispatch, ABCRule
-from .handler import ABCHandler, FuncHandler
+from .composition import CompositionDispatch
+from .context import Context
+from .dispatch import ABCRule, Dispatch, TelegrinderCtx
+from .handler import ABCHandler, FuncHandler, MessageReplyHandler
 from .middleware import ABCMiddleware
-from .view import ABCView, MessageView, CallbackQueryView, InlineQueryView
+from .process import check_rule, process_inner
+from .return_manager import (
+    ABCReturnManager,
+    BaseReturnManager,
+    CallbackQueryReturnManager,
+    InlineQueryReturnManager,
+    Manager,
+    MessageReturnManager,
+    register_manager,
+)
+from .view import (
+    ABCStateView,
+    ABCView,
+    BaseStateView,
+    BaseView,
+    CallbackQueryView,
+    InlineQueryView,
+    MessageView,
+    ViewBox,
+)
+from .waiter_machine import WaiterMachine
+
+__all__ = (
+    "ABCDispatch",
+    "ABCHandler",
+    "ABCMiddleware",
+    "ABCReturnManager",
+    "ABCRule",
+    "ABCStateView",
+    "ABCView",
+    "BaseReturnManager",
+    "BaseStateView",
+    "BaseView",
+    "CallbackQueryReturnManager",
+    "CallbackQueryView",
+    "CompositionDispatch",
+    "Context",
+    "Dispatch",
+    "FuncHandler",
+    "InlineQueryReturnManager",
+    "InlineQueryView",
+    "Manager",
+    "MessageReplyHandler",
+    "MessageReturnManager",
+    "MessageView",
+    "TelegrinderCtx",
+    "ViewBox",
+    "WaiterMachine",
+    "check_rule",
+    "process_inner",
+    "register_manager",
+)

telegrinder/bot/dispatch/abc.py

@@ -1,19 +1,21 @@
+import typing
 from abc import ABC, abstractmethod
+
 from telegrinder.api.abc import ABCAPI
+from telegrinder.tools.global_context import ABCGlobalContext
 from telegrinder.types import Update
-from .view.abc import ABCView
-import typing
 
 
 class ABCDispatch(ABC):
-    @abstractmethod
-    def feed(self, event: Update, api: ABCAPI) -> bool:
-        pass
+    global_context: ABCGlobalContext
 
     @abstractmethod
-    def load(self, external: "ABCDispatch"):
+    async def feed(self, event: Update, api: ABCAPI) -> bool:
         pass
 
     @abstractmethod
-    def mount(self, view_t: typing.Type["ABCView"], name: str):
+    def load(self, external: typing.Self):
         pass
+
+
+__all__ = ("ABCDispatch",)

telegrinder/bot/dispatch/composition.py

@@ -0,0 +1,74 @@
+import inspect
+import typing
+
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types import UpdateCute
+from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.node import (
+    ComposeError,
+    ContainerNode,
+    Node,
+    NodeCollection,
+    NodeSession,
+    compose_node,
+)
+from telegrinder.tools import magic_bundle
+from telegrinder.types import Update
+
+
+class Composition:
+    nodes: dict[str, type[Node]]
+
+    def __init__(self, func: typing.Callable, is_blocking: bool) -> None:
+        self.func = func
+        self.nodes = {
+            name: parameter.annotation
+            for name, parameter in inspect.signature(func).parameters.items()
+        }
+        self.is_blocking = is_blocking
+    
+    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:
+                await NodeCollection(nodes).close_all()
+                return None
+        return NodeCollection(nodes)
+    
+    async def __call__(self, **kwargs) -> typing.Any:
+        return await self.func(**magic_bundle(self.func, kwargs, start_idx=0, bundle_ctx=False))  # type: ignore
+
+
+class CompositionDispatch(ABCDispatch):
+    def __init__(self) -> None:
+        self.compositions: list[Composition] = []
+    
+    async def feed(self, event: Update, api: ABCAPI) -> bool:
+        update = UpdateCute(**event.to_dict(), api=api)
+        is_found = False
+        for composition in self.compositions:
+            nodes = await composition.compose_nodes(update)
+            if nodes is not None:
+                result = await composition(**nodes.values())
+                await nodes.close_all(with_value=result)
+                if composition.is_blocking:
+                    return True
+                is_found = True
+        return is_found
+    
+    def load(self, external: typing.Self):
+        self.compositions.extend(external.compositions)
+
+    def __call__(self, *container_nodes: type[Node], is_blocking: bool = True):
+        def wrapper(func: typing.Callable):
+            composition = Composition(func, is_blocking)
+            if container_nodes:
+                composition.nodes["container"] = ContainerNode.link_nodes(list(container_nodes))
+            self.compositions.append(composition)
+            return func
+        return wrapper
+
+
+__all__ = ("Composition", "CompositionDispatch")

telegrinder/bot/dispatch/context.py

@@ -0,0 +1,71 @@
+import enum
+import typing
+
+from telegrinder.types import Update
+
+T = typing.TypeVar("T")
+
+Key: typing.TypeAlias = str | enum.Enum
+AnyValue: typing.TypeAlias = typing.Any
+
+
+@typing.dataclass_transform(kw_only_default=True, order_default=True)
+class Context(dict[str, AnyValue]):
+    """Context class for rules and middlewares.
+    ```
+    class MyRule(ABCRule[T]):
+        adapter: ABCAdapter[Update, T] = RawUpdateAdapter()
+
+        async def check(self, event: T, ctx: Context) -> bool:
+            ctx.set("value", (await event.ctx_api.get_me()).unwrap())
+            return True
+    ```
+    """
+
+    raw_update: Update
+
+    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)
+    
+    def __setitem__(self, __key: Key, __value: AnyValue) -> None:
+        dict.__setitem__(self, self.key_to_str(__key), __value)
+    
+    def __getitem__(self, __key: Key) -> AnyValue:
+        return dict.__getitem__(self, self.key_to_str(__key))
+    
+    def __delitem__(self, __key: Key) -> None:
+        dict.__delitem__(self, self.key_to_str(__key))
+
+    def __setattr__(self, __name: str, __value: AnyValue) -> None:
+        self.__setitem__(__name, __value)
+    
+    def __getattr__(self, __name: str) -> AnyValue:
+        return self.__getitem__(__name)
+    
+    def __delattr__(self, __name: str) -> None:
+        self.__delitem__(__name)
+
+    @staticmethod
+    def key_to_str(key: Key) -> str:
+        return key if isinstance(key, str) else str(key.value)
+    
+    def copy(self) -> typing.Self:
+        return self.__class__(**self)
+
+    def set(self, key: Key, value: AnyValue) -> None:
+        self[key] = value
+    
+    def get(self, key: Key, default: T | None = None) -> T | AnyValue:
+        return dict.get(self, key, default)
+    
+    def delete(self, key: Key) -> None:
+        del self[key]
+
+
+__all__ = ("Context",)

telegrinder/bot/dispatch/dispatch.py

@@ -1,68 +1,76 @@
 import asyncio
+import dataclasses
+import typing
+
+from vbml.patcher import Patcher
 
-from .abc import ABCDispatch
-from telegrinder.bot.rules import ABCRule
-from .handler import ABCHandler, FuncHandler
-from telegrinder.types import Update
 from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.rules import ABCRule
 from telegrinder.modules import logger
-from .view import ABCView, MessageView, CallbackQueryView, InlineQueryView
-import typing
+from telegrinder.tools.global_context import TelegrinderCtx
+from telegrinder.types import Update
+
+from .abc import ABCDispatch
+from .handler import ABCHandler, FuncHandler
+from .handler.func import ErrorHandlerT
+from .view.box import CallbackQueryViewT, InlineQueryViewT, MessageViewT, ViewBox
 
 T = typing.TypeVar("T")
 
+Event = typing.TypeVar("Event", bound=BaseCute)
+R = typing.TypeVar("R")
+P = typing.ParamSpec("P")
+
 DEFAULT_DATACLASS = Update
 
 
-class Dispatch(ABCDispatch):
-    def __init__(self):
-        self.default_handlers: typing.List[ABCHandler] = []
-        self.message = MessageView()
-        self.callback_query = CallbackQueryView()
-        self.inline_query = InlineQueryView()
-        self.views = ["message", "callback_query", "inline_query"]
+@dataclasses.dataclass(repr=False, kw_only=True)
+class Dispatch(
+    ABCDispatch,
+    ViewBox[CallbackQueryViewT, InlineQueryViewT, MessageViewT],
+):
+    global_context: TelegrinderCtx = dataclasses.field(
+        init=False,
+        default_factory=lambda: TelegrinderCtx(),
+    )
+    default_handlers: list[ABCHandler] = dataclasses.field(
+        init=False,
+        default_factory=lambda: [],
+    )
+
+    def __repr__(self) -> str:
+        return "Dispatch(%s)" % ", ".join(
+            f"{k}={v!r}" for k, v in self.__dict__.items()
+        )
+
+    @property
+    def patcher(self) -> Patcher:
+        """Alias `patcher` to get `vbml.Patcher` from the global context"""
+        return self.global_context.vbml_patcher
 
     def handle(
         self,
         *rules: ABCRule,
         is_blocking: bool = True,
-        dataclass: typing.Any = DEFAULT_DATACLASS,
+        dataclass: type[typing.Any] = DEFAULT_DATACLASS,
+        error_handler: ErrorHandlerT | None = None,
     ):
         def wrapper(func: typing.Callable):
-            self.default_handlers.append(
-                FuncHandler(func, list(rules), is_blocking, dataclass)
+            handler = FuncHandler(
+                func, list(rules), is_blocking, dataclass, error_handler,
             )
-            return func
+            self.default_handlers.append(handler)
+            return handler
 
         return wrapper
 
-    def get_views(self) -> typing.Iterator[ABCView]:
-        for view_name in self.views:
-            view = getattr(self, view_name)
-            assert view, f"View {view_name} is undefined in dispatch"
-            yield view
-
-    def get_view(self, view_t: typing.Type[T], name: str) -> typing.Optional[T]:
-        if name not in self.views:
-            return None
-        view = getattr(self, name)
-        assert isinstance(view, view_t)
-        return view  # type: ignore
-
-    def load(self, external: "Dispatch"):
-        for view_name in self.views:
-            view = getattr(self, view_name)
-            assert view, f"View {view_name} is undefined in dispatch"
-            view_external = getattr(external, view_name)
-            assert view_external, f"View {view_name} is undefined in external dispatch"
-            view.load(view_external)
-
     async def feed(self, event: Update, api: ABCAPI) -> bool:
-        logger.debug("processing update (update_id={})", event.update_id)
-        for view in self.get_views():
+        logger.debug("Processing update (update_id={})", event.update_id)
+        for view in self.get_views().values():
             if await view.check(event):
                 logger.debug(
-                    "update {} matched view {}",
+                    "Update (update_id={}) matched view {!r}",
                     event.update_id,
                     view.__class__.__name__,
                 )
@@ -70,18 +78,47 @@ class Dispatch(ABCDispatch):
                 return True
 
         loop = asyncio.get_running_loop()
-        assert loop, "No running loop"
-
         found = False
         for handler in self.default_handlers:
-            result = await handler.check(api, event)
-            if result:
+            if await handler.check(api, event):
                 found = True
                 loop.create_task(handler.run(event))
                 if handler.is_blocking:
-                    return True
+                    break
         return found
 
-    def mount(self, view_t: typing.Type["ABCView"], name: str):
-        self.views.append(name)
-        setattr(self, name, view_t)
+    def load(self, external: typing.Self):
+        view_external = external.get_views()
+        for name, view in self.get_views().items():
+            assert (
+                name in view_external
+            ), 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/__init__.py

@@ -1,2 +1,5 @@
 from .abc import ABCHandler
 from .func import FuncHandler
+from .message_reply import MessageReplyHandler
+
+__all__ = ("ABCHandler", "FuncHandler", "MessageReplyHandler")

telegrinder/bot/dispatch/handler/abc.py

@@ -1,19 +1,25 @@
+import typing
 from abc import ABC, abstractmethod
-from telegrinder.types import Update
+
 from telegrinder.api.abc import ABCAPI
-import typing
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.model import Model
+from telegrinder.types import Update
 
-T = typing.TypeVar("T")
+T = typing.TypeVar("T", bound=Model)
 
 
 class ABCHandler(ABC, typing.Generic[T]):
     is_blocking: bool
-    ctx: dict
+    ctx: Context
 
     @abstractmethod
     async def run(self, event: T) -> typing.Any:
         pass
 
     @abstractmethod
-    async def check(self, api: ABCAPI, event: Update) -> bool:
+    async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
         pass
+
+
+__all__ = ("ABCHandler",)

telegrinder/bot/dispatch/handler/func.py

@@ -1,49 +1,58 @@
-import typing
-import types
-from telegrinder.bot.rules import ABCRule
-from telegrinder.tools import magic_bundle
-from telegrinder.types import Update
+import typing_extensions as typing
+
 from telegrinder.api.abc import ABCAPI
-from .abc import ABCHandler
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.process import check_rule
 from telegrinder.modules import logger
+from telegrinder.tools.error_handler import ABCErrorHandler, ErrorHandler
+from telegrinder.types import Update
+
+from .abc import ABCHandler
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules import ABCRule
 
-T = typing.TypeVar("T")
+F = typing.TypeVar("F", bound=typing.Callable[typing.Concatenate[typing.Any, ...], typing.Awaitable])
+EventT = typing.TypeVar("EventT", bound=BaseCute)
+ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
 
 
-class FuncHandler(ABCHandler, typing.Generic[T]):
+class FuncHandler(ABCHandler[EventT], typing.Generic[EventT, F, ErrorHandlerT]):
     def __init__(
         self,
-        func: typing.Union[types.FunctionType, typing.Callable],
-        rules: typing.List[ABCRule],
+        func: F,
+        rules: list["ABCRule[EventT]"],
         is_blocking: bool = True,
-        dataclass: typing.Optional[typing.Any] = dict,
+        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.ctx = {}
-
-    async def check(self, api: ABCAPI, event: Update) -> bool:
-        self.ctx = {}
+        self.error_handler: ErrorHandlerT = error_handler or ErrorHandler()  # type: ignore
+        self.ctx = Context()
+    
+    @property
+    def on_error(self):
+        return self.error_handler.catch
+    
+    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
         for rule in self.rules:
-            e = event
-            if rule.__event__ is None:
-                pass
-            else:
-                event_dict = event.to_dict()
-                if event_dict.get(rule.__event__.name) is None:
-                    continue
-                e = rule.__event__.dataclass(
-                    **event_dict[rule.__event__.name].to_dict(),
-                    api=api,
-                )
-            if not await rule.run_check(e, self.ctx):
-                logger.debug("Rule {} failed", rule)
+            if not await check_rule(api, rule, event, self.ctx):
+                logger.debug("Rule {!r} failed!", rule)
+                self.ctx = preset_ctx
                 return False
         return True
 
-    async def run(self, event: T) -> typing.Any:
-        if self.dataclass:
-            event = self.dataclass(**event)
-        return await self.func(event, **magic_bundle(self.func, self.ctx))
+    async def run(self, event: EventT) -> 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()
+
+
+__all__ = ("FuncHandler",)

telegrinder/bot/dispatch/handler/message_reply.py

@@ -0,0 +1,46 @@
+import typing
+
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types import MessageCute
+from telegrinder.bot.dispatch.context import Context
+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 .abc import ABCHandler
+
+
+class MessageReplyHandler(ABCHandler[MessageCute]):
+    def __init__(
+        self,
+        text: str,
+        *rules: ABCRule[MessageCute],
+        as_reply: bool = False,
+        is_blocking: bool = True,
+    ):
+        self.text = text
+        self.rules = list(rules)
+        self.as_reply = as_reply
+        self.is_blocking = is_blocking
+        self.dataclass = MessageCute
+        self.ctx = Context()
+
+    async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
+        ctx = ctx or Context()
+        self.ctx |= ctx
+        for rule in self.rules:
+            if not await check_rule(api, rule, event, self.ctx):
+                logger.debug("Rule {!r} failed!", rule)
+                return False
+        return True
+
+    async def run(self, event: MessageCute) -> typing.Any:
+        await event.answer(
+            text=self.text,
+            reply_to_message_id=(event.message_id if self.as_reply else Nothing),
+        )
+
+
+__all__ = ("MessageReplyHandler",)

telegrinder/bot/dispatch/middleware/__init__.py

@@ -1 +1,3 @@
 from .abc import ABCMiddleware
+
+__all__ = ("ABCMiddleware",)

telegrinder/bot/dispatch/middleware/abc.py

@@ -1,12 +1,18 @@
-from abc import ABC
 import typing
+from abc import ABC
+
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.dispatch.context import Context
 
-T = typing.TypeVar("T")
+T = typing.TypeVar("T", bound=BaseCute)
 
 
 class ABCMiddleware(ABC, typing.Generic[T]):
-    async def pre(self, event: T, ctx: dict) -> bool:
+    async def pre(self, event: T, ctx: Context) -> bool:
         ...
 
-    async def post(self, event: T, responses: typing.List[typing.Any], ctx: dict):
+    async def post(self, event: T, responses: list[typing.Any], ctx: Context):
         ...
+
+
+__all__ = ("ABCMiddleware",)