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

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
+        k: v.unwrap() if 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,71 @@ 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.Any]]:
+        return {
+            get_origin(value.__annotations__["data"]): value
+            for key, value in vars(self.__class__).items()
+            if key.startswith("convert_") and callable(value)   
+        }
+
+    @staticmethod
+    def convert_enum(data: enum.Enum, _: bool = True) -> typing.Any:
+        return data.value
+    
+    @staticmethod
+    def convert_datetime(data: datetime, _: bool = True) -> int:
+        return int(data.timestamp())
+
+    def __call__(self, data: typing.Any, *, serialize: bool = True) -> typing.Any:
+        converter = self.get_converter(get_origin(type(data)))
+        if converter is not None:
+            if isinstance(converter, staticmethod):
+                return converter(data, serialize)
+            return converter(self, data, serialize)
+        return data
+    
+    def get_converter(self, t: type[typing.Any]):
+        for type, converter in self.converters.items():
+            if issubclass(t, type):
+                return converter
+        return None
+    
+    def convert_model(self, data: Model, serialize: bool = True) -> str | dict[str, typing.Any]:
+        converted_dct = self(data.to_dict(), serialize=False)
+        return encoder.encode(converted_dct) if serialize is True else converted_dct
+    
+    def convert_dct(self, data: dict[str, typing.Any], serialize: bool = True) -> dict[str, typing.Any]:
+        return {
+            k: self(v, serialize=serialize)
+            for k, v in data.items()
+            if type(v) not in (NoneType, Nothing)
+        }
+    
+    def convert_lst(self, data: list[typing.Any], serialize: bool = True) -> str | list[typing.Any]:
+        converted_lst = [self(x, serialize=False) for x in data]
+        return encoder.encode(converted_lst) if serialize is True else converted_lst
+    
+    def convert_tpl(self, data: tuple[typing.Any, ...], _: bool = True) -> str | tuple[typing.Any, ...]:
+        if (
+            isinstance(data, tuple)
+            and len(data) == 2
+            and isinstance(data[0], str)
+            and isinstance(data[1], bytes)
+        ):
+            attach_name = secrets.token_urlsafe(16)
+            self.files[attach_name] = data
+            return "attach://{}".format(attach_name)
+        return data
+    
+
 __all__ = (
+    "DataConverter",
     "Model",
-    "convert",
     "full_result",
     "get_params",
     "MODEL_CONFIG",

telegrinder/modules.py

@@ -5,30 +5,30 @@ from choicelib import choice_in_order
 
 
 class JSONModule(typing.Protocol):
-    def loads(self, s: str) -> dict | list:
+    def loads(self, s: str | bytes) -> 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:
         ...
 
 
 class LoggerModule(typing.Protocol):
-    def debug(self, __msg: object, *args: object, **kwargs: object):
+    def debug(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
 
-    def info(self, __msg: object, *args: object, **kwargs: object):
+    def info(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
 
-    def warning(self, __msg: object, *args: object, **kwargs: object):
+    def warning(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
 
-    def error(self, __msg: object, *args: object, **kwargs: object):
+    def error(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
 
-    def critical(self, __msg: object, *args: object, **kwargs: object):
+    def critical(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
 
-    def exception(self, __msg: object, *args: object, **kwargs: object):
+    def exception(self, __msg: object, *args: object, **kwargs: object) -> None:
         ...
 
     def set_level(
@@ -187,7 +187,7 @@ elif logging_module == "logging":
 
 
     class LogMessage:
-        def __init__(self, fmt, args, kwargs):
+        def __init__(self, fmt: typing.Any, args: typing.Any, kwargs: typing.Any) -> None:
             self.fmt = fmt
             self.args = args
             self.kwargs = kwargs
@@ -195,17 +195,27 @@ elif logging_module == "logging":
         def __str__(self) -> str:
             return self.fmt.format(*self.args, **self.kwargs)
 
+
     class TelegrinderLoggingStyleAdapter(logging.LoggerAdapter):
-        def __init__(self, logger, extra=None):
+        def __init__(
+            self,
+            logger: LoggerModule,
+            extra: dict[str, typing.Any] | None = None,
+        ) -> None:
             super().__init__(logger, extra or {})
 
-        def log(self, level, msg, *args, **kwargs):
+        def log(self, level: int, msg: object, *args: object, **kwargs: object) -> None:
             if self.isEnabledFor(level):
                 kwargs.setdefault("stacklevel", 2)
                 msg, args, kwargs = self.proc(msg, args, kwargs)
                 self.logger._log(level, msg, args, **kwargs)
 
-        def proc(self, msg, args, kwargs):
+        def proc(
+            self,
+            msg: object,
+            args: tuple[object, ...],
+            kwargs: dict[str, object],
+        ) -> tuple[LogMessage | object, tuple[object, ...], dict[str, object]]:
             log_kwargs = {
                 key: kwargs[key]
                 for key in inspect.getfullargspec(self.logger._log).args[1:]

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]):
@@ -174,11 +191,11 @@ class Encoder:
         return self.enc_hooks[origin_type](obj)
     
     @typing.overload
-    def encode(self, obj: typing.Any) -> str:
+    def encode(self, obj: typing.Any, *, as_str: typing.Literal[True] = True) -> str:
         ...
 
     @typing.overload
-    def encode(self, obj: typing.Any, *, as_str: bool = False) -> bytes:
+    def encode(self, obj: typing.Any, *, as_str: typing.Literal[False] = False) -> bytes:
         ...
 
     def encode(self, obj: typing.Any, *, as_str: bool = True) -> str | bytes:
@@ -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

@@ -1,5 +1,5 @@
 from .buttons import BaseButton
-from .error_handler import ABCErrorHandler, Catcher, ErrorHandler
+from .error_handler import ABCErrorHandler, Catcher, CatcherError, ErrorHandler
 from .formatting import (
     BaseSpecFormat,
     ChannelBoostLink,
@@ -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,
@@ -89,7 +62,6 @@ from .keyboard import (
     InlineKeyboard,
     Keyboard,
     RowButtons,
-    keyboard_remove,
 )
 from .loop_wrapper import ABCLoopWrapper, DelayedTask, LoopWrapper
 from .magic import magic_bundle, resolve_arg_names
@@ -107,6 +79,7 @@ __all__ = (
     "BaseSpecFormat",
     "Button",
     "Catcher",
+    "CatcherError",
     "ChannelBoostLink",
     "CtxVar",
     "DelayedTask",
@@ -150,7 +123,6 @@ __all__ = (
     "get_start_group_link",
     "invite_chat_link",
     "italic",
-    "keyboard_remove",
     "link",
     "magic_bundle",
     "mention",

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/tools/error_handler/__init__.py

@@ -1,8 +1,10 @@
 from .abc import ABCErrorHandler
+from .error import CatcherError
 from .error_handler import Catcher, ErrorHandler
 
 __all__ = (
     "ABCErrorHandler",
     "Catcher",
+    "CatcherError",
     "ErrorHandler",
 )

telegrinder/tools/error_handler/abc.py

@@ -13,7 +13,11 @@ Handler = typing.Callable[typing.Concatenate[EventT, ...], typing.Awaitable[typi
 
 class ABCErrorHandler(ABC, typing.Generic[EventT]):
     @abstractmethod
-    def catch(self) -> typing.Callable[[typing.Callable], typing.Callable]:
+    def register_catcher(
+        self,
+        *args: typing.Any,
+        **kwargs: typing.Any,
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
         ...
 
     @abstractmethod

telegrinder/tools/error_handler/error.py

@@ -0,0 +1,10 @@
+import typing
+
+
+class CatcherError(TypeError):
+    def __init__(self, exc: typing.Any, error: str) -> None:
+        self.exc = exc
+        self.error = error
+
+
+__all__ = ("CatcherError",)