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

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

telegrinder/bot/dispatch/return_manager/message.py

@@ -0,0 +1,25 @@
+from telegrinder.bot.cute_types import MessageCute
+from telegrinder.bot.dispatch.context import Context
+
+from .abc import BaseReturnManager, register_manager
+
+
+class MessageReturnManager(BaseReturnManager[MessageCute]):  
+    @register_manager(str)
+    @staticmethod
+    async def str_manager(value: str, event: MessageCute, ctx: Context) -> None:
+        await event.answer(value)
+    
+    @register_manager(list | tuple)
+    @staticmethod
+    async def seq_manager(value: list[str] | tuple[str, ...], event: MessageCute, ctx: Context) -> None:
+        for message in value:
+            await event.answer(message)
+    
+    @register_manager(dict)
+    @staticmethod
+    async def dict_manager(value: dict, event: MessageCute, ctx: Context) -> None:
+        await event.answer(**value)
+
+
+__all__ = ("MessageReturnManager",)

telegrinder/bot/dispatch/view/__init__.py

@@ -1,4 +1,16 @@
-from .abc import ABCView
-from .message import MessageView
+from .abc import ABCStateView, ABCView, BaseStateView, BaseView
+from .box import ViewBox
 from .callback_query import CallbackQueryView
 from .inline_query import InlineQueryView
+from .message import MessageView
+
+__all__ = (
+    "ABCView",
+    "ABCStateView",
+    "BaseView",
+    "BaseStateView",
+    "CallbackQueryView",
+    "InlineQueryView",
+    "MessageView",
+    "ViewBox",
+)

telegrinder/bot/dispatch/view/abc.py

@@ -1,6 +1,22 @@
+import typing
 from abc import ABC, abstractmethod
+
+from fntypes.co import Nothing, Some
+
 from telegrinder.api.abc import ABCAPI
-from telegrinder.types import Update
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.handler.func import ErrorHandlerT, FuncHandler
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
+from telegrinder.bot.dispatch.process import process_inner
+from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.model import Model
+from telegrinder.msgspec_utils import Option
+from telegrinder.types.objects import Update
+
+EventType = typing.TypeVar("EventType", bound=BaseCute)
+MiddlewareT = typing.TypeVar("MiddlewareT", bound=ABCMiddleware)
 
 
 class ABCView(ABC):
@@ -13,5 +29,115 @@ class ABCView(ABC):
         pass
 
     @abstractmethod
-    async def load(self, external: "ABCView"):
+    def load(self, external: typing.Self) -> None:
         pass
