telegrinder 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

telegrinder/bot/scenario/checkbox.py

@@ -1,147 +1,167 @@
-import dataclasses
-import secrets
-import typing
-
-from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
-from telegrinder.bot.dispatch.waiter_machine import StateViewHasher, WaiterMachine
-from telegrinder.bot.scenario.abc import ABCScenario
-from telegrinder.tools.keyboard import InlineButton, InlineKeyboard
-from telegrinder.tools.parse_mode import ParseMode
-from telegrinder.types.objects import InlineKeyboardMarkup
-
-if typing.TYPE_CHECKING:
-    from telegrinder.api import API
-    from telegrinder.bot.dispatch.view.base import BaseStateView
-
-
-@dataclasses.dataclass(slots=True)
-class Choice:
-    name: str
-    is_picked: bool
-    default_text: str
-    picked_text: str
-    code: str
-
-
-class Checkbox(ABCScenario[CallbackQueryCute]):
-    INVALID_CODE = "Invalid code"
-    CALLBACK_ANSWER = "Done"
-    PARSE_MODE = ParseMode.HTML
-
-    def __init__(
-        self,
-        waiter_machine: WaiterMachine,
-        chat_id: int,
-        message: str,
-        *,
-        ready_text: str = "Ready",
-        cancel_text: str | None = None,
-        max_in_row: int = 3,
-    ) -> None:
-        self.chat_id = chat_id
-        self.message = message
-        self.choices: list[Choice] = []
-        self.ready = ready_text
-        self.max_in_row = max_in_row
-        self.random_code = secrets.token_hex(8)
-        self.waiter_machine = waiter_machine
-        self.cancel_text = cancel_text
-
-    def __repr__(self) -> str:
-        return (
-            "<{}@{!r}: (choices={!r}, max_in_row={}) with waiter_machine={!r}, ready_text={!r} "
-            "for chat_id={} with message={!r}>"
-        ).format(
-            self.__class__.__name__,
-            self.random_code,
-            self.choices,
-            self.max_in_row,
-            self.waiter_machine,
-            self.ready,
-            self.chat_id,
-            self.message,
-        )
-
-    def get_markup(self) -> InlineKeyboardMarkup:
-        kb = InlineKeyboard()
-        choices = self.choices.copy()
-        while choices:
-            while len(kb.keyboard[-1]) < self.max_in_row and choices:
-                choice = choices.pop(0)
-                kb.add(
-                    InlineButton(
-                        text=(choice.default_text if not choice.is_picked else choice.picked_text),
-                        callback_data=self.random_code + "/" + choice.code,
-                    )
-                )
-            kb.row()
-
-        kb.add(InlineButton(self.ready, callback_data=self.random_code + "/ready"))
-        if self.cancel_text is not None:
-            kb.row()
-            kb.add(InlineButton(self.cancel_text, callback_data=self.random_code + "/cancel"))
-        return kb.get_markup()
-
-    def add_option(
-        self,
-        name: str,
-        default_text: str,
-        picked_text: str,
-        *,
-        is_picked: bool = False,
-    ) -> typing.Self:
-        self.choices.append(
-            Choice(name, is_picked, default_text, picked_text, secrets.token_hex(8)),
-        )
-        return self
-
-    async def handle(self, cb: CallbackQueryCute) -> bool:
-        code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
-        if code == "ready":
-            return False
-        elif code == "cancel":
-            self.choices = []
-            return False
-
-        for i, choice in enumerate(self.choices):
-            if choice.code == code:
-                # Toggle choice
-                self.choices[i].is_picked = not self.choices[i].is_picked
-                await cb.edit_text(
-                    text=self.message,
-                    parse_mode=self.PARSE_MODE,
-                    reply_markup=self.get_markup(),
-                )
-                break
-
-        return True
-
-    async def wait(
-        self,
-        api: "API",
-        view: "BaseStateView[CallbackQueryCute]",
-    ) -> tuple[dict[str, bool], int]:
-        assert len(self.choices) > 0
-        message = (
-            await api.send_message(
-                chat_id=self.chat_id,
-                text=self.message,
-                parse_mode=self.PARSE_MODE,
-                reply_markup=self.get_markup(),
-            )
-        ).unwrap()
-
-        while True:
-            q, _ = await self.waiter_machine.wait(StateViewHasher(view), message.message_id)
-            should_continue = await self.handle(q)
-            await q.answer(self.CALLBACK_ANSWER)
-            if not should_continue:
-                break
-
-        return (
-            {choice.name: choice.is_picked for choice in self.choices},
-            message.message_id,
-        )
-
-
-__all__ = ("Checkbox", "Choice")
+import dataclasses
+import secrets
+import typing
+
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
+from telegrinder.bot.dispatch.waiter_machine.machine import WaiterMachine
+from telegrinder.bot.scenario.abc import ABCScenario
+from telegrinder.tools.keyboard import InlineButton, InlineKeyboard
+from telegrinder.tools.parse_mode import ParseMode
+from telegrinder.types.objects import InlineKeyboardMarkup
+
+if typing.TYPE_CHECKING:
+    from telegrinder.api.api import API
+    from telegrinder.bot.dispatch.view.base import BaseStateView
+
+Key = typing.TypeVar("Key", bound=typing.Hashable)
+
+
+@dataclasses.dataclass(slots=True)
+class Choice(typing.Generic[Key]):
+    key: Key
+    is_picked: bool
+    default_text: str
+    picked_text: str
+    code: str
+
+
+class _Checkbox(ABCScenario[CallbackQueryCute]):
+    INVALID_CODE = "Invalid code"
+    CALLBACK_ANSWER = "Done"
+    PARSE_MODE = ParseMode.HTML
+
+    def __init__(
+        self,
+        waiter_machine: WaiterMachine,
+        chat_id: int,
+        message: str,
+        *,
+        ready_text: str = "Ready",
+        cancel_text: str | None = None,
+        max_in_row: int = 3,
+    ) -> None:
+        self.chat_id = chat_id
+        self.message = message
+        self.choices: list[Choice[typing.Hashable]] = []
+        self.ready = ready_text
+        self.max_in_row = max_in_row
+        self.random_code = secrets.token_hex(8)
+        self.waiter_machine = waiter_machine
+        self.cancel_text = cancel_text
+
+    def __repr__(self) -> str:
+        return (
+            "<{}@{!r}: (choices={!r}, max_in_row={}) with waiter_machine={!r}, ready_text={!r} "
+            "for chat_id={} with message={!r}>"
+        ).format(
+            self.__class__.__name__,
+            self.random_code,
+            self.choices,
+            self.max_in_row,
+            self.waiter_machine,
+            self.ready,
+            self.chat_id,
+            self.message,
+        )
+
+    def get_markup(self) -> InlineKeyboardMarkup:
+        kb = InlineKeyboard()
+        choices = self.choices.copy()
+        while choices:
+            while len(kb.keyboard[-1]) < self.max_in_row and choices:
+                choice = choices.pop(0)
+                kb.add(
+                    InlineButton(
+                        text=(choice.default_text if not choice.is_picked else choice.picked_text),
+                        callback_data=self.random_code + "/" + choice.code,
+                    )
+                )
+            kb.row()
+
+        kb.add(InlineButton(self.ready, callback_data=self.random_code + "/ready"))
+        if self.cancel_text is not None:
+            kb.row()
+            kb.add(InlineButton(self.cancel_text, callback_data=self.random_code + "/cancel"))
+        return kb.get_markup()
+
+    def add_option(
+        self,
+        key: Key,
+        default_text: str,
+        picked_text: str,
+        *,
+        is_picked: bool = False,
+    ) -> "Checkbox[Key]":
+        self.choices.append(
+            Choice(key, is_picked, default_text, picked_text, secrets.token_hex(8)),
+        )
+        return self  # type: ignore
+
+    async def handle(self, cb: CallbackQueryCute) -> bool:
+        code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
+        if code == "ready":
+            return False
+        elif code == "cancel":
+            self.choices = []
+            return False
+
+        for i, choice in enumerate(self.choices):
+            if choice.code == code:
+                # Toggle choice
+                self.choices[i].is_picked = not self.choices[i].is_picked
+                await cb.edit_text(
+                    text=self.message,
+                    parse_mode=self.PARSE_MODE,
+                    reply_markup=self.get_markup(),
+                )
+                break
+
+        return True
+
+    async def wait(
+        self,
+        hasher: Hasher[CallbackQueryCute, int],
+        api: "API",
+        view: "BaseStateView[CallbackQueryCute]",
+    ) -> tuple[dict[typing.Hashable, bool], int]:
+        assert len(self.choices) > 0
+        message = (
+            await api.send_message(
+                chat_id=self.chat_id,
+                text=self.message,
+                parse_mode=self.PARSE_MODE,
+                reply_markup=self.get_markup(),
+            )
+        ).unwrap()
+
+        while True:
+            q, _ = await self.waiter_machine.wait(hasher, message.message_id)
+            should_continue = await self.handle(q)
+            await q.answer(self.CALLBACK_ANSWER)
+            if not should_continue:
+                break
+
+        return (
+            {choice.key: choice.is_picked for choice in self.choices},
+            message.message_id,
+        )
+
+
+if typing.TYPE_CHECKING:
+
+    class Checkbox(_Checkbox, typing.Generic[Key]):
+        choices: list[Choice[Key]]
+
+        async def wait(
+            self,
+            hasher: Hasher[CallbackQueryCute, int],
+            api: "API",
+            view: "BaseStateView[CallbackQueryCute]",
+        ) -> tuple[dict[Key, bool], int]: ...
+
+else:
+    Checkbox = _Checkbox
+
+
+__all__ = ("Checkbox", "Choice")

