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

telegrinder/bot/dispatch/return_manager/abc.py

@@ -2,97 +2,135 @@ import dataclasses
 import types
 import typing
 from abc import ABC, abstractmethod
+from functools import cached_property
 
+from fntypes.result import Error, Ok
+
+from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.model import Model
 from telegrinder.modules import logger
+from telegrinder.node.base import IsNode, get_nodes
+from telegrinder.node.composer import compose_nodes
+from telegrinder.tools import fullname
+from telegrinder.tools.aio import maybe_awaitable
+from telegrinder.tools.magic.function import bundle
+from telegrinder.types.objects import Update
+
+type ManagerFunction = typing.Callable[..., typing.Any | typing.Awaitable[typing.Any]]
+
+
+def _get_types(x: typing.Any, /) -> type[typing.Any] | tuple[typing.Any, ...]:
+    while True:
+        if isinstance(x, types.UnionType | typing._UnionGenericAlias):  # type: ignore
+            return tuple(_get_types(x) for x in typing.get_args(x))
+
+        if isinstance(x, typing.TypeAliasType):
+            x = x.__value__
 
+        if isinstance(x, types.GenericAlias | typing._GenericAlias):  # type: ignore
+            x = typing.get_origin(x)
 
-def get_union_types(t: types.UnionType | typing.Any) -> tuple[type[typing.Any], ...] | 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
+        if isinstance(x, type):
+            return x
 
 
-def register_manager(return_type: type[typing.Any] | types.UnionType):
-    def wrapper(func: typing.Callable[..., typing.Awaitable[typing.Any]]):
-        return Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
+def register_manager(return_type: typing.Any, /) -> typing.Callable[[ManagerFunction], "Manager"]:
+    def wrapper(function: ManagerFunction, /) -> "Manager":
+        function = function.__func__ if isinstance(function, classmethod | staticmethod) else function
+        types = _get_types(return_type)
+        return Manager((types,) if not isinstance(types, tuple) else types, function)
 
     return wrapper
 
 
-@dataclasses.dataclass(frozen=True, slots=True)
+@dataclasses.dataclass
 class Manager:
-    types: tuple[type, ...]
-    callback: typing.Callable[..., typing.Awaitable[typing.Any]]
+    types: tuple[typing.Any, ...]
+    function: ManagerFunction
 
-    async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
-        await self.callback(*args, **kwargs)
+    @cached_property
+    def required_nodes(self) -> dict[str, IsNode]:
+        return get_nodes(self.function, start_idx=1)
 
+    async def __call__(
+        self,
+        response: typing.Any,
+        update: Update,
+        api: API,
+        context: Context,
+    ) -> None:
+        data = {Update: update, API: api}
+        node_col = None
+
+        if self.required_nodes:
+            match await compose_nodes(self.required_nodes, context, data=data):
+                case Ok(value):
+                    node_col = value
+                case Error(compose_error):
+                    logger.debug(
+                        "Cannot compose nodes for return manager `{}`, error {!r}",
+                        fullname(self.function),
+                        compose_error.message,
+                    )
+                    return None
+
+        temp_ctx = context.copy()
+        try:
+            bundle_function = bundle(self.function, {**data, Context: temp_ctx}, typebundle=True)
+            bundle_function &= bundle(
+                self.function,
+                context | ({} if node_col is None else node_col.values),
+            )
+            await maybe_awaitable(bundle_function(response))
+        finally:
+            context |= temp_ctx
+
+            if node_col is not None:
+                await node_col.close_all()
+
+
+class ABCReturnManager(ABC):
+    @property
+    @abstractmethod
+    def managers(self) -> list[Manager]:
+        pass
 
-class ABCReturnManager[Event: Model](ABC):
     @abstractmethod
-    async def run(self, response: typing.Any, event: Event, ctx: Context) -> None:
+    async def run(self, response: typing.Any, api: API, update: Update, context: Context) -> None:
         pass
 
 
-class BaseReturnManager[Event: Model](ABCReturnManager[Event]):
+class BaseReturnManager(ABCReturnManager):
     def __repr__(self) -> str:
-        return "<{}: {}>".format(
-            self.__class__.__name__,
-            ", ".join(x.callback.__name__ + "=" + repr(x) for x in self.managers),
-        )
+        return "<{}: {}>".format(fullname(self), self.managers)
 
-    @property
+    @cached_property
     def managers(self) -> list[Manager]:
