telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/tools/keyboard/abc.py

@@ -0,0 +1,84 @@
+import abc
+import typing
+
+from telegrinder.types.objects import InlineKeyboardMarkup, ReplyKeyboardMarkup
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.keyboard.button import BaseButton
+
+from telegrinder.tools.keyboard.utils import RowButtons, copy_keyboard
+
+type DictStrAny = dict[str, typing.Any]
+type AnyMarkup = ReplyKeyboardMarkup | InlineKeyboardMarkup
+type RawKeyboard = list[list[DictStrAny]]
+type Button = DictStrAny | list[DictStrAny] | BaseButton | RowButtons[BaseButton]
+
+
+class ABCKeyboard(typing.Protocol):
+    keyboard: RawKeyboard
+
+    __button_class__: typing.ClassVar[type[BaseButton]]
+
+    @abc.abstractmethod
+    def dict(self) -> DictStrAny:
+        pass
+
+    @abc.abstractmethod
+    def get_markup(self) -> AnyMarkup:
+        pass
+
+    @abc.abstractmethod
+    def copy(self, **with_changes: typing.Any) -> typing.Self:
+        pass
+
+    def add(self, button: Button, /) -> typing.Self:
+        if not self.keyboard:
+            self.row()
+
+        if isinstance(button, RowButtons):
+            self.keyboard[-1].extend(button.get_data())
+            if button.auto_row:
+                self.row()
+            return self
+
+        if isinstance(button, list):
+            self.keyboard[-1].extend(button)
+            return self
+
+        self.keyboard[-1].append(button if isinstance(button, dict) else button.get_data())
+        return self
+
+    def row(self) -> typing.Self:
+        if len(self.keyboard) and not len(self.keyboard[-1]):
+            return self
+
+        self.keyboard.append([])
+        return self
+
+    def format_text(self, **format_data: typing.Any) -> typing.Self:
+        copy_keyboard = self.copy()
+
+        for row in self.keyboard:
+            for button in row:
+                button.update(dict(text=button["text"].format(**format_data)))
+
+        return copy_keyboard
+
+    def merge(self, other: typing.Self, /) -> typing.Self:
+        self.keyboard.extend(copy_keyboard(other.keyboard))
+        return self
+
+    def merge_to_last_row(self, other: typing.Self, /) -> typing.Self:
+        total_rows = len(other.keyboard)
+
+        for index, row in enumerate(copy_keyboard(other.keyboard), start=1):
+            for button in row:
+                self.keyboard[-1].append(button)
+
+            if index < total_rows:
+                self.keyboard.append([])
+
+        return self
+
+
+__all__ = ("ABCKeyboard",)

telegrinder/tools/keyboard/base.py

