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

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

telegrinder/bot/dispatch/process.py

@@ -1,61 +1,34 @@
 import typing
 
-from .waiter import Waiter
-from .middleware.abc import ABCMiddleware
-from .handler.abc import ABCHandler
-from telegrinder.types import Update
-from telegrinder.modules import logger
-
-T = typing.TypeVar("T")
-E = typing.TypeVar("E")
-
-
-async def process_waiters(
-    waiters: typing.Dict[T, Waiter],
-    key: T,
-    event: typing.Optional[E],
-    raw_event: dict,
-    str_handler: typing.Callable,
-) -> bool:
-    if key not in waiters:
-        return False
-
-    logger.debug(
-        "update {} found in waiter (key={})", event.__class__.__name__, str(key)
-    )
+from fntypes.result import Error
 
-    waiter = waiters[key]
-    ctx = {}
+from telegrinder.api.abc import ABCAPI
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.modules import logger
+from telegrinder.tools.i18n.base import I18nEnum
+from telegrinder.types import Update
 
-    for rule in waiter.rules:
-        chk_event = event
-        if rule.__event__ is None:
-            chk_event = raw_event
-        if not await rule.run_check(chk_event, ctx):
-            if not waiter.default:
-                return True
-            elif isinstance(waiter.default, str):
-                await str_handler(waiter.default)
-            else:
-                await waiter.default(event)
-            return True
+from .middleware.abc import ABCMiddleware
+from .return_manager.abc import ABCReturnManager
 
-    logger.debug("waiter set as ready")
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.handler.abc import ABCHandler
+    from telegrinder.bot.rules.abc import ABCRule
 
-    waiters.pop(key)
-    setattr(waiter.event, "e", (event, ctx))
-    waiter.event.set()
-    return True
+T = typing.TypeVar("T", bound=BaseCute)
+_ = typing.Any
 
 
 async def process_inner(
     event: T,
     raw_event: Update,
-    middlewares: typing.List[ABCMiddleware[T]],
-    handlers: typing.List[ABCHandler[T]],
+    middlewares: list[ABCMiddleware[T]],
+    handlers: list["ABCHandler[T]"],
+    return_manager: ABCReturnManager[T],
 ) -> bool:
-    logger.debug("processing {}", event.__class__.__name__)
-    ctx = {}
+    logger.debug("Processing {!r}...", event.__class__.__name__)
+    ctx = Context(raw_update=raw_event)
 
     for middleware in middlewares:
         if await middleware.pre(event, ctx) is False:
