telegrinder 0.3.0.post2__py3-none-any.whl → 0.3.2__py3-none-any.whl

telegrinder/bot/cute_types/update.py

@@ -1,75 +1,75 @@
-import typing
-from functools import cached_property
-
-from fntypes.co import Nothing, Some
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.base import BaseCute
-from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
-from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
-from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
-from telegrinder.bot.cute_types.inline_query import InlineQueryCute
-from telegrinder.bot.cute_types.message import MessageCute
-from telegrinder.msgspec_utils import Option
-from telegrinder.types.objects import *
-
-EventModel = typing.TypeVar("EventModel", bound=Model)
-
-
-class UpdateCute(BaseCute[Update], Update, kw_only=True):
-    api: API
-
-    message: Option[MessageCute] = Nothing()
-    """Optional. New incoming message of any kind - text, photo, sticker, etc."""
-
-    edited_message: Option[MessageCute] = Nothing()
-    """Optional. New version of a message that is known to the bot and was edited.
-    This update may at times be triggered by changes to message fields that are
-    either unavailable or not actively used by your bot."""
-
-    channel_post: Option[MessageCute] = Nothing()
-    """Optional. New incoming channel post of any kind - text, photo, sticker,
-    etc."""
-
-    edited_channel_post: Option[MessageCute] = Nothing()
-    """Optional. New version of a channel post that is known to the bot and was edited.
-    This update may at times be triggered by changes to message fields that are
-    either unavailable or not actively used by your bot."""
-
-    business_message: Option[MessageCute] = Nothing()
-    """Optional. New message from a connected business account."""
-
-    edited_business_message: Option[MessageCute] = Nothing()
-    """Optional. New version of a message from a connected business account."""
-
-    inline_query: Option[InlineQueryCute] = Nothing()
-    """Optional. New incoming inline query."""
-
-    callback_query: Option[CallbackQueryCute] = Nothing()
-    """Optional. New incoming callback query."""
-
-    my_chat_member: Option[ChatMemberUpdatedCute] = Nothing()
-    """Optional. The bot's chat member status was updated in a chat. For private
-    chats, this update is received only when the bot is blocked or unblocked
-    by the user."""
-
-    chat_member: Option[ChatMemberUpdatedCute] = Nothing()
-    """Optional. A chat member's status was updated in a chat. The bot must be an
-    administrator in the chat and must explicitly specify `chat_member` in
-    the list of allowed_updates to receive these updates."""
-
-    chat_join_request: Option[ChatJoinRequestCute] = Nothing()
-    """Optional. A request to join the chat has been sent. The bot must have the can_invite_users
-    administrator right in the chat to receive these updates."""
-
-    @cached_property
-    def incoming_update(self) -> Model:
-        return getattr(self, self.update_type.value).unwrap()
-
-    def get_event(self, event_model: type[EventModel]) -> Option[EventModel]:
-        if isinstance(self.incoming_update, event_model):
-            return Some(self.incoming_update)
-        return Nothing()
-
-
-__all__ = ("UpdateCute",)
+import typing
+from functools import cached_property
+
+from fntypes.co import Nothing, Some
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
+from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
+from telegrinder.bot.cute_types.inline_query import InlineQueryCute
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.msgspec_utils import Option
+from telegrinder.types.objects import *
+
+EventModel = typing.TypeVar("EventModel", bound=Model)
+
+
+class UpdateCute(BaseCute[Update], Update, kw_only=True):
+    api: API
+
+    message: Option[MessageCute] = Nothing()
+    """Optional. New incoming message of any kind - text, photo, sticker, etc."""
+
+    edited_message: Option[MessageCute] = Nothing()
+    """Optional. New version of a message that is known to the bot and was edited.
+    This update may at times be triggered by changes to message fields that are
+    either unavailable or not actively used by your bot."""
+
+    channel_post: Option[MessageCute] = Nothing()
+    """Optional. New incoming channel post of any kind - text, photo, sticker,
+    etc."""
+
+    edited_channel_post: Option[MessageCute] = Nothing()
+    """Optional. New version of a channel post that is known to the bot and was edited.
+    This update may at times be triggered by changes to message fields that are
+    either unavailable or not actively used by your bot."""
+
+    business_message: Option[MessageCute] = Nothing()
+    """Optional. New message from a connected business account."""
+
+    edited_business_message: Option[MessageCute] = Nothing()
+    """Optional. New version of a message from a connected business account."""
+
+    inline_query: Option[InlineQueryCute] = Nothing()
+    """Optional. New incoming inline query."""
+
+    callback_query: Option[CallbackQueryCute] = Nothing()
+    """Optional. New incoming callback query."""
+
+    my_chat_member: Option[ChatMemberUpdatedCute] = Nothing()
+    """Optional. The bot's chat member status was updated in a chat. For private
+    chats, this update is received only when the bot is blocked or unblocked
+    by the user."""
+
+    chat_member: Option[ChatMemberUpdatedCute] = Nothing()
+    """Optional. A chat member's status was updated in a chat. The bot must be an
+    administrator in the chat and must explicitly specify `chat_member` in
+    the list of allowed_updates to receive these updates."""
+
+    chat_join_request: Option[ChatJoinRequestCute] = Nothing()
+    """Optional. A request to join the chat has been sent. The bot must have the can_invite_users
+    administrator right in the chat to receive these updates."""
+
+    @cached_property
+    def incoming_update(self) -> Model:
+        return getattr(self, self.update_type.value).unwrap()
+
+    def get_event(self, event_model: type[EventModel]) -> Option[EventModel]:
+        if isinstance(self.incoming_update, event_model):
+            return Some(self.incoming_update)
+        return Nothing()
+
+
+__all__ = ("UpdateCute",)