+
+
+class ABCStateView(ABCView, typing.Generic[EventType]):
+    @abstractmethod
+    def get_state_key(self, event: EventType) -> int | None:
+        pass
+
+    def __repr__(self) -> str:
+        return "<{!r}: {}>".format(
+            self.__class__.__name__,
+            ", ".join(f"{k}={v!r}" for k, v in self.__dict__.items())
+        )
+
+
+class BaseView(ABCView, typing.Generic[EventType]):
+    auto_rules: list[ABCRule[EventType]]
+    handlers: list[ABCHandler[EventType]]
+    middlewares: list[ABCMiddleware[EventType]]
+    return_manager: ABCReturnManager[EventType]
+
+    @classmethod
+    def get_event_type(cls) -> Option[type[EventType]]:
+        for base in cls.__dict__.get("__orig_bases__", ()):
+            if issubclass(typing.get_origin(base) or base, ABCView):
+                for generic_type in typing.get_args(base):
+                    if issubclass(typing.get_origin(generic_type) or generic_type, BaseCute):
+                        return Some(generic_type)
+        return Nothing()
+    
+    @classmethod
+    def get_raw_event(cls, update: Update) -> Option[Model]:
+        match update.update_type:
+            case Some(update_type):
+                return getattr(update, update_type.value)
+            case _:
+                return Nothing()
+
+    def __call__(
+        self,
+        *rules: ABCRule[EventType],
+        is_blocking: bool = True,
+        error_handler: ErrorHandlerT | None = None,
+    ):
+        def wrapper(
+            func: typing.Callable[
+                typing.Concatenate[EventType, ...],
+                typing.Coroutine,
+            ]
+        ):
+            func_handler = FuncHandler(
+                func,
+                [*self.auto_rules, *rules],
+                is_blocking,
+                dataclass=None,
+                error_handler=error_handler,
+            )
+            self.handlers.append(func_handler)
+            return func_handler
+
+        return wrapper
+    
+    def register_middleware(self, *args: typing.Any, **kwargs: typing.Any):
+        def wrapper(cls: type[MiddlewareT]):
+            self.middlewares.append(cls(*args, **kwargs))
+            return cls
+        
+        return wrapper
+    
+    async def check(self, event: Update) -> bool:
+        match self.get_raw_event(event):
+            case Some(e) if issubclass(
+                self.get_event_type().expect(
+                    "{!r} has no event type in generic.".format(self.__class__.__name__),
+                ),
+                e.__class__,
+            ):
+                return True
+            case _:
+                return False
+        
+    async def process(self, event: Update, api: ABCAPI) -> bool:
+        return await process_inner(
+            self.get_event_type().unwrap().from_update(
+                update=self.get_raw_event(event).unwrap(),
+                bound_api=api,
+            ),
+            event,
+            self.middlewares,
+            self.handlers,
+            self.return_manager,
+        )
+
+    def load(self, external: typing.Self) -> None:
+        self.auto_rules.extend(external.auto_rules)
+        self.handlers.extend(external.handlers)
+        self.middlewares.extend(external.middlewares)
+
+
+class BaseStateView(ABCStateView[EventType], BaseView[EventType], ABC, typing.Generic[EventType]):
+    @abstractmethod
+    def get_state_key(self, event: EventType) -> int | None:
+        pass
+
+
+__all__ = (
+    "ABCView",
+    "ABCStateView",
+    "BaseView",
+    "BaseStateView",
+)

telegrinder/bot/dispatch/view/box.py

@@ -0,0 +1,38 @@
+import dataclasses
+
+import typing_extensions as typing
+
+from .abc import ABCView
+from .callback_query import CallbackQueryView
+from .inline_query import InlineQueryView
+from .message import MessageView
+
+CallbackQueryViewT = typing.TypeVar(
+    "CallbackQueryViewT", bound=ABCView, default=CallbackQueryView
+)
+InlineQueryViewT = typing.TypeVar(
+    "InlineQueryViewT", bound=ABCView, default=InlineQueryView
+)
+MessageViewT = typing.TypeVar("MessageViewT", bound=ABCView, default=MessageView)
+
+
+@dataclasses.dataclass(kw_only=True)
+class ViewBox(typing.Generic[CallbackQueryViewT, InlineQueryViewT, MessageViewT]):
+    callback_query: CallbackQueryViewT = dataclasses.field(  # type: ignore
+        default_factory=lambda: CallbackQueryView(),
+    )
+    inline_query: InlineQueryViewT = dataclasses.field(  # type: ignore
+        default_factory=lambda: InlineQueryView(),
+    )
+    message: MessageViewT = dataclasses.field(  # type: ignore
+        default_factory=lambda: MessageView(),
+    )
+
+    def get_views(self) -> dict[str, ABCView]:
+        return {
+            name: view for name, view in self.__dict__.items()
+            if isinstance(view, ABCView)
+        }
+
+
+__all__ = ("ViewBox",)

telegrinder/bot/dispatch/view/callback_query.py

@@ -1,46 +1,20 @@
-from .abc import ABCView
-from telegrinder.bot.dispatch.handler import ABCHandler, FuncHandler
-from telegrinder.bot.dispatch.waiter import Waiter
-from telegrinder.bot.dispatch.middleware import ABCMiddleware
-from telegrinder.bot.rules import ABCRule
-from telegrinder.bot.cute_types import CallbackQueryCute
-from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.dispatch.waiter import WithWaiter
-from telegrinder.bot.dispatch.process import process_waiters, process_inner
-from telegrinder.types import Update
-import typing
-
+from fntypes.option import Some
 
