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

telegrinder/bot/dispatch/return_manager/abc.py

@@ -1,112 +1,112 @@
-import dataclasses
-import types
-import typing
-from abc import ABC, abstractmethod
-
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.model import Model
-from telegrinder.modules import logger
-
-T = typing.TypeVar("T")
-Event = typing.TypeVar("Event", bound=Model, contravariant=True)
-
-
-def get_union_types(t: types.UnionType) -> tuple[type, ...] | None:
-    if type(t) in (types.UnionType, typing._UnionGenericAlias):  # type: ignore
-        return tuple(typing.get_origin(x) or x for x in typing.get_args(t))
-    return None
-
-
-def register_manager(return_type: type[typing.Any] | types.UnionType):
-    def wrapper(func: typing.Callable[..., typing.Awaitable[typing.Any]]):
-        return Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
-
-    return wrapper
-
-
-@dataclasses.dataclass(frozen=True, slots=True)
-class Manager:
-    types: tuple[type, ...]
-    callback: typing.Callable[..., typing.Awaitable[typing.Any]]
-
-    async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
-        await self.callback(*args, **kwargs)
-
-
-class ABCReturnManager(ABC, typing.Generic[Event]):
-    @abstractmethod
-    async def run(self, response: typing.Any, event: Event, ctx: Context) -> None:
-        pass
-
-
-class BaseReturnManager(ABCReturnManager[Event]):
-    def __repr__(self) -> str:
-        return "<{}: {}>".format(
-            self.__class__.__name__,
-            ", ".join(x.callback.__name__ + "=" + repr(x) for x in self.managers),
-        )
-
-    @property
-    def managers(self) -> list[Manager]:
-        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
-    async def ctx_manager(value: Context, event: Event, ctx: Context) -> None:
-        """Basic manager for returning context from handler."""
-
-        ctx.update(value)
-
-    async def run(self, response: typing.Any, event: Event, ctx: Context) -> None:
-        logger.debug("Run return manager for response: {!r}", response)
-        for manager in self.managers:
-            if typing.Any in manager.types or any(type(response) is x for x in manager.types):
-                logger.debug("Run manager {!r}...", manager.callback.__name__)
-                await manager(response, event, ctx)
-
-    @typing.overload
-    def register_manager(
-        self,
-        return_type: type[T],
-    ) -> typing.Callable[[typing.Callable[[T, Event, Context], typing.Awaitable[typing.Any]]], Manager]: ...
-
-    @typing.overload
-    def register_manager(
-        self,
-        return_type: tuple[type[T], ...],
-    ) -> typing.Callable[
-        [typing.Callable[[tuple[T, ...], Event, Context], typing.Awaitable[typing.Any]]],
-        Manager,
-    ]: ...
-
-    def register_manager(
-        self,
-        return_type: type[T] | tuple[type[T], ...],
-    ) -> typing.Callable[
-        [typing.Callable[[T | tuple[T, ...], Event, Context], typing.Awaitable[typing.Any]]],
-        Manager,
-    ]:
-        def wrapper(func: typing.Callable[[T, Event, Context], typing.Awaitable]) -> Manager:
-            manager = Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
-            self.managers.append(manager)
-            return manager
-
-        return wrapper
-
-
-__all__ = (
+import dataclasses
+import types
+import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.model import Model
+from telegrinder.modules import logger
+
+T = typing.TypeVar("T")
+Event = typing.TypeVar("Event", bound=Model, contravariant=True)
+
+
+def get_union_types(t: types.UnionType) -> tuple[type, ...] | None:
+    if type(t) in (types.UnionType, typing._UnionGenericAlias):  # type: ignore
+        return tuple(typing.get_origin(x) or x for x in typing.get_args(t))
+    return None
+
+
+def register_manager(return_type: type[typing.Any] | types.UnionType):
+    def wrapper(func: typing.Callable[..., typing.Awaitable[typing.Any]]):
+        return Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
+
+    return wrapper
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Manager:
+    types: tuple[type, ...]
+    callback: typing.Callable[..., typing.Awaitable[typing.Any]]
+
+    async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
+        await self.callback(*args, **kwargs)
+
+
+class ABCReturnManager(ABC, typing.Generic[Event]):
+    @abstractmethod
+    async def run(self, response: typing.Any, event: Event, ctx: Context) -> None:
+        pass
+
+
+class BaseReturnManager(ABCReturnManager[Event]):
+    def __repr__(self) -> str:
+        return "<{}: {}>".format(
+            self.__class__.__name__,
+            ", ".join(x.callback.__name__ + "=" + repr(x) for x in self.managers),
+        )
+
+    @property
+    def managers(self) -> list[Manager]:
+        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
+    async def ctx_manager(value: Context, event: Event, ctx: Context) -> None:
+        """Basic manager for returning context from handler."""
+
+        ctx.update(value)
+
+    async def run(self, response: typing.Any, event: Event, ctx: Context) -> None:
+        logger.debug("Run return manager for response: {!r}", response)
+        for manager in self.managers:
+            if typing.Any in manager.types or any(type(response) is x for x in manager.types):
+                logger.debug("Run manager {!r}...", manager.callback.__name__)
+                await manager(response, event, ctx)
+
+    @typing.overload
+    def register_manager(
+        self,
+        return_type: type[T],
+    ) -> typing.Callable[[typing.Callable[[T, Event, Context], typing.Awaitable[typing.Any]]], Manager]: ...
+
+    @typing.overload
+    def register_manager(
+        self,
+        return_type: tuple[type[T], ...],
+    ) -> typing.Callable[
+        [typing.Callable[[tuple[T, ...], Event, Context], typing.Awaitable[typing.Any]]],
+        Manager,
+    ]: ...
+
+    def register_manager(
+        self,
+        return_type: type[T] | tuple[type[T], ...],
+    ) -> typing.Callable[
+        [typing.Callable[[T | tuple[T, ...], Event, Context], typing.Awaitable[typing.Any]]],
+        Manager,
+    ]:
+        def wrapper(func: typing.Callable[[T, Event, Context], typing.Awaitable]) -> Manager:
+            manager = Manager(get_union_types(return_type) or (return_type,), func)  # type: ignore
+            self.managers.append(manager)
+            return manager
+
+        return wrapper
+
+
+__all__ = (
     "ABCReturnManager",
     "BaseReturnManager",
     "Manager",
     "get_union_types",
-    "register_manager",
-)
+    "register_manager",
+)

