telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/bot/scenario/checkbox.py

@@ -0,0 +1,183 @@
+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 View
+
+type MessageId = int
+type CallbackQueryView = View
+
+
+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[T](ABCScenario):
+    choices: list[Choice[typing.Hashable]]
+
+    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 = []
+        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(
+            type(self).__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, MessageId],
+        view: CallbackQueryView,
+        api: API,
+    ) -> tuple[dict[typing.Hashable, bool], MessageId]:
+        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,
+                view=view,
+                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, MessageId],
+            view: CallbackQueryView,
+            api: API,
+        ) -> tuple[dict[Key, bool], MessageId]: ...
+
+else:
+    Checkbox = _Checkbox
+
+
+__all__ = ("Checkbox", "Choice")

telegrinder/bot/scenario/choice.py

@@ -0,0 +1,44 @@
+import typing
+
+from telegrinder.api.api import API
+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 CallbackQueryView, Checkbox, ChoiceAction, MessageId
+
+
+class Choice[Key: typing.Hashable](Checkbox[Key]):
+    async def handle(self, cb: CallbackQueryCute) -> bool:
+        code = cb.data.unwrap().replace(f"{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: Hasher[CallbackQueryCute, MessageId],
+        view: CallbackQueryView,
+        api: API,
+    ) -> tuple[Key, MessageId]:
+        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, view, api)
+        return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
+
+
+__all__ = ("Choice",)

telegrinder/client/__init__.py

@@ -0,0 +1,11 @@
+from telegrinder.client.abc import ABCClient, Response
+from telegrinder.client.form_data import MultipartBuilderProto, encode_form_data
+from telegrinder.client.rnet import RnetClient
+
+__all__ = (
+    "ABCClient",
+    "MultipartBuilderProto",
+    "Response",
+    "RnetClient",
+    "encode_form_data",
+)

telegrinder/client/abc.py

@@ -0,0 +1,136 @@
+import dataclasses
+import typing
+from abc import ABC, abstractmethod
+from datetime import timedelta
+from http import HTTPStatus
+
+from telegrinder.client.form_data import MultipartBuilderProto, encode_form_data
+
+if typing.TYPE_CHECKING:
+    import datetime
+
+type Data = typing.Any
+type Files = dict[str, tuple[str, typing.Any]]
+type Timeout = int | float | datetime.timedelta
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class Response[T = typing.Any]:
+    response: T
+    content: bytes
+    status: HTTPStatus
+
+
+class ABCClient(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
+
+    @property
+    @abstractmethod
+    def timeout(self) -> datetime.timedelta:
+        pass
+
+    @abstractmethod
+    async def request(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        timeout: int | float | timedelta | None = None,
+        **kwargs: typing.Any,
+    ) -> Response:
+        pass
+
+    @abstractmethod
+    async def request_text(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        timeout: Timeout | None = None,
+        **kwargs: typing.Any,
+    ) -> str:
+        pass
+
+    @abstractmethod
+    async def request_json(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        timeout: Timeout | 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,
+        timeout: Timeout | None = None,
+        **kwargs: typing.Any,
+    ) -> bytes:
+        pass
+
+    @abstractmethod
+    async def request_bytes(
+        self,
+        url: str,
+        method: str = "GET",
+        data: Data | None = None,
+        timeout: Timeout | None = None,
+        **kwargs: typing.Any,
+    ) -> bytes:
+        pass
+
+    @abstractmethod
+    async def close(self, **kwargs: typing.Any) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def multipart_form_builder(cls) -> MultipartBuilderProto:
+        pass
+
+    @classmethod
+    def get_form(
+        cls,
+        *,
+        data: dict[str, typing.Any] | None = None,
+        files: Files | None = None,
+    ) -> typing.Any:
+        builder = cls.multipart_form_builder()
+
+        if not data and not files:
+            return builder.build()
+
+        data = data or {}
+        files = files or {}
+
+        for k, v in encode_form_data(data, files).items():
+            builder.add_field(k, v)
+
+        for n, (filename, content) in files.items():
+            builder.add_field(n, content, filename=filename)
+
+        return builder.build()
+
+    async def __aenter__(self) -> typing.Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: typing.Any,
+        exc_val: typing.Any,
+        exc_tb: typing.Any,
+    ) -> None:
+        await self.close()
+
+
+__all__ = ("ABCClient", "Response")

telegrinder/client/form_data.py