telegrinder/bot/scenario/choice.py

@@ -1,44 +1,46 @@
-import typing
-
-from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
-from telegrinder.bot.scenario.checkbox import Checkbox
-
-if typing.TYPE_CHECKING:
-    from telegrinder.api import API
-    from telegrinder.bot.dispatch.view.base import BaseStateView
-
-
-class Choice(Checkbox):
-    async def handle(self, cb: CallbackQueryCute) -> bool:
-        code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
-        if code == "ready":
-            return False
-
-        for choice in self.choices:
-            choice.is_picked = False
-
-        for i, choice in enumerate(self.choices):
-            if choice.code == code:
-                self.choices[i].is_picked = True
-                await cb.ctx_api.edit_message_text(
-                    text=self.message,
-                    chat_id=cb.message.unwrap().v.chat.id,
-                    message_id=cb.message.unwrap().v.message_id,
-                    parse_mode=self.PARSE_MODE,
-                    reply_markup=self.get_markup(),
-                )
-
-        return True
-
-    async def wait(
-        self,
-        api: "API",
-        view: "BaseStateView[CallbackQueryCute]",
-    ) -> tuple[str, int]:
-        if len(tuple(choice for choice in self.choices if choice.is_picked)) != 1:
-            raise ValueError("Exactly one choice must be picked")
-        choices, m_id = await super().wait(api, view)
-        return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
-
-
-__all__ = ("Choice",)
+import typing
+
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.bot.dispatch.waiter_machine.hasher.hasher import Hasher
+from telegrinder.bot.scenario.checkbox import Checkbox
+
+if typing.TYPE_CHECKING:
+    from telegrinder.api import API
+    from telegrinder.bot.dispatch.view.base import BaseStateView
+
+
+class Choice(Checkbox):
+    async def handle(self, cb: CallbackQueryCute) -> bool:
+        code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
+        if code == "ready":
+            return False
+
+        for choice in self.choices:
+            choice.is_picked = False
+
+        for i, choice in enumerate(self.choices):
+            if choice.code == code:
+                self.choices[i].is_picked = True
+                await cb.ctx_api.edit_message_text(
+                    text=self.message,
+                    chat_id=cb.message.unwrap().v.chat.id,
+                    message_id=cb.message.unwrap().v.message_id,
+                    parse_mode=self.PARSE_MODE,
+                    reply_markup=self.get_markup(),
+                )
+
+        return True
+
+    async def wait(
+        self,
+        hasher: Hasher[CallbackQueryCute, int],
+        api: "API",
+        view: "BaseStateView[CallbackQueryCute]",
+    ) -> tuple[str, int]:
+        if len(tuple(choice for choice in self.choices if choice.is_picked)) != 1:
+            raise ValueError("Exactly one choice must be picked")
+        choices, m_id = await super().wait(hasher, api, view)
+        return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
+
+
+__all__ = ("Choice",)

