telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/bot/cute_types/message_reaction_count_updated.py

@@ -0,0 +1,9 @@
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.types.objects import MessageReactionCountUpdated
+
+
+class MessageReactionCountUpdatedCute(BaseCute[MessageReactionCountUpdated], MessageReactionCountUpdated, kw_only=True):
+    pass
+
+
+__all__ = ("MessageReactionCountUpdatedCute",)

telegrinder/bot/cute_types/message_reaction_updated.py

@@ -0,0 +1,9 @@
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.types.objects import MessageReactionUpdated
+
+
+class MessageReactionUpdatedCute(BaseCute[MessageReactionUpdated], MessageReactionUpdated, kw_only=True):
+    pass
+
+
+__all__ = ("MessageReactionUpdatedCute",)

telegrinder/bot/cute_types/paid_media_purchased.py

@@ -0,0 +1,11 @@
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.types.objects import PaidMediaPurchased, User
+
+
+class PaidMediaPurchasedCute(BaseCute[PaidMediaPurchased], PaidMediaPurchased, kw_only=True):
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+
+__all__ = ("PaidMediaPurchasedCute",)

telegrinder/bot/cute_types/poll.py

@@ -0,0 +1,9 @@
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.types.objects import Poll
+
+
+class PollCute(BaseCute[Poll], Poll, kw_only=True):
+    pass
+
+
+__all__ = ("PollCute",)

telegrinder/bot/cute_types/poll_answer.py

@@ -0,0 +1,9 @@
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.types.objects import PollAnswer
+
+
+class PollAnswerCute(BaseCute[PollAnswer], PollAnswer, kw_only=True):
+    pass
+
+
+__all__ = ("PollAnswerCute",)

telegrinder/bot/cute_types/pre_checkout_query.py

@@ -0,0 +1,36 @@
+import typing
+
+from kungfu.library.monad.result import Result
+
+from telegrinder.api.error import APIError
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
+from telegrinder.types.methods_utils import get_params
+from telegrinder.types.objects import PreCheckoutQuery, User
+
+
+class PreCheckoutQueryCute(BaseCute[PreCheckoutQuery], PreCheckoutQuery, kw_only=True):
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+    @shortcut("answer_pre_checkout_query", custom_params={"pre_checkout_query_id"})
+    async def answer(
+        self,
+        ok: bool,
+        *,
+        error_message: str | None = None,
+        pre_checkout_query_id: str | None = None,
+        **other: typing.Any,
+    ) -> Result[bool, APIError]:
+        """Shortcut `API.answer_pre_checkout_query()`, see the [documentation](https://core.telegram.org/bots/api#answerprecheckoutquery)
+
+        Once the user has confirmed their payment and shipping details, the Bot
+        API sends the final confirmation in the form of an Update with the field pre_checkout_query.
+        Use this method to respond to such pre-checkout queries. On success, True
+        is returned. Note: The Bot API must receive an answer within 10 seconds after
+        the pre-checkout query was sent."""
+        params = compose_method_params(get_params(locals()), self, default_params={("pre_checkout_query_id", "id")})
+        return await self.ctx_api.answer_pre_checkout_query(**params)
+
+
+__all__ = ("PreCheckoutQueryCute",)

telegrinder/bot/cute_types/shipping_query.py

@@ -0,0 +1,11 @@
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.types.objects import ShippingQuery, User
+
+
+class ShippingQueryCute(BaseCute[ShippingQuery], ShippingQuery, kw_only=True):
+    @property
+    def from_user(self) -> User:
+        return self.from_
+
+
+__all__ = ("ShippingQueryCute",)

telegrinder/bot/cute_types/update.py

