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

telegrinder/msgspec_utils.py

@@ -0,0 +1,207 @@
+import types  # noqa: TCH003
+import typing
+
+import fntypes.option
+import msgspec
+from fntypes.co import Error, Ok, Result, Variative
+
+T = typing.TypeVar("T")
+Ts = typing.TypeVarTuple("Ts")
+
+if typing.TYPE_CHECKING:
+    from fntypes.option import Option
+else:
+
+    Value = typing.TypeVar("Value")
+
+    class OptionMeta(type):
+        def __instancecheck__(cls, __instance: typing.Any) -> bool:
+            return isinstance(__instance, fntypes.option.Some | fntypes.option.Nothing)
+
+
+    class Option(typing.Generic[Value], metaclass=OptionMeta):
+        pass
+
+DecHook: typing.TypeAlias = typing.Callable[[type[T], object], object]
+EncHook: typing.TypeAlias = typing.Callable[[T], object]
+
+Nothing: typing.Final[fntypes.option.Nothing] = fntypes.option.Nothing()
+
+
+def get_origin(t: type[T]) -> type[T]:
+    return typing.cast(T, typing.get_origin(t)) or t
+
+
+def repr_type(t: type) -> str:
+    return getattr(t, "__name__", repr(get_origin(t)))
+
+
+def msgspec_convert(obj: typing.Any, t: type[T]) -> Result[T, msgspec.ValidationError]:
+    try:
+        return Ok(decoder.convert(obj, type=t, strict=True))
+    except msgspec.ValidationError as exc:
+        return Error(exc)
+
+
+def option_dec_hook(tp: type["Option[typing.Any]"], obj: typing.Any) -> typing.Any:
+    if obj is None:
+        return Nothing
+    generic_args = typing.get_args(tp)
+    value_type: typing.Any | type[typing.Any] = typing.Any if not generic_args else generic_args[0]
+    return msgspec_convert({"value": obj}, fntypes.option.Some[value_type]).unwrap()
+
+
+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] = {
+            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)
+        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}
+            reverse = True
+
+        union_types = (
+            *sorted(struct_fields_match_sums, key=lambda k: struct_fields_match_sums[k], reverse=reverse),
+            *union_types,
+        )
+    
+    for t in union_types:
+        match msgspec_convert(obj, t):
+            case Ok(value):
+                return tp(value)
+
+    raise TypeError(
+        "Object of type `{}` does not belong to types `{}`".format(
+            repr_type(type(obj)),
+            " | ".join(map(repr_type, union_types)),
+        )
+    )
+
+
+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)
+
+
+class Decoder:
+    def __init__(self) -> None:
+        self.dec_hooks: dict[type | types.UnionType, DecHook[typing.Any]] = {
+            Option: option_dec_hook,
+            Variative: variative_dec_hook,
+        }
+
+    def add_dec_hook(self, tp: type[T]):
+        def decorator(func: DecHook[T]) -> DecHook[T]:
+            return self.dec_hooks.setdefault(get_origin(tp), 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 convert(
+        self,
+        obj: object,
+        *,
+        type: type[T] = dict,
+        strict: bool = True,
+        from_attributes: bool = False,
+        builtin_types: typing.Iterable[type] | None = None,
+        str_keys: bool = False,
+    ) -> T:
+        return msgspec.convert(
+            obj,
+            type,
+            strict=strict,
+            from_attributes=from_attributes,
+            dec_hook=self.dec_hook,
+            builtin_types=builtin_types,
+            str_keys=str_keys,
+        )
+
+    def decode(
+        self,
+        buf: str | bytes,
+        *,
+        type: type[T] = dict,
+        strict: bool = True,
+    ) -> T:
+        return msgspec.json.decode(
+            buf,
+            type=type,
+            strict=strict,
+            dec_hook=self.dec_hook,
+        )
+
+
+class Encoder:
+    def __init__(self) -> None:
+        self.enc_hooks: dict[type, EncHook] = {
+            fntypes.option.Some: option_enc_hook,
+            fntypes.option.Nothing: option_enc_hook,
+            Variative: variative_enc_hook,
+        }
+
+    def add_dec_hook(self, tp: type[T]):
+        def decorator(func: EncHook[T]) -> EncHook[T]:
+            return self.enc_hooks.setdefault(get_origin(tp), func)
+        
+        return decorator
+    
+    def enc_hook(self, obj: object) -> object:
+        origin_type = get_origin(type(obj))
+        if origin_type not in self.enc_hooks:
+            raise NotImplementedError(
+                "Not implemented encode hook for "
+                f"object of type `{repr_type(origin_type)}`."
+            )
+        return self.enc_hooks[origin_type](obj)
+    
+    @typing.overload
+    def encode(self, obj: typing.Any) -> str:
+        ...
+
+    @typing.overload
+    def encode(self, obj: typing.Any, *, as_str: bool = False) -> bytes:
+        ...
+
+    def encode(self, obj: typing.Any, *, as_str: bool = True) -> str | bytes:
+        buf = msgspec.json.encode(obj, enc_hook=self.enc_hook)
+        return buf.decode() if as_str else buf
+
+
+decoder: typing.Final[Decoder] = Decoder()
+encoder: typing.Final[Encoder] = Encoder()
+
+
+__all__ = (
+    "Decoder",
+    "Encoder",
+    "Option",
+    "Nothing",
+    "get_origin",
+    "repr_type",
+    "msgspec_convert",
+    "option_dec_hook",
+    "option_enc_hook",
+    "variative_dec_hook",
+    "variative_enc_hook",
+    "decoder",
+    "encoder",
+)

telegrinder/node/__init__.py

@@ -0,0 +1,31 @@
+from .attachment import Attachment, Audio, Photo, Video
+from .base import ComposeError, DataNode, Node, ScalarNode
+from .composer import NodeCollection, NodeSession, compose_node
+from .container import ContainerNode
+from .message import MessageNode
+from .rule import RuleContext
+from .source import Source
+from .text import Text
+from .tools import generate
+from .update import UpdateNode
+
+__all__ = (
+    "Node",
+    "DataNode",
+    "ScalarNode",
+    "Attachment",
+    "Photo",
+    "Video",
+    "Text",
+    "Audio",
+    "UpdateNode",
+    "compose_node",
+    "ComposeError",
+    "MessageNode",
+    "Source",
+    "NodeSession",
+    "NodeCollection",
+    "ContainerNode",
+    "generate",
+    "RuleContext",
+)

telegrinder/node/attachment.py

@@ -0,0 +1,71 @@
+import dataclasses
+import typing
+
+from fntypes.option import Nothing
+
+import telegrinder.types
+from telegrinder.msgspec_utils import Option
+
+from .base import ComposeError, DataNode, ScalarNode
+from .message import MessageNode
+
+
+@dataclasses.dataclass
+class Attachment(DataNode):
+    attachment_type: typing.Literal["audio", "document", "photo", "poll", "video"]
+    _: dataclasses.KW_ONLY
+    audio: Option[telegrinder.types.Audio] = dataclasses.field(default_factory=lambda: Nothing())
+    document: Option[telegrinder.types.Document] = dataclasses.field(default_factory=lambda: Nothing())
+    photo: Option[list[telegrinder.types.PhotoSize]] = dataclasses.field(default_factory=lambda: Nothing())
+    poll: Option[telegrinder.types.Poll] = dataclasses.field(default_factory=lambda: Nothing())
+    video: Option[telegrinder.types.Video] = dataclasses.field(default_factory=lambda: Nothing())
+
+    @classmethod
+    async def compose(cls, message: MessageNode) -> "Attachment":
+        for attachment_type in ("audio", "document", "photo", "poll", "video"):
+            if (attachment := getattr(message, attachment_type, None)) is not None:
+                return cls(attachment_type, **{attachment_type: attachment})
+        return cls.compose_error("No attachment found in message")
+
+
+@dataclasses.dataclass
+class Photo(DataNode):
+    sizes: list[telegrinder.types.PhotoSize]
+
+    @classmethod
+    async def compose(cls, attachment: Attachment) -> typing.Self:
+        return cls(attachment.photo.expect(ComposeError("Attachment is not an photo")))
+
+
+class Video(ScalarNode, telegrinder.types.Video):
+    @classmethod
+    async def compose(cls, attachment: Attachment) -> telegrinder.types.Video:
+        return attachment.video.expect(ComposeError("Attachment is not an video"))
+
+
+class Audio(ScalarNode, telegrinder.types.Audio):
+    @classmethod
+    async def compose(cls, attachment: Attachment) -> telegrinder.types.Audio:
+        return attachment.audio.expect(ComposeError("Attachment is not an audio"))
+
+
+class Document(ScalarNode, telegrinder.types.Document):
+    @classmethod
+    async def compose(cls, attachment: Attachment) -> telegrinder.types.Document:
+        return attachment.document.expect(ComposeError("Attachment is not an document"))
+
+
+class Poll(ScalarNode, telegrinder.types.Poll):
+    @classmethod
+    async def compose(cls, attachment: Attachment) -> telegrinder.types.Poll:
+        return attachment.poll.expect(ComposeError("Attachment is not an poll"))
+
+
+__all__ = (
+    "Attachment",
+    "Audio",
+    "Document",
+    "Photo",
+    "Poll",
+    "Video",
+)

telegrinder/node/base.py

@@ -0,0 +1,93 @@
+import abc
+import inspect
+import typing
+
+ComposeResult: typing.TypeAlias = typing.Coroutine[typing.Any, typing.Any, typing.Any] | typing.AsyncGenerator[typing.Any, None]
+
+
+class ComposeError(BaseException):
+    pass
+
+
+class Node(abc.ABC):
+    node: str = "node"
+
+    @classmethod
+    @abc.abstractmethod
+    def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
+        pass
+
+    @classmethod
+    def compose_error(cls, error: str | None = None) -> typing.NoReturn:
+        raise ComposeError(error)
+
+    @classmethod
+    def get_sub_nodes(cls) -> dict[str, type[typing.Self]]:
+        parameters = inspect.signature(cls.compose).parameters
+        
+        sub_nodes = {}
+        for name, param in parameters.items():
+            if param.annotation is inspect._empty:
+                continue
+            node = param.annotation
+            sub_nodes[name] = node
+        return sub_nodes
+    
+    @classmethod
+    def as_node(cls) -> type[typing.Self]:
+        return cls
+    
+    @classmethod
+    def is_generator(cls) -> bool:
+        return inspect.isasyncgenfunction(cls.compose)
+
+
+class DataNode(Node, abc.ABC):
+    node = "data"
+
+    @typing.dataclass_transform()
+    @classmethod
+    @abc.abstractmethod
+    async def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
+        pass
+
+
+class ScalarNodeProto(Node, abc.ABC):
+    @classmethod
+    @abc.abstractmethod
+    async def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
+        pass
+
+
+SCALAR_NODE = type("ScalarNode", (), {"node": "scalar"})
+
+
+if typing.TYPE_CHECKING:
+
+    class ScalarNode(ScalarNodeProto, abc.ABC): 
+        pass
+    
+else:
+
+    def create_node(cls, bases, dct):
+        dct.update(cls.__dict__)
+        return type(cls.__name__, bases, dct)
+
+    def create_class(name, bases, dct):
+        return type(
+            "Scalar", 
+            (SCALAR_NODE,), 
+            {"as_node": classmethod(lambda cls: create_node(cls, bases, dct))},
+        )
+
+    class ScalarNode(ScalarNodeProto, abc.ABC, metaclass=create_class):
+        pass
+
+
+__all__ = (
+    "ScalarNode",
+    "SCALAR_NODE",
+    "DataNode",
+    "Node",
+    "ComposeError",
+)

telegrinder/node/composer.py

@@ -0,0 +1,71 @@
+import typing
+
+from telegrinder.bot.cute_types import UpdateCute
+from telegrinder.node import Node
+
+
+class NodeSession:
+    def __init__(
+        self, 
+        value: typing.Any,
+        subnodes: dict[str, typing.Self],
+        generator: typing.AsyncGenerator[typing.Any, None] | None = None,
+    ):
+        self.value = value
+        self.subnodes = subnodes
+        self.generator = generator
+    
+    async def close(self, with_value: typing.Any | None = None) -> None:
+        for subnode in self.subnodes.values():
+            await subnode.close()
+        
+        if self.generator is None:
+            return
+        try:
+            await self.generator.asend(with_value)
+        except StopAsyncIteration:
+            self.generator = None
+
+    def __repr__(self) -> str:
+        return f"<NodeSession {self.value}" + ("ACTIVE>" if self.generator else ">")
+
+
+class NodeCollection:
+    def __init__(self, sessions: dict[str, NodeSession]) -> None:
+        self.sessions = sessions
+
+    def values(self) -> dict[str, typing.Any]:
+        return {name: session.value for name, session in self.sessions.items()}
+    
+    async def close_all(self, with_value: typing.Any | None = None) -> None:
+        for session in self.sessions.values():
+            await session.close(with_value)
+
+
+async def compose_node(
+    node: type[Node],
+    update: UpdateCute,
+    ready_context: dict[str, NodeSession] | None = None,
+) -> NodeSession:
+    _node = node.as_node()
+    context = NodeCollection(ready_context.copy() if ready_context else {})
+
+    for name, subnode in _node.get_sub_nodes().items():
+        if subnode is UpdateCute:
+            context.sessions[name] = NodeSession(update, {})
+        else:
+            context.sessions[name] = await compose_node(subnode, update)
+
+    generator: typing.AsyncGenerator | None
+
+    if _node.is_generator():
+        generator = typing.cast(typing.AsyncGenerator, _node.compose(**context.values()))
+        value = await generator.asend(None)
+    else:
+        generator = None
+        value = await _node.compose(**context.values())  # type: ignore
+    
+    return NodeSession(value, context.sessions, generator)
+
+
+__all__ = ("NodeCollection", "NodeSession", "compose_node")

telegrinder/node/container.py

@@ -0,0 +1,22 @@
+import typing
+
+from .base import Node
+
+
+class ContainerNode(Node):
+    linked_nodes: typing.ClassVar[list[type[Node]]]
+
+    @classmethod
+    async def compose(cls, **kw) -> tuple["Node", ...]:
+        return tuple(t[1] for t in sorted(kw.items(), key=lambda t: t[0]))
+
+    @classmethod
+    def get_sub_nodes(cls) -> dict[str, type["Node"]]:
+        return {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
+    
+    @classmethod
+    def link_nodes(cls, linked_nodes: list[type[Node]]) -> type["ContainerNode"]:
+        return type("_ContainerNode", (cls,), {"linked_nodes": linked_nodes})
+
+
+__all__ = ("ContainerNode",)

telegrinder/node/message.py

@@ -0,0 +1,18 @@
+import typing
+
+from telegrinder.bot.cute_types import MessageCute
+
+from .base import ComposeError, ScalarNode
+from .update import UpdateNode
+
+
+class MessageNode(ScalarNode, MessageCute):
+    @classmethod
+    async def compose(cls, update: UpdateNode) -> typing.Self:
+        return cls(
+            **update.message.expect(ComposeError).to_dict(),
+            api=update.api,
+        )
+
+
+__all__ = ("MessageNode",)

telegrinder/node/rule.py

@@ -0,0 +1,56 @@
+import dataclasses
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node.base import ComposeError, Node
+from telegrinder.node.update import UpdateNode
+
+
+class RuleContext(dict):
+    dataclass = dict
+    rules: tuple[ABCRule, ...] = ()
+
+    @classmethod
+    async def compose(cls, update: UpdateNode):
+        ctx = Context()
+        for rule in cls.rules:
+            if not await check_rule(update.api, rule, update, ctx):
+                raise ComposeError
+        try:
+            return cls.dataclass(**ctx)  # type: ignore
+        except Exception as exc:
+            raise ComposeError(f"Dataclass validation error: {exc}")
+
+    @classmethod
+    def as_node(cls) -> type[typing.Self]:
+        return cls
+    
+    @classmethod
+    def get_sub_nodes(cls) -> dict:
+        return {"update": UpdateNode}
+
+    @classmethod
+    def is_generator(cls) -> typing.Literal[False]:
+        return False
+
+    def __new__(cls, *rules: ABCRule) -> type[Node]:
+        return type("_RuleNode", (cls,), {"dataclass": dict, "rules": rules})  # type: ignore
+    
+    def __class_getitem__(cls, item: tuple[ABCRule, ...]) -> typing.Self:
+        if not isinstance(item, tuple):
+            item = (item,)
+        return cls(*item)
+    
+    @staticmethod
+    def generate_dataclass(cls_: type["RuleContext"]):  # noqa: ANN205
+        return dataclasses.dataclass(type(cls_.__name__, (object,), dict(cls_.__dict__)))
+    
+    def __init_subclass__(cls) -> None:
+        if cls.__name__ == "_RuleNode":
+            return
+        cls.dataclass = cls.generate_dataclass(cls)
+
+
+__all__ = ("RuleContext",)

telegrinder/node/source.py

@@ -0,0 +1,31 @@
+import dataclasses
+import typing
+
+from telegrinder.api import API
+from telegrinder.msgspec_utils import Nothing, Option
+from telegrinder.types import Chat, Message
+
+from .base import DataNode
+from .message import MessageNode
+
+
+@dataclasses.dataclass
+class Source(DataNode):
+    api: API
+    chat: Chat
+    thread_id: Option[int] = dataclasses.field(default_factory=lambda: Nothing)
+
+    @classmethod
+    async def compose(cls, message: MessageNode) -> typing.Self:
+        return cls(
+            api=message.ctx_api,
+            chat=message.chat,
+            thread_id=message.message_thread_id,
+        )
+    
+    async def send(self, text: str) -> Message:
+        result = await self.api.send_message(self.chat.id, message_thread_id=self.thread_id, text=text)
+        return result.unwrap()
+
+
+__all__ = ("Source",)

telegrinder/node/text.py

@@ -0,0 +1,13 @@
+import typing
+
+from .base import ComposeError, ScalarNode
+from .message import MessageNode
+
+
+class Text(ScalarNode, str):
+    @classmethod
+    async def compose(cls, message: MessageNode) -> typing.Self:
+        return cls(message.text.expect(ComposeError("Message has no text")))
+
+
+__all__ = ("Text",)

telegrinder/node/tools/__init__.py

@@ -0,0 +1,3 @@
+from .generator import generate
+
+__all__ = ("generate",)

telegrinder/node/tools/generator.py

@@ -0,0 +1,40 @@
+import inspect
+import typing
+
+from telegrinder.node.base import ComposeError, Node
+from telegrinder.node.container import ContainerNode
+
+T = typing.TypeVar("T")
+
+
+def cast_false_to_none(value: T) -> T | None:
+    if value is False:
+        return None
+    return value
+
+
+def error_on_none(value: T | None) -> T:
+    if value is None:
+        raise ComposeError
+    return value
+
+
+def generate(
+    subnodes: tuple[type[Node], ...], 
+    func: typing.Callable[..., typing.Any],
+    casts: tuple[typing.Callable, ...] = (cast_false_to_none, error_on_none),
+) -> type[ContainerNode]:
+    async def compose(**kw: typing.Any) -> typing.Any:
+        args = await ContainerNode.compose(**kw)
+        result = func(*args)
+        if inspect.isawaitable(result):
+            result = await result
+        for cast in casts:
+            result = cast(result)
+        return result
+
+    container = ContainerNode.link_nodes(list(subnodes))
+    return type("_ContainerNode", (container,), {"compose": compose})
+
+
+__all__ = ("generate",)

telegrinder/node/update.py

@@ -0,0 +1,12 @@
+from telegrinder.bot.cute_types import UpdateCute
+
+from .base import ScalarNode
+
+
+class UpdateNode(ScalarNode, UpdateCute):
+    @classmethod
+    async def compose(cls, update: UpdateCute) -> UpdateCute:
+        return update
+
+
+__all__ = ("UpdateNode",)

telegrinder/rules.py

@@ -1 +1 @@
-from .bot.rules import *
+from .bot.rules import *  # noqa: F403