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

telegrinder/bot/dispatch/view/abc.py

@@ -16,6 +16,7 @@ from telegrinder.msgspec_utils import Option
 from telegrinder.types.objects import Update
 
 EventType = typing.TypeVar("EventType", bound=BaseCute)
+MiddlewareT = typing.TypeVar("MiddlewareT", bound=ABCMiddleware)
 
 
 class ABCView(ABC):
@@ -60,16 +61,12 @@ class BaseView(ABCView, typing.Generic[EventType]):
         return Nothing()
     
     @classmethod
-    def get_event_raw(cls, update: Update) -> Option[Model]:
-        match cls.get_event_type():
-            case Some(event_type):
-                for field in update.__struct_fields__:
-                    event_raw = getattr(update, field)
-                    if isinstance(event_raw, Some | Nothing):
-                        event_raw = event_raw.unwrap_or_none()
-                    if event_raw is not None and issubclass(event_type, event_raw.__class__):
-                        return Some(event_raw)
-        return Nothing()
+    def get_raw_event(cls, update: Update) -> Option[Model]:
+        match update.update_type:
+            case Some(update_type):
+                return getattr(update, update_type.value)
+            case _:
+                return Nothing()
 
     def __call__(
         self,
@@ -96,20 +93,30 @@ class BaseView(ABCView, typing.Generic[EventType]):
         return wrapper
     
     def register_middleware(self, *args: typing.Any, **kwargs: typing.Any):
-        def wrapper(cls: type[ABCMiddleware[EventType]]):
+        def wrapper(cls: type[MiddlewareT]):
             self.middlewares.append(cls(*args, **kwargs))
             return cls
         
         return wrapper
     
     async def check(self, event: Update) -> bool:
-        return bool(self.get_event_raw(event))
+        match self.get_raw_event(event):
+            case Some(e) if issubclass(
+                self.get_event_type().expect(
+                    "{!r} has no event type in generic.".format(self.__class__.__name__),
+                ),
+                e.__class__,
+            ):
+                return True
+            case _:
+                return False
         
     async def process(self, event: Update, api: ABCAPI) -> bool:
-        event_raw = self.get_event_raw(event).unwrap()
-        event_type = self.get_event_type().unwrap()
         return await process_inner(
-            event_type(**event_raw.to_dict(), api=api),
+            self.get_event_type().unwrap().from_update(
+                update=self.get_raw_event(event).unwrap(),
+                bound_api=api,
+            ),
             event,
             self.middlewares,
             self.handlers,

telegrinder/bot/rules/adapter/event.py

@@ -14,14 +14,20 @@ CuteT = typing.TypeVar("CuteT", bound=BaseCute)
 
 
 class EventAdapter(ABCAdapter[Update, CuteT]):
-    def __init__(self, event_name: str, model: type[CuteT]):
+    def __init__(self, event_name: str, model: type[CuteT]) -> None:
         self.event_name = event_name
         self.model = model
     
     def __repr__(self) -> str:
-        return "<{}: adapt Update.{} -> {}>".format(
+        raw_update_type = Update.__annotations__.get(self.event_name, "Unknown")
+        raw_update_type = (
+            typing.get_args(raw_update_type)[0].__forward_arg__
+            if typing.get_args(raw_update_type)
+            else raw_update_type
+        )
+        return "<{}: adapt {} -> {}>".format(
             self.__class__.__name__,
-            self.event_name,
+            raw_update_type,
             self.model.__name__,
         )
 
@@ -29,14 +35,14 @@ class EventAdapter(ABCAdapter[Update, CuteT]):
         update_dct = update.to_dict()
         if self.event_name not in update_dct:
             return Error(
-                AdapterError(f"Update is not of event type {self.event_name!r}.")
+                AdapterError(f"Update is not of event type {self.event_name!r}."),
             )
         if update_dct[self.event_name] is Nothing:
             return Error(
-                AdapterError(f"Update is not an {self.event_name!r}.")
+                AdapterError(f"Update is not an {self.event_name!r}."),
             )
         return Ok(
-            self.model.from_update(update_dct[self.event_name].unwrap(), bound_api=api)
+            self.model.from_update(update_dct[self.event_name].unwrap(), bound_api=api),
         )
 
 

telegrinder/client/__init__.py

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

telegrinder/client/abc.py

@@ -1,35 +1,49 @@
 import typing
 from abc import ABC, abstractmethod
 
-ClientData = typing.Any
-
 
 class ABCClient(ABC):
     @abstractmethod
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: typing.Any, **kwargs: typing.Any):
         pass
 
     @abstractmethod
     async def request_text(
-        self, url: str, method: str = "GET", data: dict | None = None, **kwargs
+        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 | None = None, **kwargs
-    ) -> dict:
+        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 | None = None, **kwargs
+        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 | None = None, **kwargs
+        self,
+        url: str,
+        method: str = "GET",
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
     ) -> bytes:
         pass
 
@@ -39,14 +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", "ClientData")
+__all__ = ("ABCClient",)

telegrinder/client/aiohttp.py

@@ -1,3 +1,4 @@
+import secrets
 import ssl
 import typing
 
@@ -18,19 +19,27 @@ class AiohttpClient(ABCClient):
         session: ClientSession | None = None,
         json_processing_module: JSONModule | None = None,
         timeout: aiohttp.ClientTimeout | None = None,
-        **session_params,
-    ):
+        **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: dict | None = None,
-        **kwargs,
+        data: dict[str, typing.Any] | None = None,
+        **kwargs: typing.Any,
     ) -> "ClientResponse":
         if not self.session:
             self.session = ClientSession(
@@ -54,9 +63,9 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: dict | None = 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",
@@ -68,8 +77,8 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: 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)  # type: ignore
         return await response.text(encoding="utf-8")