-class CallbackQueryView(ABCView, WithWaiter[int, CallbackQueryCute]):
-    def __init__(self):
-        self.auto_rules: list[ABCRule] = []
-        self.handlers: typing.List[ABCHandler[CallbackQueryCute]] = []
-        self.middlewares: typing.List[ABCMiddleware[CallbackQueryCute]] = []
-        self.short_waiters: typing.Dict[int, Waiter] = {}
-
-    def __call__(self, *rules: ABCRule, is_blocking: bool = True):
-        def wrapper(func: typing.Callable[..., typing.Coroutine]):
-            self.handlers.append(
-                FuncHandler(func, [*self.auto_rules, *rules], is_blocking, dataclass=None)
-            )
-            return func
+from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.dispatch.return_manager import CallbackQueryReturnManager
 
-        return wrapper
+from .abc import BaseStateView
 
-    async def check(self, event: Update) -> bool:
-        return bool(event.callback_query)
 
-    async def process(self, event: Update, api: ABCAPI):
-        query = CallbackQueryCute(**event.callback_query.to_dict(), api=api)
+class CallbackQueryView(BaseStateView[CallbackQueryCute]):
+    def __init__(self) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = CallbackQueryReturnManager()
 
-        if await process_waiters(
-            self.short_waiters, query.message.message_id, query, event, query.answer
-        ):
-            return
+    def get_state_key(self, event: CallbackQueryCute) -> int | None:
+        return event.message.map(lambda variative: variative.v.message_id).unwrap_or_none()
 
-        return await process_inner(query, event, self.middlewares, self.handlers)
 
-    def load(self, external: "CallbackQueryView"):
-        self.handlers.extend(external.handlers)
-        self.middlewares.extend(external.middlewares)
-        external.short_waiters = self.short_waiters
+__all__ = ("CallbackQueryView",)

telegrinder/bot/dispatch/view/inline_query.py

@@ -1,46 +1,18 @@
-from .abc import ABCView
-from telegrinder.bot.dispatch.handler import ABCHandler, FuncHandler
-from telegrinder.bot.dispatch.waiter import Waiter
-from telegrinder.bot.dispatch.middleware import ABCMiddleware
-from telegrinder.bot.rules import ABCRule
 from telegrinder.bot.cute_types import InlineQueryCute
-from telegrinder.api.abc import ABCAPI
-from telegrinder.bot.dispatch.waiter import WithWaiter
-from telegrinder.bot.dispatch.process import process_waiters, process_inner
-from telegrinder.types import Update
-import typing
+from telegrinder.bot.dispatch.return_manager import InlineQueryReturnManager
 
+from .abc import BaseStateView
 
-class InlineQueryView(ABCView, WithWaiter[str, InlineQueryCute]):
-    def __init__(self):
-        self.auto_rules: list[ABCRule] = []
-        self.handlers: typing.List[ABCHandler[InlineQueryCute]] = []
-        self.middlewares: typing.List[ABCMiddleware[InlineQueryCute]] = []
-        self.short_waiters: typing.Dict[str, Waiter] = {}
 
-    def __call__(self, *rules: ABCRule, is_blocking: bool = True):
-        def wrapper(func: typing.Callable[..., typing.Coroutine]):
-            self.handlers.append(
-                FuncHandler(func, [*self.auto_rules, *rules], is_blocking, dataclass=None)
-            )
-            return func
+class InlineQueryView(BaseStateView[InlineQueryCute]):
+    def __init__(self) -> None:
+        self.auto_rules = []
+        self.handlers = []
+        self.middlewares = []
+        self.return_manager = InlineQueryReturnManager()
 
-        return wrapper
+    def get_state_key(self, event: InlineQueryCute) -> int | None:
+        return event.from_.id
 
-    def load(self, external: "InlineQueryView"):
-        self.handlers.extend(external.handlers)
-        self.middlewares.extend(external.middlewares)
-        external.short_waiters = self.short_waiters
 
-    async def check(self, event: Update) -> bool:
-        return bool(event.inline_query)
-
-    async def process(self, event: Update, api: ABCAPI):
-        query = InlineQueryCute(**event.inline_query.to_dict(), api=api)
-
-        if await process_waiters(
-            self.short_waiters, query.id, query, event, query.answer
-        ):
-            return
-
-        return await process_inner(query, event, self.middlewares, self.handlers)
+__all__ = ("InlineQueryView",)