@@ -0,0 +1,108 @@
+import abc
+import typing
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.keyboard.abc import Button, RawKeyboard
+    from telegrinder.tools.keyboard.button import BaseButton
+
+from telegrinder.tools.keyboard.abc import ABCKeyboard
+from telegrinder.tools.keyboard.utils import RowButtons, copy_keyboard, get_keyboard_button_rules, is_dunder
+
+BUTTON_CLASS_KEY: typing.Final = "__button_class__"
+
+
+class KeyboardMeta(type):
+    if not typing.TYPE_CHECKING:
+
+        def __getattribute__(cls, __name: str) -> typing.Any:
+            if (
+                not is_dunder(__name)
+                and ABCKeyboard not in type.__getattribute__(cls, "__bases__")
+                and hasattr(cls, BUTTON_CLASS_KEY)
+                and (button_rule := get_keyboard_button_rules(cls).get(__name)) is not None
+            ):
+                return button_rule
+
+            return super().__getattribute__(__name)
+
+
+class ABCBaseKeyboard(typing._ProtocolMeta, KeyboardMeta):  # type: ignore
+    pass
+
+
+class BaseKeyboard[KeyboardButton: BaseButton = typing.Any](typing.Protocol, metaclass=ABCBaseKeyboard):
+    keyboard: RawKeyboard
+
+    __keyboard_instance__: typing.ClassVar[typing.Self]
+    __button_class__: typing.ClassVar[type[BaseButton[typing.Self]]]
+
+    @abc.abstractmethod
+    def copy(self, **with_changes: typing.Any) -> typing.Self:
+        pass
+
+    @abc.abstractmethod
+    def __init_subclass__(cls) -> None:
+        pass
+
+    def __and__(self, other: object, /) -> typing.Self:
+        if not isinstance(other, self.__button_class__ | type(self)):
+            return NotImplemented
+        return self.add(other) if isinstance(other, self.__button_class__) else self.merge(other)  # type: ignore
+
+    def __or__(self, other: object, /) -> typing.Self:
+        if not isinstance(other, self.__button_class__ | type(self)):
+            return NotImplemented
+        kb = self.row()
+        return kb.add(other) if isinstance(other, self.__button_class__) else kb.merge_to_last_row(other)  # type: ignore
+
+    def add(self, button: Button, /) -> typing.Self:
+        if not self.keyboard:
+            self.row()
+
+        if isinstance(button, RowButtons):
+            self.keyboard[-1].extend(button.get_data())
+            if button.auto_row:
+                self.row()
+            return self
+
+        if isinstance(button, list):
+            self.keyboard[-1].extend(button)
+            return self
+
+        self.keyboard[-1].append(button if isinstance(button, dict) else button.get_data())
+        return self
+
+    def row(self) -> typing.Self:
+        if len(self.keyboard) and not len(self.keyboard[-1]):
+            return self
+
+        self.keyboard.append([])
+        return self
+
+    def format_text(self, **format_data: typing.Any) -> typing.Self:
+        copy_keyboard = self.copy()
+
+        for row in self.keyboard:
+            for button in row:
+                button.update(dict(text=button["text"].format(**format_data)))
+
+        return copy_keyboard
+
+    def merge(self, other: BaseKeyboard[KeyboardButton], /) -> typing.Self:
+        self.keyboard.extend(copy_keyboard(other.keyboard))
+        return self
+
+    def merge_to_last_row(self, other: BaseKeyboard[KeyboardButton], /) -> typing.Self:
+        total_rows = len(other.keyboard)
+
+        for index, row in enumerate(copy_keyboard(other.keyboard), start=1):
+            for button in row:
+                self.keyboard[-1].append(button)
+
+            if index < total_rows:
+                self.keyboard.append([])
+
+        return self
+
+
+__all__ = ("BaseKeyboard",)

telegrinder/tools/keyboard/button.py

