telegrinder 0.3.4.post1__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/msgspec_utils.py

@@ -1,48 +1,40 @@
-import dataclasses
 import typing
 from contextlib import contextmanager
 
 import fntypes.option
 import fntypes.result
 import msgspec
-from fntypes.co import Error, Ok, Result, Variative
+from fntypes.co import Error, Ok, Variative
 
 if typing.TYPE_CHECKING:
     from datetime import datetime
 
     from fntypes.option import Option
 
-    def get_class_annotations(obj: typing.Any) -> dict[str, type[typing.Any]]: ...
+    def get_class_annotations(obj: typing.Any, /) -> dict[str, typing.Any]: ...
 
-    def get_type_hints(obj: typing.Any) -> dict[str, type[typing.Any]]: ...
+    def get_type_hints(obj: typing.Any, /) -> dict[str, typing.Any]: ...
 
 else:
     from datetime import datetime as dt
 
     from msgspec._utils import get_class_annotations, get_type_hints
 
-    Value = typing.TypeVar("Value")
-    Err = typing.TypeVar("Err")
-
     datetime = type("datetime", (dt,), {})
 
     class OptionMeta(type):
         def __instancecheck__(cls, __instance: typing.Any) -> bool:
-            return isinstance(__instance, fntypes.option.Some | fntypes.option.Nothing)
+            return isinstance(__instance, (fntypes.option.Some | fntypes.option.Nothing, msgspec.UnsetType))
 
-    class Option(typing.Generic[Value], metaclass=OptionMeta):
+    class Option[Value](metaclass=OptionMeta):
         pass
 
 
-T = typing.TypeVar("T")
-
-DecHook: typing.TypeAlias = typing.Callable[[type[T], typing.Any], typing.Any]
-EncHook: typing.TypeAlias = typing.Callable[[T], typing.Any]
+type DecHook[T] = typing.Callable[typing.Concatenate[type[T], typing.Any, ...], typing.Any]
+type EncHook[T] = typing.Callable[typing.Concatenate[T, ...], typing.Any]
 
-Nothing: typing.Final[fntypes.option.Nothing] = fntypes.option.Nothing()
 
-
-def get_origin(t: type[T]) -> type[T]:
+def get_origin[T](t: type[T]) -> type[T]:
     return typing.cast(T, typing.get_origin(t)) or t
 
 
@@ -60,6 +52,14 @@ def is_common_type(type_: typing.Any) -> typing.TypeGuard[type[typing.Any]]:
     )
 
 
+def struct_as_dict(struct: msgspec.Struct, /) -> dict[str, typing.Any]:
+    return {
+        k: v
+        for k, v in msgspec.structs.asdict(struct).items()
+        if not isinstance(v, msgspec.UnsetType | type(None) | fntypes.option.Nothing)
+    }
+
+
 def type_check(obj: typing.Any, t: typing.Any) -> bool:
     return (
         isinstance(obj, t)
@@ -70,7 +70,7 @@ def type_check(obj: typing.Any, t: typing.Any) -> bool:
     )
 
 
-def msgspec_convert(obj: typing.Any, t: type[T]) -> Result[T, str]:
+def msgspec_convert[T](obj: typing.Any, t: type[T]) -> fntypes.result.Result[T, str]:
     try:
         return Ok(decoder.convert(obj, type=t, strict=True))
     except msgspec.ValidationError:
@@ -95,9 +95,15 @@ def msgspec_to_builtins(
         return Error(exc)
 
 
-def option_dec_hook(tp: type[Option[typing.Any]], obj: typing.Any) -> Option[typing.Any]:
-    if obj is None or isinstance(obj, fntypes.Nothing):
-        return Nothing
+def option_dec_hook(
+    tp: type[Option[typing.Any]],
+    obj: typing.Any,
+) -> fntypes.option.Option[typing.Any] | msgspec.UnsetType:
+    if obj is msgspec.UNSET:
+        return obj
+
+    if obj is None or isinstance(obj, fntypes.option.Nothing):
+        return fntypes.option.Nothing()
 
     (value_type,) = typing.get_args(tp) or (typing.Any,)
     orig_value_type = typing.get_origin(value_type) or value_type
@@ -156,11 +162,6 @@ def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
     )
 
 