@@ -64,12 +37,12 @@ async def process_inner(
     found = False
     responses = []
     for handler in handlers:
-        result = await handler.check(event.api, raw_event)
-        if result:
-            handler.ctx.update(ctx)
+        if await handler.check(event.api, raw_event, ctx):
             found = True
+            handler.ctx |= ctx
             response = await handler.run(event)
             responses.append(response)
+            await return_manager.run(response, event, ctx)
             if handler.is_blocking:
                 break
 
@@ -77,3 +50,34 @@ async def process_inner(
         await middleware.post(event, responses, ctx)
 
     return found
+
+
+async def check_rule(
+    api: ABCAPI,
+    rule: "ABCRule",
+    update: Update,
+    ctx: Context,
+) -> bool:
+    """Checks requirements, adapts update.
+    Returns check result."""
+
+    cute_model = await rule.adapter.adapt(api, update)
+    match cute_model:
+        case Error(err):
+            logger.debug("Adapter failed with error message: {!r}", str(err))
+            return False
+
+    ctx_copy = ctx.copy()
+    for requirement in rule.requires:
+        if not await check_rule(api, requirement, update, ctx_copy):
+            return False
+
+    ctx |= ctx_copy
+
+    if I18nEnum.I18N in ctx:
+        rule = await rule.translate(ctx.get(I18nEnum.I18N))
+
+    return await rule.check(cute_model.unwrap(), ctx)
+
+
+__all__ = ("check_rule", "process_inner")

telegrinder/bot/dispatch/return_manager/__init__.py

@@ -0,0 +1,19 @@
+from .abc import (
+    ABCReturnManager,
+    BaseReturnManager,
+    Manager,
+    register_manager,
+)
+from .callback_query import CallbackQueryReturnManager
+from .inline_query import InlineQueryReturnManager
+from .message import MessageReturnManager
+
+__all__ = (
+    "ABCReturnManager",
+    "BaseReturnManager",
+    "CallbackQueryReturnManager",
+    "InlineQueryReturnManager",
+    "Manager",
+    "MessageReturnManager",
+    "register_manager",
+) 

telegrinder/bot/dispatch/return_manager/abc.py

@@ -0,0 +1,95 @@
+import dataclasses
+import types
+import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.modules import logger
+
+T = typing.TypeVar("T")
+EventT = typing.TypeVar("EventT", bound=BaseCute, contravariant=True)
+
+
+def get_union_types(t: types.UnionType) -> tuple[type, ...] | None:
+    if type(t) in (types.UnionType, typing._UnionGenericAlias):  # type: ignore
+        return tuple(typing.get_origin(x) or x for x in typing.get_args(t))
+    return None
+
+
+def register_manager(return_type: type | types.UnionType):
+    def wrapper(func: typing.Callable[..., typing.Awaitable]):
+        return Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
+    
+    return wrapper
+
+
+@dataclasses.dataclass(frozen=True)
+class Manager:
+    types: tuple[type, ...]
+    callback: typing.Callable[..., typing.Awaitable]
+
+    async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
+        try:
+            await self.callback(*args, **kwargs)
+        except BaseException as ex:
+            logger.exception(ex)
+
+
+class ABCReturnManager(ABC, typing.Generic[EventT]):
+    @abstractmethod
+    async def run(self, response: typing.Any, event: EventT, ctx: Context) -> None:
+        pass
+
+
+class BaseReturnManager(ABCReturnManager[EventT]):
+    @property
+    def managers(self) -> list[Manager]:
+        return [
+            manager
+            for manager in (vars(BaseReturnManager) | vars(self.__class__)).values()
+            if isinstance(manager, Manager)
+        ]
+
+    @register_manager(Context)
+    @staticmethod
+    async def ctx_manager(value: Context, event: EventT, ctx: Context) -> None:
+        """Basic manager for returning context from handler."""
+        
+        ctx.update(value)
+    
+    async def run(self, response: typing.Any, event: EventT, ctx: Context) -> None:
+        for manager in self.managers:
+            if typing.Any in manager.types or any(type(response) is x for x in manager.types):
+                await manager(response, event, ctx)
+    
+    @typing.overload
+    def register_manager(self, return_type: type[T]) -> typing.Callable[
+        [typing.Callable[[T, EventT, Context], typing.Awaitable]], Manager
+    ]:
+        ...
+    
+    @typing.overload
+    def register_manager(self, return_type: tuple[type[T], ...]) -> typing.Callable[
+        [typing.Callable[[tuple[T, ...], EventT, Context], typing.Awaitable]], Manager
+    ]:
+        ...
+
+    def register_manager(self, return_type: type[T] | tuple[type[T], ...]) -> typing.Callable[
+        [typing.Callable[[T | tuple[T, ...], EventT, Context], typing.Awaitable]], Manager
+    ]:
+        def wrapper(func: typing.Callable[[T, EventT, Context], typing.Awaitable]) -> Manager:
+            manager = Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
+            setattr(self.__class__, func.__name__, manager)
+            return manager
+        
+        return wrapper
+
+
+__all__ = (
+    "ABCReturnManager",
+    "BaseReturnManager",
+    "Manager",
+    "register_manager",
+    "get_union_types",
+)

telegrinder/bot/dispatch/return_manager/callback_query.py

@@ -0,0 +1,19 @@
+from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.dispatch.context import Context
+
+from .abc import BaseReturnManager, register_manager
+
+
+class CallbackQueryReturnManager(BaseReturnManager[CallbackQueryCute]):
+    @register_manager(str)
+    @staticmethod
+    async def str_manager(value: str, event: CallbackQueryCute, ctx: Context) -> None:
+        await event.answer(value)
+    
+    @register_manager(dict)
+    @staticmethod
+    async def dict_manager(value: dict, event: CallbackQueryCute, ctx: Context) -> None:
+        await event.answer(**value)
+
+
+__all__ = ("CallbackQueryReturnManager",)

telegrinder/bot/dispatch/return_manager/inline_query.py

@@ -0,0 +1,14 @@
+from telegrinder.bot.cute_types import InlineQueryCute
+from telegrinder.bot.dispatch.context import Context
+
+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:
+        await event.answer(**value)
+
+
+__all__ = ("InlineQueryReturnManager",)