telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/bot/dispatch/middleware/media_group.py

@@ -0,0 +1,69 @@
+import asyncio
+import dataclasses
+import typing
+
+from kungfu.library.monad.option import Some
+
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
+
+type MediaGroupId = str
+
+WAIT_TIME: typing.Final = 2.0
+MAX_GROUP_PARTS: typing.Final = 10
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class MediaGroupData:
+    event: asyncio.Event
+    timer: asyncio.TimerHandle
+    messages: list[MessageCute] = dataclasses.field(default_factory=list)
+
+
+class MediaGroupMiddleware(ABCMiddleware):
+    media_groups: dict[MediaGroupId, MediaGroupData]
+
+    def __init__(self, *, wait_time: float = WAIT_TIME) -> None:
+        self.wait_time = wait_time
+        self.media_groups = {}
+
+    async def pre(self, message: MessageCute | None, context: Context) -> bool:
+        if message is None:
+            return True
+
+        media_group_id = message.media_group_id.unwrap_or_none()
+
+        if not media_group_id:
+            return True
+
+        if media_group_id not in self.media_groups:
+            media_group_data = MediaGroupData(
+                event=(event := asyncio.Event()),
+                timer=asyncio.get_running_loop().call_later(self.wait_time, event.set),
+                messages=[message],
+            )
+            self.media_groups[media_group_id] = media_group_data
+
+            await event.wait()
+
+            message.media_group_messages = Some(media_group_data.messages)
+            self.media_groups.pop(media_group_id, None)
+            return True
+
+        media_group_data = self.media_groups[media_group_id]
+        media_group_data.messages.append(message)
+
+        if len(media_group_data.messages) >= MAX_GROUP_PARTS:
+            if not media_group_data.timer.cancelled():
+                media_group_data.timer.cancel()
+
+            if not media_group_data.event.is_set():
+                media_group_data.event.set()
+
+            self.media_groups.pop(media_group_id, None)
+
+        return False
+
+
+__all__ = ("MediaGroupMiddleware",)

telegrinder/bot/dispatch/process.py

@@ -0,0 +1,93 @@
+import typing
+
+from kungfu.library.monad.result import Error, Ok, Result
+from nodnod.error import NodeError
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.middleware.abc import run_post_middleware, run_pre_middleware
+from telegrinder.modules import logger
+from telegrinder.node.compose import compose
+from telegrinder.tools.fullname import fullname
+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 View
+    from telegrinder.bot.rules.abc import ABCRule
+
+
+async def process_inner(
+    api: API,
+    update: Update,
+    context: Context,
+    view: View,
+) -> Result[str, str]:
+    for middleware in view.middlewares:
+        if await run_pre_middleware(middleware, context) is False:
+            await logger.ainfo(
+                "Update(id={}, type={!r}) processed with view `{}`. Pre-middleware `{}` raised failure.",
+                update.update_id,
+                update.update_type,
+                view,
+                fullname(middleware),
+            )
+            return Error(f"Pre-middleware `{fullname(middleware)}` raised failure.")
+
+    found_handlers: list[ABCHandler] = []
+    responses: list[typing.Any] = []
+
+    for handler in view.handlers:
+        match await handler.run(api, update, context):
+            case Ok(response):
+                found_handlers.append(handler)
+                responses.append(response)
+
+                if view.return_manager is not None:
+                    await view.return_manager.run(response, api, update, context)
+
+                if handler.final is True:
+                    break
+            case Error(error):
+                await logger.adebug("Running handler `{!r}` failed with error: {}", handler, error)
+
+    context.responses = responses
+
+    for middleware in view.middlewares:
+        await run_post_middleware(middleware, context)
+
+    if not found_handlers:
+        return Error("No found corresponded handlers.")
+
+    return Ok(
+        f"Handler{'s' if len(found_handlers) > 1 else ''}: " + "".join(repr(handler) for handler in found_handlers)
+    )
+
+
+async def check_rule(rule: ABCRule, context: Context) -> bool:
+    ctx_copy = context.copy()
+
+    for requirement in rule.requires:
+        if not await check_rule(requirement, ctx_copy):
+            return False
+
+    context |= ctx_copy
+
+    await logger.adebug("  → Checking rule `{!r}`...", rule)
+
+    async with compose(rule.composable, context) as result:
+        match result:
+            case Ok(result):
+                await logger.adebug("    * Rule `{!r}` is {}", rule, "ok" if result else "failed")
+                return result
+            case Error(error):
+                await logger.adebug(
+                    "    * Rule `{}` failed with error:{}\n",
+                    fullname(rule),
+                    NodeError(f"* failed to compose check of `{fullname(rule)}` rule", from_error=error),
+                )
+
+    return False
+
+
+__all__ = ("check_rule", "process_inner")

