telegrinder 0.1.dev168__py3-none-any.whl → 0.1.dev170__py3-none-any.whl

telegrinder/bot/rules/text.py

@@ -1,28 +1,24 @@
+from telegrinder import node
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.tools.i18n.base import ABCTranslator
 
-from .abc import ABC, Message, with_caching_translations
-from .message import MessageRule
+from .abc import ABCRule, with_caching_translations
+from .node import NodeRule
 
 
-class HasText(MessageRule):
-    async def check(self, message: Message, ctx: Context) -> bool:
-        return bool(message.text)
+class HasText(NodeRule):
+    def __init__(self) -> None:
+        super().__init__(node.text.Text)
 
 
-class TextMessageRule(MessageRule, ABC, requires=[HasText()]):
-    pass
-
-
-class Text(TextMessageRule):
+class Text(ABCRule):
     def __init__(self, texts: str | list[str], *, ignore_case: bool = False) -> None:
         if not isinstance(texts, list):
             texts = [texts]
         self.texts = texts if not ignore_case else list(map(str.lower, texts))
         self.ignore_case = ignore_case
 
-    async def check(self, message: Message, ctx: Context) -> bool:
-        text = message.text.unwrap()
+    async def check(self, text: node.text.Text, ctx: Context) -> bool:
         return (text if not self.ignore_case else text.lower()) in self.texts
 
     @with_caching_translations
@@ -33,4 +29,4 @@ class Text(TextMessageRule):
         )
 
 
-__all__ = ("HasText", "Text", "TextMessageRule")
+__all__ = ("HasText", "Text")

telegrinder/bot/rules/update.py

@@ -2,15 +2,15 @@ from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.types.enums import UpdateType
 
-from .abc import ABCRule, T
+from .abc import ABCRule
 
 
-class IsUpdate(ABCRule[T]):
+class IsUpdateType(ABCRule):
     def __init__(self, update_type: UpdateType, /) -> None:
         self.update_type = update_type
 
     async def check(self, event: UpdateCute, ctx: Context) -> bool:
-        return event.update_type.unwrap_or_none() == self.update_type
+        return event.update_type == self.update_type
 
 
-__all__ = ("IsUpdate",)
+__all__ = ("IsUpdateType",)

telegrinder/bot/scenario/__init__.py

@@ -1,5 +1,5 @@
 from .abc import ABCScenario
-from .checkbox import Checkbox, Choice
-from .choice import SingleChoice
+from .checkbox import Checkbox
+from .choice import Choice
 
-__all__ = ("ABCScenario", "Checkbox", "Choice", "SingleChoice")
+__all__ = ("ABCScenario", "Checkbox", "Choice")

telegrinder/bot/scenario/choice.py

@@ -1,7 +1,6 @@
 import typing
 
 from telegrinder.bot.cute_types import CallbackQueryCute
-from telegrinder.bot.dispatch.waiter_machine import WaiterMachine
 
 from .checkbox import Checkbox
 
@@ -10,7 +9,7 @@ if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch.view.abc import BaseStateView
 
 
-class SingleChoice(Checkbox):
+class Choice(Checkbox):
     async def handle(self, cb: CallbackQueryCute) -> bool:
         code = cb.data.unwrap().replace(self.random_code + "/", "", 1)
         if code == "ready":
@@ -43,4 +42,4 @@ class SingleChoice(Checkbox):
         return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
 
 
-__all__ = ("SingleChoice",)
+__all__ = ("Choice",)

telegrinder/model.py

@@ -1,5 +1,6 @@
 import dataclasses
 import enum
+import keyword
 import secrets
 import typing
 from datetime import datetime
@@ -19,7 +20,7 @@ T = typing.TypeVar("T")
 MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
     "omit_defaults": True,
     "dict": True,
-    "rename": {"from_": "from"},
+    "rename": {kw + "_": kw for kw in keyword.kwlist},
 }
 
 