@@ -0,0 +1,181 @@
+import abc
+import dataclasses
+import typing
+from functools import cached_property
+
+import msgspec
+
+from telegrinder.msgspec_utils.encoder import encoder
+from telegrinder.tools.keyboard.utils import freaky_keyboard_merge
+from telegrinder.tools.serialization.json_ser import JSONSerializer
+from telegrinder.tools.serialization.utils import get_model_serializer
+from telegrinder.types.objects import (
+    CallbackGame,
+    CopyTextButton,
+    KeyboardButtonPollType,
+    KeyboardButtonRequestChat,
+    KeyboardButtonRequestUsers,
+    LoginUrl,
+    SwitchInlineQueryChosenChat,
+    WebAppInfo,
+)
+
+if typing.TYPE_CHECKING:
+    from _typeshed import DataclassInstance
+
+    from telegrinder.bot.rules.abc import ABCRule
+    from telegrinder.bot.rules.button import ButtonRule
+    from telegrinder.tools.keyboard import keyboard
+    from telegrinder.tools.keyboard.base import BaseKeyboard
+    from telegrinder.tools.keyboard.button import BaseButton
+    from telegrinder.tools.serialization.abc import ABCDataSerializer
+
+type CallbackData = str | dict[str, typing.Any] | DataclassInstance | msgspec.Struct
+type Keyboard = keyboard.Keyboard
+type InlineKeyboard = keyboard.InlineKeyboard
+
+
+@dataclasses.dataclass(kw_only=True)
+class BaseButton[T: BaseKeyboard = typing.Any](abc.ABC):
+    new_row: bool = dataclasses.field(default=False)
+
+    @property
+    @abc.abstractmethod
+    def keyboard_class(self) -> type[T]:
+        pass
+
+    @property
+    @abc.abstractmethod
+    def rule(self) -> ABCRule:
+        pass
+
+    if typing.TYPE_CHECKING:
+
+        def __get__(self, instance: T | None, owner: type[T]) -> ButtonRule[typing.Self]: ...
+
+        @property
+        def as_keyboard(self: BaseButton[T]) -> type[T]: ...
+    else:
+
+        def as_keyboard(self, *args, **kwargs):
+            return self.keyboard_class(*args, **kwargs).add(self)
+
+    def __and__(self, other: object, /) -> T:
+        if not isinstance(other, self.keyboard_class | type(self)):
+            return NotImplemented
+        return freaky_keyboard_merge(self, other)
+
+    def __or__(self, other: object, /) -> T:
+        if not isinstance(other, self.keyboard_class | type(self)):
+            return NotImplemented
+        return freaky_keyboard_merge(self, other, row=True)
+
+    def get_data(self) -> dict[str, typing.Any]:
+        return {k: v for k, v in dataclasses.asdict(self).items() if v is not None and k != "new_row"}
+
+
+@dataclasses.dataclass
+class Button(BaseButton[Keyboard]):
+    text: str
+    request_contact: bool = dataclasses.field(default=False, kw_only=True)
+    request_location: bool = dataclasses.field(default=False, kw_only=True)
+    request_chat: KeyboardButtonRequestChat | None = dataclasses.field(
+        default=None,
+        kw_only=True,
+    )
+    request_user: KeyboardButtonRequestUsers | None = dataclasses.field(default=None, kw_only=True)
+    request_poll: KeyboardButtonPollType | None = dataclasses.field(
+        default=None,
+        kw_only=True,
+    )
+    web_app: WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
+
+    @cached_property
+    def rule(self) -> ABCRule:
+        from telegrinder.bot.rules.text import Text
+
+        return Text(self.text)
+
+    @cached_property
+    def keyboard_class(self) -> type[Keyboard]:
+        from telegrinder.tools.keyboard.keyboard import Keyboard
+
+        return Keyboard
+
+
+@dataclasses.dataclass
+class InlineButton(BaseButton[InlineKeyboard]):
+    text: str
+    url: str | None = dataclasses.field(default=None, kw_only=True)
+    login_url: LoginUrl | None = dataclasses.field(default=None, kw_only=True)
+    pay: bool | None = dataclasses.field(default=None, kw_only=True)
+    callback_data: CallbackData | None = dataclasses.field(default=None, kw_only=True)
+    callback_data_serializer: ABCDataSerializer[typing.Any] | None = dataclasses.field(
+        default=None,
+        kw_only=True,
+    )
+    callback_game: CallbackGame | None = dataclasses.field(default=None, kw_only=True)
+    copy_text: str | CopyTextButton | None = dataclasses.field(default=None, kw_only=True)
+    switch_inline_query: str | None = dataclasses.field(default=None, kw_only=True)
+    switch_inline_query_current_chat: str | None = dataclasses.field(default=None, kw_only=True)
+    switch_inline_query_chosen_chat: SwitchInlineQueryChosenChat | None = dataclasses.field(
+        default=None,
+        kw_only=True,
+    )
+    web_app: str | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
+
+    def __post_init__(self) -> None:
+        model_serializer = get_model_serializer(self.callback_data)
+
+        self.input_callback_data = self.callback_data
+        self.callback_data_serializer = self.callback_data_serializer or (
+            None if model_serializer is None else model_serializer(type(self.callback_data))
+        )
+
+        if (
+            self.callback_data_serializer is None
+            and isinstance(self.callback_data, msgspec.Struct | dict)
+            or dataclasses.is_dataclass(self.callback_data)
+        ):
+            self.callback_data_serializer = self.callback_data_serializer or JSONSerializer(
+                type(self.callback_data),
+            )
+
+        if self.callback_data_serializer is not None:
+            self.callback_data = self.callback_data_serializer.serialize(self.callback_data)
+        elif self.callback_data is not None and not isinstance(self.callback_data, str):
+            self.callback_data = encoder.encode(self.callback_data)
+
+        if isinstance(self.copy_text, str):
+            self.copy_text = CopyTextButton(text=self.copy_text)
+
+        if isinstance(self.web_app, str):
+            self.web_app = WebAppInfo(url=self.web_app)
+
+    @cached_property
+    def rule(self) -> ABCRule:
+        from telegrinder.bot.rules.payload import PayloadEqRule, PayloadJsonEqRule, PayloadModelRule
+
+        if isinstance(self.input_callback_data, str):
+            return PayloadEqRule(self.input_callback_data)
+
+        if isinstance(self.input_callback_data, dict):
+            return PayloadJsonEqRule(self.input_callback_data)
+
+        if self.input_callback_data is not None:
+            return PayloadModelRule(
+                type(self.input_callback_data),
+                payload=self.input_callback_data,
+                serializer=type(self.callback_data_serializer) if self.callback_data_serializer else None,
+            )
+
+        raise ValueError("Cannot create rule, because callback data is not defined.")
+
+    @cached_property
+    def keyboard_class(self) -> type[InlineKeyboard]:
+        from telegrinder.tools.keyboard.keyboard import InlineKeyboard
+
+        return InlineKeyboard
+
+
+__all__ = ("BaseButton", "Button", "InlineButton")

