telegrinder 0.2.0.post2__py3-none-any.whl → 0.2.2__py3-none-any.whl

telegrinder/bot/dispatch/handler/message_reply.py

@@ -3,57 +3,34 @@ 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.abc import ABCHandler
-from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.bot.dispatch.handler.base import BaseReplyHandler
 from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.modules import logger
-from telegrinder.types.objects import ReplyParameters, Update
 
 
-class MessageReplyHandler(ABCHandler[MessageCute]):
+class MessageReplyHandler(BaseReplyHandler):
     def __init__(
         self,
         text: str,
         *rules: ABCRule,
+        parse_mode: str | None = None,
         is_blocking: bool = True,
         as_reply: bool = False,
         preset_context: Context | None = None,
         **default_params: typing.Any,
     ) -> None:
         self.text = text
-        self.rules = list(rules)
-        self.as_reply = as_reply
-        self.is_blocking = is_blocking
-        self.default_params = default_params
-        self.preset_context = preset_context or Context()
-
-    def __repr__(self) -> str:
-        return "<{}: with rules={!r}, {}: {!r}>".format(
-            ("blocking " if self.is_blocking else "") + self.__class__.__name__,
-            self.rules,
-            "answer text as reply" if self.as_reply else "answer text",
-            self.text,
+        self.parse_mode = parse_mode
+        super().__init__(
+            *rules,
+            is_blocking=is_blocking,
+            as_reply=as_reply,
+            preset_context=preset_context,
+            **default_params,
         )
 
-    async def check(self, api: API, event: Update, ctx: Context | None = None) -> bool:
-        ctx = Context(raw_update=event) if ctx is None else ctx
-        temp_ctx = ctx.copy()
-        temp_ctx |= self.preset_context
-
-        for rule in self.rules:
-            if not await check_rule(api, rule, event, ctx):
-                logger.debug("Rule {!r} failed!", rule)
-                return False
-
-        ctx |= temp_ctx
-        return True
-
     async def run(self, _: API, event: MessageCute, __: Context) -> typing.Any:
-        await event.answer(
-            text=self.text,
-            reply_parameters=ReplyParameters(event.message_id) if self.as_reply else None,
-            **self.default_params,
-        )
+        method = event.answer if not self.as_reply else event.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,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",)

telegrinder/bot/dispatch/handler/sticker_reply.py

@@ -0,0 +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",)

telegrinder/bot/dispatch/handler/video_reply.py

@@ -0,0 +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",)

telegrinder/bot/dispatch/process.py

@@ -35,7 +35,7 @@ async def process_inner(
     logger.debug("Run pre middlewares...")
     for middleware in middlewares:
         middleware_result = await middleware.pre(event, ctx)
-        logger.debug("Middleware {!r} returned {!r}", middleware.__class__.__name__, middleware_result)
+        logger.debug("Middleware {!r} returned: {!r}", middleware.__class__.__qualname__, middleware_result)
         if middleware_result is False:
             return False
 
@@ -59,7 +59,7 @@ async def process_inner(
 
     logger.debug("Run post middlewares...")
     for middleware in middlewares:
-        logger.debug("Run post middleware {!r}", middleware.__class__.__name__)
+        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():

telegrinder/bot/dispatch/return_manager/abc.py

@@ -27,13 +27,10 @@ def register_manager(return_type: type[typing.Any] | types.UnionType):
 @dataclasses.dataclass(frozen=True, slots=True)
 class Manager:
     types: tuple[type, ...]
-    callback: typing.Callable[..., typing.Awaitable]
+    callback: typing.Callable[..., typing.Awaitable[typing.Any]]
 
     async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
-        try:
-            await self.callback(*args, **kwargs)
-        except BaseException as ex:
-            logger.exception(ex)
+        await self.callback(*args, **kwargs)
 
 
 class ABCReturnManager(ABC, typing.Generic[Event]):
@@ -51,11 +48,16 @@ class BaseReturnManager(ABCReturnManager[Event]):
 
     @property
     def managers(self) -> list[Manager]:
-        return [
+        managers = self.__dict__.get("managers")
+        if managers is not None:
+            return managers
+        managers_lst = [
             manager
             for manager in (vars(BaseReturnManager) | vars(self.__class__)).values()
             if isinstance(manager, Manager)
         ]
+        self.__dict__["managers"] = managers_lst
+        return managers_lst
 
     @register_manager(Context)
     @staticmethod
@@ -73,7 +75,8 @@ class BaseReturnManager(ABCReturnManager[Event]):
 
     @typing.overload
     def register_manager(
-        self, return_type: type[T]
+        self,
+        return_type: type[T],
     ) -> typing.Callable[[typing.Callable[[T, Event, Context], typing.Awaitable[typing.Any]]], Manager]: ...
 
     @typing.overload
@@ -94,7 +97,7 @@ class BaseReturnManager(ABCReturnManager[Event]):
     ]:
         def wrapper(func: typing.Callable[[T, Event, Context], typing.Awaitable]) -> Manager:
             manager = Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
-            setattr(self.__class__, func.__name__, manager)
+            self.managers.append(manager)
             return manager
 
         return wrapper

telegrinder/bot/dispatch/return_manager/callback_query.py

@@ -1,6 +1,6 @@
 import typing
 
-from telegrinder.bot.cute_types import CallbackQueryCute
+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
 
@@ -11,7 +11,7 @@ class CallbackQueryReturnManager(BaseReturnManager[CallbackQueryCute]):
     async def str_manager(value: str, event: CallbackQueryCute, ctx: Context) -> None:
         await event.answer(value)
 
-    @register_manager(dict)
+    @register_manager(dict[str, typing.Any])
     @staticmethod
     async def dict_manager(value: dict[str, typing.Any], event: CallbackQueryCute, ctx: Context) -> None:
         await event.answer(**value)

telegrinder/bot/dispatch/return_manager/inline_query.py

@@ -1,12 +1,12 @@
 import typing
 
-from telegrinder.bot.cute_types import InlineQueryCute
+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)
+    @register_manager(dict[str, typing.Any])
     @staticmethod
     async def dict_manager(value: dict[str, typing.Any], event: InlineQueryCute, ctx: Context) -> None:
         await event.answer(**value)

telegrinder/bot/dispatch/return_manager/message.py

@@ -1,6 +1,6 @@
 import typing
 
-from telegrinder.bot.cute_types import MessageCute
+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
@@ -12,7 +12,7 @@ class MessageReturnManager(BaseReturnManager[MessageCute]):
     async def str_manager(value: str, event: MessageCute, ctx: Context) -> None:
         await event.answer(value)
 
-    @register_manager(list | tuple)
+    @register_manager(list[str] | tuple[str, ...])
     @staticmethod
     async def seq_manager(
         value: list[str] | tuple[str, ...],
@@ -22,7 +22,7 @@ class MessageReturnManager(BaseReturnManager[MessageCute]):
         for message in value:
             await event.answer(message)
 
-    @register_manager(dict)
+    @register_manager(dict[str, typing.Any])
     @staticmethod
     async def dict_manager(value: dict[str, typing.Any], event: MessageCute, ctx: Context) -> None:
         await event.answer(**value)

telegrinder/bot/dispatch/view/__init__.py

@@ -1,4 +1,5 @@
-from telegrinder.bot.dispatch.view.abc import ABCStateView, ABCView, BaseStateView, BaseView
+from telegrinder.bot.dispatch.view.abc import ABCStateView, ABCView
+from telegrinder.bot.dispatch.view.base import BaseStateView, BaseView
 from telegrinder.bot.dispatch.view.box import ViewBox
 from telegrinder.bot.dispatch.view.callback_query import CallbackQueryView
 from telegrinder.bot.dispatch.view.chat_join_request import ChatJoinRequestView

telegrinder/bot/dispatch/view/abc.py

@@ -1,30 +1,12 @@
 import typing
 from abc import ABC, abstractmethod
-from functools import cached_property
 
-from fntypes.co import Nothing, Some
-
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.dispatch.handler.abc import ABCHandler
-from telegrinder.bot.dispatch.handler.func import FuncHandler
-from telegrinder.bot.dispatch.middleware.abc import ABCMiddleware
-from telegrinder.bot.dispatch.process import process_inner
-from telegrinder.bot.dispatch.return_manager.abc import ABCReturnManager
-from telegrinder.bot.rules.abc import ABCRule
-from telegrinder.model import Model
-from telegrinder.msgspec_utils import Option
-from telegrinder.tools.error_handler.error_handler import ABCErrorHandler, ErrorHandler
 from telegrinder.types.objects import Update
 
 Event = typing.TypeVar("Event", bound=BaseCute)
-ErrorHandlerT = typing.TypeVar("ErrorHandlerT", bound=ABCErrorHandler)
-MiddlewareT = typing.TypeVar("MiddlewareT", bound=ABCMiddleware)
-
-FuncType: typing.TypeAlias = typing.Callable[
-    typing.Concatenate[Event, ...],
-    typing.Coroutine[typing.Any, typing.Any, typing.Any],
-]
 
 
 class ABCView(ABC):
@@ -54,169 +36,8 @@ class ABCStateView(ABCView, typing.Generic[Event]):
         pass
 
 
-class BaseView(ABCView, typing.Generic[Event]):
-    auto_rules: list[ABCRule]
-    handlers: list[ABCHandler[Event]]
-    middlewares: list[ABCMiddleware[Event]]
-    return_manager: ABCReturnManager[Event] | None = None
-
-    @staticmethod
-    def get_raw_event(update: Update) -> Option[Model]:
-        return getattr(update, update.update_type.value)
-
-    @cached_property
-    def get_event_type(self) -> Option[type[Event]]:
-        for base in self.__class__.__dict__.get("__orig_bases__", ()):
-            if issubclass(typing.get_origin(base) or base, ABCView):
-                for generic_type in typing.get_args(base):
-                    if issubclass(typing.get_origin(generic_type) or generic_type, BaseCute):
-                        return Some(generic_type)
-        return Nothing()
-
-    @typing.overload
-    @classmethod
-    def to_handler(
-        cls,
-        *rules: ABCRule,
-    ) -> typing.Callable[
-        [FuncType[Event]],
-        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
-    ]: ...
-
-    @typing.overload
-    @classmethod
-    def to_handler(
-        cls,
-        *rules: ABCRule,
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[FuncType[Event]], FuncHandler[Event, FuncType[Event], ErrorHandlerT]]: ...
-
-    @typing.overload
-    @classmethod
-    def to_handler(
-        cls,
-        *rules: ABCRule,
-        error_handler: typing.Literal[None] = None,
-        is_blocking: bool = True,
-    ) -> typing.Callable[
-        [FuncType[Event]],
-        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
-    ]: ...
-
-    @classmethod
-    def to_handler(  # type: ignore
-        cls,
-        *rules: ABCRule,
-        error_handler: ABCErrorHandler | None = None,
-        is_blocking: bool = True,
-    ):
-        def wrapper(func: FuncType[Event]):
-            return FuncHandler(
-                func,
-                list(rules),
-                is_blocking=is_blocking,
-                dataclass=None,
-                error_handler=error_handler or ErrorHandler(),
-            )
-
-        return wrapper
-
-    @typing.overload
-    def __call__(
-        self,
-        *rules: ABCRule,
-    ) -> typing.Callable[
-        [FuncType[Event]],
-        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
-    ]: ...
-
-    @typing.overload
-    def __call__(  # type: ignore
-        self,
-        *rules: ABCRule,
-        error_handler: ErrorHandlerT,
-        is_blocking: bool = True,
-    ) -> typing.Callable[[FuncType[Event]], FuncHandler[Event, FuncType[Event], ErrorHandlerT]]: ...
-
-    @typing.overload
-    def __call__(
-        self,
-        *rules: ABCRule,
-        error_handler: typing.Literal[None] = None,
-        is_blocking: bool = True,
-    ) -> typing.Callable[
-        [FuncType[Event]],
-        FuncHandler[Event, FuncType[Event], ErrorHandler[Event]],
-    ]: ...
-
-    def __call__(  # type: ignore
-        self,
-        *rules: ABCRule,
-        error_handler: ABCErrorHandler | None = None,
-        is_blocking: bool = True,
-    ):
-        def wrapper(func: FuncType[Event]):
-            func_handler = FuncHandler(
-                func,
-                [*self.auto_rules, *rules],
-                is_blocking=is_blocking,
-                dataclass=None,
-                error_handler=error_handler or ErrorHandler(),
-            )
-            self.handlers.append(func_handler)
-            return func_handler
-
-        return wrapper
-
-    def register_middleware(self, *args: typing.Any, **kwargs: typing.Any):
-        def wrapper(cls: type[MiddlewareT]) -> type[MiddlewareT]:
-            self.middlewares.append(cls(*args, **kwargs))
-            return cls
-
-        return wrapper
-
-    async def check(self, event: Update) -> bool:
-        match self.get_raw_event(event):
-            case Some(e) if issubclass(
-                self.get_event_type.expect(
-                    "{!r} has no event type in generic.".format(self.__class__.__name__),
-                ),
-                e.__class__,
-            ) and (self.handlers or self.middlewares):
-                return True
-            case _:
-                return False
-
-    async def process(self, event: Update, api: API) -> bool:
-        return await process_inner(
-            api,
-            self.get_event_type.unwrap().from_update(
-                update=self.get_raw_event(event).unwrap(),
-                bound_api=api,
-            ),
-            event,
-            self.middlewares,
-            self.handlers,
-            self.return_manager,
-        )
-
-    def load(self, external: typing.Self) -> None:
-        self.auto_rules.extend(external.auto_rules)
-        self.handlers.extend(external.handlers)
-        self.middlewares.extend(external.middlewares)
-
-
-class BaseStateView(ABCStateView[Event], BaseView[Event], ABC, typing.Generic[Event]):
-    @abstractmethod
-    def get_state_key(self, event: Event) -> int | None:
-        pass
-
-
 __all__ = (
-    "ABCStateView",
     "ABCEventRawView",
+    "ABCStateView",
     "ABCView",
-    "BaseStateView",
-    "BaseView",
 )