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

telegrinder/bot/dispatch/middleware/global_middleware.py

@@ -1,50 +1,36 @@
-import inspect
 import typing
 from contextlib import contextmanager
 
-from telegrinder.api import API
-from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
 from telegrinder.bot.rules.abc import ABCRule, check_rule
-from telegrinder.node import IsNode, compose_nodes
-from telegrinder.tools.adapter.abc import ABCAdapter
-from telegrinder.tools.adapter.raw_update import RawUpdateAdapter
+from telegrinder.node.base import IsNode
+from telegrinder.node.composer import compose_nodes
 from telegrinder.types import Update
+from telegrinder.types.objects import Update
 
 
 class GlobalMiddleware(ABCMiddleware):
-    adapter = RawUpdateAdapter()
-
-    def __init__(self):
+    def __init__(self) -> None:
         self.filters: set[ABCRule] = set()
-        self.source_filters: dict[ABCAdapter | IsNode, dict[typing.Any, ABCRule]] = {}
+        self.source_filters: dict[IsNode, dict[typing.Any, ABCRule]] = {}
 
-    async def pre(self, event: UpdateCute, ctx: Context) -> bool:
+    async def pre(self, event: Update, api: API, ctx: Context) -> bool:
         for filter in self.filters:
-            if not await check_rule(event.api, filter, event, ctx):
+            if not await check_rule(api, filter, event, ctx):
                 return False
 
-        # Simple implication.... Grouped by source categories
+        # Simple implication. Grouped by source categories
         for source, identifiers in self.source_filters.items():
-            if isinstance(source, ABCAdapter):
-                result = source.adapt(event.api, event, ctx)
-                if inspect.isawaitable(result):
-                    result = await result
-
-                result = result.unwrap_or_none()
-                if result is None:
-                    return True
-
+            result = await compose_nodes({"value": source}, ctx, {Update: event, API: api})
+            if result := result.unwrap():
+                result = result.values["value"]
             else:
-                result = await compose_nodes({"value": source}, ctx, {Update: event, API: event.api})
-                if result := result.unwrap():
-                    result = result.values["value"]
-                else:
-                    return True
+                return True
 
             if result in identifiers:
-                return await check_rule(event.api, identifiers[result], event, ctx)
+                return await check_rule(api, identifiers[result], event, ctx)
 
         return True
 
@@ -52,8 +38,8 @@ class GlobalMiddleware(ABCMiddleware):
     def apply_filters(
         self,
         *filters: ABCRule,
-        source_filter: tuple[ABCAdapter | IsNode, typing.Any, ABCRule] | None = None,
-    ):
+        source_filter: tuple[IsNode, typing.Any, ABCRule] | None = None,
+    ) -> typing.Generator[None, typing.Any, None]:
         if source_filter is not None:
             self.source_filters.setdefault(source_filter[0], {})
             self.source_filters[source_filter[0]].update({source_filter[1]: source_filter[2]})
@@ -62,9 +48,8 @@ class GlobalMiddleware(ABCMiddleware):
         yield
         self.filters.difference_update(filters)
 
-        if source_filter is not None:  # noqa: SIM102
-            if identifiers := self.source_filters.get(source_filter[0]):
-                identifiers.pop(source_filter[1], None)
+        if source_filter is not None and (identifiers := self.source_filters.get(source_filter[0])):
+            identifiers.pop(source_filter[1], None)
 
 
 __all__ = ("GlobalMiddleware",)

telegrinder/bot/dispatch/process.py

@@ -1,151 +1,130 @@
+from __future__ import annotations
+
 import typing
 
-from fntypes.option import Nothing, 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, 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.node.composer import CONTEXT_STORE_NODES_KEY, compose_nodes
+from telegrinder.tools.aio import maybe_awaitable
+from telegrinder.tools.fullname import fullname
+from telegrinder.tools.magic.function import bundle
 from telegrinder.types.objects import Update
 
 if typing.TYPE_CHECKING:
-    from telegrinder.bot.dispatch.handler.abc import ABCHandler
+    from telegrinder.bot.dispatch.view.base import BaseView
     from telegrinder.bot.rules.abc import ABCRule
 
 
-async def process_inner[Event: Model](
+async def process_inner(
     api: API,
-    event: Event,
-    raw_event: Update,
+    event: Update,
     ctx: Context,
-    middlewares: list[ABCMiddleware[Event]],
-    handlers: list["ABCHandler[Event]"],
-    return_manager: ABCReturnManager[Event] | None = None,
+    view: BaseView,
 ) -> 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:
+    for m in view.middlewares:
+        if (
+            type(m).pre is not ABCMiddleware.pre
+            and await run_middleware(m.pre, api, event, ctx, required_nodes=m.pre_required_nodes) is False
+        ):
+            logger.info(
+                "Update(id={}, type={!r}) processed with view `{}`. Pre-middleware `{}` raised failure.",
+                event.update_id,
+                event.update_type,
+                type(view).__name__,
+                fullname(m),
+            )
             return False
 
-    found = False
-    responses = []
+    found_handlers = []
+    responses = list[typing.Any]()
     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,
+    for handler in view.handlers:
+        match await handler.run(api, event, ctx):
+            case Ok(response):
+                found_handlers.append(handler)
+                responses.append(response)
+
+                if view.return_manager is not None:
+                    await view.return_manager.run(response, api, event, ctx)
+
+                if handler.final is True:
+                    break
+            case Error(error):
+                logger.debug(error)
+
+    ctx = ctx_copy
+    ctx.responses = responses
+
+    for m in view.middlewares:
+        if type(m).post is not ABCMiddleware.post:
+            await run_middleware(
+                m.post,
+                api,
+                event,
+                ctx,
+                required_nodes=m.post_required_nodes,
+            )
+
+    logger.info(
+        "Update(id={}, type={!r}) processed with view `{}`. {}",
+        event.update_id,
+        event.update_type,
+        type(view).__name__,
+        "No found corresponded handlers."
+        if not found_handlers
+        else f"Handler{'s' if len(found_handlers) > 1 else ''}: {', '.join(f'`{x!r}`' for x in found_handlers)}",
     )
-    return found
+    return bool(found_handlers)
 
 
 async def check_rule(
     api: API,
-    rule: "ABCRule",
+    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):
+        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
+    node_col = None
+    data = {Update: update, API: api, Context: ctx}
 
     # 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
+    if rule.required_nodes:
+        match await compose_nodes(rule.required_nodes, ctx, data=data):
+            case Ok(value):
+                node_col = value
+            case Error(compose_error):
+                logger.debug(
+                    "Cannot compose nodes for rule `{!r}`, error: {!r}",
+                    rule,
+                    compose_error.message,
+                )
+                return False
 
     # 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
+    try:
+        bundle_check = bundle(rule.check, data, typebundle=True)
+        bundle_check &= bundle(rule.check, ctx | ({} if node_col is None else node_col.values))
+        return await maybe_awaitable(bundle_check())
+    finally:
+        # Closing node sessions if there are any
+        if node_col is not None:
+            await node_col.close_all()
 
 
 __all__ = ("check_rule", "process_inner")

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)