telegrinder 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/bot/dispatch/process.py

@@ -1,157 +1,151 @@
-import inspect
-import typing
-
-from fntypes.option import Nothing, Option, Some
-from fntypes.result import Error, Ok
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.update import UpdateCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
-from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
-from telegrinder.model import Model
-from telegrinder.modules import logger
-from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, NodeScope, compose_nodes
-from telegrinder.tools.i18n.abc import I18nEnum
-from telegrinder.types.objects import Update
-
-if typing.TYPE_CHECKING:
-    from telegrinder.bot.dispatch.handler.abc import ABCHandler
-    from telegrinder.bot.rules.abc import ABCRule
-    from telegrinder.bot.rules.adapter.abc import ABCAdapter
-
-T = typing.TypeVar("T")
-Event = typing.TypeVar("Event", bound=Model)
-
-
-async def run_adapter(
-    adapter: "ABCAdapter[Update, T]",
-    api: API,
-    update: Update,
-    context: Context,
-) -> Option[T]:
-    adapt_result = adapter.adapt(api, update, context)
-    match await adapt_result if inspect.isawaitable(adapt_result) else adapt_result:
-        case Ok(value):
-            return Some(value)
-        case Error(err):
-            logger.debug("Adapter failed with error message: {!r}", str(err))
-            return Nothing()
-
-
-async def process_inner(
-    api: API,
-    event: Event,
-    raw_event: Update,
-    middlewares: list[ABCMiddleware[Event]],
-    handlers: list["ABCHandler[Event]"],
-    return_manager: ABCReturnManager[Event] | None = None,
-) -> bool:
-    logger.debug("Processing {!r}...", event.__class__.__name__)
-    ctx = Context(raw_update=raw_event)
-    ctx[CONTEXT_STORE_NODES_KEY] = {}  # For per-event shared nodes
-
-    logger.debug("Run pre middlewares...")
-    for middleware in middlewares:
-        if middleware.adapter is not None:
-            match await run_adapter(middleware.adapter, api, raw_event, ctx):
-                case Some(val):
-                    event = val
-                case Nothing():
-                    return False
-
-        middleware_result = await middleware.pre(event, ctx)
-        logger.debug("Middleware {!r} returned: {!r}", middleware.__class__.__qualname__, middleware_result)
-        if middleware_result is False:
-            return False
-
-    found = False
-    responses = []
-    ctx_copy = ctx.copy()
-
-    for handler in handlers:
-        if await handler.check(api, raw_event, ctx):
-            logger.debug("Handler {!r} matched, run...", handler)
-            found = True
-            response = await handler.run(api, event, ctx)
-            logger.debug("Handler {!r} returned: {!r}", handler, response)
-            responses.append(response)
-            if return_manager is not None:
-                await return_manager.run(response, event, ctx)
-            if handler.is_blocking:
-                break
-
-        ctx = ctx_copy
-
-    logger.debug("Run post middlewares...")
-    for middleware in middlewares:
-        logger.debug("Run post middleware {!r}", middleware.__class__.__qualname__)
-        await middleware.post(event, responses, ctx)
-
-    for session in ctx.get(CONTEXT_STORE_NODES_KEY, {}).values():
-        await session.close(scopes=(NodeScope.PER_EVENT,))
-
-    logger.debug(
-        "{} handlers, returns {!r}",
-        "No found" if not found else "Found",
-        found,
-    )
-    return found
-
-
-async def check_rule(
-    api: API,
-    rule: "ABCRule",
-    update: Update,
-    ctx: Context,
-) -> bool:
-    """Checks requirements, adapts update.
-    Returns check result."""
-
-    # Running adapter
-    match await run_adapter(rule.adapter, api, update, ctx):
-        case Some(val):
-            adapted_value = val
-        case Nothing():
-            return False
-
-    # Preparing update
-    if isinstance(adapted_val := ctx.get(rule.adapter.ADAPTED_VALUE_KEY or ""), UpdateCute):
-        update = adapted_val
-    elif isinstance(adapted_value, UpdateCute):
-        update = adapted_value
-    else:
-        update = UpdateCute.from_update(update, bound_api=api)
-
-    # Running subrules to fetch requirements
-    ctx_copy = ctx.copy()
-    for requirement in rule.requires:
-        if not await check_rule(api, requirement, update, ctx_copy):
-            return False
-
-    # Translating translatable rules
-    if I18nEnum.I18N in ctx:
-        rule = await rule.translate(ctx[I18nEnum.I18N])
-
-    ctx |= ctx_copy
-
-    # Composing required nodes
-    nodes = rule.required_nodes
-    node_col = None
-    if nodes:
-        result = await compose_nodes(nodes, ctx, data={Update: update, API: api})
-        if not result:
-            return False
-        node_col = result.value
-
-    # Running check
-    result = await rule.bounding_check(adapted_value, ctx, node_col=node_col)
-
-    # Closing node sessions if there are any
-    if node_col is not None:
-        await node_col.close_all()
-
-    return result
-
-
-__all__ = ("check_rule", "process_inner")
+import typing
+
+from fntypes.option import Nothing, Some
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware, run_middleware
+from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
+from telegrinder.model import Model
+from telegrinder.modules import logger
+from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, NodeScope, compose_nodes
+from telegrinder.tools.adapter.abc import run_adapter
+from telegrinder.tools.i18n.abc import I18nEnum
+from telegrinder.types.objects import Update
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.handler.abc import ABCHandler
+    from telegrinder.bot.rules.abc import ABCRule
+
+
+async def process_inner[Event: Model](
+    api: API,
+    event: Event,
+    raw_event: Update,
+    ctx: Context,
+    middlewares: list[ABCMiddleware[Event]],
+    handlers: list["ABCHandler[Event]"],
+    return_manager: ABCReturnManager[Event] | None = None,
+) -> bool:
+    logger.debug("Processing {!r}...", event.__class__.__name__)
+    ctx[CONTEXT_STORE_NODES_KEY] = {}  # For per-event shared nodes
+
+    logger.debug("Run pre middlewares...")
+    for m in middlewares:
+        result = await run_middleware(m.pre, api, event, raw_event=raw_event, ctx=ctx, adapter=m.adapter)
+        logger.debug("Middleware {!r} returned: {!r}", m, result)
+        if result is False:
+            return False
+
+    found = False
+    responses = []
+    ctx_copy = ctx.copy()
+
+    for handler in handlers:
+        adapted_event = event
+
+        if await handler.check(api, raw_event, ctx):
+            if handler.adapter is not None:
+                match await run_adapter(handler.adapter, api, raw_event, ctx):
+                    case Some(value):
+                        adapted_event = value
+                    case Nothing():
+                        continue
+
+            found = True
+            logger.debug("Handler {!r} matched, run...", handler)
+            response = await handler.run(api, adapted_event, ctx)
+            logger.debug("Handler {!r} returned: {!r}", handler, response)
+            responses.append(response)
+
+            if return_manager is not None:
+                await return_manager.run(response, event, ctx)
+            if handler.final:
+                break
+
+        ctx = ctx_copy
+
+    logger.debug("Run post middlewares...")
+    ctx.set("responses", responses)
+
+    for m in middlewares:
+        await run_middleware(
+            m.post,
+            api,
+            event,
+            raw_event=raw_event,
+            ctx=ctx,
+            adapter=m.adapter,
+        )
+
+    for session in ctx.get(CONTEXT_STORE_NODES_KEY, {}).values():
+        await session.close(scopes=(NodeScope.PER_EVENT,))
+
+    logger.debug(
+        "{} handlers, returns {!r}",
+        "No found" if not found else "Found",
+        found,
+    )
+    return found
+
+
+async def check_rule(
+    api: API,
+    rule: "ABCRule",
+    update: Update,
+    ctx: Context,
+) -> bool:
+    """Checks requirements, adapts update.
+    Returns check result.
+    """
+    update_cute = None if not isinstance(update, UpdateCute) else update
+
+    # Running adapter
+    match await run_adapter(rule.adapter, api, update, ctx):
+        case Some(val):
+            adapted_value = val
+        case Nothing():
+            return False
+
+    # Preparing update
+    if isinstance(adapted_value, UpdateCute):
+        update_cute = adapted_value
+    elif isinstance(adapted_val := ctx.get(rule.adapter.ADAPTED_VALUE_KEY or ""), UpdateCute):
+        update_cute = adapted_val
+    else:
+        update_cute = UpdateCute.from_update(update, bound_api=api)
+
+    # Running subrules to fetch requirements
+    ctx_copy = ctx.copy()
+    for requirement in rule.requires:
+        if not await check_rule(api, requirement, update_cute, ctx_copy):
+            return False
+
+    # Translating translatable rules
+    if I18nEnum.I18N in ctx:
+        rule = await rule.translate(ctx[I18nEnum.I18N])
+
+    ctx |= ctx_copy
+
+    # Composing required nodes
+    nodes = rule.required_nodes
+    node_col = None
+    if nodes:
+        result = await compose_nodes(nodes, ctx, data={Update: update, API: api})
+        if not result:
+            logger.debug(f"Cannot compose nodes for rule, error: {str(result.error)}")
+            return False
+        node_col = result.value
+
+    # Running check
+    result = await rule.bounding_check(ctx, adapted_value=adapted_value, node_col=node_col)
+
+    # Closing node sessions if there are any
+    if node_col is not None:
+        await node_col.close_all()
+
+    return result
+
+
+__all__ = ("check_rule", "process_inner")