telegrinder/bot/dispatch/return_manager/callback_query.py

@@ -1,20 +1,20 @@
-import typing
-
-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
-
-
-class CallbackQueryReturnManager(BaseReturnManager[CallbackQueryCute]):
-    @register_manager(str)
-    @staticmethod
-    async def str_manager(value: str, event: CallbackQueryCute, ctx: Context) -> None:
-        await event.answer(value)
-
-    @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)
-
-
-__all__ = ("CallbackQueryReturnManager",)
+import typing
+
+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
+
+
+class CallbackQueryReturnManager(BaseReturnManager[CallbackQueryCute]):
+    @register_manager(str)
+    @staticmethod
+    async def str_manager(value: str, event: CallbackQueryCute, ctx: Context) -> None:
+        await event.answer(value)
+
+    @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)
+
+
+__all__ = ("CallbackQueryReturnManager",)

telegrinder/bot/dispatch/return_manager/inline_query.py

@@ -1,15 +1,15 @@
-import typing
-
-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[str, typing.Any])
-    @staticmethod
-    async def dict_manager(value: dict[str, typing.Any], event: InlineQueryCute, ctx: Context) -> None:
-        await event.answer(**value)
-
-
-__all__ = ("InlineQueryReturnManager",)
+import typing
+
+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[str, typing.Any])
+    @staticmethod
+    async def dict_manager(value: dict[str, typing.Any], event: InlineQueryCute, ctx: Context) -> None:
+        await event.answer(**value)
+
+
+__all__ = ("InlineQueryReturnManager",)

telegrinder/bot/dispatch/return_manager/message.py

