telegrinder 0.1.dev20__py3-none-any.whl → 0.1.dev159__py3-none-any.whl

telegrinder/bot/scenario/__init__.py

@@ -1,3 +1,5 @@
 from .abc import ABCScenario
 from .checkbox import Checkbox
 from .choice import SingleChoice
+
+__all__ = ("ABCScenario", "Checkbox", "SingleChoice")

telegrinder/bot/scenario/abc.py

@@ -1,12 +1,19 @@
-from abc import ABC, abstractmethod
 import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.bot.cute_types.base import BaseCute
 
 if typing.TYPE_CHECKING:
-    from telegrinder.bot.dispatch import Dispatch
-    from telegrinder.api import API
+    from telegrinder.api import ABCAPI
+    from telegrinder.bot.dispatch.view.abc import ABCStateView
 
+EventT = typing.TypeVar("EventT", bound=BaseCute)
 
-class ABCScenario(ABC):
+
+class ABCScenario(ABC, typing.Generic[EventT]):
     @abstractmethod
-    def wait(self, api: "API", dispatch: "Dispatch") -> typing.Any:
+    def wait(self, api: "ABCAPI", view: "ABCStateView[EventT]") -> typing.Any:
         pass
+
+
+__all__ = ("ABCScenario",)

telegrinder/bot/scenario/checkbox.py

@@ -1,22 +1,25 @@
-from .abc import ABCScenario
-from dataclasses import dataclass
-from telegrinder.tools import InlineKeyboard, InlineButton
-from telegrinder.types.objects import InlineKeyboardMarkup
-from telegrinder.bot.cute_types import CallbackQueryCute
-import typing
+import dataclasses
 import random
 import string
+import typing
+
+from telegrinder.bot.cute_types import CallbackQueryCute
+from telegrinder.bot.dispatch.waiter_machine import WaiterMachine
+from telegrinder.tools import InlineButton, InlineKeyboard
+from telegrinder.tools.parse_mode import ParseMode
+from telegrinder.types.objects import InlineKeyboardMarkup
+
+from .abc import ABCScenario
 
 if typing.TYPE_CHECKING:
-    from telegrinder.bot.dispatch import Dispatch
     from telegrinder.api import API
+    from telegrinder.bot.dispatch.view.abc import BaseStateView
 
 
-@dataclass
+@dataclasses.dataclass
 class Choice:
     name: str
     is_picked: bool
-
     default_text: str
     picked_text: str
     code: str
@@ -26,13 +29,14 @@ def random_code(length: int) -> str:
     return "".join(random.choices(string.ascii_letters + string.digits, k=length))
 
 
-class Checkbox(ABCScenario):
-    INVALID_CODE: str = "Invalid code"
-    CALLBACK_ANSWER: str = "Done"
-    PARSE_MODE: str = "MarkdownV2"
+class Checkbox(ABCScenario[CallbackQueryCute]):
+    INVALID_CODE: typing.ClassVar[str] = "Invalid code"
+    CALLBACK_ANSWER: typing.ClassVar[str] = "Done"
+    PARSE_MODE: typing.ClassVar[str] = ParseMode.MARKDOWNV2
 
     def __init__(
         self,
+        waiter_machine: WaiterMachine,
         chat_id: int,
         msg: str,
         ready_text: str = "Ready",
@@ -40,13 +44,14 @@ class Checkbox(ABCScenario):
     ):
         self.chat_id = chat_id
         self.msg = msg
-        self.choices: typing.List[Choice] = []
+        self.choices: list[Choice] = []
         self.ready = ready_text
         self.max_in_row = max_in_row
         self.random_code = random_code(16)
+        self.waiter_machine = waiter_machine
 
     def get_markup(self) -> InlineKeyboardMarkup:
-        kb = InlineKeyboard(resize_keyboard=True)
+        kb = InlineKeyboard()
         choices = self.choices.copy()
         while choices:
             while len(kb.keyboard[-1]) < self.max_in_row and choices:
@@ -60,20 +65,24 @@ class Checkbox(ABCScenario):
                     )
                 )
             kb.row()