telegrinder/tools/keyboard/data.py

@@ -0,0 +1,31 @@
+import dataclasses
+import typing
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.keyboard.abc import DictStrAny, RawKeyboard
+
+
+class KeyboardParams(typing.TypedDict, total=False):
+    is_persistent: bool
+    one_time_keyboard: bool
+    resize_keyboard: bool
+    is_selective: bool
+    input_field_placeholder: str | None
+
+
+@dataclasses.dataclass(frozen=True)
+class KeyboardModel:
+    keyboard: RawKeyboard
+    is_persistent: bool = dataclasses.field(default=False, kw_only=True)
+    one_time_keyboard: bool = dataclasses.field(default=False, kw_only=True)
+    resize_keyboard: bool = dataclasses.field(default=False, kw_only=True)
+    is_selective: bool = dataclasses.field(default=False, kw_only=True)
+    input_field_placeholder: str | None = dataclasses.field(default=None, kw_only=True)
+
+    def dict(self) -> DictStrAny:
+        dct = dataclasses.asdict(self)
+        dct["keyboard"] = [row for row in self.keyboard if row]
+        return dct
+
+
+__all__ = ("KeyboardModel", "KeyboardParams")

telegrinder/tools/keyboard/keyboard.py

@@ -0,0 +1,160 @@
+import dataclasses
+import typing
+
+from telegrinder.tools.keyboard.abc import ABCKeyboard, DictStrAny, RawKeyboard
+from telegrinder.tools.keyboard.abc import Button as ButtonType
+from telegrinder.tools.keyboard.base import BaseKeyboard
+from telegrinder.tools.keyboard.button import BaseButton, Button, InlineButton
+from telegrinder.tools.keyboard.data import KeyboardModel, KeyboardParams
+from telegrinder.tools.keyboard.utils import (
+    RowButtons,
+    bound_keyboard_method,
+    copy_keyboard,
+    init_keyboard,
+)
+from telegrinder.types.objects import InlineKeyboardMarkup, ReplyKeyboardMarkup, ReplyKeyboardRemove
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.serialization.abc import ABCDataSerializer
+
+
+class Keyboard(BaseKeyboard[Button], ABCKeyboard):
+    __button_class__ = Button
+    __slots__ = ("keyboard_model",)
+
+    def __init_subclass__(cls, *, max_in_row: int = 0, **kwargs: typing.Unpack[KeyboardParams]) -> None:
+        cls.__keyboard_instance__ = init_keyboard(cls(**kwargs), max_in_row=max_in_row)
+
+    def __init__(
+        self,
+        *,
+        keyboard_model: KeyboardModel | None = None,
+        **kwargs: typing.Unpack[KeyboardParams],
+    ) -> None:
+        self.keyboard_model = keyboard_model or KeyboardModel(keyboard=[[]], **kwargs)
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__}: keyboard_model={self.keyboard_model!r}>"
+
+    @property
+    def keyboard(self) -> RawKeyboard:
+        return self.keyboard_model.keyboard
+
+    @property
+    def is_persistent(self) -> bool:
+        return self.keyboard_model.is_persistent
+
+    @property
+    def one_time_keyboard(self) -> bool:
+        return self.keyboard_model.one_time_keyboard
+
+    @property
+    def resize_keyboard(self) -> bool:
+        return self.keyboard_model.resize_keyboard
+
+    @property
+    def is_selective(self) -> bool:
+        return self.keyboard_model.is_selective
+
+    @property
+    def input_field_placeholder(self) -> str | None:
+        return self.keyboard_model.input_field_placeholder
+
+    @bound_keyboard_method
+    def copy(self, **with_changes: typing.Any) -> typing.Self:
+        keyboard_model = dataclasses.replace(
+            self.keyboard_model,
+            keyboard=copy_keyboard(self.keyboard),
+            **with_changes,
+        )
+        return type(self)(keyboard_model=keyboard_model)
+
+    @bound_keyboard_method
+    def dict(self) -> DictStrAny:
+        return self.keyboard_model.dict()
+
+    @bound_keyboard_method
+    def get_markup(self) -> ReplyKeyboardMarkup:
+        return ReplyKeyboardMarkup.from_dict(self.dict())
+
+    @bound_keyboard_method
+    def get_keyboard_remove(self) -> ReplyKeyboardRemove:
+        return ReplyKeyboardRemove(remove_keyboard=True, selective=self.is_selective)
+
+    def placeholder(self, value: str | None, /) -> typing.Self:
+        return self.copy(input_field_placeholder=value)
+
+    def resize(self) -> typing.Self:
+        return self.copy(resize_keyboard=True)
+
+    def one_time(self) -> typing.Self:
+        return self.copy(one_time_keyboard=True)
+
+    def selective(self) -> typing.Self:
+        return self.copy(is_selective=True)
+
+    def persistent(self) -> typing.Self:
+        return self.copy(is_persistent=True)
+
+    def no_resize(self) -> typing.Self:
+        return self.copy(resize_keyboard=False)
+
+    def no_one_time(self) -> typing.Self:
+        return self.copy(one_time_keyboard=False)
+
+    def no_selective(self) -> typing.Self:
+        return self.copy(is_selective=False)
+
+    def no_persistent(self) -> typing.Self:
+        return self.copy(is_persistent=False)
+
+
+class InlineKeyboard(BaseKeyboard[InlineButton], ABCKeyboard):
+    __button_class__ = InlineButton
+    __serializer__: ABCDataSerializer | None = None
+    __slots__ = ("keyboard", "serializer")
+
+    def __init_subclass__(
+        cls,
+        *,
+        max_in_row: int = 0,
+        serializer: ABCDataSerializer | None = None,
+    ) -> None:
+        cls.__keyboard_instance__ = init_keyboard(cls(), max_in_row=max_in_row)
+        cls.__serializer__ = serializer
+
+    def __init__(
+        self,
+        *,
+        serializer: ABCDataSerializer | None = None,
+    ) -> None:
+        self.keyboard = [[]]
+        self.serializer = serializer or self.__serializer__
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__}: keyboard={self.keyboard!r}>"
+
+    def add(self, button: ButtonType, /) -> typing.Self:
+        if isinstance(button, BaseButton | RowButtons):
+            for b in button.buttons if isinstance(button, RowButtons) else (button,):
+                if isinstance(b, InlineButton) and b.callback_data_serializer is None:
+                    b.callback_data_serializer = self.serializer
+
+        return super().add(button)
+
+    @bound_keyboard_method
+    def copy(self, **with_changes: typing.Any) -> typing.Self:
+        new_keyboard = type(self)()
+        new_keyboard.keyboard = copy_keyboard(self.keyboard)
+        return new_keyboard
+
+    @bound_keyboard_method
+    def dict(self) -> DictStrAny:
+        return dict(inline_keyboard=[row for row in self.keyboard if row])
+
+    @bound_keyboard_method
+    def get_markup(self) -> InlineKeyboardMarkup:
+        return InlineKeyboardMarkup.from_dict(self.dict())
+
+
+__all__ = ("InlineKeyboard", "Keyboard")