@@ -78,8 +87,8 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: 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)  # type: ignore
         if response._body is None:
@@ -90,8 +99,8 @@ class AiohttpClient(ABCClient):
         self,
         url: str,
         method: str = "GET",
-        data: dict | None = 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
@@ -101,18 +110,22 @@ 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()

telegrinder/model.py

@@ -1,10 +1,14 @@
+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
+from .msgspec_utils import decoder, encoder, get_origin
 
 T = typing.TypeVar("T")
 
@@ -41,31 +45,12 @@ def full_result(
     return result.map(lambda v: decoder.decode(v, type=full_t))  # type: ignore
 
 
-def convert(d: typing.Any, serialize: bool = True) -> typing.Any:
-    if isinstance(d, Model):
-        converted_dct = convert(d.to_dict(), serialize=False)
-        return encoder.encode(converted_dct) if serialize is True else converted_dct
-    
-    if isinstance(d, dict):
-        return {
-            k: convert(v, serialize=serialize)
-            for k, v in d.items()
-            if type(v) not in (NoneType, Nothing)
-        }
-    
-    if isinstance(d, list):
-        converted_lst = [convert(x, serialize=False) for x in d]
-        return encoder.encode(converted_lst) if serialize is True else converted_lst
-    
-    return d
-
-
 def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     return {
         k: v.unwrap() if v and isinstance(v, Some) else v
         for k, v in (
-            *params.items(),
             *params.pop("other", {}).items(),
+            *params.items(),
         )
         if k != "self" and type(v) not in (NoneType, Nothing)
     }
@@ -87,9 +72,72 @@ class Model(msgspec.Struct, **MODEL_CONFIG):
         }
 
 
