telegrinder 0.1.dev170__py3-none-any.whl → 0.2.0__py3-none-any.whl

telegrinder/msgspec_utils.py

@@ -1,3 +1,4 @@
+import dataclasses
 import typing
 
 import fntypes.option
@@ -9,10 +10,16 @@ if typing.TYPE_CHECKING:
     from datetime import datetime
 
     from fntypes.option import Option
-    from fntypes.result import Result
+
+    def get_class_annotations(obj: typing.Any) -> dict[str, type[typing.Any]]: ...
+
+    def get_type_hints(obj: typing.Any) -> dict[str, type[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")
 
@@ -22,20 +29,12 @@ else:
         def __instancecheck__(cls, __instance: typing.Any) -> bool:
             return isinstance(__instance, fntypes.option.Some | fntypes.option.Nothing)
 
-    class ResultMeta(type):
-        def __instancecheck__(cls, __instance: typing.Any) -> bool:
-            return isinstance(__instance, fntypes.result.Ok | fntypes.result.Error)
 
     class Option(typing.Generic[Value], metaclass=OptionMeta):
         pass
 
-    class Result(typing.Generic[Value, Err], metaclass=ResultMeta):
-        pass
-
 
 T = typing.TypeVar("T")
-Type = typing.TypeVar("Type", bound=type | typing.Any)
-Ts = typing.TypeVarTuple("Ts")
 
 DecHook: typing.TypeAlias = typing.Callable[[type[T], typing.Any], typing.Any]
 EncHook: typing.TypeAlias = typing.Callable[[T], typing.Any]
@@ -47,10 +46,29 @@ def get_origin(t: type[T]) -> type[T]:
     return typing.cast(T, typing.get_origin(t)) or t
 
 
-def repr_type(t: type) -> str:
+def repr_type(t: typing.Any) -> str:
     return getattr(t, "__name__", repr(get_origin(t)))
 
 
+def is_common_type(type_: typing.Any) -> typing.TypeGuard[type[typing.Any]]:
+    if not isinstance(type_, type):
+        return False
+    return (
+        type_ in (str, int, float, bool, None, Variative)
+        or issubclass(type_, msgspec.Struct)
+        or hasattr(type_, "__dataclass_fields__")
+    )
+
+
+def type_check(obj: typing.Any, t: typing.Any) -> bool:
+    return (
+        isinstance(obj, t)
+        if isinstance(t, type)
+        and issubclass(t, msgspec.Struct)
+        else type(obj) in t if isinstance(t, tuple) else type(obj) is t
+    )
+
+
 def msgspec_convert(obj: typing.Any, t: type[T]) -> Result[T, str]:
     try:
         return Ok(decoder.convert(obj, type=t, strict=True))
@@ -63,68 +81,68 @@ def msgspec_convert(obj: typing.Any, t: type[T]) -> Result[T, str]:
         )
 
 
-def option_dec_hook(tp: type[Option[typing.Any]], obj: typing.Any) -> Option[typing.Any]:
-    orig_type = get_origin(tp)
-    (value_type,) = typing.get_args(tp) or (typing.Any,)
-
-    if obj is None and orig_type in (fntypes.option.Nothing, Option):
-        return fntypes.option.Nothing()
-    return fntypes.option.Some(msgspec_convert(obj, value_type).unwrap())
+def msgspec_to_builtins(
+    obj: typing.Any,
+    *,
+    str_keys: bool = False,
+    builtin_types: typing.Iterable[type[typing.Any]] | None = None,
+    order: typing.Literal["deterministic", "sorted"] | None = None,
+) -> fntypes.result.Result[typing.Any, msgspec.ValidationError]:
+    try:
+        return Ok(encoder.to_builtins(**locals()))
+    except msgspec.ValidationError as exc:
+        return Error(exc)
 
 
-def result_dec_hook(
-    tp: type[Result[typing.Any, typing.Any]], obj: typing.Any
-) -> Result[typing.Any, typing.Any]:
-    if not isinstance(obj, dict):
-        raise TypeError(f"Cannot parse to Result object of type `{repr_type(type(obj))}`.")
+def option_dec_hook(tp: type[Option[typing.Any]], obj: typing.Any) -> Option[typing.Any]:
+    if obj is None:
+        return Nothing
 
-    orig_type = get_origin(tp)
-    (first_type, second_type) = (
-        typing.get_args(tp) + (typing.Any,) if len(typing.get_args(tp)) == 1 else typing.get_args(tp)
-    ) or (typing.Any, typing.Any)
+    (value_type,) = typing.get_args(tp) or (typing.Any,)
+    orig_value_type = typing.get_origin(value_type) or value_type
+    orig_obj = obj
 
-    if orig_type is Ok and "ok" in obj:
-        return Ok(msgspec_convert(obj["ok"], first_type).unwrap())
+    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 orig_type is Error and "error" in obj:
-        return Error(msgspec_convert(obj["error"], first_type).unwrap())
+        if not type_check(orig_obj, orig_value_type):
+            raise TypeError(f"Expected `{repr_type(orig_value_type)}`, got `{repr_type(type(orig_obj))}`.")
 
-    if orig_type is Result:
-        match obj:
-            case {"ok": ok}:
-                return Ok(msgspec_convert(ok, first_type).unwrap())
-            case {"error": error}:
-                return Error(msgspec_convert(error, second_type).unwrap())
+        return fntypes.option.Some(obj)
 
-    raise msgspec.ValidationError(f"Cannot parse object `{obj!r}` to Result.")
+    return fntypes.option.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):
-        struct_fields_match_sums: dict[type[msgspec.Struct], int] = {
+        models_struct_fields: 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 struct_fields_match_sums)
+        union_types = tuple(t for t in union_types if t not in models_struct_fields)
         reverse = False
 