telegrinder/bot/dispatch/return_manager/__init__.py

@@ -1,19 +1,21 @@
-from telegrinder.bot.dispatch.return_manager.abc import (
-    ABCReturnManager,
-    BaseReturnManager,
-    Manager,
-    register_manager,
-)
-from telegrinder.bot.dispatch.return_manager.callback_query import CallbackQueryReturnManager
-from telegrinder.bot.dispatch.return_manager.inline_query import InlineQueryReturnManager
-from telegrinder.bot.dispatch.return_manager.message import MessageReturnManager
-
-__all__ = (
+from telegrinder.bot.dispatch.return_manager.abc import (
+    ABCReturnManager,
+    BaseReturnManager,
+    Manager,
+    register_manager,
+)
+from telegrinder.bot.dispatch.return_manager.callback_query import CallbackQueryReturnManager
+from telegrinder.bot.dispatch.return_manager.inline_query import InlineQueryReturnManager
+from telegrinder.bot.dispatch.return_manager.message import MessageReturnManager
+from telegrinder.bot.dispatch.return_manager.pre_checkout_query import PreCheckoutQueryManager
+
+__all__ = (
     "ABCReturnManager",
     "BaseReturnManager",
     "CallbackQueryReturnManager",
     "InlineQueryReturnManager",
     "Manager",
     "MessageReturnManager",
-    "register_manager",
-)
+    "PreCheckoutQueryManager",
+    "register_manager",
+)