+@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__ = (
+    "DataConverter",
     "Model",
-    "convert",
     "full_result",
     "get_params",
     "MODEL_CONFIG",

telegrinder/modules.py

@@ -5,10 +5,10 @@ from choicelib import choice_in_order
 
 
 class JSONModule(typing.Protocol):
-    def loads(self, s: str) -> dict | list:
+    def loads(self, s: str) -> dict[str, typing.Any] | list[typing.Any]:
         ...
 
-    def dumps(self, o: dict | list) -> str:
+    def dumps(self, o: dict[str, typing.Any] | list[typing.Any]) -> str:
         ...
 
 

telegrinder/msgspec_utils.py

@@ -1,4 +1,3 @@
-import types  # noqa: TCH003
 import typing
 
 import fntypes.option
@@ -9,11 +8,17 @@ T = typing.TypeVar("T")
 Ts = typing.TypeVarTuple("Ts")
 
 if typing.TYPE_CHECKING:
+    import types
+    from datetime import datetime
+
     from fntypes.option import Option
 else:
+    from datetime import datetime as dt
 
     Value = typing.TypeVar("Value")
 
+    datetime = type("datetime", (dt,), {})
+
     class OptionMeta(type):
         def __instancecheck__(cls, __instance: typing.Any) -> bool:
             return isinstance(__instance, fntypes.option.Some | fntypes.option.Nothing)
@@ -22,8 +27,8 @@ else:
     class Option(typing.Generic[Value], metaclass=OptionMeta):
         pass
 
-DecHook: typing.TypeAlias = typing.Callable[[type[T], object], object]
-EncHook: typing.TypeAlias = typing.Callable[[T], object]
+DecHook: typing.TypeAlias = typing.Callable[[type[T], typing.Any], object]
+EncHook: typing.TypeAlias = typing.Callable[[T], typing.Any]
 
 Nothing: typing.Final[fntypes.option.Nothing] = fntypes.option.Nothing()
 
@@ -43,7 +48,11 @@ def msgspec_convert(obj: typing.Any, t: type[T]) -> Result[T, msgspec.Validation
         return Error(exc)
 
 
-def option_dec_hook(tp: type["Option[typing.Any]"], obj: typing.Any) -> typing.Any:
+def datetime_dec_hook(tp: type[datetime], obj: int | float) -> datetime:
+    return tp.fromtimestamp(obj)
+
+
+def option_dec_hook(tp: type[Option[typing.Any]], obj: typing.Any) -> Option[typing.Any]:
     if obj is None:
         return Nothing
     generic_args = typing.get_args(tp)
@@ -85,19 +94,26 @@ def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
     )
 
 
-def option_enc_hook(obj: "Option[typing.Any]") -> typing.Any | None:
+def datetime_enc_hook(obj: datetime) -> int:
+    return int(obj.timestamp())
+
+
+def option_enc_hook(obj: Option[typing.Any]) -> typing.Any | None:
     return obj.value if isinstance(obj, fntypes.option.Some) else None
 
 
-def variative_enc_hook(obj: Variative) -> typing.Any:
-    return typing.cast(typing.Any, obj.v)
+def variative_enc_hook(obj: Variative[typing.Any]) -> typing.Any:
+    return obj.v
 
 
 class Decoder:
     def __init__(self) -> None:
-        self.dec_hooks: dict[type | types.UnionType, DecHook[typing.Any]] = {
+        self.dec_hooks: dict[
+            typing.Union[type[typing.Any], "types.UnionType"], DecHook[typing.Any]
+        ] = {
             Option: option_dec_hook,
             Variative: variative_dec_hook,
+            datetime: datetime_dec_hook,
         }
 
     def add_dec_hook(self, tp: type[T]):
@@ -156,6 +172,7 @@ class Encoder:
             fntypes.option.Some: option_enc_hook,
             fntypes.option.Nothing: option_enc_hook,
             Variative: variative_enc_hook,
+            datetime: datetime_enc_hook,
         }
 
     def add_dec_hook(self, tp: type[T]):
@@ -198,10 +215,13 @@ __all__ = (
     "get_origin",
     "repr_type",
     "msgspec_convert",
+    "datetime_dec_hook",
+    "datetime_enc_hook",
     "option_dec_hook",
     "option_enc_hook",
     "variative_dec_hook",
     "variative_enc_hook",
+    "datetime",
     "decoder",
     "encoder",
 )

telegrinder/tools/__init__.py

@@ -54,33 +54,6 @@ from .i18n import (
     SimpleI18n,
     SimpleTranslator,
 )
-from .inline_query import (
-    inline_query_article,
-    inline_query_audio,
-    inline_query_cached_audio,
-    inline_query_cached_document,
-    inline_query_cached_gif,
-    inline_query_cached_mpeg4_gif,
-    inline_query_cached_photo,
-    inline_query_cached_sticker,
-    inline_query_cached_video,
-    inline_query_cached_voice,
-    inline_query_contact,
-    inline_query_document,
-    inline_query_game,
-    inline_query_gif,
-    inline_query_location,
-    inline_query_mpeg4_gif,
-    inline_query_photo,
-    inline_query_venue,
-    inline_query_video,
-    inline_query_voice,
-    input_contact_message_content,
-    input_invoice_message_content,
-    input_location_message_content,
-    input_text_message_content,
-    input_venue_message_content,
-)
 from .kb_set import KeyboardSetBase, KeyboardSetYAML
 from .keyboard import (
     AnyMarkup,

telegrinder/tools/buttons.py

@@ -4,6 +4,15 @@ import typing
 import msgspec
 
 from telegrinder.model import encoder
+from telegrinder.types import (
+    CallbackGame,
+    KeyboardButtonPollType,
+    KeyboardButtonRequestChat,
+    KeyboardButtonRequestUsers,
+    SwitchInlineQueryChosenChat,
+    WebAppInfo,
+)
+from telegrinder.types.objects import LoginUrl
 
 ButtonT = typing.TypeVar("ButtonT", bound="BaseButton")
 
@@ -43,8 +52,10 @@ class Button(BaseButton):
     _: dataclasses.KW_ONLY
     request_contact: bool = False
     request_location: bool = False
-    request_poll: dict | None = None
-    web_app: dict | None = None
+    request_chat: dict[str, typing.Any] | KeyboardButtonRequestChat | None = None
+    request_user: dict[str, typing.Any] | KeyboardButtonRequestUsers | None = None
+    request_poll: dict[str, typing.Any] | KeyboardButtonPollType | None = None
+    web_app: dict[str, typing.Any] | WebAppInfo | None = None
 
 
 @dataclasses.dataclass
@@ -52,7 +63,7 @@ class InlineButton(BaseButton):
     text: str
     _: dataclasses.KW_ONLY
     url: str | None = None
-    login_url: dict | None = None
+    login_url: dict[str, typing.Any] | LoginUrl | None = None
     pay: bool | None = None
     callback_data: typing.Union[
         str,
@@ -60,10 +71,13 @@ class InlineButton(BaseButton):
         DataclassInstance,
         msgspec.Struct,
     ] | None = None
-    callback_game: dict | None = None
+    callback_game: dict[str, typing.Any] | CallbackGame | None = None
     switch_inline_query: str | None = None
     switch_inline_query_current_chat: str | None = None
-    web_app: dict | None = None
+    switch_inline_query_chosen_chat: dict[
+        str, typing.Any
+    ] | SwitchInlineQueryChosenChat | None = None
+    web_app: dict[str, typing.Any] | WebAppInfo | None = None
 
 
 __all__ = (

telegrinder/types/enums.py

@@ -152,17 +152,19 @@ class ReactionEmoji(str, enum.Enum):
     ENRAGED_FACE = "😡"
 
 
-class DefaultUserColor(int, enum.Enum):
-    """Type of DefaultUserColor.
+class DefaultAccentColor(int, enum.Enum):
+    """Type of DefaultAccentColor.
 
     One of 7 possible user colors:
-    - red
-    - orange
-    - purple
-    - green
-    - cyan
-    - blue
-    - pink
+    - Red
+    - Orange
+    - Purple
+    - Green
+    - Cyan
+    - Blue
+    - Pink
+
+    Docs: https://core.telegram.org/bots/api#accent-colors
     """
 
     RED = 0