-        if len(set(struct_fields_match_sums.values())) != len(struct_fields_match_sums.values()):
-            struct_fields_match_sums = {m: len(m.__struct_fields__) for m in struct_fields_match_sums}
+        if len(set(models_struct_fields.values())) != len(models_struct_fields.values()):
+            models_struct_fields = {m: len(m.__struct_fields__) for m in models_struct_fields}
             reverse = True
 
         union_types = (
             *sorted(
-                struct_fields_match_sums,
-                key=lambda k: struct_fields_match_sums[k],
+                models_struct_fields,
+                key=lambda k: models_struct_fields[k],
                 reverse=reverse,
             ),
             *union_types,
         )
 
     for t in union_types:
+        if not isinstance(obj, dict | list) and is_common_type(t) and type_check(obj, t):
+            return tp(obj)
         match msgspec_convert(obj, t):
             case Ok(value):
                 return tp(value)
@@ -137,6 +155,11 @@ 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.
@@ -155,7 +178,6 @@ class 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.dec_hook(int, "123")  #> TypeError: Unknown type `int`. You can implement decode hook for this type.
 
     decoder.convert("123", type=int, strict=False)  #> 123
     decoder.convert(1, type=Digit)  #> <Digit.ONE: 1>
@@ -166,12 +188,9 @@ class Decoder:
 
     def __init__(self) -> None:
         self.dec_hooks: dict[typing.Any, DecHook[typing.Any]] = {
-            Result: result_dec_hook,
             Option: option_dec_hook,
             Variative: variative_dec_hook,
             datetime: lambda t, obj: t.fromtimestamp(obj),
-            fntypes.result.Error: result_dec_hook,
-            fntypes.result.Ok: result_dec_hook,
             fntypes.option.Some: option_dec_hook,
             fntypes.option.Nothing: option_dec_hook,
         }
@@ -250,8 +269,6 @@ class Encoder:
     encoder.enc_hooks[dt] = lambda d: int(d.timestamp())
 
     encoder.enc_hook(dt.now())  #> 1713354732