+        
         kb.add(InlineButton(self.ready, callback_data=self.random_code + "/ready"))
         return kb.get_markup()
 
     def add_option(
-        self, name: str, default_text: str, picked_text: str, is_picked: bool = False
-    ) -> "Checkbox":
+        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, random_code(16))
+            Choice(name, is_picked, default_text, picked_text, random_code(16)),
         )
         return self
 
     async def handle(self, cb: CallbackQueryCute) -> bool:
-        code = cb.data.replace(self.random_code + "/", "", 1)
-
+        code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
         if code == "ready":
             return False
 
@@ -81,9 +90,7 @@ class Checkbox(ABCScenario):
             if choice.code == code:
                 # Toggle choice
                 self.choices[i].is_picked = not self.choices[i].is_picked
-                await cb.ctx_api.edit_message_text(
-                    cb.message.chat.id,
-                    cb.message.message_id,
+                await cb.edit_text(
                     text=self.msg,
                     parse_mode=self.PARSE_MODE,
                     reply_markup=self.get_markup(),
@@ -93,21 +100,32 @@ class Checkbox(ABCScenario):
         return True
 
     async def wait(
-        self, api: "API", dispatch: "Dispatch"
-    ) -> typing.Tuple[typing.Dict[str, bool], int]:
+        self,
+        api: "API",
+        view: "BaseStateView[CallbackQueryCute]",
+    ) -> tuple[dict[str, bool], int]:
         assert len(self.choices) > 1
         message = (
             await api.send_message(
-                self.chat_id, text=self.msg, parse_mode=self.PARSE_MODE, reply_markup=self.get_markup()
+                self.chat_id,
+                text=self.msg,
+                parse_mode=self.PARSE_MODE,
+                reply_markup=self.get_markup(),
             )
         ).unwrap()
+        
         while True:
             q: CallbackQueryCute
-            q, _ = await dispatch.callback_query.wait_for_answer(message.message_id)
+            q, _ = await self.waiter_machine.wait(view, (api, 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
+        
+        return (
+            {choice.name: choice.is_picked for choice in self.choices},
+            message.message_id,
+        )
+
+
+__all__ = ("Checkbox", "Choice", "random_code")

telegrinder/bot/scenario/choice.py

@@ -1,16 +1,17 @@
-from .checkbox import Checkbox
-from telegrinder.bot.cute_types import CallbackQueryCute
 import typing
 
+from telegrinder.bot.cute_types import CallbackQueryCute
+
+from .checkbox import Checkbox
+
 if typing.TYPE_CHECKING:
     from telegrinder.api import API
-    from telegrinder.bot.dispatch import Dispatch
+    from telegrinder.bot.dispatch.view.abc import BaseStateView
 
 
 class SingleChoice(Checkbox):
     async def handle(self, cb: CallbackQueryCute) -> bool:
-        code = cb.data.replace(self.random_code + "/", "", 1)
-
+        code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
         if code == "ready":
             return False
 
@@ -21,8 +22,8 @@ class SingleChoice(Checkbox):
             if choice.code == code:
                 self.choices[i].is_picked = True
                 await cb.ctx_api.edit_message_text(
-                    cb.message.chat.id,
-                    cb.message.message_id,
+                    chat_id=cb.message.unwrap().v.chat.id,
+                    message_id=cb.message.unwrap().v.message_id,
                     text=self.msg,
                     parse_mode=self.PARSE_MODE,
                     reply_markup=self.get_markup(),
@@ -31,9 +32,14 @@ class SingleChoice(Checkbox):
         return True
 
     async def wait(
-        self, api: "API", dispatch: "Dispatch"
-    ) -> typing.Tuple[str, int]:
+        self,
+        api: "API",
+        cb_view: "BaseStateView[CallbackQueryCute]",
+    ) -> tuple[str, int]:
         if len([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, dispatch)
+        choices, m_id = await super().wait(api, cb_view)
         return list(choices.keys())[list(choices.values()).index(True)], m_id
+
+
+__all__ = ("SingleChoice",)

telegrinder/client/__init__.py

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

telegrinder/client/abc.py

@@ -1,12 +1,10 @@
-from abc import ABC, abstractmethod
 import typing
-
-ClientData = typing.Any
+from abc import ABC, abstractmethod
 
 
 class ABCClient(ABC):
     @abstractmethod
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: typing.Any, **kwargs: typing.Any):
         pass
 
     @abstractmethod
@@ -14,8 +12,8 @@ class ABCClient(ABC):
         self,
         url: str,
         method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
     ) -> str:
         pass
 
@@ -24,9 +22,9 @@ class ABCClient(ABC):
         self,
         url: str,
         method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
-    ) -> dict:
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
+    ) -> dict[str, typing.Any]:
         pass
 
     @abstractmethod