@@ -1,36 +1,36 @@
-import typing
-
-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
-
-
-class MessageReturnManager(BaseReturnManager[MessageCute]):
-    @register_manager(str)
-    @staticmethod
-    async def str_manager(value: str, event: MessageCute, ctx: Context) -> None:
-        await event.answer(value)
-
-    @register_manager(list[str] | tuple[str, ...])
-    @staticmethod
-    async def seq_manager(
-        value: list[str] | tuple[str, ...],
-        event: MessageCute,
-        ctx: Context,
-    ) -> None:
-        for message in value:
-            await event.answer(message)
-
-    @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)
-
-    @register_manager(HTMLFormatter)
-    @staticmethod
-    async def htmlformatter_manager(value: HTMLFormatter, event: MessageCute, ctx: Context) -> None:
-        await event.answer(value, parse_mode=HTMLFormatter.PARSE_MODE)
-
-
-__all__ = ("MessageReturnManager",)
+import typing
+
+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
+
+
+class MessageReturnManager(BaseReturnManager[MessageCute]):
+    @register_manager(str)
+    @staticmethod
+    async def str_manager(value: str, event: MessageCute, ctx: Context) -> None:
+        await event.answer(value)
+
+    @register_manager(list[str] | tuple[str, ...])
+    @staticmethod
+    async def seq_manager(
+        value: list[str] | tuple[str, ...],
+        event: MessageCute,
+        ctx: Context,
+    ) -> None:
+        for message in value:
+            await event.answer(message)
+
+    @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)
+
+    @register_manager(HTMLFormatter)
+    @staticmethod
+    async def htmlformatter_manager(value: HTMLFormatter, event: MessageCute, ctx: Context) -> None:
+        await event.answer(value, parse_mode=HTMLFormatter.PARSE_MODE)
+
+
+__all__ = ("MessageReturnManager",)

telegrinder/bot/dispatch/view/__init__.py

@@ -1,14 +1,14 @@
-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
-from telegrinder.bot.dispatch.view.chat_member import ChatMemberView
-from telegrinder.bot.dispatch.view.inline_query import InlineQueryView
-from telegrinder.bot.dispatch.view.message import MessageView
-from telegrinder.bot.dispatch.view.raw import RawEventView
-
-__all__ = (
+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
+from telegrinder.bot.dispatch.view.chat_member import ChatMemberView
+from telegrinder.bot.dispatch.view.inline_query import InlineQueryView
+from telegrinder.bot.dispatch.view.message import MessageView
+from telegrinder.bot.dispatch.view.raw import RawEventView
+
+__all__ = (
     "ABCStateView",
     "ABCView",
     "BaseStateView",
@@ -19,5 +19,5 @@ __all__ = (
     "InlineQueryView",
     "MessageView",
     "RawEventView",
-    "ViewBox",
-)
+    "ViewBox",
+)

telegrinder/bot/dispatch/view/abc.py

@@ -1,43 +1,43 @@
-import typing
-from abc import ABC, abstractmethod
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.base import BaseCute
-from telegrinder.bot.dispatch.handler.abc import ABCHandler
-from telegrinder.types.objects import Update
-
-Event = typing.TypeVar("Event", bound=BaseCute)
-
-
-class ABCView(ABC):
-    def __repr__(self) -> str:
-        return "<{}>".format(self.__class__.__name__)
-
-    @abstractmethod
-    async def check(self, event: Update) -> bool:
-        pass
-
-    @abstractmethod
-    async def process(self, event: Update, api: API) -> bool:
-        pass
-
-    @abstractmethod
-    def load(self, external: typing.Self) -> None:
-        pass
-
-
-class ABCEventRawView(ABCView, ABC, typing.Generic[Event]):
-    handlers: list[ABCHandler[Event]]
-
-
-class ABCStateView(ABCView, typing.Generic[Event]):
-    @abstractmethod
-    def get_state_key(self, event: Event) -> int | None:
-        pass
-
-
-__all__ = (
+import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.dispatch.handler.abc import ABCHandler
+from telegrinder.types.objects import Update
+
+Event = typing.TypeVar("Event", bound=BaseCute)
+
+
+class ABCView(ABC):
+    def __repr__(self) -> str:
+        return "<{}>".format(self.__class__.__name__)
+
+    @abstractmethod
+    async def check(self, event: Update) -> bool:
+        pass
+
+    @abstractmethod
+    async def process(self, event: Update, api: API) -> bool:
+        pass
+
+    @abstractmethod
+    def load(self, external: typing.Self) -> None:
+        pass
+
+
+class ABCEventRawView(ABCView, ABC, typing.Generic[Event]):
+    handlers: list[ABCHandler[Event]]
+
+
+class ABCStateView(ABCView, typing.Generic[Event]):
+    @abstractmethod
+    def get_state_key(self, event: Event) -> int | None:
+        pass
+
+
+__all__ = (
     "ABCEventRawView",
     "ABCStateView",
-    "ABCView",
-)
+    "ABCView",
+)