telegrinder/bot/cute_types/utils.py

@@ -1,95 +1,95 @@
-import typing
-
-from telegrinder.model import get_params
-from telegrinder.types.objects import (
-    InputFile,
-    InputMediaAnimation,
-    InputMediaAudio,
-    InputMediaDocument,
-    InputMediaPhoto,
-    InputMediaVideo,
-    LinkPreviewOptions,
-    MessageEntity,
-    ReactionEmoji,
-    ReactionType,
-    ReactionTypeEmoji,
-    ReplyParameters,
-)
-
-InputMedia: typing.TypeAlias = typing.Union[
-    InputMediaAnimation,
-    InputMediaAudio,
-    InputMediaDocument,
-    InputMediaPhoto,
-    InputMediaVideo,
-]
-
-INPUT_MEDIA_TYPES: typing.Final[dict[str, type[InputMedia]]] = {
-    "animation": InputMediaAnimation,
-    "audio": InputMediaAudio,
-    "document": InputMediaDocument,
-    "photo": InputMediaPhoto,
-    "video": InputMediaVideo,
-}
-
-
-def compose_reactions(
-    reactions: str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType],
-    /,
-) -> list[ReactionType]:
-    if not isinstance(reactions, list):
-        reactions = [reactions]
-    return [
-        (
-            ReactionTypeEmoji("emoji", emoji)
-            if isinstance(emoji, ReactionEmoji)
-            else (ReactionTypeEmoji("emoji", ReactionEmoji(emoji)) if isinstance(emoji, str) else emoji)
-        )
-        for emoji in ([reactions] if isinstance(reactions, str) else reactions)  # type: ignore
-    ]
-
-
-def compose_reply_params(
-    message_id: int | None,
-    chat_id: int | str | None,
-    *,
-    allow_sending_without_reply: bool | None = None,
-    quote: str | None = None,
-    quote_parse_mode: str | None = None,
-    quote_entities: list[MessageEntity] | None = None,
-    quote_position: int | None = None,
-    **other: typing.Any,
-) -> ReplyParameters:
-    return ReplyParameters(**get_params(locals()))
-
-
-def compose_link_preview_options(
-    *,
-    is_disabled: bool | None = None,
-    url: str | None = None,
-    prefer_small_media: bool | None = None,
-    prefer_large_media: bool | None = None,
-    show_above_text: bool | None = None,
-    **other: typing.Any,
-) -> LinkPreviewOptions:
-    return LinkPreviewOptions(**get_params(locals()))
-
-
-def input_media(
-    type: typing.Literal["animation", "audio", "document", "photo", "video"],
-    media: str | InputFile,
-    *,
-    caption: str | None = None,
-    parse_mode: str | None = None,
-    caption_entities: list[MessageEntity] | None = None,
-    **other: typing.Any,
-) -> InputMedia:
-    return INPUT_MEDIA_TYPES[type](**get_params(locals()))
-
-
-__all__ = (
+import typing
+
+from telegrinder.model import get_params
+from telegrinder.types.objects import (
+    InputFile,
+    InputMediaAnimation,
+    InputMediaAudio,
+    InputMediaDocument,
+    InputMediaPhoto,
+    InputMediaVideo,
+    LinkPreviewOptions,
+    MessageEntity,
+    ReactionEmoji,
+    ReactionType,
+    ReactionTypeEmoji,
+    ReplyParameters,
+)
+
+InputMedia: typing.TypeAlias = typing.Union[
+    InputMediaAnimation,
+    InputMediaAudio,
+    InputMediaDocument,
+    InputMediaPhoto,
+    InputMediaVideo,
+]
+
+INPUT_MEDIA_TYPES: typing.Final[dict[str, type[InputMedia]]] = {
+    "animation": InputMediaAnimation,
+    "audio": InputMediaAudio,
+    "document": InputMediaDocument,
+    "photo": InputMediaPhoto,
+    "video": InputMediaVideo,
+}
+
+
+def compose_reactions(
+    reactions: str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType],
+    /,
+) -> list[ReactionType]:
+    if not isinstance(reactions, list):
+        reactions = [reactions]
+    return [
+        (
+            ReactionTypeEmoji("emoji", emoji)
+            if isinstance(emoji, ReactionEmoji)
+            else (ReactionTypeEmoji("emoji", ReactionEmoji(emoji)) if isinstance(emoji, str) else emoji)
+        )
+        for emoji in ([reactions] if isinstance(reactions, str) else reactions)  # type: ignore
+    ]
+
+
+def compose_reply_params(
+    message_id: int | None,
+    chat_id: int | str | None,
+    *,
+    allow_sending_without_reply: bool | None = None,
+    quote: str | None = None,
+    quote_parse_mode: str | None = None,
+    quote_entities: list[MessageEntity] | None = None,
+    quote_position: int | None = None,
+    **other: typing.Any,
+) -> ReplyParameters:
+    return ReplyParameters(**get_params(locals()))
+
+
+def compose_link_preview_options(
+    *,
+    is_disabled: bool | None = None,
+    url: str | None = None,
+    prefer_small_media: bool | None = None,
+    prefer_large_media: bool | None = None,
+    show_above_text: bool | None = None,
+    **other: typing.Any,
+) -> LinkPreviewOptions:
+    return LinkPreviewOptions(**get_params(locals()))
+
+
+def input_media(
+    type: typing.Literal["animation", "audio", "document", "photo", "video"],
+    media: str | InputFile,
+    *,
+    caption: str | None = None,
+    parse_mode: str | None = None,
+    caption_entities: list[MessageEntity] | None = None,
+    **other: typing.Any,
+) -> InputMedia:
+    return INPUT_MEDIA_TYPES[type](**get_params(locals()))
+
+
+__all__ = (
     "compose_link_preview_options",
     "compose_reactions",
     "compose_reply_params",
-    "input_media",
-)
+    "input_media",
+)