telegrinder/client/__init__.py

@@ -1,4 +1,4 @@
-from .abc import ABCClient
-from .aiohttp import AiohttpClient
-
-__all__ = ("ABCClient", "AiohttpClient")
+from .abc import ABCClient
+from .aiohttp import AiohttpClient
+
+__all__ = ("ABCClient", "AiohttpClient")

telegrinder/client/abc.py

@@ -1,75 +1,75 @@
-import typing
-from abc import ABC, abstractmethod
-
-
-class ABCClient(ABC):
-    @abstractmethod
-    def __init__(self, *args: typing.Any, **kwargs: typing.Any):
-        pass
-
-    @abstractmethod
-    async def request_text(
-        self,
-        url: str,
-        method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
-        **kwargs: typing.Any,
-    ) -> str:
-        pass
-
-    @abstractmethod
-    async def request_json(
-        self,
-        url: str,
-        method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
-        **kwargs: typing.Any,
-    ) -> dict[str, typing.Any]:
-        pass
-
-    @abstractmethod
-    async def request_content(
-        self,
-        url: str,
-        method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
-        **kwargs: typing.Any,
-    ) -> bytes:
-        pass
-
-    @abstractmethod
-    async def request_bytes(
-        self,
-        url: str,
-        method: str = "GET",
-        data: dict[str, typing.Any] | None = None,
-        **kwargs: typing.Any,
-    ) -> bytes:
-        pass
-
-    @abstractmethod
-    async def close(self) -> None:
-        pass
-
-    @classmethod
-    @abstractmethod
-    def get_form(
-        cls,
-        data: dict[str, typing.Any],
-        files: dict[str, tuple[str, bytes]] | None = None,
-    ) -> typing.Any:
-        pass
-
-    async def __aenter__(self) -> typing.Self:
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException],
-        exc_val: typing.Any,
-        exc_tb: typing.Any,
-    ) -> None:
-        await self.close()
-
-
-__all__ = ("ABCClient",)
+import typing
+from abc import ABC, abstractmethod
+
+
+class ABCClient(ABC):
+    @abstractmethod
+    def __init__(self, *args: typing.Any, **kwargs: typing.Any):
+        pass
+
+    @abstractmethod
+    async def request_text(
+        self,
+        url: str,
+        method: str = "GET",
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    async def request_json(
+        self,
+        url: str,
+        method: str = "GET",
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
+    ) -> dict[str, typing.Any]:
+        pass
+
+    @abstractmethod
+    async def request_content(
+        self,
+        url: str,
+        method: str = "GET",
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
+    ) -> bytes:
+        pass
+
+    @abstractmethod
+    async def request_bytes(
+        self,
+        url: str,
+        method: str = "GET",
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
+    ) -> bytes:
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def get_form(
+        cls,
+        data: dict[str, typing.Any],
+        files: dict[str, tuple[str, bytes]] | None = None,
+    ) -> typing.Any:
+        pass
+
+    async def __aenter__(self) -> typing.Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException],
+        exc_val: typing.Any,
+        exc_tb: typing.Any,
+    ) -> None:
+        await self.close()
+
+
+__all__ = ("ABCClient",)