-        managers = self.__dict__.get("managers")
-        if managers is not None:
-            return managers
-        managers_lst = [
+        return [
             manager
-            for manager in (vars(BaseReturnManager) | vars(self.__class__)).values()
+            for manager in (vars(BaseReturnManager) | vars(type(self))).values()
             if isinstance(manager, Manager)
         ]
-        self.__dict__["managers"] = managers_lst
-        return managers_lst
-
-    @register_manager(Context)
-    @staticmethod
-    async def ctx_manager(value: Context, event: Event, ctx: Context) -> None:
-        """Basic manager for returning context from handler."""
-        ctx.update(value)
 
-    async def run(self, response: typing.Any, event: Event, ctx: Context) -> None:
-        logger.debug("Run return manager for response: {!r}", response)
-        for manager in self.managers:
-            if typing.Any in manager.types or any(type(response) is x for x in manager.types):
-                logger.debug("Run manager {!r}...", manager.callback.__name__)
-                await manager(response, event, ctx)
-
-    @typing.overload
-    def register_manager[T](
+    async def run(
         self,
-        return_type: type[T],
-    ) -> typing.Callable[[typing.Callable[[T, Event, Context], typing.Awaitable[typing.Any]]], Manager]: ...
-
-    @typing.overload
-    def register_manager[T](
-        self,
-        return_type: tuple[type[T], ...],
-    ) -> typing.Callable[
-        [typing.Callable[[tuple[T, ...], Event, Context], typing.Awaitable[typing.Any]]],
-        Manager,
-    ]: ...
-
-    def register_manager[T](
-        self,
-        return_type: type[T] | tuple[type[T], ...],
-    ) -> typing.Callable[
-        [typing.Callable[[T | tuple[T, ...], Event, Context], typing.Awaitable[typing.Any]]],
-        Manager,
-    ]:
-        def wrapper(func: typing.Callable[[T, Event, Context], typing.Awaitable]) -> Manager:
-            manager = Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
+        response: typing.Any,
+        api: API,
+        update: Update,
+        context: Context,
+    ) -> None:
+        for manager in self.managers:
+            if typing.Any in manager.types or type(response) in manager.types:
+                logger.debug(
+                    "Running manager `{}` for response `{!r}`",
+                    fullname(manager.function),
+                    response,
+                )
+                await manager(response, update, api, context)
+
+    def register_manager(self, return_type: typing.Any, /) -> typing.Callable[[ManagerFunction], Manager]:
+        def wrapper(function: ManagerFunction, /) -> Manager:
+            manager = register_manager(return_type)(function)
             self.managers.append(manager)
             return manager
 
@@ -103,6 +141,5 @@ __all__ = (
     "ABCReturnManager",
     "BaseReturnManager",
     "Manager",
-    "get_union_types",
     "register_manager",
 )

telegrinder/bot/dispatch/return_manager/callback_query.py

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

telegrinder/bot/dispatch/return_manager/inline_query.py

@@ -1,14 +1,13 @@
 import typing
 
 from telegrinder.bot.cute_types.inline_query import InlineQueryCute
-from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
 
 
-class InlineQueryReturnManager(BaseReturnManager[InlineQueryCute]):
-    @register_manager(dict[str, typing.Any])
+class InlineQueryReturnManager(BaseReturnManager):
+    @register_manager(dict)
     @staticmethod
-    async def dict_manager(value: dict[str, typing.Any], event: InlineQueryCute, ctx: Context) -> None:
+    async def dict_manager(value: dict[str, typing.Any], event: InlineQueryCute) -> None:
         await event.answer(**value)
 
 

telegrinder/bot/dispatch/return_manager/message.py

@@ -1,35 +1,33 @@
 import typing
 
 from telegrinder.bot.cute_types.message import MessageCute
-from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
 from telegrinder.tools.formatting import HTMLFormatter
 
 
-class MessageReturnManager(BaseReturnManager[MessageCute]):
+class MessageReturnManager(BaseReturnManager):
     @register_manager(str)
     @staticmethod
-    async def str_manager(value: str, event: MessageCute, ctx: Context) -> None:
+    async def str_manager(value: str, event: MessageCute) -> None:
         await event.answer(value)
 
-    @register_manager(list[str] | tuple[str, ...])
+    @register_manager(list | tuple)
     @staticmethod
     async def seq_manager(
-        value: list[str] | tuple[str, ...],
+        value: list[typing.Any] | tuple[typing.Any, ...],
         event: MessageCute,
-        ctx: Context,
     ) -> None:
         for message in value:
-            await event.answer(message)
+            await event.answer(str(message))
 
-    @register_manager(dict[str, typing.Any])
+    @register_manager(dict)
     @staticmethod
-    async def dict_manager(value: dict[str, typing.Any], event: MessageCute, ctx: Context) -> None:
+    async def dict_manager(value: dict[str, typing.Any], event: MessageCute) -> None:
         await event.answer(**value)
 
     @register_manager(HTMLFormatter)
     @staticmethod
-    async def htmlformatter_manager(value: HTMLFormatter, event: MessageCute, ctx: Context) -> None:
+    async def htmlformatter_manager(value: HTMLFormatter, event: MessageCute) -> None:
         await event.answer(value, parse_mode=HTMLFormatter.PARSE_MODE)
 
 

telegrinder/bot/dispatch/return_manager/pre_checkout_query.py

@@ -1,19 +1,18 @@
 import typing
 
 from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
-from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
 
 
-class PreCheckoutQueryManager(BaseReturnManager[PreCheckoutQueryCute]):
+class PreCheckoutQueryManager(BaseReturnManager):
     @register_manager(bool)
     @staticmethod
-    async def bool_manager(value: bool, event: PreCheckoutQueryCute, ctx: Context) -> None:
+    async def bool_manager(value: bool, event: PreCheckoutQueryCute) -> None:
         await event.answer(value)
 
-    @register_manager(dict[str, typing.Any])
+    @register_manager(dict)
     @staticmethod
-    async def dict_manager(value: dict[str, typing.Any], event: PreCheckoutQueryCute, ctx: Context) -> None:
+    async def dict_manager(value: dict[str, typing.Any], event: PreCheckoutQueryCute) -> None:
         await event.answer(**value)
 
 

telegrinder/bot/dispatch/view/__init__.py

@@ -1,22 +1,22 @@
-from telegrinder.bot.dispatch.view.abc import ABCStateView, ABCView
-from telegrinder.bot.dispatch.view.base import BaseStateView, BaseView
+from telegrinder.bot.dispatch.view.abc import ABCView
+from telegrinder.bot.dispatch.view.base import BaseView
 from telegrinder.bot.dispatch.view.box import ViewBox
 from telegrinder.bot.dispatch.view.callback_query import CallbackQueryView
 from telegrinder.bot.dispatch.view.chat_join_request import ChatJoinRequestView
 from telegrinder.bot.dispatch.view.chat_member import ChatMemberView
+from telegrinder.bot.dispatch.view.error import ErrorView
 from telegrinder.bot.dispatch.view.inline_query import InlineQueryView
 from telegrinder.bot.dispatch.view.message import MessageView
 from telegrinder.bot.dispatch.view.pre_checkout_query import PreCheckoutQueryView
 from telegrinder.bot.dispatch.view.raw import RawEventView
 
 __all__ = (
-    "ABCStateView",
     "ABCView",
-    "BaseStateView",
     "BaseView",
     "CallbackQueryView",
     "ChatJoinRequestView",
     "ChatMemberView",
+    "ErrorView",
     "InlineQueryView",
     "MessageView",
     "PreCheckoutQueryView",

telegrinder/bot/dispatch/view/abc.py

@@ -1,8 +1,8 @@
 import typing
 from abc import ABC, abstractmethod
+from collections import deque
 
 from telegrinder.api.api import API
-from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
 from telegrinder.types.objects import Update
@@ -10,7 +10,7 @@ from telegrinder.types.objects import Update
 
 class ABCView(ABC):
     def __repr__(self) -> str:
-        return "<{}>".format(self.__class__.__name__)
+        return "<{}>".format(type(self).__name__)
 
     @abstractmethod
     async def check(self, event: Update) -> bool:
@@ -20,7 +20,7 @@ class ABCView(ABC):
     async def process(
         self,
         event: Update,
-        api: API[typing.Any],
+        api: API,
         context: Context,
     ) -> bool:
         pass
@@ -30,18 +30,8 @@ class ABCView(ABC):
         pass
 
 
-class ABCEventRawView[Event: BaseCute](ABCView, ABC):
-    handlers: list[ABCHandler[Event]]
+class ABCEventRawView(ABCView, ABC):
+    handlers: deque[ABCHandler]
 
 
-class ABCStateView[Event: BaseCute](ABCView):
-    @abstractmethod
-    def get_state_key(self, event: Event) -> int | None:
-        pass
-
-
-__all__ = (
-    "ABCEventRawView",
-    "ABCStateView",
-    "ABCView",
-)
+__all__ = ("ABCEventRawView", "ABCView")