telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/bot/dispatch/handler/audio_reply.py

@@ -0,0 +1,43 @@
+import typing
+
+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 AudioReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        audio: InputFile | str,
+        *rules: ABCRule,
+        caption: str | None = None,
+        parse_mode: str | None = None,
+        final: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.audio = audio
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            final=final,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def handle(self, message: MessageCute) -> None:
+        method = message.answer_audio if not self.as_reply else message.reply_audio
+        await method(
+            audio=self.audio,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("AudioReplyHandler",)

telegrinder/bot/dispatch/handler/base.py

@@ -0,0 +1,34 @@
+import abc
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.func import FuncHandler
+from telegrinder.bot.rules.abc import ABCRule
+
+
+class BaseReplyHandler(FuncHandler, abc.ABC):
+    final: bool
+
+    def __init__(
+        self,
+        *rules: ABCRule,
+        final: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.as_reply = as_reply
+        self.default_params = default_params
+        super().__init__(
+            function=self.handle,
+            rules=list(rules),
+            final=final,
+            preset_context=preset_context or Context(),
+        )
+
+    @abc.abstractmethod
+    async def handle(self, *args: typing.Any, **kwargs: typing.Any) -> typing.Any:
+        pass
+
+
+__all__ = ("BaseReplyHandler",)

telegrinder/bot/dispatch/handler/document_reply.py

@@ -0,0 +1,43 @@
+import typing
+
+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 DocumentReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        document: InputFile | str,
+        *rules: ABCRule,
+        caption: str | None = None,
+        parse_mode: str | None = None,
+        final: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.document = document
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            final=final,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def handle(self, message: MessageCute) -> None:
+        method = message.answer_document if not self.as_reply else message.reply_document
+        await method(
+            document=self.document,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("DocumentReplyHandler",)

telegrinder/bot/dispatch/handler/func.py

@@ -0,0 +1,73 @@
+import dataclasses
+import typing
+from collections import deque
+
+from kungfu.library.monad.result import Error, Result
+from nodnod.agent.event_loop.agent import EventLoopAgent
+from nodnod.error import NodeError
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.bot.dispatch.process import check_rule
+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 nodnod.agent.base import Agent
+
+    from telegrinder.bot.rules.abc import ABCRule
+
+type Function[**P = ..., R = typing.Any] = typing.Callable[P, R]
+
+
+@dataclasses.dataclass(repr=False, slots=True)
+class FuncHandler[T: Function](ABCHandler):
+    function: T
+    rules: dataclasses.InitVar[typing.Iterable[ABCRule] | None] = dataclasses.field(default=None)
+    agent: type[Agent] | None = dataclasses.field(default=None, kw_only=True)
+    final: bool = dataclasses.field(default=True, kw_only=True)
+    preset_context: Context = dataclasses.field(default_factory=lambda: Context(), kw_only=True)
+
+    def __post_init__(self, rules: typing.Iterable[ABCRule] | None) -> None:
+        self.check_rules = deque(rules or ())
+
+    def __repr__(self) -> str:
+        return fullname(self.function)
+
+    @property
+    def __call__(self) -> Function:
+        return self.function
+
+    async def run(
+        self,
+        api: API,
+        update: Update,
+        context: Context,
+        check: bool = True,
+    ) -> Result[typing.Any, str]:
+        temp_ctx = context | self.preset_context
+
+        if check and self.check_rules:
+            await logger.adebug("Checking rules for handler `{!r}`...", self)
+
+            for rule in self.check_rules:
+                if not await check_rule(rule, temp_ctx):
+                    return Error(f"Rule {rule!r} failed.")
+
+            await logger.adebug("Rules passed, composing nodes and running handler `{!r}`...", self)
+        else:
+            await logger.adebug("Composing nodes and running handler `{!r}`...", self)
+
+        context |= temp_ctx
+        async with compose(self.function, context, agent_cls=self.agent or EventLoopAgent) as result:
+            return result.map_err(
+                lambda error: "{}\n".format(
+                    NodeError(f"* failed to compose handler `{self!r}`", from_error=error),
+                ),
+            )
+
+
+__all__ = ("FuncHandler",)

telegrinder/bot/dispatch/handler/media_group_reply.py

@@ -0,0 +1,43 @@
+import typing
+
+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 InputMedia
+
+
+class MediaGroupReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        media: InputMedia | list[InputMedia],
+        *rules: ABCRule,
+        caption: str | list[str] | None = None,
+        parse_mode: str | list[str] | None = None,
+        final: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.media = media
+        self.parse_mode = parse_mode
+        self.caption = caption
+        super().__init__(
+            *rules,
+            final=final,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def handle(self, message: MessageCute) -> None:
+        method = message.answer_media_group if not self.as_reply else message.reply_media_group
+        await method(
+            media=self.media,
+            parse_mode=self.parse_mode,
+            caption=self.caption,
+            **self.default_params,
+        )
+
+
+__all__ = ("MediaGroupReplyHandler",)

telegrinder/bot/dispatch/handler/message_reply.py

@@ -0,0 +1,35 @@
+import typing
+
+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
+
+
+class MessageReplyHandler(BaseReplyHandler):
+    def __init__(
+        self,
+        text: str,
+        *rules: ABCRule,
+        parse_mode: str | None = None,
+        final: bool = True,
+        as_reply: bool = False,
+        preset_context: Context | None = None,
+        **default_params: typing.Any,
+    ) -> None:
+        self.text = text
+        self.parse_mode = parse_mode
+        super().__init__(
+            *rules,
+            final=final,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def handle(self, message: MessageCute) -> None:
+        method = message.answer if not self.as_reply else message.reply
+        await method(text=self.text, parse_mode=self.parse_mode, **self.default_params)
+
+
+__all__ = ("MessageReplyHandler",)

telegrinder/bot/dispatch/handler/photo_reply.py

@@ -0,0 +1,43 @@
+import typing
+
+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,
+        final: 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,
+            final=final,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def handle(self, message: MessageCute) -> None:
+        method = message.answer_photo if not self.as_reply else message.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

@@ -0,0 +1,36 @@
+import typing
+
+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,
+        final: 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,
+            final=final,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def handle(self, message: MessageCute) -> None:
+        method = message.answer_sticker if not self.as_reply else message.reply_sticker
+        await method(sticker=self.sticker, emoji=self.emoji, **self.default_params)
+
+
+__all__ = ("StickerReplyHandler",)

telegrinder/bot/dispatch/handler/video_reply.py

@@ -0,0 +1,43 @@
+import typing
+
+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,
+        final: 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,
+            final=final,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
+        )
+
+    async def run(self, message: MessageCute) -> None:
+        method = message.answer_video if not self.as_reply else message.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

@@ -0,0 +1,13 @@
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware, run_post_middleware, run_pre_middleware
+from telegrinder.bot.dispatch.middleware.box import MiddlewareBox
+from telegrinder.bot.dispatch.middleware.filter import FilterMiddleware
+from telegrinder.bot.dispatch.middleware.media_group import MediaGroupMiddleware
+
+__all__ = (
+    "ABCMiddleware",
+    "FilterMiddleware",
+    "MediaGroupMiddleware",
+    "MiddlewareBox",
+    "run_post_middleware",
+    "run_pre_middleware",
+)

telegrinder/bot/dispatch/middleware/abc.py

@@ -0,0 +1,112 @@
+import typing
+from abc import ABC
+from functools import cached_property
+
+from kungfu.library.monad.result import Error, Ok
+from nodnod.agent.event_loop.agent import EventLoopAgent
+from nodnod.error import NodeError
+from nodnod.interface.node_from_function import create_node_from_function
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.modules import logger
+from telegrinder.node.compose import compose, create_composable
+from telegrinder.node.utils import get_globals_from_function, get_locals_from_function
+from telegrinder.tools.fullname import fullname
+from telegrinder.tools.lifespan import Lifespan
+
+if typing.TYPE_CHECKING:
+    from nodnod.agent.base import Agent
+
+    from telegrinder.node.compose import Composable
+
+type Node = typing.Any
+type MiddlewareResult = bool | typing.Awaitable[bool | None] | None
+
+
+async def run_pre_middleware(middleware: ABCMiddleware, context: Context) -> bool:
+    if middleware.is_pre:
+        return bool(await run_middleware(middleware, context, composable=middleware.pre_composable))
+    return True
+
+
+async def run_post_middleware(middleware: ABCMiddleware, context: Context) -> None:
+    if middleware.is_post:
+        await run_middleware(middleware, context, composable=middleware.post_composable)
+
+
+async def run_middleware(
+    middleware: ABCMiddleware,
+    context: Context,
+    *,
+    composable: Composable[typing.Any],
+) -> bool | None:
+    async with compose(composable, context) as result:
+        match result:
+            case Ok(response):
+                return response
+            case Error(error):
+                await logger.adebug(
+                    "Middleware `{!r}` failed with error:{}\n",
+                    middleware_name := fullname(middleware),
+                    NodeError(f"* failed to compose middleware `{middleware_name}`", from_error=error),
+                )
+
+
+class ABCMiddleware(ABC):
+    agent_cls: type[Agent] = EventLoopAgent
+    pre_required_nodes: typing.Mapping[str, Node] | None = None
+    post_required_nodes: typing.Mapping[str, Node] | None = None
+
+    def __repr__(self) -> str:
+        return "<{}{}>".format(
+            "".join(
+                (
+                    f"{'pre-' if self.is_pre else ''}",
+                    f"{'post-' if self.is_post else ''}",
+                ),
+            ),
+            f"middleware `{fullname(self)}`",
+        )
+
+    @property
+    def is_pre(self) -> bool:
+        return type(self).pre is not ABCMiddleware.pre
+
+    @property
+    def is_post(self) -> bool:
+        return type(self).post is not ABCMiddleware.post
+
+    @cached_property
+    def pre_composable(self) -> Composable:
+        return self.get_composable(self.pre, self.agent_cls, required_nodes=self.pre_required_nodes)
+
+    @cached_property
+    def post_composable(self) -> Composable:
+        return self.get_composable(self.post, self.agent_cls, required_nodes=self.post_required_nodes)
+
+    @staticmethod
+    def get_composable(
+        method: typing.Callable[..., typing.Any],
+        agent_cls: type[Agent] | None,
+        required_nodes: typing.Mapping[str, Node] | None,
+    ) -> Composable:
+        node = create_node_from_function(
+            method,
+            dependencies=required_nodes,
+            forward_refs=get_globals_from_function(method),
+            namespace=get_locals_from_function(method),
+        )
+        return create_composable(node, agent_cls=agent_cls)
+
+    def pre(self, *args: typing.Any, **kwargs: typing.Any) -> MiddlewareResult: ...
+
+    def post(self, *args: typing.Any, **kwargs: typing.Any) -> MiddlewareResult: ...
+
+    def to_lifespan(self, context: Context) -> Lifespan:
+        return Lifespan(
+            startup_tasks=[run_pre_middleware(self, context)],
+            shutdown_tasks=[run_post_middleware(self, context)],
+        )
+
+
+__all__ = ("ABCMiddleware", "run_post_middleware", "run_pre_middleware")

telegrinder/bot/dispatch/middleware/box.py

@@ -0,0 +1,32 @@
+import dataclasses
+import typing
+from collections import deque
+
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
+from telegrinder.bot.dispatch.middleware.filter import FilterMiddleware
+from telegrinder.bot.dispatch.middleware.media_group import MediaGroupMiddleware
+from telegrinder.tools.singleton import Singleton
+
+
+@dataclasses.dataclass(frozen=True)
+class MiddlewareBox(Singleton):
+    filter: FilterMiddleware = dataclasses.field(default_factory=FilterMiddleware)
+    media_group: MediaGroupMiddleware = dataclasses.field(default_factory=MediaGroupMiddleware)
+    _custom_middlewares: deque[ABCMiddleware] = dataclasses.field(
+        default_factory=deque,
+        repr=False,
+    )
+
+    def __call__[Middleware: ABCMiddleware](self, middleware: type[Middleware], /) -> type[Middleware]:
+        self.put(middleware())
+        return middleware
+
+    def __iter__(self) -> typing.Iterator[ABCMiddleware]:
+        for middleware in (self.filter, self.media_group, *self._custom_middlewares):
+            yield middleware
+
+    def put(self, middleware: ABCMiddleware, /) -> None:
+        self._custom_middlewares.append(middleware)
+
+
+__all__ = ("MiddlewareBox",)

telegrinder/bot/dispatch/middleware/filter.py

@@ -0,0 +1,88 @@
+import typing
+from contextlib import contextmanager
+
+from kungfu.library.monad.result import Error, Ok
+from nodnod.agent.base import Agent
+from nodnod.agent.event_loop.agent import EventLoopAgent
+from nodnod.interface.agent_from_node import create_agent_from_node
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
+from telegrinder.node.compose import compose
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.dispatch.process import check_rule
+    from telegrinder.bot.rules.abc import ABCRule
+
+else:
+
+    def check_rule(*args: typing.Any, **kwargs: typing.Any) -> bool:
+        from telegrinder.bot.dispatch.process import check_rule
+
+        return check_rule(*args, **kwargs)
+
+
+type AnyNode = typing.Any
+type Value = typing.Any
+
+
+class FilterMiddleware(ABCMiddleware):
+    source_filters: dict[AnyNode, tuple[type[Agent], dict[Value, tuple[ABCRule, ...]]]]
+    _source_node_agents: dict[AnyNode, Agent]
+
+    def __init__(self) -> None:
+        self.source_filters = dict()
+        self._source_node_agents = dict()
+
+    async def pre(self, context: Context) -> bool:
+        for source_node, (agent_cls, source_filter) in self.source_filters.items():
+            if source_node not in self._source_node_agents:
+                agent = self._source_node_agents[source_node] = create_agent_from_node(source_node, agent_cls=agent_cls)
+            else:
+                agent = self._source_node_agents[source_node]
+
+            async with compose(source_node, context, agent=agent) as result:
+                match result:
+                    case Error(_):
+                        return False
+                    case Ok(value) if value not in source_filter:
+                        return False
+                    case _:
+                        for filter in source_filter[result.value]:
+                            if not await check_rule(filter, context):
+                                return False
+
+            return True
+
+        return True
+
+    @contextmanager
+    def hold(
+        self,
+        source_node: AnyNode,
+        source_value: Value,
+        /,
+        *filters: ABCRule,
+        agent_cls: type[Agent] | None = None,
+    ) -> typing.Generator[None, typing.Any, None]:
+        try:
+            self.source_filters.setdefault(source_node, (agent_cls or EventLoopAgent, {}))[1][source_value] = filters
+            yield
+        finally:
+            self.release(source_node, source_value)
+
+    def release(self, source_node: AnyNode, source_value: Value, /) -> None:
+        source_filter = self.source_filters.get(source_node)
+
+        if source_filter is not None:
+            _, source_filter = source_filter
+            source_filter.pop(source_value, None)
+
+            if not source_filter:
+                self.source_filters.pop(source_node, None)
+                self._source_node_agents.pop(source_node, None)
+        else:
+            self._source_node_agents.pop(source_node, None)
+
+
+__all__ = ("FilterMiddleware",)