@@ -0,0 +1,209 @@
+from functools import cached_property
+
+from kungfu.library.monad.option import NOTHING, Some
+
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.cute_types.business_connection import BusinessConnectionCute
+from telegrinder.bot.cute_types.business_messages_deleted import BusinessMessagesDeletedCute
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.bot.cute_types.chat_boost_removed import ChatBoostRemovedCute
+from telegrinder.bot.cute_types.chat_boost_updated import ChatBoostUpdatedCute
+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.chosen_inline_result import ChosenInlineResultCute
+from telegrinder.bot.cute_types.inline_query import InlineQueryCute
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.bot.cute_types.message_reaction_count_updated import MessageReactionCountUpdatedCute
+from telegrinder.bot.cute_types.message_reaction_updated import MessageReactionUpdatedCute
+from telegrinder.bot.cute_types.paid_media_purchased import PaidMediaPurchasedCute
+from telegrinder.bot.cute_types.poll import PollCute
+from telegrinder.bot.cute_types.poll_answer import PollAnswerCute
+from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
+from telegrinder.bot.cute_types.shipping_query import ShippingQueryCute
+from telegrinder.model import From, field
+from telegrinder.msgspec_utils import Option
+from telegrinder.types.objects import *
+
+
+class UpdateCute(BaseCute[Update], Update, kw_only=True):
+    """Cute version of the object [Update](https://core.telegram.org/bots/api#update).
+
+    This object represents a `cute` incoming update.
+    At most one of the optional parameters can be present in any given cute update.
+    """
+
+    message: Option[MessageCute] = field(
+        default=...,
+        converter=From[MessageCute | None],
+    )
+    """Optional. New incoming message of any kind - text, photo, sticker, etc."""
+
+    edited_message: Option[MessageCute] = field(
+        default=...,
+        converter=From[MessageCute | None],
+    )
+    """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] = field(
+        default=...,
+        converter=From[MessageCute | None],
+    )
+    """Optional. New incoming channel post of any kind - text, photo, sticker,
+    etc."""
+
+    edited_channel_post: Option[MessageCute] = field(
+        default=...,
+        converter=From[MessageCute | None],
+    )
+    """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_connection: Option[BusinessConnectionCute] = field(
+        default=...,
+        converter=From["BusinessConnectionCute | None"],
+    )
+    """Optional. The bot was connected to or disconnected from a business account,
+    or a user edited an existing connection with the bot."""
+
+    business_message: Option[MessageCute] = field(
+        default=...,
+        converter=From[MessageCute | None],
+    )
+    """Optional. New message from a connected business account."""
+
+    edited_business_message: Option[MessageCute] = field(
+        default=...,
+        converter=From[MessageCute | None],
+    )
+    """Optional. New version of a message from a connected business account."""
+
+    deleted_business_messages: Option[BusinessMessagesDeletedCute] = field(
+        default=...,
+        converter=From["BusinessMessagesDeletedCute | None"],
+    )
+    """Optional. Messages were deleted from a connected business account."""
+
+    message_reaction: Option[MessageReactionUpdatedCute] = field(
+        default=...,
+        converter=From["MessageReactionUpdatedCute | None"],
+    )
+    """Optional. A reaction to a message was changed by a user. The bot must be an
+    administrator in the chat and must explicitly specify `message_reaction`
+    in the list of allowed_updates to receive these updates. The update isn't
+    received for reactions set by bots."""
+
+    message_reaction_count: Option[MessageReactionCountUpdatedCute] = field(
+        default=...,
+        converter=From["MessageReactionCountUpdatedCute | None"],
+    )
+    """Optional. Reactions to a message with anonymous reactions were changed.
+    The bot must be an administrator in the chat and must explicitly specify
+    `message_reaction_count` in the list of allowed_updates to receive these
+    updates. The updates are grouped and can be sent with delay up to a few minutes."""
+
+    inline_query: Option[InlineQueryCute] = field(
+        default=...,
+        converter=From[InlineQueryCute | None],
+    )
+    """Optional. New incoming inline query."""
+
+    chosen_inline_result: Option[ChosenInlineResultCute] = field(
+        default=...,
+        converter=From["ChosenInlineResultCute | None"],
+    )
+    """Optional. The result of an inline query that was chosen by a user and sent
+    to their chat partner. Please see our documentation on the feedback collecting
+    for details on how to enable these updates for your bot."""
+
+    callback_query: Option[CallbackQueryCute] = field(
+        default=...,
+        converter=From[CallbackQueryCute | None],
+    )
+    """Optional. New incoming callback query."""
+
+    shipping_query: Option[ShippingQueryCute] = field(
+        default=...,
+        converter=From[ShippingQueryCute | None],
+    )
+    """Optional. New incoming shipping query. Only for invoices with flexible
+    price."""
+
+    pre_checkout_query: Option[PreCheckoutQueryCute] = field(
+        default=...,
+        converter=From[PreCheckoutQueryCute | None],
+    )
+    """Optional. New incoming pre-checkout query. Contains full information
+    about checkout."""
+
+    purchased_paid_media: Option[PaidMediaPurchasedCute] = field(
+        default=...,
+        converter=From["PaidMediaPurchasedCute | None"],
+    )
+    """Optional. A user purchased paid media with a non-empty payload sent by the
+    bot in a non-channel chat."""
+
+    poll: Option[PollCute] = field(
+        default=...,
+        converter=From["PollCute | None"],
+    )
+    """Optional. New poll state. Bots receive only updates about manually stopped
+    polls and polls, which are sent by the bot."""
+
+    poll_answer: Option[PollAnswerCute] = field(
+        default=...,
+        converter=From["PollAnswerCute | None"],
+    )
+    """Optional. A user changed their answer in a non-anonymous poll. Bots receive
+    new votes only in polls that were sent by the bot itself."""
+
+    my_chat_member: Option[ChatMemberUpdatedCute] = field(
+        default=...,
+        converter=From[ChatMemberUpdatedCute | None],
+    )
+    """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] = field(
+        default=...,
+        converter=From[ChatMemberUpdatedCute | None],
+    )
+    """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] = field(
+        default=...,
+        converter=From[ChatJoinRequestCute | None],
+    )
+    """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."""
+
+    chat_boost: Option[ChatBoostUpdatedCute] = field(
+        default=...,
+        converter=From["ChatBoostUpdatedCute | None"],
+    )
+    """Optional. A chat boost was added or changed. The bot must be an administrator
+    in the chat to receive these updates."""
+
+    removed_chat_boost: Option[ChatBoostRemovedCute] = field(
+        default=...,
+        converter=From["ChatBoostRemovedCute | None"],
+    )
+    """Optional. A boost was removed from a chat. The bot must be an administrator
+    in the chat to receive these updates."""
+
+    @cached_property
+    def incoming_update(self) -> BaseCute:
+        return getattr(self, self.update_type.value).unwrap()
+
+    def get_event[T: BaseCute](self, event_model: type[T], /) -> Option[T]:
+        if isinstance(self.incoming_update, event_model):
+            return Some(self.incoming_update)
+        return NOTHING
+
+
+__all__ = ("UpdateCute",)