-@typing.runtime_checkable
-class DataclassInstance(typing.Protocol):
-    __dataclass_fields__: typing.ClassVar[dict[str, dataclasses.Field[typing.Any]]]
-
-
 class Decoder:
     """Class `Decoder` for `msgspec` module with decode hook
     for objects with the specified type.
@@ -175,7 +176,7 @@ class Decoder:
         TWO = 2
         THREE = 3
 
-    decoder = Encoder()
+    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)
@@ -203,17 +204,26 @@ class Decoder:
         )
 
     @typing.overload
-    def __call__(self, type: type[T]) -> typing.ContextManager[msgspec.json.Decoder[T]]: ...
+    def __call__[T](
+        self,
+        type: type[T],
+        context: dict[str, typing.Any] | None = None,
+    ) -> typing.ContextManager[msgspec.json.Decoder[T]]: ...
 
     @typing.overload
-    def __call__(self, type: typing.Any) -> typing.ContextManager[msgspec.json.Decoder[typing.Any]]: ...
+    def __call__(
+        self,
+        type: typing.Any,
+        context: dict[str, typing.Any] | None = None,
+    ) -> typing.ContextManager[msgspec.json.Decoder[typing.Any]]: ...
 
     @typing.overload
-    def __call__(
+    def __call__[T](
         self,
         type: type[T],
         *,
         strict: bool = True,
+        context: dict[str, typing.Any] | None = None,
     ) -> typing.ContextManager[msgspec.json.Decoder[T]]: ...
 
     @typing.overload
@@ -222,34 +232,41 @@ class Decoder:
         type: typing.Any,
         *,
         strict: bool = True,
+        context: dict[str, typing.Any] | None = None,
     ) -> typing.ContextManager[msgspec.json.Decoder[typing.Any]]: ...
 
     @contextmanager
-    def __call__(self, type=object, *, strict=True):
-        """Context manager returns the `msgspec.json.Decoder` object with the `dec_hook`."""
-
+    def __call__(self, type=object, *, strict=True, context=None):
+        """Context manager returns an `msgspec.json.Decoder` object with the `dec_hook`."""
         dec_obj = msgspec.json.Decoder(
             type=typing.Any if type is object else type,
             strict=strict,
-            dec_hook=self.dec_hook,
+            dec_hook=self.dec_hook(context),
         )
         yield dec_obj
 
-    def add_dec_hook(self, t: type[T]):  # type: ignore
+    def add_dec_hook[T](self, t: type[T], /):
         def decorator(func: DecHook[T]) -> DecHook[T]:
-            return self.dec_hooks.setdefault(get_origin(t), func)  # type: ignore
+            return self.dec_hooks.setdefault(get_origin(t), func)
 
         return decorator
 
-    def dec_hook(self, tp: type[typing.Any], obj: object) -> object:
-        origin_type = t if isinstance((t := get_origin(tp)), type) else type(t)
-        if origin_type not in self.dec_hooks:
-            raise TypeError(
-                f"Unknown type `{repr_type(origin_type)}`. You can implement decode hook for this type."
-            )
-        return self.dec_hooks[origin_type](tp, obj)
+    def dec_hook(self, context: dict[str, typing.Any] | None = None):
+        from telegrinder.tools.magic import magic_bundle
+
+        def inner(tp: type[typing.Any], obj: object) -> typing.Any:
+            origin_type = t if isinstance((t := get_origin(tp)), type) else type(t)
+            if origin_type not in self.dec_hooks:
+                raise TypeError(
+                    f"Unknown type `{repr_type(origin_type)}`. You can implement decode hook for this type."
+                )
+            dec_hook_func = self.dec_hooks[origin_type]
+            kwargs = magic_bundle(dec_hook_func, context or {}, start_idx=2, bundle_ctx=False)
+            return dec_hook_func(tp, obj, **kwargs)
+
+        return inner
 
-    def convert(
+    def convert[T](
         self,
         obj: object,
         *,
@@ -258,33 +275,52 @@ class Decoder:
         from_attributes: bool = False,
         builtin_types: typing.Iterable[type[typing.Any]] | None = None,
         str_keys: bool = False,
+        context: dict[str, typing.Any] | None = None,
     ) -> T:
         return msgspec.convert(
             obj,
             type,
             strict=strict,
             from_attributes=from_attributes,
-            dec_hook=self.dec_hook,
+            dec_hook=self.dec_hook(context),
             builtin_types=builtin_types,
             str_keys=str_keys,
         )
 
     @typing.overload
-    def decode(self, buf: str | bytes) -> typing.Any: ...
+    def decode(
+        self,
+        buf: str | bytes,
+        *,
+        context: dict[str, typing.Any] | None = None,
+    ) -> typing.Any: ...
 
     @typing.overload
-    def decode(self, buf: str | bytes, *, type: type[T]) -> T: ...
+    def decode[T](
+        self,
+        buf: str | bytes,
+        *,
+        type: type[T],
+        context: dict[str, typing.Any] | None = None,
+    ) -> T: ...
 
     @typing.overload
-    def decode(self, buf: str | bytes, *, type: typing.Any) -> typing.Any: ...
+    def decode(
+        self,
+        buf: str | bytes,
+        *,
+        type: typing.Any,
+        context: dict[str, typing.Any] | None = None,
+    ) -> typing.Any: ...
 
     @typing.overload
-    def decode(
+    def decode[T](
         self,
         buf: str | bytes,
         *,
         type: type[T],
         strict: bool = True,
+        context: dict[str, typing.Any] | None = None,
     ) -> T: ...
 
     @typing.overload
@@ -294,14 +330,15 @@ class Decoder:
         *,
         type: typing.Any,
         strict: bool = True,
+        context: dict[str, typing.Any] | None = None,
     ) -> typing.Any: ...
 
-    def decode(self, buf, *, type=object, strict=True):
+    def decode(self, buf, *, type=object, strict=True, context=None):
         return msgspec.json.decode(
             buf,
             type=typing.Any if type is object else type,
             strict=strict,
-            dec_hook=self.dec_hook,
+            dec_hook=self.dec_hook(context),
         )
 
 
@@ -340,38 +377,68 @@ class Encoder:
         decimal_format: typing.Literal["string", "number"] = "string",
         uuid_format: typing.Literal["canonical", "hex"] = "canonical",
         order: typing.Literal[None, "deterministic", "sorted"] = None,
+        context: dict[str, typing.Any] | None = None,
     ) -> typing.Generator[msgspec.json.Encoder, typing.Any, None]:
-        """Context manager returns the `msgspec.json.Encoder` object with the `enc_hook`."""
-
-        enc_obj = msgspec.json.Encoder(enc_hook=self.enc_hook)
+        """Context manager returns an `msgspec.json.Encoder` object with the `enc_hook`."""
+        enc_obj = msgspec.json.Encoder(enc_hook=self.enc_hook(context))
         yield enc_obj
 
-    def add_enc_hook(self, t: type[T]):
+    def add_enc_hook[T](self, t: type[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 enc_hook(self, obj: object) -> object:
-        origin_type = get_origin(obj.__class__)
-        if origin_type not in self.enc_hooks:
-            raise NotImplementedError(
-                f"Not implemented encode hook for object of type `{repr_type(origin_type)}`."
-            )
-        return self.enc_hooks[origin_type](obj)
+    def enc_hook(self, context: dict[str, typing.Any] | None = None):
+        from telegrinder.tools.magic import magic_bundle
+
+        def inner(obj: typing.Any) -> typing.Any:
+            origin_type = get_origin(obj.__class__)
+            if origin_type not in self.enc_hooks:
+                raise NotImplementedError(
+                    f"Not implemented encode hook for object of type `{repr_type(origin_type)}`.",
+                )
+            enc_hook_func = self.enc_hooks[origin_type]
+            kwargs = magic_bundle(enc_hook_func, context or {}, start_idx=1, bundle_ctx=False)
+            return enc_hook_func(obj, **kwargs)
+
+        return inner
 
     @typing.overload
-    def encode(self, obj: typing.Any) -> str: ...
+    def encode(
+        self,
+        obj: typing.Any,
+        *,
+        context: dict[str, typing.Any] | None = None,
+    ) -> str: ...
 
     @typing.overload
-    def encode(self, obj: typing.Any, *, as_str: typing.Literal[True]) -> str: ...
+    def encode(
+        self,
+        obj: typing.Any,
+        *,
+        as_str: typing.Literal[True],
+        context: dict[str, typing.Any] | None = None,
+    ) -> str: ...
 
     @typing.overload
-    def encode(self, obj: typing.Any, *, as_str: typing.Literal[False]) -> bytes: ...
+    def encode(
+        self,
+        obj: typing.Any,
+        *,
+        as_str: typing.Literal[False],
+        context: dict[str, typing.Any] | None = None,
+    ) -> bytes: ...
 
-    def encode(self, obj: typing.Any, *, as_str: bool = True) -> str | bytes:
-        buf = msgspec.json.encode(obj, enc_hook=self.enc_hook)
+    def encode(
+        self,
+        obj: typing.Any,
+        *,
+        as_str: bool = True,
+        context: dict[str, typing.Any] | None = None,
+    ) -> str | bytes:
+        buf = msgspec.json.encode(obj, enc_hook=self.enc_hook(context))
         return buf.decode() if as_str else buf
 
     def to_builtins(
@@ -381,12 +448,13 @@ class Encoder:
         str_keys: bool = False,
         builtin_types: typing.Iterable[type[typing.Any]] | None = None,
         order: typing.Literal["deterministic", "sorted"] | None = None,
+        context: dict[str, typing.Any] | None = None,
     ) -> typing.Any:
         return msgspec.to_builtins(
             obj,
             str_keys=str_keys,
             builtin_types=builtin_types,
-            enc_hook=self.enc_hook,
+            enc_hook=self.enc_hook(context),
             order=order,
         )
 
@@ -398,7 +466,6 @@ encoder: typing.Final[Encoder] = Encoder()
 __all__ = (
     "Decoder",
     "Encoder",
-    "Nothing",
     "Option",
     "datetime",
     "decoder",
@@ -407,4 +474,5 @@ __all__ = (
     "get_type_hints",
     "msgspec_convert",
     "msgspec_to_builtins",
+    "struct_as_dict",
 )

telegrinder/node/__init__.py

@@ -1,54 +1,113 @@
-from .attachment import Attachment, Audio, Photo, Video
-from .base import ComposeError, DataNode, Name, Node, ScalarNode, is_node
-from .callback_query import CallbackQueryData, CallbackQueryNode, Field
+from .attachment import (
+    Animation,
+    Attachment,
+    Audio,
+    Document,
+    Photo,
+    SuccessfulPayment,
+    Video,
+    VideoNote,
+    Voice,
+)
+from .base import (
+    Composable,
+    ComposeError,
+    DataNode,
+    FactoryNode,
+    GlobalNode,
+    IsNode,
+    Name,
+    Node,
+    NodeComposeFunction,
+    NodeImpersonation,
+    NodeProto,
+    NodeType,
+    as_node,
+    is_node,
+    scalar_node,
+    unwrap_node,
+)
+from .callback_query import (
+    CallbackQueryData,
+    CallbackQueryDataJson,
+    Field,
+)
 from .command import CommandInfo
-from .composer import Composition, NodeCollection, NodeSession, compose_node, compose_nodes
+from .composer import NodeCollection, NodeSession, compose_node, compose_nodes
 from .container import ContainerNode
+from .either import Either, Optional
 from .event import EventNode
+from .file import File, FileId
 from .me import Me
-from .message import MessageNode
+from .payload import Payload, PayloadData, PayloadSerializer
 from .polymorphic import Polymorphic, impl
 from .rule import RuleChain
-from .scope import GLOBAL, PER_CALL, PER_EVENT, NodeScope, global_node, per_call, per_event
-from .source import ChatSource, Source, UserSource
+from .scope import (
+    GLOBAL,
+    PER_CALL,
+    PER_EVENT,
+    NodeScope,
+    global_node,
+    per_call,
+    per_event,
+)
+from .source import ChatSource, Source, UserId, UserSource
 from .text import Text, TextInteger, TextLiteral
 from .tools import generate_node
-from .update import UpdateNode
 
 __all__ = (
+    "Animation",
     "Attachment",
     "Audio",
     "CallbackQueryData",
-    "CallbackQueryNode",
+    "CallbackQueryDataJson",
     "ChatSource",
     "CommandInfo",
+    "Composable",
     "ComposeError",
-    "Composition",
     "ContainerNode",
     "DataNode",
+    "Document",
+    "Either",
     "EventNode",
+    "FactoryNode",
+    "Field",
     "Field",
+    "File",
+    "FileId",
     "GLOBAL",
+    "GlobalNode",
+    "IsNode",
     "Me",
-    "MessageNode",
     "Name",
     "Node",
     "NodeCollection",
+    "NodeComposeFunction",
+    "NodeImpersonation",
+    "NodeProto",
     "NodeScope",
     "NodeSession",
+    "NodeType",
+    "Optional",
     "PER_CALL",
     "PER_EVENT",
+    "Payload",
+    "PayloadData",
+    "PayloadSerializer",
     "Photo",
     "Polymorphic",
     "RuleChain",
-    "ScalarNode",
     "Source",
+    "SuccessfulPayment",
     "Text",
     "TextInteger",
     "TextLiteral",
-    "UpdateNode",
+    "UserId",
     "UserSource",
     "Video",
+    "VideoNote",
+    "Voice",
+    "as_node",
     "compose_node",
     "compose_nodes",
     "generate_node",
@@ -57,4 +116,6 @@ __all__ = (
     "is_node",
     "per_call",
     "per_event",
+    "scalar_node",
+    "unwrap_node",
 )