telegrinder 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

telegrinder/msgspec_utils/custom_types/literal.py

@@ -0,0 +1,25 @@
+import typing
+
+
+class _LiteralMeta(type):
+    __args__: tuple[typing.Any, ...]
+
+    def __getitem__[T](cls: type[T], values: typing.Any, /) -> type[T]:
+        values = (values,) if not isinstance(values, tuple) else values
+        return _LiteralMeta(cls.__name__, (cls,), {"__args__": values})  # type: ignore
+
+    def __instancecheck__(cls, instance: typing.Any, /) -> bool:
+        return instance in cls.__args__
+
+
+class _Literal(metaclass=_LiteralMeta):
+    pass
+
+
+if typing.TYPE_CHECKING:
+    from typing import Literal
+else:
+    Literal = _Literal
+
+
+__all__ = ("Literal",)

telegrinder/msgspec_utils/custom_types/option.py

@@ -0,0 +1,17 @@
+import typing
+
+if typing.TYPE_CHECKING:
+    from fntypes.option import Option
+else:
+    import fntypes
+    import msgspec
+
+    class OptionMeta(type):
+        def __instancecheck__(cls, __instance):
+            return isinstance(__instance, (fntypes.option.Some | fntypes.option.Nothing, msgspec.UnsetType))
+
+    class Option[Value](metaclass=OptionMeta):
+        pass
+
+
+__all__ = ("Option",)

telegrinder/msgspec_utils/decoder.py