@@ -34,8 +32,8 @@ class ABCClient(ABC):
         self,
         url: str,
         method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
     ) -> bytes:
         pass
 
@@ -44,8 +42,8 @@ class ABCClient(ABC):
         self,
         url: str,
         method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
     ) -> bytes:
         pass
 
@@ -55,11 +53,23 @@ class ABCClient(ABC):
 
     @classmethod
     @abstractmethod
-    def get_form(cls, data: dict) -> typing.Any:
+    def get_form(
+        cls,
+        data: dict[str, typing.Any],
+        files: dict[str, tuple[str, bytes]] | None = None,
+    ) -> typing.Any:
         pass
 
-    async def __aenter__(self) -> "ABCClient":
+    async def __aenter__(self) -> typing.Self:
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException],
+        exc_val: typing.Any,
+        exc_tb: typing.Any,
+    ) -> None:
         await self.close()
+
+
+__all__ = ("ABCClient",)

telegrinder/client/aiohttp.py

@@ -1,12 +1,13 @@
+import secrets
 import ssl
 import typing
 
 import aiohttp
+import certifi
+from aiohttp import ClientSession, TCPConnector
 
 from telegrinder.client.abc import ABCClient
-from aiohttp import ClientSession, TCPConnector
-from telegrinder.modules import json, JSONModule
-import certifi
+from telegrinder.modules import JSONModule, json
 
 if typing.TYPE_CHECKING:
     from aiohttp import ClientResponse
@@ -15,22 +16,30 @@ if typing.TYPE_CHECKING:
 class AiohttpClient(ABCClient):
     def __init__(
         self,
-        session: typing.Optional[ClientSession] = None,
-        json_processing_module: typing.Optional[JSONModule] = None,
-        timeout: typing.Optional[aiohttp.ClientTimeout] = None,
-        **session_params
-    ):
+        session: ClientSession | None = None,
+        json_processing_module: JSONModule | None = None,
+        timeout: aiohttp.ClientTimeout | None = None,
+        **session_params: typing.Any,
+    ) -> None:
         self.session = session
         self.json_processing_module = json_processing_module or json
         self.session_params = session_params
         self.timeout = timeout or aiohttp.ClientTimeout(total=0)
-
+    
+    def __repr__(self) -> str:
+        return "<{}: session={!r}, timeout={}, closed={}>".format(
+            self.__class__.__name__,
+            self.session,
+            self.timeout,
+            False if self.session is None else self.session.closed,
+        )
+    
     async def request_raw(
         self,
         url: str,
         method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
     ) -> "ClientResponse":
         if not self.session:
             self.session = ClientSession(
@@ -41,7 +50,11 @@ class AiohttpClient(ABCClient):
                 **self.session_params,
             )
         async with self.session.request(
-            url=url, method=method, data=data, timeout=self.timeout, **kwargs
+            url=url,
+            method=method,
+            data=data,
+            timeout=self.timeout,
+            **kwargs,
         ) as response:
             await response.read()
             return response
@@ -50,32 +63,34 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
-    ) -> dict:
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
+    ) -> dict[str, typing.Any]:
         response = await self.request_raw(url, method, data, **kwargs)
         return await response.json(
-            encoding="utf-8", loads=self.json_processing_module.loads, content_type=None
+            encoding="utf-8",
+            loads=self.json_processing_module.loads,
+            content_type=None,
         )
 
     async def request_text(
         self,
         url: str,
         method: str = "GET",
-        data: typing.Union[dict, aiohttp.FormData, None] = None,
-        **kwargs
+        data: dict[str, typing.Any] | aiohttp.FormData | None = None,
+        **kwargs: typing.Any,
     ) -> str:
-        response = await self.request_raw(url, method, data, **kwargs)
+        response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
         return await response.text(encoding="utf-8")
 
     async def request_bytes(
         self,
         url: str,
         method: str = "GET",
-        data: typing.Union[dict, aiohttp.FormData, None] = None,
-        **kwargs
+        data: dict[str, typing.Any] | aiohttp.FormData | None = None,
+        **kwargs: typing.Any,
     ) -> bytes:
-        response = await self.request_raw(url, method, data, **kwargs)
+        response = await self.request_raw(url, method, data, **kwargs)  # type: ignore
         if response._body is None:
             await response.read()
         return response._body
@@ -84,8 +99,8 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: typing.Optional[dict] = None,
-        **kwargs
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
     ) -> bytes:
         response = await self.request_raw(url, method, data, **kwargs)
         return response._body
@@ -95,19 +110,26 @@ class AiohttpClient(ABCClient):
             await self.session.close()
 
     @classmethod
-    def get_form(cls, data: dict) -> aiohttp.formdata.FormData:
+    def get_form(
+        cls,
+        data: dict[str, typing.Any],
+        files: dict[str, tuple[str, bytes]] | None = None,
+    ) -> aiohttp.formdata.FormData:
+        files = files or {}
         form = aiohttp.formdata.FormData(quote_fields=False)
         for k, v in data.items():
-            params = {}
-            if isinstance(v, tuple):
-                params["filename"], v = v[0], v[1]
-            else:
-                v = str(v)
-            form.add_field(k, v, **params)
+            form.add_field(k, str(v))
+        
+        for n, f in files.items():
+            form.add_field(n, f[1], filename=f[0])
+        
         return form
 
-    def __del__(self):
+    def __del__(self) -> None:
         if self.session and not self.session.closed:
             if self.session._connector is not None and self.session._connector_owner:
                 self.session._connector.close()
             self.session._connector = None
+
+
+__all__ = ("AiohttpClient",)

telegrinder/model.py

@@ -1,65 +1,144 @@
-import msgspec
-from telegrinder.result import Result
-from telegrinder.modules import json
-from msgspec import Raw
+import dataclasses
+import enum
+import secrets
 import typing
+from datetime import datetime
+from types import NoneType
+
+import msgspec
+from fntypes.co import Nothing, Result, Some
+
+from .msgspec_utils import decoder, encoder, get_origin
+
+T = typing.TypeVar("T")
 
 if typing.TYPE_CHECKING:
     from telegrinder.api.error import APIError
+    
 
-T = typing.TypeVar("T")
-encoder = msgspec.json.Encoder()
+MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
+    "omit_defaults": True,
+    "dict": True,
+    "rename": {"from_": "from"},
+}
 
 
+@typing.overload
 def full_result(
-    result: Result[msgspec.Raw, "APIError"], full_t: typing.Type[T]
+    result: Result[msgspec.Raw, "APIError"], full_t: type[T]
 ) -> Result[T, "APIError"]:
-    if not result.is_ok:
-        return result
-    return Result(True, value=msgspec.json.decode(result.value, type=full_t))
-
-
-def convert(d: typing.Any) -> typing.Any:
-    if isinstance(d, Model):
-        return msgspec.json.encode(d).decode()
-    elif isinstance(d, dict):
-        return {k: convert(v) for k, v in d.items() if v is not None}
-    elif isinstance(d, list):
-        return json.dumps(d)
-    return d
+    ...
 
 
-model_config = {"rename": {"from_": "from"}, "omit_defaults": True}
-
+@typing.overload
+def full_result(
+    result: Result[msgspec.Raw, "APIError"],
+    full_t: tuple[type[T], ...],
+) -> Result[T, "APIError"]:
+    ...
 
-class Model(msgspec.Struct, **model_config):
-    _dict_cached: typing.Optional[dict] = None
 