@@ -45,14 +46,17 @@ def full_result(
 
 
 def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
-    return {
-        k: v.unwrap() if isinstance(v, Some) else v
-        for k, v in (
-            *params.pop("other", {}).items(),
-            *params.items(),
-        )
-        if k != "self" and type(v) not in (NoneType, Nothing)
-    }
+    validated_params = {}
+    for k, v in (
+        *params.pop("other", {}).items(),
+        *params.items(),
+    ):
+        if isinstance(v, Proxy):
+            v = v.get()
+        if k == "self" or type(v) in (NoneType, Nothing):
+            continue
+        validated_params[k] = v.unwrap() if isinstance(v, Some) else v
+    return validated_params
 
 
 class Model(msgspec.Struct, **MODEL_CONFIG):
@@ -69,9 +73,7 @@ class Model(msgspec.Struct, **MODEL_CONFIG):
         if "model_as_dict" not in self.__dict__:
             self.__dict__["model_as_dict"] = msgspec.structs.asdict(self)
         return {
-            key: value
-            for key, value in self.__dict__["model_as_dict"].items()
-            if key not in exclude_fields
+            key: value for key, value in self.__dict__["model_as_dict"].items() if key not in exclude_fields
         }
 
 
@@ -82,7 +84,7 @@ class DataConverter:
     def __repr__(self) -> str:
         return "<{}: {}>".format(
             self.__class__.__name__,
-            ", ".join(f"{k}={v!r}" for k, v in self.converters),
+            ", ".join(f"{k}={v.__name__!r}" for k, v in self.converters.items()),
         )
 
     @property
@@ -129,9 +131,7 @@ class DataConverter:
         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)
+            k: self(v, serialize=serialize) for k, v in data.items() if type(v) not in (NoneType, Nothing)
         }
 
     def convert_lst(
@@ -159,8 +159,43 @@ class DataConverter:
         return data
 
 
+class Proxy:
+    def __init__(self, cfg: "_ProxiedDict", key: str):
+        self.key = key
+        self.cfg = cfg
+
+    def get(self) -> typing.Any | None:
+        return self.cfg._defaults.get(self.key)
+
+
+class _ProxiedDict(typing.Generic[T]):
+    def __init__(self, tp: type[T]) -> None:
+        self.type = tp
+        self._defaults = {}
+
+    def __setattribute__(self, name: str, value: typing.Any, /) -> None:
+        self._defaults[name] = value
+
+    def __getitem__(self, key: str, /) -> None:
+        return Proxy(self, key)  # type: ignore
+
+    def __setitem__(self, key: str, value: typing.Any, /) -> None:
+        self._defaults[key] = value
+
+
+if typing.TYPE_CHECKING:
+
+    def ProxiedDict(typed_dct: type[T]) -> T | _ProxiedDict[T]:  # noqa: N802
+        ...
+
+else:
+    ProxiedDict = _ProxiedDict
+
+
 __all__ = (
+    "Proxy",
     "DataConverter",
+    "ProxiedDict",
     "MODEL_CONFIG",
     "Model",
     "full_result",

telegrinder/modules.py

@@ -40,10 +40,13 @@ class LoggerModule(typing.Protocol):
 
 logger: LoggerModule
 json: JSONModule = choice_in_order(
-    ["orjson", "ujson", "hyperjson"], do_import=True, default="telegrinder.msgspec_json"
+    ["orjson", "ujson", "hyperjson"],
+    default="telegrinder.msgspec_json",
+    do_import=True,
 )
-logging_module = choice_in_order(["loguru"], default="logging")
 logging_level = os.getenv("LOGGER_LEVEL", default="DEBUG").upper()
+logging_module = choice_in_order(["loguru"], default="logging")
+asyncio_module = choice_in_order(["uvloop"], default="asyncio")
 
 if logging_module == "loguru":
     import os
@@ -201,9 +204,7 @@ elif logging_module == "logging":
             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:]
-                if key in kwargs
+                key: kwargs[key] for key in inspect.getfullargspec(self.logger._log).args[1:] if key in kwargs
             }
 
             if isinstance(msg, str):
@@ -214,10 +215,17 @@ elif logging_module == "logging":
     handler = logging.StreamHandler(sys.stderr)
     handler.setFormatter(TelegrinderLoggingFormatter())
     logger = logging.getLogger("telegrinder")  # type: ignore
-    logger.setLevel(logging.getLevelName(logging_level))  # type: ignore
+    logger.setLevel(logging_level)  # type: ignore
     logger.addHandler(handler)  # type: ignore
     logger = TelegrinderLoggingStyleAdapter(logger)  # type: ignore
 
+if asyncio_module == "uvloop":
+    import asyncio
+
+    import uvloop  # type: ignore
+
+    asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())  # type: ignore
+
 
 def _set_logger_level(level):
     level = level.upper()

telegrinder/msgspec_utils.py

@@ -1,6 +1,7 @@
 import typing
 
 import fntypes.option