@@ -0,0 +1,389 @@
+import datetime as dt
+import typing
+from contextlib import contextmanager
+
+import fntypes.co
+import msgspec
+from fntypes.result import Error, Ok, Result
+from fntypes.variative import Variative
+
+from telegrinder.msgspec_utils.abc import SupportsCast
+from telegrinder.msgspec_utils.custom_types.datetime import datetime, timedelta
+from telegrinder.msgspec_utils.custom_types.enum_meta import BaseEnumMeta
+from telegrinder.msgspec_utils.custom_types.literal import _Literal
+from telegrinder.msgspec_utils.custom_types.option import Option
+from telegrinder.msgspec_utils.tools import (
+    bundle,
+    fullname,
+    get_origin,
+    is_common_type,
+    type_check,
+)
+
+type Context = dict[str, typing.Any]
+type DecHook[T] = typing.Callable[typing.Concatenate[type[T], typing.Any, ...], typing.Any]
+
+
+def option_dec_hook(
+    tp: type[Option[typing.Any]],
+    obj: typing.Any,
+    /,
+) -> fntypes.co.Option[typing.Any] | msgspec.UnsetType:
+    if obj is msgspec.UNSET:
+        return obj
+
+    if obj is None or isinstance(obj, fntypes.co.Nothing):
+        return fntypes.co.Nothing()
+
+    (value_type,) = typing.get_args(tp) or (typing.Any,)
+    orig_value_type = typing.get_origin(value_type) or value_type
+    orig_obj = obj
+
+    if not isinstance(orig_obj, dict | list) and is_common_type(orig_value_type):
+        if orig_value_type is Variative:
+            obj = value_type(orig_obj)  # type: ignore
+            orig_value_type = typing.get_args(value_type)
+
+        if not type_check(orig_obj, orig_value_type):
+            raise msgspec.ValidationError(
+                f"Expected `{fullname(orig_value_type)}` or `builtins.None`, got `{fullname(orig_obj)}`.",
+            )
+
+        return fntypes.co.Some(obj)
+
+    return fntypes.co.Some(decoder.convert(orig_obj, type=value_type))
+
+
+def variative_dec_hook(tp: type[Variative], obj: typing.Any, /) -> Variative:
+    union_types = typing.get_args(tp)
+
+    if isinstance(obj, dict):
+        reverse = False
+        models_fields_count: dict[type[msgspec.Struct], int] = {
+            m: sum(1 for k in obj if k in m.__struct_fields__)
+            for m in union_types
+            if issubclass(get_origin(m), msgspec.Struct)
+        }
+        union_types = tuple(t for t in union_types if t not in models_fields_count)
+
+        if len(set(models_fields_count.values())) != len(models_fields_count.values()):
+            models_fields_count = {m: len(m.__struct_fields__) for m in models_fields_count}
+            reverse = True
+
+        union_types = (
+            *sorted(
+                models_fields_count,
+                key=lambda k: models_fields_count[k],
+                reverse=reverse,
+            ),
+            *union_types,
+        )
+
+    if not isinstance(obj, dict | list) and any(is_common_type(t) and type_check(obj, t) for t in union_types):
+        return tp(obj)
+
+    for t in union_types:
+        match convert(obj, t):
+            case Ok(value):
+                return tp(value)
+            case Error(_):
+                continue
+            case _ as arg:
+                typing.assert_never(arg)
+
+    raise msgspec.ValidationError(
+        "Object of type `{}` doesn't belong to `{}[{}]`.".format(
+            fullname(obj),
+            fullname(Variative),
+            ", ".join(fullname(get_origin(x)) for x in union_types),
+        )
+    )
+
+
+def datetime_dec_hook(tp: type[datetime], obj: typing.Any, /) -> datetime:
+    if isinstance(obj, datetime):
+        return obj
+
+    if isinstance(obj, dt.datetime):
+        assert issubclass(tp, SupportsCast)
+        return tp.cast(obj)
+
+    if isinstance(obj, int | float):
+        return tp.fromtimestamp(timestamp=obj)
+
+    raise TypeError(
+        "Cannot validate object of type `{}` into `datetime.datetime`".format(
+            fullname(obj),
+        ),
+    )
+
+
+def timedelta_dec_hook(tp: type[timedelta], obj: typing.Any, /) -> timedelta:
+    if isinstance(obj, timedelta):
+        return obj
+
+    if isinstance(obj, dt.timedelta):
+        assert issubclass(tp, SupportsCast)
+        return tp.cast(obj)
+
+    if isinstance(obj, int | float):
+        return tp(seconds=obj)
+
+    raise TypeError(
+        "Cannot validate object of type `{}` into `datetime.timedelta`".format(
+            fullname(obj),
+        ),
+    )
+
+
+def convert[T](
+    obj: typing.Any,
+    t: type[T],
+    /,
+    *,
+    context: Context | None = None,
+) -> Result[T, str]:
+    try:
+        return Ok(decoder.convert(obj, type=t, strict=True, context=context))
+    except msgspec.ValidationError:
+        return Error(
+            "Expected object of type `{}`, got `{}`.".format(
+                fullname(t),
+                fullname(obj),
+            )
+        )
+
+
+def literal_dec_hook(literal: type[_Literal], obj: typing.Any, /) -> typing.Any:
+    if obj in literal.__args__:
+        return obj
+
+    raise msgspec.ValidationError(
+        "Invalid literal value {!r} of either {}.".format(
+            obj,
+            literal.__args__[0]
+            if len(literal.__args__) == 1
+            else (", ".join(f"`{x}`" for x in literal.__args__[:-1])) + f" or `{literal.__args__[-1]}`",
+        )
+    )
+
+
+class Decoder:
+    """Class `Decoder` for `msgspec` module with decode hook
+    for objects with the specified type.
+
+    ```
+    import enum
+
+    from datetime import datetime as dt
+
+    class Digit(enum.IntEnum):
+        ONE = 1
+        TWO = 2
+        THREE = 3
+
+    decoder = Decoder()
+    decoder.dec_hooks[dt] = lambda t, timestamp: t.fromtimestamp(timestamp)
+
+    decoder.dec_hook(dt, 1713354732)  #> datetime.datetime(2024, 4, 17, 14, 52, 12)
+
+    decoder.convert("123", type=int, strict=False)  #> 123
+    decoder.convert(1, type=Digit)  #> <Digit.ONE: 1>
+
+    decoder.decode(b'{"digit":3}', type=dict[str, Digit])  #> {'digit': <Digit.THREE: 3>}
+    ```
+    """
+
+    dec_hooks: dict[typing.Any, DecHook[typing.Any]]
+    abstract_dec_hooks: dict[typing.Any, DecHook[typing.Any]]
+
+    def __init__(self) -> None:
+        self.dec_hooks = {
+            Option: option_dec_hook,
+            Variative: variative_dec_hook,
+            datetime: datetime_dec_hook,
+            timedelta: timedelta_dec_hook,
+            fntypes.option.Some: option_dec_hook,
+            fntypes.option.Nothing: option_dec_hook,
+        }
+        self.abstract_dec_hooks = {
+            BaseEnumMeta: lambda enum_type, member: enum_type(member),
+            _Literal: literal_dec_hook,
+        }
+
+    def __repr__(self) -> str:
+        return "<{}: dec_hooks={!r}, abstract_dec_hooks={!r}>".format(
+            type(self).__name__,
+            self.dec_hooks,
+            self.abstract_dec_hooks,
+        )
+
+    @typing.overload
+    def __call__[T](
+        self,
+        type: type[T],
+        context: Context | None = None,
+    ) -> typing.ContextManager[msgspec.json.Decoder[T]]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        type: typing.Any,
+        context: Context | None = None,
+    ) -> typing.ContextManager[msgspec.json.Decoder[typing.Any]]: ...
+
+    @typing.overload
+    def __call__[T](
+        self,
+        type: type[T],
+        *,
+        strict: bool = True,
+        context: Context | None = None,
+    ) -> typing.ContextManager[msgspec.json.Decoder[T]]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        type: typing.Any,
+        *,
+        strict: bool = True,
+        context: Context | None = None,
+    ) -> typing.ContextManager[msgspec.json.Decoder[typing.Any]]: ...
+
+    @contextmanager
+    def __call__(
+        self,
+        type: typing.Any = object,
+        *,
+        strict: bool = True,
+        context: Context | None = None,
+    ) -> typing.Generator[msgspec.json.Decoder, typing.Any, None]:
+        """Context manager returns an `msgspec.json.Decoder` object with passed the `dec_hook`."""
+        yield msgspec.json.Decoder(
+            type=typing.Any if type is object else type,
+            strict=strict,
+            dec_hook=self.dec_hook(context),
+        )
+
+    def add_dec_hook[T](self, t: type[T], /) -> typing.Callable[[DecHook[T]], DecHook[T]]:
+        def decorator(func: DecHook[T], /) -> DecHook[T]:
+            return self.dec_hooks.setdefault(get_origin(t), func)
+
+        return decorator
+
+    def add_abstract_dec_hook[T](self, abstract_type: type[T], /) -> typing.Callable[[DecHook[T]], DecHook[T]]:
+        def decorator(func: DecHook[T], /) -> DecHook[T]:
+            return self.abstract_dec_hooks.setdefault(get_origin(abstract_type), func)
+
+        return decorator
+
+    def get_abstract_dec_hook(self, subtype: type[typing.Any], /) -> DecHook[typing.Any] | None:
+        for abstract, dec_hook in self.abstract_dec_hooks.items():
+            if issubclass(subtype, abstract) or issubclass(type(subtype), abstract):
+                return dec_hook
+
+        return None
+
+    def dec_hook(self, context: Context | None = None, /) -> DecHook[typing.Any]:
+        def inner(tp: typing.Any, obj: typing.Any, /) -> typing.Any:
+            origin_type = get_origin(tp)
+
+            if (dec_hook_func := self.dec_hooks.get(origin_type)) is None and (
+                dec_hook_func := self.get_abstract_dec_hook(origin_type)
+            ) is None:
+                raise NotImplementedError(
+                    f"Not implemented decode hook for type `{fullname(origin_type)}`. "
+                    "You can implement decode hook for this type.",
+                )
+
+            return bundle(dec_hook_func, context or {}, start_idx=2)(tp, obj)
+
+        return inner
+
+    def convert[T](
+        self,
+        obj: object,
+        *,
+        type: type[T] = dict,
+        strict: bool = True,
+        from_attributes: bool = False,
+        builtin_types: typing.Iterable[type[typing.Any]] | None = None,
+        str_keys: bool = False,
+        context: Context | None = None,
+    ) -> T:
+        return msgspec.convert(
+            obj,
+            type,
+            strict=strict,
+            from_attributes=from_attributes,
+            dec_hook=self.dec_hook(context),
+            builtin_types=builtin_types,
+            str_keys=str_keys,
+        )
+
+    @typing.overload
+    def decode(
+        self,
+        buf: str | bytes,
+        *,
+        context: Context | None = None,
+    ) -> typing.Any: ...
+
+    @typing.overload
+    def decode[T](
+        self,
+        buf: str | bytes,
+        *,
+        type: type[T],
+        context: Context | None = None,
+    ) -> T: ...
+
+    @typing.overload
+    def decode(
+        self,
+        buf: str | bytes,
+        *,
+        type: typing.Any,
+        context: Context | None = None,
+    ) -> typing.Any: ...
+
+    @typing.overload
+    def decode[T](
+        self,
+        buf: str | bytes,
+        *,
+        type: type[T],
+        strict: bool = True,
+        context: Context | None = None,
+    ) -> T: ...
+
+    @typing.overload
+    def decode(
+        self,
+        buf: str | bytes,
+        *,
+        type: typing.Any,
+        strict: bool = True,
+        context: Context | None = None,
+    ) -> typing.Any: ...
+
+    def decode(
+        self,
+        buf: str | bytes,
+        *,
+        type: typing.Any = object,
+        strict: bool = True,
+        context: Context | None = None,
+    ) -> typing.Any:
+        return msgspec.json.decode(
+            buf,
+            type=typing.Any if type is object else type,
+            strict=strict,
+            dec_hook=self.dec_hook(context),
+        )
+
+
+decoder: typing.Final[Decoder] = Decoder()
+
+
+__all__ = ("Decoder", "convert", "decoder")