telegrinder/bot/cute_types/utils.py

@@ -0,0 +1,141 @@
+import collections
+import typing
+
+from telegrinder.tools.formatting.html import FORMATTERS, link, pre_code, tg_emoji
+from telegrinder.tools.strings import to_utf16_map, utf16_to_py_index
+from telegrinder.types.enums import ContentType, MessageEntityType
+from telegrinder.types.methods_utils import get_params
+from telegrinder.types.objects import (
+    InputFile,
+    InputMediaAnimation,
+    InputMediaAudio,
+    InputMediaDocument,
+    InputMediaPhoto,
+    InputMediaVideo,
+    MessageEntity,
+    ReactionEmoji,
+    ReactionType,
+    ReactionTypeEmoji,
+)
+
+type InputMedia = typing.Union[
+    InputMediaAnimation,
+    InputMediaAudio,
+    InputMediaDocument,
+    InputMediaPhoto,
+    InputMediaVideo,
+]
+
+type MediaType = typing.Literal["animation", "audio", "document", "photo", "video"]
+
+EntitiesDict = collections.defaultdict[int, list[MessageEntity]]
+
+MEDIA_TYPES: typing.Final = (
+    ContentType.ANIMATION,
+    ContentType.AUDIO,
+    ContentType.DOCUMENT,
+    ContentType.PHOTO,
+    ContentType.VIDEO,
+)
+INPUT_TYPES: typing.Final = (
+    InputMediaAnimation,
+    InputMediaAudio,
+    InputMediaDocument,
+    InputMediaPhoto,
+    InputMediaVideo,
+)
+INPUT_MEDIA_TYPES: typing.Final[dict[ContentType, type[InputMedia]]] = dict(zip(MEDIA_TYPES, INPUT_TYPES))
+HTML_FORMAT_ENTITIES: typing.Final[tuple[MessageEntityType, ...]] = (
+    MessageEntityType.PRE,
+    MessageEntityType.CODE,
+    MessageEntityType.TEXT_LINK,
+    MessageEntityType.CUSTOM_EMOJI,
+    *tuple(x for x in MessageEntityType if x.name.lower() in FORMATTERS),
+)
+
+
+def build_html(text: str, entities: list[MessageEntity], /) -> str:
+    utf16_map = to_utf16_map(text)
+    text_length_utf16 = utf16_map[-1]
+    events = set[int]()
+
+    for entity in entities:
+        events.add(entity.offset)
+        events.add(entity.offset + entity.length)
+
+    events = sorted(events)
+    utf16_to_py = {u: utf16_to_py_index(utf16_map, u) for u in events + [0, text_length_utf16]}
+
+    opens = EntitiesDict(list)
+    closes = EntitiesDict(list)
+
+    for entity in entities:
+        opens[entity.offset].append(entity)
+        closes[entity.offset + entity.length].append(entity)
+
+    result = list[str]()
+    stack = collections.deque[MessageEntity]()
+    utf16_pos = 0
+
+    while utf16_pos < text_length_utf16:
+        py_start = utf16_to_py[utf16_pos]
+        next_events = [u for u in events if u > utf16_pos]
+        next_utf16 = min(next_events) if next_events else text_length_utf16
+        py_end = utf16_to_py[next_utf16]
+
+        if closes[utf16_pos]:
+            for _ in closes[utf16_pos]:
+                stack.pop()
+
+        if opens[utf16_pos]:
+            for e in sorted(opens[utf16_pos], key=lambda e: e.length, reverse=True):
+                stack.append(e)
+
+        chunk = text[py_start:py_end]
+        formatted = chunk
+
+        for e in reversed(stack):
+            if (formatter := FORMATTERS.get(e.type.name.lower())) is not None:
+                formatted = formatter(formatted)
+            elif e.type in (MessageEntityType.PRE, MessageEntityType.CODE):
+                formatted = pre_code(formatted, lang=e.language.unwrap_or_none())
+            elif e.type == MessageEntityType.TEXT_LINK:
+                formatted = link(e.url.unwrap(), text=formatted)
+            elif e.type == MessageEntityType.CUSTOM_EMOJI:
+                formatted = tg_emoji(formatted, emoji_id=e.custom_emoji_id.map(int).unwrap())
+
+        result.append(formatted)
+        utf16_pos = next_utf16
+
+    return "".join(result)
+
+
+def compose_reactions(
+    reactions: str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType],
+    /,
+) -> list[ReactionType]:
+    if not isinstance(reactions, list):
+        reactions = [reactions]
+    return [
+        (
+            ReactionTypeEmoji(emoji)
+            if isinstance(emoji, ReactionEmoji)
+            else (ReactionTypeEmoji(ReactionEmoji(emoji)) if isinstance(emoji, str) else emoji)
+        )
+        for emoji in reactions
+    ]
+
+
+def input_media(
+    type: MediaType,
+    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[ContentType(type)](**get_params(locals()))
+
+
+__all__ = ("build_html", "compose_reactions", "input_media")

telegrinder/bot/dispatch/__init__.py

@@ -0,0 +1,99 @@
+from telegrinder.bot.dispatch.abc import ABCDispatch
+from telegrinder.bot.dispatch.action import action
+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, FilterMiddleware, MediaGroupMiddleware, MiddlewareBox
+from telegrinder.bot.dispatch.process import check_rule, process_inner
+from telegrinder.bot.dispatch.return_manager import (
+    ABCReturnManager,
+    BaseReturnManager,
+    CallbackQueryReturnManager,
+    InlineQueryReturnManager,
+    Manager,
+    MessageReturnManager,
+    PreCheckoutQueryReturnManager,
+    register_manager,
+)
+from telegrinder.bot.dispatch.router import ABCRouter, Router
+from telegrinder.bot.dispatch.view import (
+    ABCView,
+    ErrorView,
+    EventModelView,
+    EventView,
+    MediaGroupView,
+    RawEventView,
+    View,
+    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,
+    WaiterMachine,
+)
+
+__all__ = (
+    "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",
+    "ABCDispatch",
+    "ABCHandler",
+    "ABCMiddleware",
+    "ABCReturnManager",
+    "ABCRouter",
+    "ABCView",
+    "AudioReplyHandler",
+    "BaseReturnManager",
+    "CallbackQueryReturnManager",
+    "Context",
+    "Dispatch",
+    "DocumentReplyHandler",
+    "ErrorView",
+    "EventModelView",
+    "EventView",
+    "FilterMiddleware",
+    "FuncHandler",
+    "Hasher",
+    "InlineQueryReturnManager",
+    "Manager",
+    "MediaGroupMiddleware",
+    "MediaGroupReplyHandler",
+    "MediaGroupView",
+    "MessageReplyHandler",
+    "MessageReturnManager",
+    "MiddlewareBox",
+    "PhotoReplyHandler",
+    "PreCheckoutQueryReturnManager",
+    "RawEventView",
+    "Router",
+    "ShortState",
+    "StickerReplyHandler",
+    "TelegrinderContext",
+    "VideoReplyHandler",
+    "View",
+    "ViewBox",
+    "WaiterMachine",
+    "action",
+    "check_rule",
+    "process_inner",
+    "register_manager",
+)

telegrinder/bot/dispatch/abc.py

@@ -0,0 +1,74 @@
+import importlib.util as importlib_util
+import os
+import pathlib
+import sys
+import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.api.api import API
+from telegrinder.types.objects import Update
+
+
+class PathExistsError(BaseException):
+    pass
+
+
+class ABCDispatch(ABC):
+    @abstractmethod
+    async def feed(self, api: API, update: Update) -> typing.Any:
+        pass
+
+    @abstractmethod
+    def load(self, external: typing.Self) -> None:
+        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,
+        *,
+        recursive: bool = False,
+    ) -> 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 `{directory!s}` doesn't exists.")
+
+        found = False
+        files_iter = os.walk(directory) if recursive else [(directory, [], os.listdir(directory))]
+
+        for root, _, files in files_iter:
+            for f in files:
+                if f.endswith(".py") and f != "__init__.py":
+                    module_path = os.path.join(root, f)
+                    relative_path = os.path.relpath(module_path, sys.path[0])
+                    module_name = os.path.splitext(relative_path)[0].replace(os.sep, ".")
+
+                    if module_name not in sys.modules:
+                        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)
+                    else:
+                        module = sys.modules[module_name]
+
+                    for obj in vars(module).values():
+                        if isinstance(obj, type(self)):
+                            found = True
+                            self.load(obj)
+
+        return found
+
+
+__all__ = ("ABCDispatch",)