telegrinder 0.1.dev170__py3-none-any.whl → 0.2.0__py3-none-any.whl

telegrinder/bot/dispatch/__init__.py

@@ -1,10 +1,10 @@
-from .abc import ABCDispatch
-from .context import Context
-from .dispatch import ABCRule, Dispatch, TelegrinderCtx
-from .handler import ABCHandler, FuncHandler, MessageReplyHandler
-from .middleware import ABCMiddleware
-from .process import check_rule, process_inner
-from .return_manager import (
+from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.dispatch import Dispatch, TelegrinderContext
+from telegrinder.bot.dispatch.handler import ABCHandler, FuncHandler, MessageReplyHandler
+from telegrinder.bot.dispatch.middleware import ABCMiddleware
+from telegrinder.bot.dispatch.process import check_rule, process_inner
+from telegrinder.bot.dispatch.return_manager import (
     ABCReturnManager,
     BaseReturnManager,
     CallbackQueryReturnManager,
@@ -13,7 +13,7 @@ from .return_manager import (
     MessageReturnManager,
     register_manager,
 )
-from .view import (
+from telegrinder.bot.dispatch.view import (
     ABCStateView,
     ABCView,
     BaseStateView,
@@ -26,14 +26,13 @@ from .view import (
     RawEventView,
     ViewBox,
 )
-from .waiter_machine import ShortState, WaiterMachine, clear_wm_storage_worker
+from telegrinder.bot.dispatch.waiter_machine import ShortState, WaiterMachine, clear_wm_storage_worker
 
 __all__ = (
     "ABCDispatch",
     "ABCHandler",
     "ABCMiddleware",
     "ABCReturnManager",
-    "ABCRule",
     "ABCStateView",
     "ABCView",
     "BaseReturnManager",
@@ -54,7 +53,7 @@ __all__ = (
     "MessageView",
     "RawEventView",
     "ShortState",
-    "TelegrinderCtx",
+    "TelegrinderContext",
     "ViewBox",
     "WaiterMachine",
     "check_rule",

telegrinder/bot/dispatch/abc.py

@@ -1,16 +1,19 @@
 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 telegrinder.api import API
+from telegrinder.tools.global_context.abc import ABCGlobalContext
+from telegrinder.types.objects import Update
 
 
 class ABCDispatch(ABC):
-    global_context: ABCGlobalContext
+    @property
+    @abstractmethod
+    def global_context(self) -> ABCGlobalContext:
+        pass
 
     @abstractmethod
-    async def feed(self, event: Update, api: ABCAPI) -> bool:
+    async def feed(self, event: Update, api: API) -> bool:
         pass
 
     @abstractmethod

telegrinder/bot/dispatch/context.py

@@ -10,15 +10,15 @@ 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 = RawUpdateAdapter()
+    """Context class like dict & dotdict.
 
+    For example:
+    ```python
+    class MyRule(ABCRule[T]):
         async def check(self, event: T, ctx: Context) -> bool:
-            ctx.set("value", (await event.ctx_api.get_me()).unwrap())
+            ctx.me = (await event.ctx_api.get_me()).unwrap()
+            ctx["items"] = [1, 2, 3]
             return True
     ```
     """
@@ -68,13 +68,22 @@ class Context(dict[str, AnyValue]):
     def set(self, key: Key, value: AnyValue) -> None:
         self[key] = value
 
-    def get(self, key: Key, default: T | None = None) -> T | AnyValue:
+    @typing.overload
+    def get(self, key: Key) -> AnyValue | None: ...
+
+    @typing.overload
+    def get(self, key: Key, default: T) -> T | AnyValue: ...
+
+    @typing.overload
+    def get(self, key: Key, default: None = None) -> AnyValue | None: ...
+
+    def get(self, key: Key, default: T | None = None) -> T | AnyValue | None:
         return dict.get(self, key, default)
 
     def get_or_set(self, key: Key, default: T) -> T:
         if key not in self:
             self.set(key, default)
-        return self.get(key)
+        return self.get(key, default)
 
     def delete(self, key: Key) -> None:
         del self[key]

telegrinder/bot/dispatch/dispatch.py

@@ -1,23 +1,14 @@
-import asyncio
 import dataclasses
 import typing
 
 from vbml.patcher import Patcher
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.cute_types.update import UpdateCute
-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
-
-from .abc import ABCDispatch
-from .handler import ABCHandler, FuncHandler
-from .handler.func import ErrorHandlerT
-from .view.box import (
+from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.bot.dispatch.handler.func import ErrorHandlerT, FuncHandler
+from telegrinder.bot.dispatch.view.box import (
     CallbackQueryView,
     ChatJoinRequestView,
     ChatMemberView,
@@ -26,10 +17,16 @@ from .view.box import (
     RawEventView,
     ViewBox,
 )
+from telegrinder.modules import logger
+from telegrinder.tools.error_handler.error_handler import ErrorHandler
+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.rules.abc import ABCRule
 
 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)
 
@@ -48,18 +45,18 @@ class Dispatch(
         RawEventView,
     ],
 ):
-    global_context: TelegrinderCtx = dataclasses.field(
-        init=False,
-        default_factory=lambda: TelegrinderCtx(),
-    )
-    default_handlers: list[ABCHandler] = dataclasses.field(
+    _global_context: TelegrinderContext = dataclasses.field(
         init=False,
-        default_factory=lambda: [],
+        default_factory=lambda: TelegrinderContext(),
     )
 
     def __repr__(self) -> str:
         return "Dispatch(%s)" % ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items())
 
+    @property
+    def global_context(self) -> TelegrinderContext:
+        return self._global_context
+
     @property
     def patcher(self) -> Patcher:
         """Alias `patcher` to get `vbml.Patcher` from the global context."""
@@ -69,28 +66,48 @@ class Dispatch(
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        dataclass: type[T],
+        is_blocking: bool = True,
     ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
+        update_type: UpdateType,
         is_blocking: bool = True,
     ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
         dataclass: type[T],
+        update_type: UpdateType,
         is_blocking: bool = True,
     ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandler]]: ...
 
     @typing.overload
     def handle(  # type: ignore
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
+
+    @typing.overload
+    def handle(  # type: ignore
+        self,
+        *rules: "ABCRule",
+        update_type: UpdateType,
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
     ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
@@ -98,7 +115,7 @@ class Dispatch(
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
         dataclass: type[T],
         error_handler: ErrorHandlerT,
         is_blocking: bool = True,
@@ -107,7 +124,18 @@ class Dispatch(
     @typing.overload
     def handle(
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
+        dataclass: type[T],
+        update_type: UpdateType,
+        error_handler: ErrorHandlerT,
+        is_blocking: bool = True,
+    ) -> typing.Callable[[Handler[T]], FuncHandler[UpdateCute, Handler[T], ErrorHandlerT]]: ...
+
+    @typing.overload
+    def handle(
+        self,
+        *rules: "ABCRule",
+        update_type: UpdateType | None = None,
         dataclass: type[T] = DEFAULT_DATACLASS,
         error_handler: typing.Literal[None] = None,
         is_blocking: bool = True,
@@ -115,7 +143,8 @@ class Dispatch(
 
     def handle(  # type: ignore
         self,
-        *rules: ABCRule,
+        *rules: "ABCRule",
+        update_type: UpdateType | None = None,
         dataclass: type[typing.Any] = DEFAULT_DATACLASS,
         error_handler: ErrorHandlerT | None = None,
         is_blocking: bool = True,
@@ -127,36 +156,30 @@ class Dispatch(
                 is_blocking=is_blocking,
                 dataclass=dataclass,
                 error_handler=error_handler or ErrorHandler(),
+                update_type=update_type,
             )
-            self.default_handlers.append(handler)
+            self.raw_event.handlers.append(handler)
             return handler
 
         return wrapper
 
-    async def feed(self, event: Update, api: ABCAPI) -> bool:
-        logger.debug("Processing update (update_id={})", event.update_id)
-        await self.raw_event.process(event, api)
-
+    async def feed(self, event: Update, api: API) -> bool:
+        logger.debug(
+            "Processing update (update_id={}, update_type={!r})",
+            event.update_id,
+            event.update_type.name,
+        )
         for view in self.get_views().values():
             if await view.check(event):
                 logger.debug(
-                    "Update (update_id={}) matched view {!r}.",
+                    "Update (update_id={}, update_type={!r}) matched view {!r}.",
                     event.update_id,
-                    view.__class__.__name__,
+                    event.update_type.name,
+                    view,
                 )
-                await view.process(event, api)
-                return True
-
-        ctx = Context()
-        loop = asyncio.get_running_loop()
-        found = False
-        for handler in self.default_handlers:
-            if await handler.check(api, event, ctx):
-                found = True
-                loop.create_task(handler.run(event, ctx))
-                if handler.is_blocking:
-                    break
-        return found
+                if await view.process(event, api):
+                    return True
+        return False
 
     def load(self, external: typing.Self) -> None:
         view_external = external.get_views()

telegrinder/bot/dispatch/handler/__init__.py

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

telegrinder/bot/dispatch/handler/abc.py

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

telegrinder/bot/dispatch/handler/func.py

@@ -1,17 +1,20 @@
 import dataclasses
+from functools import cached_property
 
 import typing_extensions as typing
 
-from telegrinder.api.abc import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.cute_types import BaseCute, UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.model import Model
 from telegrinder.modules import logger
-from telegrinder.node import Node, compose_nodes, is_node
+from telegrinder.node.base import Node, get_nodes
+from telegrinder.node.composer import compose_nodes
+from telegrinder.node.event import EVENT_NODE_KEY
 from telegrinder.tools.error_handler import ABCErrorHandler, ErrorHandler
-from telegrinder.tools.magic import get_annotations
-from telegrinder.types import Update
 from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Update
 
 from .abc import ABCHandler
 
@@ -22,11 +25,11 @@ F = typing.TypeVar(
     "F",
     bound=typing.Callable[typing.Concatenate[typing.Any, ...], typing.Awaitable[typing.Any]],
 )
-Event = typing.TypeVar("Event", bound=BaseCute)
+Event = typing.TypeVar("Event", bound=Model)
 ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler, default=ErrorHandler)
 
 
-@dataclasses.dataclass(repr=False)
+@dataclasses.dataclass(repr=False, slots=True)
 class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
     func: F
     rules: list["ABCRule"]
@@ -49,48 +52,69 @@ class FuncHandler(ABCHandler[Event], typing.Generic[Event, F, ErrorHandlerT]):
             self.error_handler,
         )
 
-    def get_required_nodes(self) -> dict[str, type[Node]]:
-        return {k: v for k, v in get_annotations(self.func).items() if is_node(v)}
+    @cached_property
+    def required_nodes(self) -> dict[str, type[Node]]:
+        return get_nodes(self.func)
 
-    async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
+    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
 
-        ctx = ctx or Context()
+        logger.debug("Checking handler {!r}...", self)
+        ctx = Context(raw_update=event) if ctx is None else ctx
         temp_ctx = ctx.copy()
         temp_ctx |= self.preset_context
 
-        nodes = self.get_required_nodes()
+        nodes = self.required_nodes
         node_col = None
+        update = event
 
         if nodes:
-            node_col = await compose_nodes(nodes, UpdateCute.from_update(event, api), ctx)
-            if node_col is None:
+            result = await compose_nodes(nodes, ctx, data={Update: event, API: api})
+            if not result:
+                logger.debug(f"Cannot compose nodes for handler. {result.error}")
                 return False
-            temp_ctx |= node_col.values()
+
+            node_col = result.value
+            temp_ctx |= node_col.values
+
+            if EVENT_NODE_KEY in ctx:
+                for name, node in nodes.items():
+                    if node is ctx[EVENT_NODE_KEY] and name in temp_ctx:
+                        ctx[EVENT_NODE_KEY] = temp_ctx.pop(name)
 
         for rule in self.rules:
-            if not await check_rule(api, rule, event, temp_ctx):
+            if not await check_rule(api, rule, update, temp_ctx):
                 logger.debug("Rule {!r} failed!", rule)
                 return False
 
+        logger.debug("All checks passed for handler.")
+
         temp_ctx["node_col"] = node_col
         ctx |= temp_ctx
         return True
 
-    async def run(self, event: Event, ctx: Context) -> typing.Any:
-        api = event.api
+    async def run(self, api: API, event: Event, ctx: Context) -> typing.Any:
+        logger.debug(f"Running func handler {self.func}")
+        dataclass_type = typing.get_origin(self.dataclass) or self.dataclass
 
-        if self.dataclass is not None:
-            if self.update_type is not None:
+        if dataclass_type is Update and (event_node := ctx.pop(EVENT_NODE_KEY, None)) is not None:
+            event = event_node
+
+        elif dataclass_type is not None:
+            if self.update_type is not None and isinstance(event, Update):
                 update = event.to_dict()[self.update_type.value].unwrap()
                 event = (
                     self.dataclass.from_update(update, bound_api=api)  # type: ignore
-                    if issubclass(self.dataclass, BaseCute)
-                    else self.dataclass(**update.to_dict())
+                    if issubclass(dataclass_type, BaseCute)
+                    else self.dataclass(**update.to_dict())  # type: ignore
                 )
+
+            elif issubclass(dataclass_type, UpdateCute) and isinstance(event, Update):
+                event = self.dataclass.from_update(event, bound_api=api)  # type: ignore
+
             else:
-                event = self.dataclass(**event.to_dict())
+                event = self.dataclass(**event.to_dict())  # type: ignore
 
         result = (await self.error_handler.run(self.func, event, api, ctx)).unwrap()
         if node_col := ctx.node_col:

telegrinder/bot/dispatch/handler/message_reply.py

@@ -1,15 +1,14 @@
 import typing
 
-from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.cute_types import MessageCute
+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.abc import ABCHandler
 from telegrinder.bot.dispatch.process import check_rule
 from telegrinder.bot.rules.abc import ABCRule
 from telegrinder.modules import logger
 from telegrinder.types.objects import ReplyParameters, Update
 
-from .abc import ABCHandler
-
 
 class MessageReplyHandler(ABCHandler[MessageCute]):
     def __init__(
@@ -36,8 +35,8 @@ class MessageReplyHandler(ABCHandler[MessageCute]):
             self.text,
         )
 
-    async def check(self, api: ABCAPI, event: Update, ctx: Context | None = None) -> bool:
-        ctx = ctx or Context()
+    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
 
@@ -49,7 +48,7 @@ class MessageReplyHandler(ABCHandler[MessageCute]):
         ctx |= temp_ctx
         return True
 
-    async def run(self, event: MessageCute, _: Context) -> typing.Any:
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
         await event.answer(
             text=self.text,
             reply_parameters=ReplyParameters(event.message_id) if self.as_reply else None,

telegrinder/bot/dispatch/middleware/__init__.py

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

telegrinder/bot/dispatch/middleware/abc.py

@@ -1,10 +1,10 @@
 import typing
 from abc import ABC
 
-from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.context import Context
+from telegrinder.model import Model
 
-Event = typing.TypeVar("Event", bound=BaseCute)
+Event = typing.TypeVar("Event", bound=Model)
 
 
 class ABCMiddleware(ABC, typing.Generic[Event]):