telegrinder/msgspec_utils/encoder.py

@@ -0,0 +1,206 @@
+import datetime as dt
+import typing
+from contextlib import contextmanager
+
+import msgspec
+from fntypes.option import Nothing, Some
+from fntypes.result import Error, Ok, Result
+from fntypes.variative import Variative
+
+from telegrinder.msgspec_utils.abc import SupportsCast
+from telegrinder.msgspec_utils.custom_types.datetime import datetime, timedelta
+from telegrinder.msgspec_utils.custom_types.enum_meta import BaseEnumMeta
+from telegrinder.msgspec_utils.tools import bundle, fullname, get_origin
+
+type Context = dict[str, typing.Any]
+type Order = typing.Literal["deterministic", "sorted"]
+type EncHook[T] = typing.Callable[typing.Concatenate[T, ...], typing.Any]
+
+
+def to_builtins(
+    obj: typing.Any,
+    *,
+    str_keys: bool = False,
+    builtin_types: typing.Iterable[type[typing.Any]] | None = None,
+    order: Order | None = None,
+    context: Context | None = None,
+) -> Result[typing.Any, msgspec.ValidationError]:
+    try:
+        return Ok(
+            encoder.to_builtins(
+                obj,
+                str_keys=str_keys,
+                builtin_types=builtin_types,
+                order=order,
+                context=context,
+            ),
+        )
+    except msgspec.ValidationError as error:
+        return Error(error)
+
+
+class Encoder:
+    """Class `Encoder` for `msgspec` module with encode hooks for objects.
+
+    ```
+    from datetime import datetime
+
+    class MyDatetime(datetime):
+        ...
+
+    encoder = Encoder()
+    encoder.enc_hooks[MyDatetime] = lambda d: int(d.timestamp())
+
+    encoder.enc_hook(MyDatetime.now())  #> 1713354732
+    encoder.encode({"digit": Digit.ONE})  #> '{"digit":1}'
+    ```
+    """
+
+    cast_types: dict[type[typing.Any], type[SupportsCast]]
+    enc_hooks: dict[typing.Any, EncHook[typing.Any]]
+    abstract_enc_hooks: dict[typing.Any, EncHook[typing.Any]]
+
+    def __init__(self) -> None:
+        self.cast_types = {  # type: ignore
+            dt.datetime: datetime,
+            dt.timedelta: timedelta,
+        }
+        self.enc_hooks = {
+            Some: lambda some: some.value,
+            Nothing: lambda _: None,
+            Variative: lambda variative: variative.v,
+            datetime: lambda date: int(date.timestamp()),
+            timedelta: lambda time: time.total_seconds(),
+        }
+        self.abstract_enc_hooks = {
+            BaseEnumMeta: lambda enum_member: enum_member.value,
+        }
+
+    def __repr__(self) -> str:
+        return "<{}: cast_types={!r}, enc_hooks={!r}, abstract_enc_hooks={!r}>".format(
+            type(self).__name__,
+            self.cast_types,
+            self.enc_hooks,
+            self.abstract_enc_hooks,
+        )
+
+    @contextmanager
+    def __call__(
+        self,
+        *,
+        decimal_format: typing.Literal["string", "number"] = "string",
+        uuid_format: typing.Literal["canonical", "hex"] = "canonical",
+        order: Order | None = None,
+        context: Context | None = None,
+    ) -> typing.Generator[msgspec.json.Encoder, typing.Any, None]:
+        """Context manager returns the `msgspec.json.Encoder` object with passed the `enc_hook`."""
+        yield msgspec.json.Encoder(
+            enc_hook=self.enc_hook(context),
+            decimal_format=decimal_format,
+            uuid_format=uuid_format,
+            order=order,
+        )
+
+    def add_enc_hook[T](self, t: type[T], /) -> typing.Callable[[EncHook[T]], EncHook[T]]:
+        def decorator(func: EncHook[T], /) -> EncHook[T]:
+            encode_hook = self.enc_hooks.setdefault(get_origin(t), func)
+            return func if encode_hook is not func else encode_hook
+
+        return decorator
+
+    def add_abstract_enc_hook[T](self, abstract_type: type[T], /) -> typing.Callable[[EncHook[T]], EncHook[T]]:
+        def decorator(func: EncHook[T], /) -> EncHook[T]:
+            return self.abstract_enc_hooks.setdefault(get_origin(abstract_type), func)
+
+        return decorator
+
+    def get_abstract_enc_hook(self, subtype: type[typing.Any], /) -> EncHook[typing.Any] | None:
+        for abstract, enc_hook in self.abstract_enc_hooks.items():
+            if issubclass(subtype, abstract) or issubclass(type(subtype), abstract):
+                return enc_hook
+
+        return None
+
+    def enc_hook(self, context: Context | None = None, /) -> EncHook[typing.Any]:
+        def inner(obj: typing.Any, /) -> typing.Any:
+            origin_type = get_origin(obj)
+
+            if (enc_hook_func := self.enc_hooks.get(origin_type)) is None and (
+                enc_hook_func := self.get_abstract_enc_hook(origin_type)
+            ) is None:
+                raise NotImplementedError(
+                    f"Not implemented encode hook for object of type `{fullname(origin_type)}`. "
+                    "You can implement encode hook for this object.",
+                )
+
+            return bundle(enc_hook_func, context or {}, start_idx=1)(obj)
+
+        return inner
+
+    @typing.overload
+    def encode(
+        self,
+        obj: typing.Any,
+        *,
+        order: Order | None = None,
+        context: Context | None = None,
+    ) -> str: ...
+
+    @typing.overload
+    def encode(
+        self,
+        obj: typing.Any,
+        *,
+        as_str: typing.Literal[True],
+        order: Order | None = None,
+        context: Context | None = None,
+    ) -> str: ...
+
+    @typing.overload
+    def encode(
+        self,
+        obj: typing.Any,
+        *,
+        as_str: typing.Literal[False],
+        order: Order | None = None,
+        context: Context | None = None,
+    ) -> bytes: ...
+
+    def encode(
+        self,
+        obj: typing.Any,
+        *,
+        as_str: bool = True,
+        order: Order | None = None,
+        context: Context | None = None,
+    ) -> str | bytes:
+        buf = msgspec.json.encode(obj, enc_hook=self.enc_hook(context), order=order)
+        return buf.decode() if as_str else buf
+
+    def to_builtins(
+        self,
+        obj: typing.Any,
+        *,
+        str_keys: bool = False,
+        builtin_types: typing.Iterable[type[typing.Any]] | None = None,
+        order: Order | None = None,
+        context: Context | None = None,
+    ) -> typing.Any:
+        return msgspec.to_builtins(
+            obj,
+            str_keys=str_keys,
+            builtin_types=builtin_types,
+            enc_hook=self.enc_hook(context),
+            order=order,
+        )
+
+    def cast(self, obj: typing.Any, /) -> typing.Any:
+        if (caster := self.cast_types.get(get_origin(obj))) is not None:
+            return caster.cast(obj)
+        return obj
+
+
+encoder: typing.Final[Encoder] = Encoder()
+
+
+__all__ = ("Encoder", "encoder", "to_builtins")

telegrinder/{msgspec_json.py → msgspec_utils/json.py}

@@ -1,14 +1,15 @@
 import typing
 
-from telegrinder.msgspec_utils import decoder, encoder
-
-
-def loads(s: str | bytes) -> typing.Any:
-    return decoder.decode(s)
+from telegrinder.msgspec_utils.decoder import decoder
+from telegrinder.msgspec_utils.encoder import encoder
 
 
 def dumps(o: typing.Any) -> str:
     return encoder.encode(o)
 
 
+def loads(s: str | bytes) -> typing.Any:
+    return decoder.decode(s)
+
+
 __all__ = ("dumps", "loads")