telegrinder/bot/dispatch/return_manager/abc.py

@@ -1,112 +1,108 @@
-import dataclasses
-import types
-import typing
-from abc import ABC, abstractmethod
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.model import Model
-from telegrinder.modules import logger
-
-T = typing.TypeVar("T")
-Event = typing.TypeVar("Event", bound=Model, 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[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
-
-    return wrapper
-
-
-@dataclasses.dataclass(frozen=True, slots=True)
-class Manager:
-    types: tuple[type, ...]
-    callback: typing.Callable[..., typing.Awaitable[typing.Any]]
-
-    async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
-        await self.callback(*args, **kwargs)
-
-
-class ABCReturnManager(ABC, typing.Generic[Event]):
-    @abstractmethod
-    async def run(self, response: typing.Any, event: Event, ctx: Context) -> None:
-        pass
-
-
-class BaseReturnManager(ABCReturnManager[Event]):
-    def __repr__(self) -> str:
-        return "<{}: {}>".format(
-            self.__class__.__name__,
-            ", ".join(x.callback.__name__ + "=" + repr(x) for x in self.managers),
-        )
-
-    @property
-    def managers(self) -> list[Manager]:
-        managers = self.__dict__.get("managers")
-        if managers is not None:
-            return managers
-        managers_lst = [
-            manager
-            for manager in (vars(BaseReturnManager) | vars(self.__class__)).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(
-        self,
-        return_type: type[T],
-    ) -> typing.Callable[[typing.Callable[[T, Event, Context], typing.Awaitable[typing.Any]]], Manager]: ...
-
-    @typing.overload
-    def register_manager(
-        self,
-        return_type: tuple[type[T], ...],
-    ) -> typing.Callable[
-        [typing.Callable[[tuple[T, ...], Event, Context], typing.Awaitable[typing.Any]]],
-        Manager,
-    ]: ...
-
-    def register_manager(
-        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
-            self.managers.append(manager)
-            return manager
-
-        return wrapper
-
-
-__all__ = (
+import dataclasses
+import types
+import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.model import Model
+from telegrinder.modules import logger
+
+
+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
+
+
+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
+
+    return wrapper
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Manager:
+    types: tuple[type, ...]
+    callback: typing.Callable[..., typing.Awaitable[typing.Any]]
+
+    async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
+        await self.callback(*args, **kwargs)
+
+
+class ABCReturnManager[Event: Model](ABC):
+    @abstractmethod
+    async def run(self, response: typing.Any, event: Event, ctx: Context) -> None:
+        pass
+
+
+class BaseReturnManager[Event: Model](ABCReturnManager[Event]):
+    def __repr__(self) -> str:
+        return "<{}: {}>".format(
+            self.__class__.__name__,
+            ", ".join(x.callback.__name__ + "=" + repr(x) for x in self.managers),
+        )
+
+    @property
+    def managers(self) -> list[Manager]:
+        managers = self.__dict__.get("managers")
+        if managers is not None:
+            return managers
+        managers_lst = [
+            manager
+            for manager in (vars(BaseReturnManager) | vars(self.__class__)).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](
+        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
+            self.managers.append(manager)
+            return manager
+
+        return wrapper
+
+
+__all__ = (
     "ABCReturnManager",
     "BaseReturnManager",
     "Manager",
     "get_union_types",
-    "register_manager",
-)
+    "register_manager",
+)

telegrinder/bot/dispatch/return_manager/callback_query.py

@@ -1,20 +1,20 @@
-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]):
-    @register_manager(str)
-    @staticmethod
-    async def str_manager(value: str, event: CallbackQueryCute, ctx: Context) -> None:
-        await event.answer(value)
-
-    @register_manager(dict[str, typing.Any])
-    @staticmethod
-    async def dict_manager(value: dict[str, typing.Any], event: CallbackQueryCute, ctx: Context) -> None:
-        await event.answer(**value)
-
-
-__all__ = ("CallbackQueryReturnManager",)
+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]):
+    @register_manager(str)
+    @staticmethod
+    async def str_manager(value: str, event: CallbackQueryCute, ctx: Context) -> None:
+        await event.answer(value)
+
+    @register_manager(dict[str, typing.Any])
+    @staticmethod
+    async def dict_manager(value: dict[str, typing.Any], event: CallbackQueryCute, ctx: Context) -> None:
+        await event.answer(**value)
+
+
+__all__ = ("CallbackQueryReturnManager",)

telegrinder/bot/dispatch/return_manager/inline_query.py

@@ -1,15 +1,15 @@
-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])
-    @staticmethod
-    async def dict_manager(value: dict[str, typing.Any], event: InlineQueryCute, ctx: Context) -> None:
-        await event.answer(**value)
-
-
-__all__ = ("InlineQueryReturnManager",)
+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])
+    @staticmethod
+    async def dict_manager(value: dict[str, typing.Any], event: InlineQueryCute, ctx: Context) -> None:
+        await event.answer(**value)
+
+
+__all__ = ("InlineQueryReturnManager",)