telegrinder/bot/dispatch/__init__.py

@@ -1,56 +1,56 @@
-from telegrinder.bot.dispatch.abc import ABCDispatch
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.dispatch.dispatch import Dispatch, TelegrinderContext
-from telegrinder.bot.dispatch.handler import (
-    ABCHandler,
-    AudioReplyHandler,
-    DocumentReplyHandler,
-    FuncHandler,
-    MediaGroupReplyHandler,
-    MessageReplyHandler,
-    PhotoReplyHandler,
-    StickerReplyHandler,
-    VideoReplyHandler,
-)
-from telegrinder.bot.dispatch.middleware import ABCMiddleware
-from telegrinder.bot.dispatch.process import check_rule, process_inner
-from telegrinder.bot.dispatch.return_manager import (
-    ABCReturnManager,
-    BaseReturnManager,
-    CallbackQueryReturnManager,
-    InlineQueryReturnManager,
-    Manager,
-    MessageReturnManager,
-    register_manager,
-)
-from telegrinder.bot.dispatch.view import (
-    ABCStateView,
-    ABCView,
-    BaseStateView,
-    BaseView,
-    CallbackQueryView,
-    ChatJoinRequestView,
-    ChatMemberView,
-    InlineQueryView,
-    MessageView,
-    RawEventView,
-    ViewBox,
-)
-from telegrinder.bot.dispatch.waiter_machine import (
-    CALLBACK_QUERY_FOR_MESSAGE,
-    CALLBACK_QUERY_FROM_CHAT,
-    CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE,
-    MESSAGE_FROM_USER,
-    MESSAGE_FROM_USER_IN_CHAT,
-    MESSAGE_IN_CHAT,
-    Hasher,
-    ShortState,
-    StateViewHasher,
-    WaiterMachine,
-    clear_wm_storage_worker,
-)
-
-__all__ = (
+from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.dispatch import Dispatch, TelegrinderContext
+from telegrinder.bot.dispatch.handler import (
+    ABCHandler,
+    AudioReplyHandler,
+    DocumentReplyHandler,
+    FuncHandler,
+    MediaGroupReplyHandler,
+    MessageReplyHandler,
+    PhotoReplyHandler,
+    StickerReplyHandler,
+    VideoReplyHandler,
+)
+from telegrinder.bot.dispatch.middleware import ABCMiddleware
+from telegrinder.bot.dispatch.process import check_rule, process_inner
+from telegrinder.bot.dispatch.return_manager import (
+    ABCReturnManager,
+    BaseReturnManager,
+    CallbackQueryReturnManager,
+    InlineQueryReturnManager,
+    Manager,
+    MessageReturnManager,
+    register_manager,
+)
+from telegrinder.bot.dispatch.view import (
+    ABCStateView,
+    ABCView,
+    BaseStateView,
+    BaseView,
+    CallbackQueryView,
+    ChatJoinRequestView,
+    ChatMemberView,
+    InlineQueryView,
+    MessageView,
+    RawEventView,
+    ViewBox,
+)
+from telegrinder.bot.dispatch.waiter_machine import (
+    CALLBACK_QUERY_FOR_MESSAGE,
+    CALLBACK_QUERY_FROM_CHAT,
+    CALLBACK_QUERY_IN_CHAT_FOR_MESSAGE,
+    MESSAGE_FROM_USER,
+    MESSAGE_FROM_USER_IN_CHAT,
+    MESSAGE_IN_CHAT,
+    Hasher,
+    ShortState,
+    StateViewHasher,
+    WaiterMachine,
+    clear_wm_storage_worker,
+)
+
+__all__ = (
     "ABCDispatch",
     "ABCHandler",
     "ABCMiddleware",
@@ -96,5 +96,5 @@ __all__ = (
     "clear_wm_storage_worker",
     "clear_wm_storage_worker",
     "process_inner",
-    "register_manager",
-)
+    "register_manager",
+)

telegrinder/bot/dispatch/abc.py

@@ -1,77 +1,77 @@
-import importlib.util as importlib_util
-import os
-import pathlib
-import sys
-import typing
-from abc import ABC, abstractmethod
-
-from fntypes.option import Option
-
-from telegrinder.api.api import API
-from telegrinder.tools.global_context.abc import ABCGlobalContext
-from telegrinder.types.objects import Update
-
-T = typing.TypeVar("T")
-
-
-class PathExistsError(BaseException):
-    pass
-
-
-class ABCDispatch(ABC):
-    @property
-    @abstractmethod
-    def global_context(self) -> ABCGlobalContext:
-        pass
-
-    @abstractmethod
-    async def feed(self, event: Update, api: API) -> bool:
-        pass
-
-    @abstractmethod
-    def load(self, external: typing.Self) -> None:
-        pass
-
-    @abstractmethod
-    def get_view(self, of_type: type[T]) -> Option[T]:
-        pass
-
-    def load_many(self, *externals: typing.Self) -> None:
-        for external in externals:
-            self.load(external)
-
-    def load_from_dir(self, directory: str | pathlib.Path) -> bool:
-        """Loads dispatchers from a directory containing Python modules where global variables
-        are declared with instances of dispatch.
-        Returns True if dispatchers were found, otherwise False."""
-
-        directory = pathlib.Path(directory)
-
-        if not directory.exists():
-            raise PathExistsError(f"Path {str(directory)!r} does not exists.")
-
-        dps: list[typing.Self] = []
-        for root, _, files in os.walk(directory):
-            for f in files:
-                if f.endswith(".py") and f != "__init__.py":
-                    module_path = os.path.join(root, f)
-                    module_name = os.path.splitext(os.path.relpath(module_path, directory))[0]
-                    module_name = module_name.replace(os.sep, ".")
-
-                    spec = importlib_util.spec_from_file_location(module_name, module_path)
-                    if spec is None or spec.loader is None:
-                        continue
-
-                    module = importlib_util.module_from_spec(spec)
-                    sys.modules[module_name] = module
-                    spec.loader.exec_module(module)
-
-                    for obj in module.__dict__.values():
-                        if isinstance(obj, self.__class__):
-                            dps.append(obj)
-
-        self.load_many(*dps)
-        return bool(dps)
-
-
-__all__ = ("ABCDispatch",)
+import importlib.util as importlib_util
+import os
+import pathlib
+import sys
+import typing
+from abc import ABC, abstractmethod
+
+from fntypes.option import Option
+
+from telegrinder.api.api import API
+from telegrinder.tools.global_context.abc import ABCGlobalContext
+from telegrinder.types.objects import Update
+
+T = typing.TypeVar("T")
+
+
+class PathExistsError(BaseException):
+    pass
+
+
+class ABCDispatch(ABC):
+    @property
+    @abstractmethod
+    def global_context(self) -> ABCGlobalContext:
+        pass
+
+    @abstractmethod
+    async def feed(self, event: Update, api: API) -> bool:
+        pass
+
+    @abstractmethod
+    def load(self, external: typing.Self) -> None:
+        pass
+
+    @abstractmethod
+    def get_view(self, of_type: type[T]) -> Option[T]:
+        pass
+
+    def load_many(self, *externals: typing.Self) -> None:
+        for external in externals:
+            self.load(external)
+
+    def load_from_dir(self, directory: str | pathlib.Path) -> bool:
+        """Loads dispatchers from a directory containing Python modules where global variables
+        are declared with instances of dispatch.
+        Returns True if dispatchers were found, otherwise False."""
+
+        directory = pathlib.Path(directory)
+
+        if not directory.exists():
+            raise PathExistsError(f"Path {str(directory)!r} does not exists.")
+
+        dps: list[typing.Self] = []
+        for root, _, files in os.walk(directory):
+            for f in files:
+                if f.endswith(".py") and f != "__init__.py":
+                    module_path = os.path.join(root, f)
+                    module_name = os.path.splitext(os.path.relpath(module_path, directory))[0]
+                    module_name = module_name.replace(os.sep, ".")
+
+                    spec = importlib_util.spec_from_file_location(module_name, module_path)
+                    if spec is None or spec.loader is None:
+                        continue
+
+                    module = importlib_util.module_from_spec(spec)
+                    sys.modules[module_name] = module
+                    spec.loader.exec_module(module)
+
+                    for obj in module.__dict__.values():
+                        if isinstance(obj, self.__class__):
+                            dps.append(obj)
+
+        self.load_many(*dps)
+        return bool(dps)
+
+
+__all__ = ("ABCDispatch",)