telegrinder 0.3.4__py3-none-any.whl → 0.4.0__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,
+        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 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,
+        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 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,
+        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, _: 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,22 +1,97 @@
-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",)
+from __future__ import annotations
+
+from abc import ABC
+
+import typing_extensions as typing
+from fntypes import Some
+
+from telegrinder.api import API
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.model import Model
+from telegrinder.modules import logger
+from telegrinder.tools.adapter.abc import ABCAdapter, run_adapter
+from telegrinder.tools.lifespan import Lifespan
+from telegrinder.types.objects import Update
+
+ToEvent = typing.TypeVar("ToEvent", bound=Model, default=typing.Any)
+
+
+async def run_middleware[Event: Model, R: bool | None](
+    method: typing.Callable[typing.Concatenate[Event, Context, ...], typing.Awaitable[R]],
+    api: API[typing.Any],
+    event: Event,
+    ctx: Context,
+    raw_event: Update | None = None,
+    adapter: "ABCAdapter[Update, Event] | None" = None,
+    *args: typing.Any,
+    **kwargs: typing.Any,
+) -> R:
+    if adapter is not None:
+        if raw_event is None:
+            raise RuntimeError("raw_event must be specified to apply adapter")
+        match await run_adapter(adapter, api, raw_event, ctx):
+            case Some(val):
+                event = val
+            case _:
+                return False  # type: ignore
+
+    logger.debug("Running {}-middleware {!r}...", method.__name__, method.__qualname__.split(".")[0])
+    return await method(event, ctx, *args, **kwargs)  # type: ignore
+
+
+class ABCMiddleware[Event: Model | BaseCute](ABC):
+    adapter: ABCAdapter[Update, Event] | None = None
+
+    def __repr__(self) -> str:
+        name = f"middleware {self.__class__.__name__!r}:"
+        has_pre = self.pre.__qualname__.split(".")[0] != "ABCMiddleware"
+        has_post = self.post.__qualname__.split(".")[0] != "ABCMiddleware"
+
+        if has_post:
+            name = "post-" + name
+        if has_pre:
+            name = "pre-" + name
+
+        return "<{} with adapter={!r}>".format(name, self.adapter)
+
+    async def pre(self, event: Event, ctx: Context) -> bool: ...
+
+    async def post(self, event: Event, ctx: Context) -> None: ...
+
+    @typing.overload
+    def to_lifespan(self, event: Event, ctx: Context | None = None, *, api: API) -> Lifespan: ...
+
+    @typing.overload
+    def to_lifespan(self, event: Event, ctx: Context | None = None) -> Lifespan: ...
+
+    def to_lifespan(
+        self,
+        event: Event,
+        ctx: Context | None = None,
+        api: API | None = None,
+        **add_context: typing.Any,
+    ) -> Lifespan:
+        if api is None:
+            if not isinstance(event, BaseCute):
+                raise LookupError("Cannot get api, please pass as kwarg or provide BaseCute api-bound event")
+            api = event.api
+
+        ctx = ctx or Context()
+        ctx |= add_context
+        return Lifespan(
+            startup_tasks=[run_middleware(self.pre, api, event, raw_event=None, ctx=ctx, adapter=None)],
+            shutdown_tasks=[
+                run_middleware(
+                    self.post,
+                    api,
+                    event,
+                    raw_event=None,
+                    ctx=ctx,
+                    adapter=None,
+                )
+            ],
+        )
+
+
+__all__ = ("ABCMiddleware", "run_middleware")

telegrinder/bot/dispatch/middleware/global_middleware.py

@@ -0,0 +1,70 @@
+import inspect
+import typing
+from contextlib import contextmanager
+
+from telegrinder.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.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.types import Update
+
+
+class GlobalMiddleware(ABCMiddleware):
+    adapter = RawUpdateAdapter()
+
+    def __init__(self):
+        self.filters: set[ABCRule] = set()
+        self.source_filters: dict[ABCAdapter | IsNode, dict[typing.Any, ABCRule]] = {}
+
+    async def pre(self, event: UpdateCute, ctx: Context) -> bool:
+        for filter in self.filters:
+            if not await check_rule(event.api, filter, event, ctx):
+                return False
+
+        # 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
+
+            else:
+                result = await compose_nodes({"value": source}, ctx, {Update: event, API: event.api})
+                if result := result.unwrap():
+                    result = result.values["value"]
+                else:
+                    return True
+
+            if result in identifiers:
+                return await check_rule(event.api, identifiers[result], event, ctx)
+
+        return True
+
+    @contextmanager
+    def apply_filters(
+        self,
+        *filters: ABCRule,
+        source_filter: tuple[ABCAdapter | IsNode, typing.Any, ABCRule] | None = 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]})
+
+        self.filters |= set(filters)
+        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)
+
+
+__all__ = ("GlobalMiddleware",)