telegrinder 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/bot/scenario/checkbox.py

@@ -1,176 +1,174 @@
-import dataclasses
-import enum
-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)
-
-
-class ChoiceCode(enum.StrEnum):
-    READY = "ready"
-    CANCEL = "cancel"
-
-
-@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 + "/" + ChoiceCode.READY))
-        if self.cancel_text is not None:
-            kb.row()
-            kb.add(InlineButton(self.cancel_text, callback_data=self.random_code + "/" + ChoiceCode.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)
-
-        match code:
-            case ChoiceCode.READY:
-                return False
-            case ChoiceCode.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")
+import dataclasses
+import enum
+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
+
+
+class ChoiceAction(enum.StrEnum):
+    READY = "ready"
+    CANCEL = "cancel"
+
+
+@dataclasses.dataclass(slots=True)
+class Choice[Key: typing.Hashable]:
+    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 + "/" + ChoiceAction.READY))
+        if self.cancel_text is not None:
+            kb.row()
+            kb.add(InlineButton(self.cancel_text, callback_data=self.random_code + "/" + ChoiceAction.CANCEL))
+
+        return kb.get_markup()
+
+    def add_option[Key: typing.Hashable](
+        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)
+
+        match code:
+            case ChoiceAction.READY:
+                return False
+            case ChoiceAction.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",
+    ) -> 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,
+                data=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[Key: typing.Hashable](_Checkbox):
+        choices: list[Choice[Key]]
+
+        async def wait(
+            self,
+            hasher: Hasher[CallbackQueryCute, int],
+            api: "API",
+        ) -> tuple[dict[Key, bool], int]: ...
+
+else:
+    Checkbox = _Checkbox
+
+
+__all__ = ("Checkbox", "Choice")

telegrinder/bot/scenario/choice.py

@@ -1,51 +1,48 @@
-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, ChoiceCode
-
-if typing.TYPE_CHECKING:
-    from telegrinder.api.api import API
-    from telegrinder.bot.dispatch.view.base import BaseStateView
-    from telegrinder.bot.scenario.checkbox import Key
-
-    class Choice(Checkbox[Key], typing.Generic[Key]):
-        async def wait(
-            self,
-            hasher: Hasher[CallbackQueryCute, int],
-            api: API,
-            view: BaseStateView[CallbackQueryCute],
-        ) -> tuple[Key, int]: ...
-
-else:
-
-    class Choice(Checkbox):
-        async def handle(self, cb):
-            code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
-            if code == ChoiceCode.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, api, view):
-            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",)
+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, ChoiceAction
+
+if typing.TYPE_CHECKING:
+    from telegrinder.api.api import API
+    from telegrinder.bot.dispatch.view.base import BaseStateView
+
+    class Choice[Key: typing.Hashable](Checkbox[Key]):
+        async def wait(
+            self,
+            hasher: Hasher[CallbackQueryCute, int],
+            api: API,
+        ) -> tuple[Key, int]: ...
+
+else:
+    class Choice(Checkbox):
+        async def handle(self, cb):
+            code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
+            if code == ChoiceAction.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, api):
+            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)
+            return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
+
+
+__all__ = ("Choice",)

telegrinder/client/__init__.py

@@ -1,4 +1,12 @@
-from .abc import ABCClient
-from .aiohttp import AiohttpClient
-
-__all__ = ("ABCClient", "AiohttpClient")
+from .abc import ABCClient
+from .aiohttp import AiohttpClient
+from .form_data import MultipartFormProto, encode_form_data
+from .sonic import AiosonicClient
+
+__all__ = (
+    "ABCClient",
+    "AiohttpClient",
+    "AiosonicClient",
+    "MultipartFormProto",
+    "encode_form_data",
+)

telegrinder/client/abc.py

@@ -1,75 +1,100 @@
-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 io
+import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.client.form_data import MultipartFormProto, encode_form_data
+
+type Data = dict[str, typing.Any] | MultipartFormProto
+
+
+class ABCClient[MultipartForm: MultipartFormProto](ABC):
+    CONNECTION_TIMEOUT_ERRORS: tuple[type[BaseException], ...] = ()
+    CLIENT_CONNECTION_ERRORS: tuple[type[BaseException], ...] = ()
+
+    @abstractmethod
+    def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
+        pass
+
+    @abstractmethod
+    async def request_text(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    async def request_json(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> dict[str, typing.Any]:
+        pass
+
+    @abstractmethod
+    async def request_content(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> bytes:
+        pass
+
+    @abstractmethod
+    async def request_bytes(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Any,
+    ) -> bytes:
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def multipart_form_factory(cls) -> MultipartForm:
+        pass
+
+    @classmethod
+    def get_form(
+        cls,
+        *,
+        data: dict[str, typing.Any],
+        files: dict[str, tuple[str, typing.Any]] | None = None,
+    ) -> MultipartForm:
+        multipart_form = cls.multipart_form_factory()
+        files = files or {}
+
+        for k, v in encode_form_data(data, files).items():
+            multipart_form.add_field(k, v)
+
+        for n, (filename, content) in {
+            k: (n, io.BytesIO(c) if isinstance(c, bytes) else c) for k, (n, c) in files.items()
+        }.items():
+            multipart_form.add_field(n, content, filename=filename)
+
+        return multipart_form
+
+    async def __aenter__(self) -> typing.Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException],
+        exc_val: typing.Any,
+        exc_tb: typing.Any,
+    ) -> bool:
+        await self.close()
+        return not bool(exc_val)
+
+
+__all__ = ("ABCClient",)