-    encoder.enc_hook(123)  #> NotImplementedError: Not implemented encode hook for object of type `int`.
-
     encoder.encode({'digit': Digit.ONE})  #> '{"digit":1}'
     ```
     """
@@ -260,10 +277,6 @@ class Encoder:
         self.enc_hooks: dict[typing.Any, EncHook[typing.Any]] = {
             fntypes.option.Some: lambda opt: opt.value,
             fntypes.option.Nothing: lambda _: None,
-            fntypes.result.Ok: lambda ok: {"ok": ok.value},
-            fntypes.result.Error: lambda err: {
-                "error": (str(err.error) if isinstance(err.error, BaseException) else err.error)
-            },
             Variative: lambda variative: variative.v,
             datetime: lambda date: int(date.timestamp()),
         }
@@ -302,6 +315,22 @@ class Encoder:
         buf = msgspec.json.encode(obj, enc_hook=self.enc_hook)
         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: typing.Literal["deterministic", "sorted"] | None = None,
+    ) -> typing.Any:
+        return msgspec.to_builtins(
+            obj,
+            str_keys=str_keys,
+            builtin_types=builtin_types,
+            enc_hook=self.enc_hook,
+            order=order,
+        )
+
 
 decoder: typing.Final[Decoder] = Decoder()
 encoder: typing.Final[Encoder] = Encoder()
@@ -315,9 +344,8 @@ __all__ = (
     "datetime",
     "decoder",
     "encoder",
-    "get_origin",
     "msgspec_convert",
-    "option_dec_hook",
-    "repr_type",
-    "variative_dec_hook",
+    "get_class_annotations",
+    "get_type_hints",
+    "msgspec_to_builtins",
 )

telegrinder/node/__init__.py

@@ -1,10 +1,13 @@
 from .attachment import Attachment, Audio, Photo, Video
 from .base import ComposeError, DataNode, Node, ScalarNode, is_node
+from .callback_query import CallbackQueryNode
 from .command import CommandInfo
 from .composer import Composition, NodeCollection, NodeSession, compose_node, compose_nodes
 from .container import ContainerNode
+from .event import EventNode
 from .me import Me
 from .message import MessageNode
+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
@@ -15,35 +18,39 @@ from .update import UpdateNode
 __all__ = (
     "Attachment",
     "Audio",
+    "CallbackQueryNode",
     "ChatSource",
+    "CommandInfo",
     "ComposeError",
+    "Composition",
     "ContainerNode",
     "DataNode",
+    "EventNode",
+    "GLOBAL",
+    "Me",
     "MessageNode",
     "Node",
     "NodeCollection",
+    "NodeScope",
     "NodeSession",
+    "PER_CALL",
+    "PER_EVENT",
     "Photo",
+    "Polymorphic",
     "RuleChain",
     "ScalarNode",
     "Source",
     "Text",
     "TextInteger",
-    "UserSource",
     "UpdateNode",
+    "UserSource",
     "Video",
     "compose_node",
+    "compose_nodes",
     "generate_node",
-    "Composition",
+    "global_node",
+    "impl",
     "is_node",
-    "compose_nodes",
-    "NodeScope",
-    "PER_CALL",
-    "PER_EVENT",
     "per_call",
     "per_event",
-    "CommandInfo",
-    "GLOBAL",
-    "global_node",
-    "Me",
 )

telegrinder/node/attachment.py

@@ -1,30 +1,33 @@
 import dataclasses
 import typing
 
-from fntypes import Option, Some
+from fntypes.co import Option, Some
 from fntypes.option import Nothing
 
 import telegrinder.types
+from telegrinder.node.base import ComposeError, DataNode, ScalarNode
+from telegrinder.node.message import MessageNode
 
-from .base import ComposeError, DataNode, ScalarNode
-from .message import MessageNode
 
-
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class Attachment(DataNode):
     attachment_type: typing.Literal["audio", "document", "photo", "poll", "video"]
     audio: Option[telegrinder.types.Audio] = dataclasses.field(
-        default_factory=lambda: Nothing(), kw_only=True
+        default_factory=lambda: Nothing(),
+        kw_only=True,
     )
     document: Option[telegrinder.types.Document] = dataclasses.field(
-        default_factory=lambda: Nothing(), kw_only=True
+        default_factory=lambda: Nothing(),
+        kw_only=True,
     )
     photo: Option[list[telegrinder.types.PhotoSize]] = dataclasses.field(
-        default_factory=lambda: Nothing(), kw_only=True
+        default_factory=lambda: Nothing(),
+        kw_only=True,
     )
     poll: Option[telegrinder.types.Poll] = dataclasses.field(default_factory=lambda: Nothing(), kw_only=True)
     video: Option[telegrinder.types.Video] = dataclasses.field(
-        default_factory=lambda: Nothing(), kw_only=True
+        default_factory=lambda: Nothing(),
+        kw_only=True,
     )
 
     @classmethod
@@ -33,17 +36,17 @@ class Attachment(DataNode):
             match getattr(message, attachment_type, Nothing()):
                 case Some(attachment):
                     return cls(attachment_type, **{attachment_type: Some(attachment)})
-        return cls.compose_error("No attachment found in message")
+        return cls.compose_error("No attachment found in message.")
 
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 class Photo(DataNode):
     sizes: list[telegrinder.types.PhotoSize]
 
     @classmethod
     async def compose(cls, attachment: Attachment) -> typing.Self:
         if not attachment.photo:
-            raise ComposeError("Attachment is not an photo")
+            raise ComposeError("Attachment is not a photo.")
         return cls(attachment.photo.unwrap())
 
 
@@ -51,7 +54,7 @@ class Video(ScalarNode, telegrinder.types.Video):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Video:
         if not attachment.video:
-            raise ComposeError("Attachment is not an video")
+            raise ComposeError("Attachment is not a video.")
         return attachment.video.unwrap()
 
 
@@ -59,7 +62,7 @@ class Audio(ScalarNode, telegrinder.types.Audio):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Audio:
         if not attachment.audio:
-            raise ComposeError("Attachment is not an audio")
+            raise ComposeError("Attachment is not an audio.")
         return attachment.audio.unwrap()
 
 
@@ -67,7 +70,7 @@ class Document(ScalarNode, telegrinder.types.Document):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Document:
         if not attachment.document:
-            raise ComposeError("Attachment is not an document")
+            raise ComposeError("Attachment is not a document.")
         return attachment.document.unwrap()
 
 
@@ -75,7 +78,7 @@ class Poll(ScalarNode, telegrinder.types.Poll):
     @classmethod
     async def compose(cls, attachment: Attachment) -> telegrinder.types.Poll:
         if not attachment.poll:
-            raise ComposeError("Attachment is not an poll")
+            raise ComposeError("Attachment is not a poll.")
         return attachment.poll.unwrap()
 
 

telegrinder/node/base.py

@@ -1,19 +1,52 @@
 import abc
 import inspect
 import typing
+from types import AsyncGeneratorType
 
-from telegrinder.tools.magic import get_annotations
+from telegrinder.node.scope import NodeScope
+from telegrinder.tools.magic import (
+    cache_magic_value,
+    get_annotations,
+)
 
-from .scope import NodeScope
+ComposeResult: typing.TypeAlias = typing.Awaitable[typing.Any] | typing.AsyncGenerator[typing.Any, None]
+
+
+def is_node(maybe_node: type[typing.Any]) -> typing.TypeGuard[type["Node"]]:
+    maybe_node = typing.get_origin(maybe_node) or maybe_node
+    return (
+        isinstance(maybe_node, type)
+        and issubclass(maybe_node, Node)
+        or isinstance(maybe_node, Node)
+        or hasattr(maybe_node, "as_node")
+    )
+
+
+@cache_magic_value("__nodes__")
+def get_nodes(function: typing.Callable[..., typing.Any]) -> dict[str, type["Node"]]:
+    return {k: v for k, v in get_annotations(function).items() if is_node(v)}
 
-ComposeResult: typing.TypeAlias = (
-    typing.Coroutine[typing.Any, typing.Any, typing.Any]
-    | typing.AsyncGenerator[typing.Any, None]
-    | typing.Any
-)
 
+@cache_magic_value("__is_generator__")
+def is_generator(function: typing.Callable[..., typing.Any]) -> typing.TypeGuard[AsyncGeneratorType[typing.Any, None]]:
+    return inspect.isasyncgenfunction(function)
 
-class ComposeError(BaseException): ...
+
+def get_node_calc_lst(node: type["Node"]) -> list[type["Node"]]:
+    """ Returns flattened list of node types in ordering required to calculate given node. Provides caching for passed node type """
+    if calc_lst := getattr(node, "__nodes_calc_lst__", None):
+        return calc_lst
+    nodes_lst: list[type["Node"]] = []
+    annotations = list(node.as_node().get_subnodes().values())
+    for node_type in annotations:
+        nodes_lst.extend(get_node_calc_lst(node_type))
+    calc_lst = [*nodes_lst, node]
+    setattr(node, "__nodes_calc_lst__", calc_lst)
+    return calc_lst
+
+
+class ComposeError(BaseException):
+    pass
 
 
 class Node(abc.ABC):
@@ -30,8 +63,8 @@ class Node(abc.ABC):
         raise ComposeError(error)
 
     @classmethod
-    def get_sub_nodes(cls) -> dict[str, type[typing.Self]]:
-        return get_annotations(cls.compose)
+    def get_subnodes(cls) -> dict[str, type["Node"]]:
+        return get_nodes(cls.compose)
 
     @classmethod
     def as_node(cls) -> type[typing.Self]:
@@ -39,7 +72,7 @@ class Node(abc.ABC):
 
     @classmethod
     def is_generator(cls) -> bool:
-        return inspect.isasyncgenfunction(cls.compose)
+        return is_generator(cls.compose)
 
 
 class DataNode(Node, abc.ABC):
@@ -68,7 +101,6 @@ if typing.TYPE_CHECKING:
         pass
 
 else:
-
     def create_node(cls, bases, dct):
         dct.update(cls.__dict__)
         return type(cls.__name__, bases, dct)
@@ -87,21 +119,13 @@ else:
         pass
 
 
-def is_node(maybe_node: type[typing.Any]) -> typing.TypeGuard[type[Node]]:
-    maybe_node = typing.get_origin(maybe_node) or maybe_node
-    return (
-        isinstance(maybe_node, type)
-        and issubclass(maybe_node, Node)
-        or isinstance(maybe_node, Node)
-        or hasattr(maybe_node, "as_node")
-    )
-
-
 __all__ = (
     "ComposeError",
     "DataNode",
     "Node",
     "SCALAR_NODE",
     "ScalarNode",
+    "ScalarNodeProto",
+    "get_nodes",
     "is_node",
 )

telegrinder/node/callback_query.py

@@ -1,18 +1,14 @@
-from telegrinder.bot.cute_types import CallbackQueryCute
-
-from .base import ComposeError, ScalarNode
-from .update import UpdateNode
+from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
+from telegrinder.node.base import ComposeError, ScalarNode
+from telegrinder.node.update import UpdateNode
 
 
 class CallbackQueryNode(ScalarNode, CallbackQueryCute):
     @classmethod
     async def compose(cls, update: UpdateNode) -> CallbackQueryCute:
         if not update.callback_query:
-            raise ComposeError
-        return CallbackQueryCute(
-            **update.callback_query.unwrap().to_dict(),
-            api=update.api,
-        )
+            raise ComposeError("Update is not a callback_query.")
+        return update.callback_query.unwrap()
 
 
 __all__ = ("CallbackQueryNode",)

telegrinder/node/command.py

@@ -1,3 +1,4 @@
+import typing
 from dataclasses import dataclass, field
 
 from fntypes import Nothing, Option, Some
@@ -16,14 +17,17 @@ def cut_mention(text: str) -> tuple[str, Option[str]]:
     return left, Some(right) if right else Nothing()
 
 
-@dataclass
+@dataclass(slots=True)
 class CommandInfo(DataNode):
     name: str
     arguments: str
     mention: Option[str] = field(default_factory=Nothing)
 
     @classmethod
-    async def compose(cls, text: Text):
+    async def compose(cls, text: Text) -> typing.Self:
         name, arguments = single_split(text, separator=" ")
         name, mention = cut_mention(name)
         return cls(name, arguments, mention)
+
+
+__all__ = ("CommandInfo", "cut_mention", "single_split")