telegrinder/tools/keyboard/utils.py

@@ -0,0 +1,95 @@
+import typing
+from functools import lru_cache
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules.button import ButtonRule
+    from telegrinder.tools.keyboard.abc import ABCKeyboard, RawKeyboard
+    from telegrinder.tools.keyboard.base import BaseKeyboard
+    from telegrinder.tools.keyboard.button import BaseButton
+
+
+@lru_cache(maxsize=1024)
+def get_keyboard_button_rules(
+    keyboard_class: type[ABCKeyboard],
+    /,
+) -> dict[str, ButtonRule[BaseButton[typing.Any]]]:
+    from telegrinder.bot.rules.button import ButtonRule
+
+    return {
+        name: ButtonRule(button=button, rule=button.rule)
+        for name, button in dict(vars(keyboard_class)).items()
+        if isinstance(button, keyboard_class.__button_class__) and not is_dunder(name)
+    }
+
+
+def is_dunder(name: str, /) -> bool:
+    return name.startswith("__") and name.endswith("__")
+
+
+def copy_keyboard(keyboard: RawKeyboard, /) -> RawKeyboard:
+    return [row.copy() for row in keyboard if row]
+
+
+def freaky_keyboard_merge[T: BaseKeyboard = typing.Any](
+    button: BaseButton[T],
+    keyboard_or_button: T | BaseButton[T],
+    /,
+    *,
+    row: bool = False,
+) -> T:
+    from telegrinder.tools.keyboard.button import BaseButton
+
+    keyboard = button.keyboard_class().add(button)
+
+    if row:
+        keyboard = keyboard.row()
+
+    return (
+        keyboard.merge_to_last_row(keyboard_or_button)
+        if not isinstance(keyboard_or_button, BaseButton)
+        else keyboard.add(keyboard_or_button)
+    )
+
+
+def init_keyboard[T: BaseKeyboard = typing.Any](
+    keyboard_instance: T,
+    /,
+    *,
+    max_in_row: int = 0,
+) -> T:
+    for button in get_keyboard_button_rules(type(keyboard_instance)).values():
+        if button.button.new_row or (max_in_row and len(keyboard_instance.keyboard[-1]) >= max_in_row):
+            keyboard_instance.row()
+
+        keyboard_instance.add(button.button)
+
+    return keyboard_instance
+
+
+class bound_keyboard_method[T: BaseKeyboard = typing.Any, **P = ..., R = typing.Any]:  # noqa: N801
+    def __init__(self, func: typing.Callable[typing.Concatenate[T, P], R], /) -> None:
+        self.func = func
+
+    def __get__(self, instance: T | None, owner: type[T]) -> typing.Callable[P, R]:
+        return self.func.__get__(instance or owner.__keyboard_instance__, owner)
+
+
+class RowButtons[KeyboardButton: BaseButton]:
+    buttons: typing.Iterable[KeyboardButton]
+
+    def __init__(self, *buttons: KeyboardButton, auto_row: bool = True) -> None:
+        self.buttons = buttons
+        self.auto_row = auto_row
+
+    def get_data(self) -> list[dict[str, typing.Any]]:
+        return [b.get_data() for b in self.buttons]
+
+
+__all__ = (
+    "RowButtons",
+    "bound_keyboard_method",
+    "copy_keyboard",
+    "freaky_keyboard_merge",
+    "get_keyboard_button_rules",
+    "init_keyboard",
+)