+import fntypes.result
 import msgspec
 from fntypes.co import Error, Ok, Result, Variative
 
@@ -8,10 +9,12 @@ if typing.TYPE_CHECKING:
     from datetime import datetime
 
     from fntypes.option import Option
+    from fntypes.result import Result
 else:
     from datetime import datetime as dt
 
     Value = typing.TypeVar("Value")
+    Err = typing.TypeVar("Err")
 
     datetime = type("datetime", (dt,), {})
 
@@ -19,14 +22,22 @@ 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], object]
+DecHook: typing.TypeAlias = typing.Callable[[type[T], typing.Any], typing.Any]
 EncHook: typing.TypeAlias = typing.Callable[[T], typing.Any]
 
 Nothing: typing.Final[fntypes.option.Nothing] = fntypes.option.Nothing()
@@ -40,18 +51,52 @@ 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]:
+def msgspec_convert(obj: typing.Any, t: type[T]) -> Result[T, str]:
     try:
         return Ok(decoder.convert(obj, type=t, strict=True))
-    except msgspec.ValidationError as exc:
-        return Error(exc)
+    except msgspec.ValidationError:
+        return Error(
+            "Expected object of type `{}`, got `{}`.".format(
+                repr_type(t),
+                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)
     (value_type,) = typing.get_args(tp) or (typing.Any,)
-    return msgspec_convert({"value": obj}, fntypes.option.Some[value_type]).unwrap()
+
+    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 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))}`.")
+
+    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)
+
+    if orig_type is Ok and "ok" in obj:
+        return Ok(msgspec_convert(obj["ok"], first_type).unwrap())
+
+    if orig_type is Error and "error" in obj:
+        return Error(msgspec_convert(obj["error"], first_type).unwrap())
+
+    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())
+
+    raise msgspec.ValidationError(f"Cannot parse object `{obj!r}` to Result.")
 
 
 def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
@@ -67,9 +112,7 @@ def variative_dec_hook(tp: type[Variative], obj: typing.Any) -> Variative:
         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
-            }
+            struct_fields_match_sums = {m: len(m.__struct_fields__) for m in struct_fields_match_sums}
             reverse = True
 
         union_types = (
@@ -123,9 +166,14 @@ 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,
         }
 
     def __repr__(self) -> str:
@@ -144,8 +192,7 @@ class Decoder:
         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."
+                f"Unknown type `{repr_type(origin_type)}`. You can implement decode hook for this type."
             )
         return self.dec_hooks[origin_type](tp, obj)
 
@@ -173,7 +220,7 @@ class Decoder:
     def decode(self, buf: str | bytes) -> typing.Any: ...
 
     @typing.overload
-    def decode(self, buf: str | bytes, *, strict: bool = True) -> typing.Any: ...
+    def decode(self, buf: str | bytes, *, type: type[T]) -> T: ...
 
     @typing.overload
     def decode(
@@ -184,16 +231,10 @@ class Decoder:
         strict: bool = True,
     ) -> T: ...
 
-    def decode(
-        self,
-        buf: str | bytes,
-        *,
-        type: type[T] = typing.Any,  # type: ignore
-        strict: bool = True,
-    ) -> T:
+    def decode(self, buf, *, type=object, strict=True):
         return msgspec.json.decode(
             buf,
-            type=type,
+            type=typing.Any if type is object else type,
             strict=strict,
             dec_hook=self.dec_hook,
         )
@@ -219,6 +260,10 @@ 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()),
         }
@@ -240,8 +285,7 @@ class Encoder:
         origin_type = get_origin(obj.__class__)
         if origin_type not in self.enc_hooks:
             raise NotImplementedError(
-                "Not implemented encode hook for "
-                f"object of type `{repr_type(origin_type)}`."
+                f"Not implemented encode hook for object of type `{repr_type(origin_type)}`."
             )
         return self.enc_hooks[origin_type](obj)
 

telegrinder/node/__init__.py

@@ -1,17 +1,21 @@
 from .attachment import Attachment, Audio, Photo, Video
-from .base import ComposeError, DataNode, Node, ScalarNode
-from .composer import NodeCollection, NodeSession, compose_node
+from .base import ComposeError, DataNode, Node, ScalarNode, is_node
+from .command import CommandInfo
+from .composer import Composition, NodeCollection, NodeSession, compose_node, compose_nodes
 from .container import ContainerNode
+from .me import Me
 from .message import MessageNode
-from .rule import RuleContext
-from .source import Source
-from .text import Text
-from .tools import generate
+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 .text import Text, TextInteger
+from .tools import generate_node
 from .update import UpdateNode
 
 __all__ = (
     "Attachment",
     "Audio",
+    "ChatSource",
     "ComposeError",
     "ContainerNode",
     "DataNode",
@@ -20,12 +24,26 @@ __all__ = (
     "NodeCollection",
     "NodeSession",
     "Photo",
-    "RuleContext",
+    "RuleChain",
     "ScalarNode",
     "Source",
     "Text",
+    "TextInteger",
+    "UserSource",
     "UpdateNode",
     "Video",
     "compose_node",
-    "generate",
+    "generate_node",
+    "Composition",
+    "is_node",
+    "compose_nodes",
+    "NodeScope",
+    "PER_CALL",
+    "PER_EVENT",
+    "per_call",
+    "per_event",
+    "CommandInfo",
+    "GLOBAL",
+    "global_node",
+    "Me",
 )

telegrinder/node/attachment.py

@@ -1,10 +1,10 @@
 import dataclasses
 import typing
 
+from fntypes import Option, Some
 from fntypes.option import Nothing
 
 import telegrinder.types
-from telegrinder.msgspec_utils import Option
 
 from .base import ComposeError, DataNode, ScalarNode
 from .message import MessageNode
@@ -13,22 +13,26 @@ 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())
+    audio: Option[telegrinder.types.Audio] = dataclasses.field(
+        default_factory=lambda: Nothing(), kw_only=True
+    )
     document: Option[telegrinder.types.Document] = dataclasses.field(
-        default_factory=lambda: Nothing()
+        default_factory=lambda: Nothing(), kw_only=True
     )
     photo: Option[list[telegrinder.types.PhotoSize]] = dataclasses.field(
-        default_factory=lambda: Nothing()
+        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
     )
-    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})
+            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")
 
 

telegrinder/node/base.py

@@ -2,8 +2,14 @@ import abc
 import inspect
 import typing
 
+from telegrinder.tools.magic import get_annotations
+
+from .scope import NodeScope
+
 ComposeResult: typing.TypeAlias = (
-    typing.Coroutine[typing.Any, typing.Any, typing.Any] | typing.AsyncGenerator[typing.Any, None]
+    typing.Coroutine[typing.Any, typing.Any, typing.Any]
+    | typing.AsyncGenerator[typing.Any, None]
+    | typing.Any
 )
 
 
@@ -12,10 +18,11 @@ class ComposeError(BaseException): ...
 
 class Node(abc.ABC):
     node: str = "node"
+    scope: NodeScope = NodeScope.PER_EVENT
 
     @classmethod
     @abc.abstractmethod
-    def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
+    def compose(cls, *args, **kwargs) -> ComposeResult:
         pass
 
     @classmethod
@@ -24,15 +31,7 @@ class Node(abc.ABC):
 
     @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
+        return get_annotations(cls.compose)
 
     @classmethod
     def as_node(cls) -> type[typing.Self]:
@@ -49,14 +48,14 @@ class DataNode(Node, abc.ABC):
     @typing.dataclass_transform()
     @classmethod
     @abc.abstractmethod
-    async def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
+    async def compose(cls, *args, **kwargs) -> ComposeResult:
         pass
 
 
 class ScalarNodeProto(Node, abc.ABC):
     @classmethod
     @abc.abstractmethod
-    async def compose(cls, *args: tuple[typing.Any, ...], **kwargs: typing.Any) -> ComposeResult:
+    async def compose(cls, *args, **kwargs) -> ComposeResult:
         pass
 
 
@@ -78,17 +77,31 @@ else:
         return type(
             "Scalar",
             (SCALAR_NODE,),
-            {"as_node": classmethod(lambda cls: create_node(cls, bases, dct))},
+            {
+                "as_node": classmethod(lambda cls: create_node(cls, bases, dct)),
+                "scope": Node.scope,
+            },
         )
 
     class ScalarNode(ScalarNodeProto, abc.ABC, metaclass=create_class):
         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",
+    "is_node",
 )

telegrinder/node/callback_query.py

@@ -0,0 +1,18 @@
+from telegrinder.bot.cute_types import CallbackQueryCute
+
+from .base import ComposeError, ScalarNode
+from .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,
+        )
+
+
+__all__ = ("CallbackQueryNode",)