@@ -0,0 +1,34 @@
+import typing
+
+from telegrinder.msgspec_utils import encoder
+
+
+def encode_form_data(
+    data: dict[str, typing.Any],
+    files: dict[str, tuple[str, typing.Any]],
+    /,
+) -> dict[str, str]:
+    context = dict(files=files)
+    return {
+        k: encoder.encode(v, context=context).strip('"')  # Remove quoted string
+        if not isinstance(v, str)
+        else v
+        for k, v in data.items()
+    }
+
+
+@typing.runtime_checkable
+class MultipartBuilderProto(typing.Protocol):
+    def add_field(
+        self,
+        name: str,
+        value: typing.Any,
+        /,
+        filename: str | None = None,
+        **kwargs: typing.Any,
+    ) -> None: ...
+
+    def build(self) -> typing.Any: ...
+
+
+__all__ = ("MultipartBuilderProto", "encode_form_data")

telegrinder/client/rnet.py

@@ -0,0 +1,198 @@
+import dataclasses
+import datetime
+import pathlib
+import sys
+import typing
+from http import HTTPStatus
+
+import certifi
+import rnet
+import rnet.exceptions
+from rnet import Method as HTTPMethod
+
+from telegrinder.__meta__ import __version__
+from telegrinder.client.abc import ABCClient, Response
+from telegrinder.modules import json
+
+if typing.TYPE_CHECKING:
+    from rnet import ClientConfig, Request
+
+type Data = dict[str, typing.Any] | rnet.Multipart
+type Method = typing.Literal["GET", "HEAD", "POST", "PUT", "DELETE", "OPTIONS", "TRACE", "PATCH"]
+
+_METHODS_MAP: typing.Final[dict[Method, HTTPMethod]] = {
+    "GET": HTTPMethod.GET,
+    "HEAD": HTTPMethod.HEAD,
+    "POST": HTTPMethod.POST,
+    "PUT": HTTPMethod.PUT,
+    "DELETE": HTTPMethod.DELETE,
+    "OPTIONS": HTTPMethod.OPTIONS,
+    "TRACE": HTTPMethod.TRACE,
+    "PATCH": HTTPMethod.PATCH,
+}
+USER_AGENT: typing.Final = "CPython/{}.{} RNET/3 Telegrinder/{}".format(
+    sys.version_info.major,
+    sys.version_info.minor,
+    __version__,
+)
+DEFAULT_CONNECTION_TIMEOUT: typing.Final = datetime.timedelta(seconds=30)
+DEFAULT_READ_TIMEOUT: typing.Final = datetime.timedelta(seconds=30)
+DEFAULT_TIMEOUT: typing.Final = datetime.timedelta(seconds=30)
+DEFAULT_HTTP2_MAX_RETRIES: typing.Final = 10
+DEFAULT_ZSTD: typing.Final = True
+DEFAULT_VERIFY: typing.Final = pathlib.Path(certifi.where())
+DEFAULT_ALLOW_REDIRECTS: typing.Final = True
+DEFAULT_HTTP2_ONLY: typing.Final = True
+DEFAULT_TCP_KEEPALIVE_TIME: typing.Final = datetime.timedelta(seconds=60)
+DEFAULT_TCP_KEEPALIVE_INTERVAL: typing.Final = datetime.timedelta(seconds=15)
+DEFAULT_TCP_KEEPALIVE_RETRIES: typing.Final = 4
+DEFAULT_TCP_USER_TIMEOUT: typing.Final = (
+    DEFAULT_TCP_KEEPALIVE_TIME + DEFAULT_TCP_KEEPALIVE_INTERVAL
+) * DEFAULT_TCP_KEEPALIVE_RETRIES
+DEFAULT_TCP_REUSEADDR: typing.Final = True
+DEFAULT_CONNECTION_POOL_IDLE_TIMEOUT: typing.Final = datetime.timedelta(seconds=60)
+DEFAULT_CONNECTION_POOL_CONNECTIONS: typing.Final = 32
+CONNECTION_POOL_MAX_SIZE: typing.Final = DEFAULT_CONNECTION_POOL_CONNECTIONS * 2
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class RnetMultipartBuilder:
+    parts: list[rnet.Part] = dataclasses.field(default_factory=list[rnet.Part])
+
+    def add_field(
+        self,
+        name: str,
+        value: typing.Any,
+        /,
+        *,
+        filename: str | None = None,
+    ) -> None:
+        self.parts.append(rnet.Part(name, value, filename=filename))
+
+    def build(self) -> rnet.Multipart:
+        return rnet.Multipart(*self.parts)
+
+
+class RnetClient(ABCClient):
+    __slots__ = ("_timeout", "_client")
+
+    CONNECTION_TIMEOUT_ERRORS: typing.ClassVar = (
+        TimeoutError,
+        rnet.exceptions.TimeoutError,
+        rnet.exceptions.RustPanic,
+    )
+    CLIENT_CONNECTION_ERRORS: typing.ClassVar = (
+        rnet.exceptions.ConnectionError,
+        rnet.exceptions.ConnectionResetError,
+        rnet.exceptions.TlsError,
+        rnet.exceptions.RustPanic,
+    )
+
+    def __init__(self, **params: typing.Unpack[ClientConfig]) -> None:
+        params.setdefault("user_agent", USER_AGENT)
+        params.setdefault("connect_timeout", DEFAULT_CONNECTION_TIMEOUT)
+        params.setdefault("read_timeout", DEFAULT_READ_TIMEOUT)
+        params.setdefault("verify", DEFAULT_VERIFY)
+        params.setdefault("http2_only", DEFAULT_HTTP2_ONLY)
+        params.setdefault("zstd", DEFAULT_ZSTD)
+        params.setdefault("tcp_keepalive", DEFAULT_TCP_KEEPALIVE_TIME)
+        params.setdefault("tcp_keepalive_interval", DEFAULT_TCP_KEEPALIVE_INTERVAL)
+        params.setdefault("tcp_keepalive_retries", DEFAULT_TCP_KEEPALIVE_RETRIES)
+        params.setdefault("tcp_user_timeout", DEFAULT_TCP_USER_TIMEOUT)
+        params.setdefault("tcp_reuse_address", DEFAULT_TCP_REUSEADDR)
+        params.setdefault("pool_idle_timeout", DEFAULT_CONNECTION_POOL_IDLE_TIMEOUT)
+        params.setdefault("pool_max_idle_per_host", DEFAULT_CONNECTION_POOL_CONNECTIONS)
+        params.setdefault("pool_max_size", CONNECTION_POOL_MAX_SIZE)
+
+        self._timeout = params.setdefault("timeout", DEFAULT_TIMEOUT)
+        self._client = rnet.Client(**params)
+
+    def __repr__(self) -> str:
+        return "<{} {!r}, timeout={!r}>".format(
+            type(self).__name__,
+            self._client,
+            self._timeout,
+        )
+
+    @property
+    def timeout(self) -> datetime.timedelta:
+        return self._timeout
+
+    @classmethod
+    def multipart_form_builder(cls) -> RnetMultipartBuilder:
+        return RnetMultipartBuilder()
+
+    async def request(
+        self,
+        url: str,
+        method: Method = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Unpack[Request],
+    ) -> Response[rnet.Response]:
+        kwargs.setdefault("version", rnet.Version.HTTP_2)
+        kwargs.setdefault("zstd", DEFAULT_ZSTD)
+
+        if data is not None:
+            if isinstance(data, rnet.Multipart):
+                kwargs["multipart"] = data
+            elif isinstance(data, dict):
+                kwargs["json"] = data
+
+        if (json_body := kwargs.pop("json", None)) is not None:
+            kwargs["body"] = json.dumps(json_body)
+
+        if (timeout := kwargs.get("timeout")) is not None and isinstance(timeout, int | float):
+            kwargs["timeout"] = datetime.timedelta(seconds=timeout)
+
+        response = await self._client.request(_METHODS_MAP[method], url, **kwargs)
+        return Response(
+            response=response,
+            content=await response.bytes(),
+            status=HTTPStatus(response.status.as_int()),
+        )
+
+    async def request_text(
+        self,
+        *,
+        url: str,
+        method: Method = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Unpack[Request],
+    ) -> str:
+        return await (await self.request(url, method, data=data, **kwargs)).response.text_with_charset(encoding="utf-8")
+
+    async def request_bytes(
+        self,
+        *,
+        url: str,
+        method: Method = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Unpack[Request],
+    ) -> bytes:
+        return (await self.request(url, method, data=data, **kwargs)).content
+
+    async def request_content(
+        self,
+        *,
+        url: str,
+        method: Method = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Unpack[Request],
+    ) -> bytes:
+        return await self.request_bytes(url=url, method=method, data=data, **kwargs)
+
+    async def request_json(
+        self,
+        *,
+        url: str,
+        method: Method = "GET",
+        data: Data | None = None,
+        **kwargs: typing.Unpack[Request],
+    ) -> dict[str, typing.Any]:
+        return json.loads(await self.request_bytes(url=url, method=method, data=data, **kwargs))
+
+    async def close(self) -> None:
+        return None
+
+
+__all__ = ("RnetClient", "RnetMultipartBuilder")