telegrinder/bot/dispatch/return_manager/__init__.py

@@ -0,0 +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
+from telegrinder.bot.dispatch.return_manager.pre_checkout_query import PreCheckoutQueryReturnManager
+
+__all__ = (
+    "ABCReturnManager",
+    "BaseReturnManager",
+    "CallbackQueryReturnManager",
+    "InlineQueryReturnManager",
+    "Manager",
+    "MessageReturnManager",
+    "PreCheckoutQueryReturnManager",
+    "register_manager",
+)

telegrinder/bot/dispatch/return_manager/abc.py

@@ -0,0 +1,107 @@
+import dataclasses
+import typing
+from abc import ABC, abstractmethod
+from functools import cached_property
+
+from kungfu.library.monad.result import Error
+from nodnod.error import NodeError
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.return_manager.utils import _get_types
+from telegrinder.modules import logger
+from telegrinder.node.compose import compose
+from telegrinder.tools import fullname
+from telegrinder.types.objects import Update
+
+if typing.TYPE_CHECKING:
+    from nodnod.agent.base import Agent
+
+type ManagerFunction = typing.Callable[..., typing.Any | typing.Awaitable[typing.Any]]
+
+
+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
+class Manager:
+    types: tuple[typing.Any, ...]
+    function: ManagerFunction
+    agent_cls: type[Agent] | None = None
+
+    async def __call__(self, response: typing.Any, context: Context) -> None:
+        ctx = context.copy()
+        ctx.handler_response = response
+
+        async with compose(
+            self.function,
+            ctx,
+            agent_cls=self.agent_cls,
+        ) as result:
+            match result:
+                case Error(error):
+                    await logger.adebug(
+                        "Return manager `{}` failed with error:{}",
+                        fullname(self.function),
+                        NodeError(f"failed to compose return manager `{fullname(self.function)}`", from_error=error),
+                    )
+
+
+class ABCReturnManager(ABC):
+    @property
+    @abstractmethod
+    def managers(self) -> list[Manager]:
+        pass
+
+    @abstractmethod
+    async def run(self, response: typing.Any, api: API, update: Update, context: Context) -> None:
+        pass
+
+
+class BaseReturnManager(ABCReturnManager):
+    def __repr__(self) -> str:
+        return "<{}: {}>".format(fullname(self), self.managers)
+
+    @cached_property
+    def managers(self) -> list[Manager]:
+        return [
+            manager for manager in (vars(BaseReturnManager) | vars(type(self))).values() if isinstance(manager, Manager)
+        ]
+
+    async def run(
+        self,
+        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:
+                await logger.adebug(
+                    "Running manager `{}` for response of type `{}`",
+                    fullname(manager.function),
+                    fullname(response),
+                )
+                await manager(response, 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
+
+        return wrapper
+
+
+__all__ = (
+    "ABCReturnManager",
+    "BaseReturnManager",
+    "Manager",
+    "register_manager",
+)

telegrinder/bot/dispatch/return_manager/callback_query.py

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

telegrinder/bot/dispatch/return_manager/inline_query.py

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

telegrinder/bot/dispatch/return_manager/message.py

@@ -0,0 +1,34 @@
+import typing
+
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
+from telegrinder.tools.formatting import HTML
+
+
+class MessageReturnManager(BaseReturnManager):
+    @register_manager(str)
+    @staticmethod
+    async def str_manager(handler_response: str, event: MessageCute) -> None:
+        await event.answer(handler_response)
+
+    @register_manager(list | tuple)
+    @staticmethod
+    async def seq_manager(
+        handler_response: list[typing.Any] | tuple[typing.Any, ...],
+        event: MessageCute,
+    ) -> None:
+        for message in handler_response:
+            await event.answer(str(message))
+
+    @register_manager(dict)
+    @staticmethod
+    async def dict_manager(handler_response: dict[str, typing.Any], event: MessageCute) -> None:
+        await event.answer(**handler_response)
+
+    @register_manager(HTML)
+    @staticmethod
+    async def html_manager(handler_response: HTML, event: MessageCute) -> None:
+        await event.answer(handler_response, parse_mode=HTML.PARSE_MODE)
+
+
+__all__ = ("MessageReturnManager",)

telegrinder/bot/dispatch/return_manager/pre_checkout_query.py

@@ -0,0 +1,19 @@
+import typing
+
+from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
+from telegrinder.bot.dispatch.return_manager.abc import BaseReturnManager, register_manager
+
+
+class PreCheckoutQueryReturnManager(BaseReturnManager):
+    @register_manager(bool)
+    @staticmethod
+    async def bool_manager(handler_response: bool, event: PreCheckoutQueryCute) -> None:
+        await event.answer(handler_response)
+
+    @register_manager(dict)
+    @staticmethod
+    async def dict_manager(handler_response: dict[str, typing.Any], event: PreCheckoutQueryCute) -> None:
+        await event.answer(**handler_response)
+
+
+__all__ = ("PreCheckoutQueryReturnManager",)

telegrinder/bot/dispatch/return_manager/utils.py

@@ -0,0 +1,20 @@
+import types
+import typing
+
+
+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)
+
+        if isinstance(x, type):
+            return x
+
+
+__all__ = ("_get_types",)

telegrinder/bot/dispatch/router/__init__.py

@@ -0,0 +1,4 @@
+from telegrinder.bot.dispatch.router.abc import ABCRouter
+from telegrinder.bot.dispatch.router.base import Router
+
+__all__ = ("ABCRouter", "Router")

telegrinder/bot/dispatch/router/abc.py

@@ -0,0 +1,15 @@
+import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.types.objects import Update
+
+
+class ABCRouter(ABC):
+    @abstractmethod
+    async def route(self, api: API, update: Update, context: Context) -> typing.Any:
+        pass
+
+
+__all__ = ("ABCRouter",)

telegrinder/bot/dispatch/router/base.py

@@ -0,0 +1,154 @@
+import dataclasses
+import typing
+
+from kungfu.library.monad.result import Error as Err
+from kungfu.library.monad.result import Ok
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.router.abc import ABCRouter
+from telegrinder.bot.dispatch.view.box import ViewBox
+from telegrinder.modules import logger
+from telegrinder.tools.magic.inspect import get_frame_module_name
+from telegrinder.types.objects import Update
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.view.base import ErrorView, EventView, RawEventView, View
+    from telegrinder.bot.dispatch.view.media_group import MediaGroupView
+
+
+@dataclasses.dataclass(kw_only=True)
+class Router[
+    MessageView: EventView = EventView,
+    EditedMessageView: EventView = EventView,
+    ChannelPostView: EventView = EventView,
+    EditedChannelPostView: EventView = EventView,
+    BusinessConnectionView: EventView = EventView,
+    BusinessMessageView: EventView = EventView,
+    EditedBusinessMessageView: EventView = EventView,
+    DeletedBusinessMessagesView: EventView = EventView,
+    MessageReactionView: EventView = EventView,
+    MessageReactionCountView: EventView = EventView,
+    InlineQueryView: EventView = EventView,
+    ChosenInlineResultView: EventView = EventView,
+    CallbackQueryView: EventView = EventView,
+    ShippingQueryView: EventView = EventView,
+    PreCheckoutQueryView: EventView = EventView,
+    PurchasedPaidMediaView: EventView = EventView,
+    PollView: EventView = EventView,
+    PollAnswerView: EventView = EventView,
+    MyChatMemberView: EventView = EventView,
+    ChatMemberView: EventView = EventView,
+    ChatJoinRequestView: EventView = EventView,
+    ChatBoostView: EventView = EventView,
+    RemovedChatBoostView: EventView = EventView,
+    MediaGroup: View = MediaGroupView,
+    Error: ErrorView = ErrorView,
+    RawEvent: RawEventView = RawEventView,
+](
+    ABCRouter,
+    ViewBox[
+        MessageView,
+        EditedMessageView,
+        ChannelPostView,
+        EditedChannelPostView,
+        BusinessConnectionView,
+        BusinessMessageView,
+        EditedBusinessMessageView,
+        DeletedBusinessMessagesView,
+        MessageReactionView,
+        MessageReactionCountView,
+        InlineQueryView,
+        ChosenInlineResultView,
+        CallbackQueryView,
+        ShippingQueryView,
+        PreCheckoutQueryView,
+        PurchasedPaidMediaView,
+        PollView,
+        PollAnswerView,
+        MyChatMemberView,
+        ChatMemberView,
+        ChatJoinRequestView,
+        ChatBoostView,
+        RemovedChatBoostView,
+        MediaGroup,
+        Error,
+        RawEvent,
+    ],
+):
+    def __post_init__(self) -> None:
+        self.name = ":".join((get_frame_module_name(), self.__class__.__name__, hex(id(self))))
+
+    def __repr__(self) -> str:
+        return f"<{self.name}>"
+
+    def __hash__(self) -> int:
+        return hash(self.name)
+
+    def __bool__(self) -> bool:
+        return any(self.views.values()) or bool(self.raw) or bool(self.event_error)
+
+    async def route_view(self, view: View, api: API, update: Update, context: Context) -> bool:
+        # Check if the view is applicable to the update
+
+        await logger.adebug(
+            "Checking view `{!r}` from router `{!r}` for update (id={}, type={!r})...",
+            view,
+            self,
+            update.update_id,
+            update.update_type,
+        )
+
+        match await view.check(api, update, context):
+            case Ok(_):
+                await logger.adebug(
+                    "View `{!r}` from router `{!r}` for update (id={}, type={!r}) is happy, processing...",
+                    view,
+                    self,
+                    update.update_id,
+                    update.update_type,
+                )
+                result = await view.process(api, update, context)
+
+                match result:
+                    case Err(error) if isinstance(error, Exception):
+                        raise error from None
+
+                await logger.ainfo(
+                    "Update(id={}, type={!r}) processed with view `{!r}` from router `{!r}`. {}",
+                    update.update_id,
+                    update.update_type,
+                    view,
+                    self,
+                    result.error if not result else result.value,
+                )
+                return bool(result)
+            case Err(error):
+                await logger.adebug(
+                    "Checking view `{!r}` from router `{!r}` for update (id={}, type={!r}) failed: {}",
+                    view,
+                    self,
+                    update.update_id,
+                    update.update_type,
+                    error,
+                )
+
+        return False
+
+    async def route(self, api: API, update: Update, context: Context) -> bool:
+        try:
+            # Filtering non-empty views
+            for view in filter(None, self.views.values()):
+                # Route the non-empty view
+                if await self.route_view(view, api, update, context):
+                    return True
+
+            return False
+        except Exception as exception:
+            if self.event_error:
+                context.exceptions_update[self] = exception  # type: ignore
+
+            raise
+
+
+__all__ = ("Router",)

telegrinder/bot/dispatch/view/__init__.py

@@ -0,0 +1,15 @@
+from telegrinder.bot.dispatch.view.abc import ABCView
+from telegrinder.bot.dispatch.view.base import ErrorView, EventModelView, EventView, RawEventView, View
+from telegrinder.bot.dispatch.view.box import ViewBox
+from telegrinder.bot.dispatch.view.media_group import MediaGroupView
+
+__all__ = (
+    "ABCView",
+    "ErrorView",
+    "EventModelView",
+    "EventView",
+    "MediaGroupView",
+    "RawEventView",
+    "View",
+    "ViewBox",
+)

telegrinder/bot/dispatch/view/abc.py

@@ -0,0 +1,15 @@
+import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.types.objects import Update
+
+
+class ABCView(ABC):
+    @abstractmethod
+    async def process(self, api: API, update: Update, context: Context) -> typing.Any:
+        pass
+
+
+__all__ = ("ABCView",)