telegrinder 0.1.dev167__py3-none-any.whl → 0.1.dev169__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/checkbox.py

@@ -33,13 +33,13 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         self,
         waiter_machine: WaiterMachine,
         chat_id: int,
-        msg: str,
+        message: str,
         *,
         ready_text: str = "Ready",
         max_in_row: int = 3,
     ) -> None:
         self.chat_id = chat_id
-        self.msg = msg
+        self.message = message
         self.choices: list[Choice] = []
         self.ready = ready_text
         self.max_in_row = max_in_row
@@ -58,7 +58,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
             self.waiter_machine,
             self.ready,
             self.chat_id,
-            self.msg,
+            self.message,
         )
 
     def get_markup(self) -> InlineKeyboardMarkup:
@@ -101,7 +101,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
                 # Toggle choice
                 self.choices[i].is_picked = not self.choices[i].is_picked
                 await cb.edit_text(
-                    text=self.msg,
+                    text=self.message,
                     parse_mode=self.PARSE_MODE,
                     reply_markup=self.get_markup(),
                 )
@@ -118,7 +118,7 @@ class Checkbox(ABCScenario[CallbackQueryCute]):
         message = (
             await api.send_message(
                 chat_id=self.chat_id,
-                text=self.msg,
+                text=self.message,
                 parse_mode=self.PARSE_MODE,
                 reply_markup=self.get_markup(),
             )

telegrinder/bot/scenario/choice.py

@@ -9,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":
@@ -22,9 +22,9 @@ class SingleChoice(Checkbox):
             if choice.code == code:
                 self.choices[i].is_picked = True
                 await cb.ctx_api.edit_message_text(
+                    text=self.message,
                     chat_id=cb.message.unwrap().v.chat.id,
                     message_id=cb.message.unwrap().v.message_id,
-                    text=self.msg,
                     parse_mode=self.PARSE_MODE,
                     reply_markup=self.get_markup(),
                 )
@@ -36,10 +36,10 @@ class SingleChoice(Checkbox):
         api: "API",
         view: "BaseStateView[CallbackQueryCute]",
     ) -> tuple[str, int]:
-        if len([choice for choice in self.choices if choice.is_picked]) != 1:
+        if len(tuple(choice for choice in self.choices if choice.is_picked)) != 1:
             raise ValueError("Exactly one choice must be picked")
         choices, m_id = await super().wait(api, view)
-        return list(choices.keys())[list(choices.values()).index(True)], m_id
+        return tuple(choices.keys())[tuple(choices.values()).index(True)], m_id
 
 
-__all__ = ("SingleChoice",)
+__all__ = ("Choice",)

telegrinder/model.py

@@ -45,14 +45,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 +72,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 +83,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 +130,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 +158,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

@@ -24,9 +24,10 @@ else:
 
 
 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()
@@ -67,9 +68,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 = (
@@ -144,8 +143,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 +171,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 +182,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,
         )
@@ -240,8 +232,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)}`."
+                "Not implemented encode hook for " f"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",)

telegrinder/node/command.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass, field
+
+from fntypes import Nothing, Option, Some
+
+from .base import DataNode
+from .text import Text
+
+
+def single_split(s: str, separator: str) -> tuple[str, str]:
+    left, *right = s.split(separator, 1)
+    return left, (right[0] if right else "")
+
+
+def cut_mention(text: str) -> tuple[str, Option[str]]:
+    left, right = single_split(text, "@")
+    return left, Some(right) if right else Nothing()
+
+
+@dataclass
+class CommandInfo(DataNode):
+    name: str
+    arguments: str
+    mention: Option[str] = field(default_factory=Nothing)
+
+    @classmethod
+    async def compose(cls, text: Text):
+        name, arguments = single_split(text, separator=" ")
+        name, mention = cut_mention(name)
+        return cls(name, arguments, mention)