telegrinder 0.3.3.post1__py3-none-any.whl → 0.3.4.post1__py3-none-any.whl

telegrinder/bot/dispatch/handler/photo_reply.py

@@ -1,44 +1,44 @@
-import typing
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.message import MessageCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
-from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.types.objects import InputFile
-
-
-class PhotoReplyHandler(BaseReplyHandler):
-    def __init__(
-        self,
-        photo: InputFile | str,
-        *rules: ABCRule,
-        caption: str | None = None,
-        parse_mode: str | None = None,
-        is_blocking: bool = True,
-        as_reply: bool = False,
-        preset_context: Context | None = None,
-        **default_params: typing.Any,
-    ) -> None:
-        self.photo = photo
-        self.parse_mode = parse_mode
-        self.caption = caption
-        super().__init__(
-            *rules,
-            is_blocking=is_blocking,
-            as_reply=as_reply,
-            preset_context=preset_context,
-            **default_params,
-        )
-
-    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
-        method = event.answer_photo if not self.as_reply else event.reply_photo
-        await method(
-            photo=self.photo,
-            parse_mode=self.parse_mode,
-            caption=self.caption,
-            **self.default_params,
-        )
-
-
-__all__ = ("PhotoReplyHandler",)
+import typing
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.types.objects import InputFile
+
+
+class PhotoReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        photo: InputFile | str,
+        *rules: ABCRule,
+        caption: str | None = None,
+        parse_mode: str | None = None,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.photo = photo
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer_photo if not self.as_reply else event.reply_photo
+        await method(
+            photo=self.photo,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("PhotoReplyHandler",)

telegrinder/bot/dispatch/handler/sticker_reply.py

@@ -1,37 +1,37 @@
-import typing
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.message import MessageCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
-from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.types.objects import InputFile
-
-
-class StickerReplyHandler(BaseReplyHandler):
-    def __init__(
-        self,
-        sticker: InputFile | str,
-        *rules: ABCRule,
-        emoji: str | None = None,
-        is_blocking: bool = True,
-        as_reply: bool = False,
-        preset_context: Context | None = None,
-        **default_params: typing.Any,
-    ) -> None:
-        self.sticker = sticker
-        self.emoji = emoji
-        super().__init__(
-            *rules,
-            is_blocking=is_blocking,
-            as_reply=as_reply,
-            preset_context=preset_context,
-            **default_params,
-        )
-
-    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
-        method = event.answer_sticker if not self.as_reply else event.reply_sticker
-        await method(sticker=self.sticker, emoji=self.emoji, **self.default_params)
-
-
-__all__ = ("StickerReplyHandler",)
+import typing
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.types.objects import InputFile
+
+
+class StickerReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        sticker: InputFile | str,
+        *rules: ABCRule,
+        emoji: str | None = None,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.sticker = sticker
+        self.emoji = emoji
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer_sticker if not self.as_reply else event.reply_sticker
+        await method(sticker=self.sticker, emoji=self.emoji, **self.default_params)
+
+
+__all__ = ("StickerReplyHandler",)

telegrinder/bot/dispatch/handler/video_reply.py

@@ -1,44 +1,44 @@
-import typing
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.message import MessageCute
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
-from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.types.objects import InputFile
-
-
-class VideoReplyHandler(BaseReplyHandler):
-    def __init__(
-        self,
-        video: InputFile | str,
-        *rules: ABCRule,
-        caption: str | None = None,
-        parse_mode: str | None = None,
-        is_blocking: bool = True,
-        as_reply: bool = False,
-        preset_context: Context | None = None,
-        **default_params: typing.Any,
-    ) -> None:
-        self.video = video
-        self.parse_mode = parse_mode
-        self.caption = caption
-        super().__init__(
-            *rules,
-            is_blocking=is_blocking,
-            as_reply=as_reply,
-            preset_context=preset_context,
-            **default_params,
-        )
-
-    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
-        method = event.answer_video if not self.as_reply else event.reply_video
-        await method(
-            video=self.video,
-            parse_mode=self.parse_mode,
-            caption=self.caption,
-            **self.default_params,
-        )
-
-
-__all__ = ("VideoReplyHandler",)
+import typing
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.types.objects import InputFile
+
+
+class VideoReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        video: InputFile | str,
+        *rules: ABCRule,
+        caption: str | None = None,
+        parse_mode: str | None = None,
+        is_blocking: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.video = video
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
+        method = event.answer_video if not self.as_reply else event.reply_video
+        await method(
+            video=self.video,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("VideoReplyHandler",)

telegrinder/bot/dispatch/middleware/__init__.py

@@ -1,3 +1,3 @@
-from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
-
-__all__ = ("ABCMiddleware",)
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
+
+__all__ = ("ABCMiddleware",)

telegrinder/bot/dispatch/middleware/abc.py

@@ -1,16 +1,22 @@
-import typing
-from abc import ABC
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.model import Model
-
-Event = typing.TypeVar("Event", bound=Model)
-
-
-class ABCMiddleware(ABC, typing.Generic[Event]):
-    async def pre(self, event: Event, ctx: Context) -> bool: ...
-
-    async def post(self, event: Event, responses: list[typing.Any], ctx: Context) -> None: ...
-
-
-__all__ = ("ABCMiddleware",)
+import typing
+from abc import ABC
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.model import Model
+from telegrinder.types.objects import Update
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules.adapter.abc import ABCAdapter
+
+Event = typing.TypeVar("Event", bound=Model)
+
+
+class ABCMiddleware(ABC, typing.Generic[Event]):
+    adapter: "ABCAdapter[Update, Event] | None" = None
+
+    async def pre(self, event: Event, ctx: Context) -> bool: ...
+
+    async def post(self, event: Event, responses: list[typing.Any], ctx: Context) -> None: ...
+
+
+__all__ = ("ABCMiddleware",)

telegrinder/bot/dispatch/process.py

@@ -1,132 +1,157 @@
-import typing
-
-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
-
-Event = typing.TypeVar("Event", bound=Model)
-
-
-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:
-        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 rule.adapter.adapt(api, update, ctx):
-        case Ok(value):
-            adapted_value = value
-        case Error(err):
-            logger.debug("Adapter failed with error message: {!r}", str(err))
-            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 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")

telegrinder/bot/dispatch/return_manager/__init__.py

@@ -1,19 +1,19 @@
-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
+
+__all__ = (
     "ABCReturnManager",
     "BaseReturnManager",
     "CallbackQueryReturnManager",
     "InlineQueryReturnManager",
     "Manager",
     "MessageReturnManager",
-    "register_manager",
-)
+    "register_manager",
+)