-    def to_dict(self) -> dict:
-        if self._dict_cached is not None:
-            return self._dict_cached
-        self._dict_cached = {k: getattr(self, k) for k in self.__struct_fields__}
-        return self._dict_cached
+def full_result(
+    result: Result[msgspec.Raw, "APIError"],
+    full_t: type[T] | tuple[type[T], ...],
+) -> Result[T, "APIError"]:
+    return result.map(lambda v: decoder.decode(v, type=full_t))  # type: ignore
 
 
-def get_params(params: dict) -> dict:
+def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     return {
-        k: v for k, v in (
+        k: v.unwrap() if v and isinstance(v, Some) else v
+        for k, v in (
+            *params.pop("other", {}).items(),
             *params.items(),
-            *params.pop("other").items()
         )
-        if k != "self"
-        and v is not None
+        if k != "self" and type(v) not in (NoneType, Nothing)
     }
 
 
+class Model(msgspec.Struct, **MODEL_CONFIG):
+    def to_dict(
+        self,
+        *,
+        exclude_fields: set[str] | None = None,
+    ) -> dict[str, typing.Any]:  
+        exclude_fields = exclude_fields or set()
+        if "model_as_dict" not in self.__dict__:
+            self.__dict__["model_as_dict"] = msgspec.structs.asdict(self)
+        return {
+            key: value
+            for key, value in self.__dict__["model_as_dict"].items()
+            if key not in exclude_fields
+        }
+
+
+@dataclasses.dataclass(kw_only=True)
+class DataConverter:
+    files: dict[str, tuple[str, bytes]] = dataclasses.field(default_factory=lambda: {})
+
+    @property
+    def converters(self) -> dict[
+        type[typing.Any], typing.Callable[[typing.Self, typing.Any, bool], typing.Any]
+    ]:
+        return {
+            get_origin(value.__annotations__["d"]): value
+            for key, value in vars(self.__class__).items()
+            if key.startswith("convert_")
+            and callable(value)
+        }
+    
+    def get_converter(
+        self, t: type[typing.Any]
+    ) -> typing.Callable[[typing.Self, typing.Any, bool], typing.Any] | None:
+        for type, converter in self.converters.items():
+            if issubclass(t, type):
+                return converter
+        return None
+    
+    def convert_model(self, d: Model, serialize: bool = True) -> str | dict[str, typing.Any]:
+        converted_dct = self.convert(d.to_dict(), serialize=False)
+        return encoder.encode(converted_dct) if serialize is True else converted_dct
+    
+    def convert_dct(self, d: dict[str, typing.Any], serialize: bool = True) -> dict[str, typing.Any]:
+        return {
+            k: self.convert(v, serialize=serialize)
+            for k, v in d.items()
+            if type(v) not in (NoneType, Nothing)
+        }
+    
+    def convert_lst(self, d: list[typing.Any], serialize: bool = True) -> str | list[typing.Any]:
+        converted_lst = [self.convert(x, serialize=False) for x in d]
+        return encoder.encode(converted_lst) if serialize is True else converted_lst
+    
+    def convert_tpl(self, d: tuple[typing.Any, ...], serialize: bool = True) -> str | tuple[typing.Any, ...]:
+        if (
+            isinstance(d, tuple)
+            and len(d) == 2
+            and isinstance(d[0], str)
+            and isinstance(d[1], bytes)
+        ):
+            attach_name = secrets.token_urlsafe(16)
+            self.files[attach_name] = d
+            return "attach://{}".format(attach_name)
+        return d
+    
+    def convert_enum(self, d: enum.Enum, serialize: bool = True) -> str:
+        return d.value
+    
+    def convert_datetime(self, d: datetime, serialize: bool = True) -> int:
+        return int(d.timestamp())
+
+    def convert(self, data: typing.Any, *, serialize: bool = True) -> typing.Any:
+        converter = self.get_converter(get_origin(type(data)))
+        if converter is not None:
+            return converter(self, data, serialize)
+        return data
+
+
 __all__ = (
-    "convert",
-    "model_config",
-    "encoder",
-    "full_result",
-    "msgspec",
+    "DataConverter",
     "Model",
-    "Raw",
+    "full_result",
     "get_params",
+    "MODEL_CONFIG",
 )