telegrinder 0.3.2__py3-none-any.whl → 0.3.3.post1__py3-none-any.whl

telegrinder/model.py

@@ -60,6 +60,57 @@ def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     return validated_params
 
 
+class From(typing.Generic[T]):
+    def __new__(cls, _: T, /) -> typing.Any: ...
+
+
+if typing.TYPE_CHECKING:
+
+    @typing.overload
+    def field(*, name: str | None = ...) -> typing.Any: ...
+
+    @typing.overload
+    def field(*, default: typing.Any, name: str | None = ...) -> typing.Any: ...
+
+    @typing.overload
+    def field(
+        *,
+        converter: typing.Callable[[typing.Any], typing.Any],
+        name: str | None = ...,
+    ) -> typing.Any: ...
+
+    @typing.overload
+    def field(
+        *,
+        default: typing.Any,
+        converter: typing.Callable[[typing.Any], typing.Any],
+        name: str | None = ...,
+    ) -> typing.Any: ...
+
+    @typing.overload
+    def field(
+        *,
+        default_factory: typing.Callable[[], typing.Any],
+        converter: typing.Callable[[typing.Any], typing.Any],
+        name: str | None = None,
+    ) -> typing.Any: ...
+
+    def field(
+        *,
+        default=...,
+        default_factory=...,
+        name=...,
+        converter=...,
+    ) -> typing.Any: ...
+else:
+    from msgspec import field as _field
+
+    def field(**kwargs):
+        kwargs.pop("converter", None)
+        return _field(**kwargs)
+
+
+@typing.dataclass_transform(field_specifiers=(field,))
 class Model(msgspec.Struct, **MODEL_CONFIG):
     @classmethod
     def from_data(cls, data: dict[str, typing.Any]) -> typing.Self:

telegrinder/msgspec_utils.py

@@ -235,7 +235,7 @@ class Decoder:
         )
         yield dec_obj
 
-    def add_dec_hook(self, t: T):  # type: ignore
+    def add_dec_hook(self, t: type[T]):  # type: ignore
         def decorator(func: DecHook[T]) -> DecHook[T]:
             return self.dec_hooks.setdefault(get_origin(t), func)  # type: ignore
 
@@ -346,7 +346,7 @@ class Encoder:
         enc_obj = msgspec.json.Encoder(enc_hook=self.enc_hook)
         yield enc_obj
 
-    def add_dec_hook(self, t: type[T]):
+    def add_enc_hook(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

telegrinder/node/__init__.py

@@ -1,23 +1,24 @@
-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
-from .text import Text, TextInteger
-from .tools import generate_node
-from .update import UpdateNode
-
-__all__ = (
+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 .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
+from .text import Text, TextInteger, TextLiteral
+from .tools import generate_node
+from .update import UpdateNode
+
+__all__ = (
     "Attachment",
     "Audio",
+    "CallbackQueryData",
     "CallbackQueryNode",
     "ChatSource",
     "CommandInfo",
@@ -26,9 +27,11 @@ __all__ = (
     "ContainerNode",
     "DataNode",
     "EventNode",
+    "Field",
     "GLOBAL",
     "Me",
     "MessageNode",
+    "Name",
     "Node",
     "NodeCollection",
     "NodeScope",
@@ -42,6 +45,7 @@ __all__ = (
     "Source",
     "Text",
     "TextInteger",
+    "TextLiteral",
     "UpdateNode",
     "UserSource",
     "Video",
@@ -52,5 +56,5 @@ __all__ = (
     "impl",
     "is_node",
     "per_call",
-    "per_event",
-)
+    "per_event",
+)

telegrinder/node/attachment.py

@@ -83,10 +83,10 @@ class Poll(ScalarNode, telegrinder.types.Poll):
 
 
 __all__ = (
-    "Attachment",
-    "Audio",
-    "Document",
-    "Photo",
-    "Poll",
+    "Attachment",
+    "Audio",
+    "Document",
+    "Photo",
+    "Poll",
     "Video",
 )

telegrinder/node/base.py

@@ -1,14 +1,15 @@
 import abc
 import inspect
-import typing
 from types import AsyncGeneratorType
 
+import typing_extensions as typing
+
 from telegrinder.node.scope import NodeScope
 from telegrinder.tools.magic import cache_magic_value, get_annotations
 
-ComposeResult: typing.TypeAlias = (
-    typing.Awaitable[typing.Any] | typing.AsyncGenerator[typing.Any, None] | typing.Any
-)
+T = typing.TypeVar("T", default=typing.Any)
+
+ComposeResult: typing.TypeAlias = T | typing.Awaitable[T] | typing.AsyncGenerator[T, None]
 
 
 def is_node(maybe_node: typing.Any) -> typing.TypeGuard[type["Node"]]:
@@ -77,20 +78,35 @@ class Node(abc.ABC):
         return is_generator(cls.compose)
 
 
+@typing.dataclass_transform(kw_only_default=True)
+class FactoryNode(Node, abc.ABC):
+    node = "factory"
+
+    @classmethod
+    @abc.abstractmethod
+    def compose(cls, *args, **kwargs) -> ComposeResult:
+        pass
+
+    def __new__(cls, **context: typing.Any) -> typing.Self:
+        namespace = dict(**cls.__dict__)
+        namespace.pop("__new__", None)
+        return type(cls.__name__, (cls,), context | namespace)  # type: ignore
+
+
+@typing.dataclass_transform()
 class DataNode(Node, abc.ABC):
     node = "data"
 
-    @typing.dataclass_transform()
     @classmethod
     @abc.abstractmethod
-    async def compose(cls, *args, **kwargs) -> ComposeResult:
+    def compose(cls, *args, **kwargs) -> ComposeResult[typing.Self]:
         pass
 
 
 class ScalarNodeProto(Node, abc.ABC):
     @classmethod
     @abc.abstractmethod
-    async def compose(cls, *args, **kwargs) -> ComposeResult:
+    def compose(cls, *args, **kwargs) -> ComposeResult:
         pass
 
 
@@ -131,9 +147,16 @@ else:
         pass
 
 
+class Name(ScalarNode, str):
+    @classmethod
+    def compose(cls) -> str: ...
+
+
 __all__ = (
     "ComposeError",
+    "FactoryNode",
     "DataNode",
+    "Name",
     "Node",
     "SCALAR_NODE",
     "ScalarNode",

telegrinder/node/callback_query.py

@@ -1,7 +1,14 @@
+import typing
+
+from fntypes.result import Error, Ok
+
 from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
-from telegrinder.node.base import ComposeError, ScalarNode
+from telegrinder.msgspec_utils import msgspec_convert
+from telegrinder.node.base import ComposeError, FactoryNode, Name, ScalarNode
 from telegrinder.node.update import UpdateNode
 
+FieldType = typing.TypeVar("FieldType")
+
 
 class CallbackQueryNode(ScalarNode, CallbackQueryCute):
     @classmethod
@@ -11,4 +18,36 @@ class CallbackQueryNode(ScalarNode, CallbackQueryCute):
         return update.callback_query.unwrap()
 
 
-__all__ = ("CallbackQueryNode",)
+class CallbackQueryData(ScalarNode, dict[str, typing.Any]):
+    @classmethod
+    def compose(cls, callback_query: CallbackQueryNode) -> dict[str, typing.Any]:
+        return callback_query.decode_callback_data().expect(
+            ComposeError("Cannot complete decode callback query data.")
+        )
+
+
+class _Field(FactoryNode):
+    field_type: type[typing.Any]
+
+    def __class_getitem__(cls, field_type: type[typing.Any], /) -> typing.Self:
+        return cls(field_type=field_type)
+
+    @classmethod
+    def compose(cls, callback_query_data: CallbackQueryData, data_name: Name) -> typing.Any:
+        if data := callback_query_data.get(data_name):
+            match msgspec_convert(data, cls.field_type):
+                case Ok(value):
+                    return value
+                case Error(err):
+                    raise ComposeError(err)
+
+        raise ComposeError(f"Cannot find callback data with name {data_name!r}.")
+
+
+if typing.TYPE_CHECKING:
+    Field = typing.Annotated[FieldType, ...]
+else:
+    Field = _Field
+
+
+__all__ = ("CallbackQueryData", "CallbackQueryNode", "Field")

telegrinder/node/composer.py

@@ -11,6 +11,7 @@ from telegrinder.bot.dispatch.context import Context
 from telegrinder.modules import logger
 from telegrinder.node.base import (
     ComposeError,
+    Name,
     Node,
     NodeScope,
     get_node_calc_lst,
@@ -53,13 +54,14 @@ async def compose_nodes(
     parent_nodes: dict[type[Node], NodeSession] = {}
     event_nodes: dict[type[Node], NodeSession] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
     # TODO: optimize flattened list calculation via caching key = tuple of node types
-    calculation_nodes: dict[type[Node], tuple[type[Node], ...]] = {
-        node_t: tuple(get_node_calc_lst(node_t)) for node_t in nodes.values()
+    calculation_nodes: dict[tuple[str, type[Node]], tuple[type[Node], ...]] = {
+        (node_name, node_t): tuple(get_node_calc_lst(node_t)) for node_name, node_t in nodes.items()
     }
 
-    for parent_node, linked_nodes in calculation_nodes.items():
+    for (parent_node_name, parent_node_t), linked_nodes in calculation_nodes.items():
         local_nodes = {}
         subnodes = {}
+        data[Name] = parent_node_name
 
         for node_t in linked_nodes:
             scope = getattr(node_t, "scope", None)
@@ -88,7 +90,7 @@ async def compose_nodes(
             elif scope is NodeScope.GLOBAL:
                 setattr(node_t, GLOBAL_VALUE_KEY, local_nodes[node_t])
 
-        parent_nodes[parent_node] = local_nodes[parent_node]
+        parent_nodes[parent_node_t] = local_nodes[parent_node_t]
 
     node_sessions = {k: parent_nodes[t] for k, t in nodes.items()}
     return Ok(NodeCollection(node_sessions))

telegrinder/node/event.py

@@ -7,7 +7,7 @@ from telegrinder.api.api import API
 from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.msgspec_utils import DataclassInstance, decoder
-from telegrinder.node.base import ComposeError, Node
+from telegrinder.node.base import ComposeError, FactoryNode
 from telegrinder.node.update import UpdateNode
 
 if typing.TYPE_CHECKING:
@@ -18,17 +18,11 @@ if typing.TYPE_CHECKING:
 EVENT_NODE_KEY = "_event_node"
 
 
-class _EventNode(Node):
+class _EventNode(FactoryNode):
     dataclass: type["DataclassType"]
 
-    def __new__(cls, dataclass: type["DataclassType"], /) -> type[typing.Self]:
-        namespace = dict(**cls.__dict__)
-        namespace.pop("__new__", None)
-        new_cls = type("EventNode", (cls,), {"dataclass": dataclass, **namespace})
-        return new_cls  # type: ignore
-
     def __class_getitem__(cls, dataclass: type["DataclassType"], /) -> typing.Self:
-        return cls(dataclass)
+        return cls(dataclass=dataclass)
 
     @classmethod
     def compose(cls, raw_update: UpdateNode, ctx: Context, api: API) -> "DataclassType":

telegrinder/node/text.py

@@ -1,4 +1,6 @@
-from telegrinder.node.base import ComposeError, ScalarNode
+import typing
+
+from telegrinder.node.base import ComposeError, FactoryNode, ScalarNode
 from telegrinder.node.message import MessageNode
 
 
@@ -18,4 +20,22 @@ class TextInteger(ScalarNode, int):
         return int(text)
 
 
-__all__ = ("Text", "TextInteger")
+if typing.TYPE_CHECKING:
+    from typing import Literal as TextLiteral
+
+else:
+
+    class TextLiteral(FactoryNode):
+        texts: tuple[str, ...]
+
+        def __class_getitem__(cls, texts, /):
+            return cls(texts=(texts,) if not isinstance(texts, tuple) else texts)
+
+        @classmethod
+        def compose(cls, text: Text) -> str:
+            if text in cls.texts:
+                return text
+            raise ComposeError("Text matching failed.")
+
+
+__all__ = ("Text", "TextInteger", "TextLiteral")

telegrinder/tools/formatting/html.py

@@ -279,30 +279,30 @@ def underline(string: str) -> TagFormat:
 
 
 __all__ = (
-    "FormatString",
-    "HTMLFormatter",
-    "SpecialFormat",
-    "block_quote",
-    "bold",
-    "channel_boost_link",
-    "code_inline",
-    "escape",
-    "get_channel_boost_link",
-    "get_invite_chat_link",
-    "get_mention_link",
-    "get_resolve_domain_link",
-    "get_start_bot_link",
-    "get_start_group_link",
-    "invite_chat_link",
-    "italic",
-    "link",
-    "mention",
-    "pre_code",
-    "resolve_domain",
-    "spoiler",
-    "start_bot_link",
-    "start_group_link",
-    "strike",
-    "tg_emoji",
+    "FormatString",
+    "HTMLFormatter",
+    "SpecialFormat",
+    "block_quote",
+    "bold",
+    "channel_boost_link",
+    "code_inline",
+    "escape",
+    "get_channel_boost_link",
+    "get_invite_chat_link",
+    "get_mention_link",
+    "get_resolve_domain_link",
+    "get_start_bot_link",
+    "get_start_group_link",
+    "invite_chat_link",
+    "italic",
+    "link",
+    "mention",
+    "pre_code",
+    "resolve_domain",
+    "spoiler",
+    "start_bot_link",
+    "start_group_link",
+    "strike",
+    "tg_emoji",
     "underline",
 )

telegrinder/tools/i18n/__init__.py

@@ -3,10 +3,10 @@ from .middleware import ABCTranslatorMiddleware
 from .simple import SimpleI18n, SimpleTranslator
 
 __all__ = (
-    "ABCI18n",
-    "ABCTranslator",
-    "ABCTranslatorMiddleware",
-    "I18nEnum",
-    "SimpleI18n",
+    "ABCI18n",
+    "ABCTranslator",
+    "ABCTranslatorMiddleware",
+    "I18nEnum",
+    "SimpleI18n",
     "SimpleTranslator",
 )

telegrinder/tools/i18n/abc.py

@@ -26,7 +26,7 @@ class I18nEnum(enum.Enum):
 
 
 __all__ = (
-    "ABCI18n",
-    "ABCTranslator",
+    "ABCI18n",
+    "ABCTranslator",
     "I18nEnum",
 )

telegrinder/tools/keyboard.py

@@ -106,7 +106,7 @@ class Keyboard(ABCMarkup[Button], KeyboardModel):
         return ReplyKeyboardMarkup(**self.dict())
 
     def keyboard_remove(self, *, selective: bool = False) -> ReplyKeyboardRemove:
-        return ReplyKeyboardRemove(remove_keyboard=True, selective=Some(selective))
+        return ReplyKeyboardRemove(remove_keyboard=True, selective=selective)
 
 
 class InlineKeyboard(ABCMarkup[InlineButton]):
@@ -124,9 +124,9 @@ class InlineKeyboard(ABCMarkup[InlineButton]):
 
 
 __all__ = (
-    "ABCMarkup",
-    "InlineKeyboard",
-    "Keyboard",
-    "KeyboardModel",
+    "ABCMarkup",
+    "InlineKeyboard",
+    "Keyboard",
+    "KeyboardModel",
     "copy_keyboard",
 )

telegrinder/tools/loop_wrapper/loop_wrapper.py

@@ -5,16 +5,17 @@ import datetime
 import typing
 
 from telegrinder.modules import logger
-
-from .abc import ABCLoopWrapper
+from telegrinder.tools.loop_wrapper.abc import ABCLoopWrapper
 
 T = typing.TypeVar("T")
 P = typing.ParamSpec("P")
-CoroFunc = typing.TypeVar("CoroFunc", bound="CoroutineFunc")
+CoroFunc = typing.TypeVar("CoroFunc", bound="CoroutineFunc[..., typing.Any]")
 
 CoroutineTask: typing.TypeAlias = typing.Coroutine[typing.Any, typing.Any, T]
 CoroutineFunc: typing.TypeAlias = typing.Callable[P, CoroutineTask[T]]
-Task: typing.TypeAlias = typing.Union[CoroutineFunc, CoroutineTask, "DelayedTask"]
+Task: typing.TypeAlias = (
+    "CoroutineFunc[P, T] | CoroutineTask[T] | DelayedTask[typing.Callable[P, CoroutineTask[T]]]"
+)
 
 
 def run_tasks(
@@ -90,7 +91,12 @@ class LoopWrapper(ABCLoopWrapper):
     ) -> None:
         self.tasks: list[CoroutineTask[typing.Any]] = tasks or []
         self.lifespan = lifespan or Lifespan()
-        self._loop = event_loop or asyncio.new_event_loop()
+        self._loop = event_loop
+
+    @property
+    def loop(self) -> asyncio.AbstractEventLoop:
+        assert self._loop is not None
+        return self._loop
 
     def __repr__(self) -> str:
         return "<{}: loop={!r} with tasks={!r}, lifespan={!r}>".format(
@@ -104,11 +110,13 @@ class LoopWrapper(ABCLoopWrapper):
         if not self.tasks:
             logger.warning("You run loop with 0 tasks!")
 
+        self._loop = asyncio.new_event_loop() if self._loop is None else self._loop
         self.lifespan.start(self._loop)
+
         while self.tasks:
             self._loop.create_task(self.tasks.pop(0))
-        tasks = asyncio.all_tasks(self._loop)
 
+        tasks = asyncio.all_tasks(self._loop)
         try:
             while tasks:
                 tasks_results, _ = self._loop.run_until_complete(
@@ -132,17 +140,17 @@ class LoopWrapper(ABCLoopWrapper):
     def add_task(self, task: Task) -> None:
         task = to_coroutine_task(task)
 
-        if self._loop and self._loop.is_running():
+        if self._loop is not None and self._loop.is_running():
             self._loop.create_task(task)
         else:
             self.tasks.append(task)
 
     def complete_tasks(self, tasks: set[asyncio.Task[typing.Any]]) -> None:
-        tasks = tasks | asyncio.all_tasks(self._loop)
+        tasks = tasks | asyncio.all_tasks(self.loop)
         task_to_cancel = asyncio.gather(*tasks, return_exceptions=True)
         task_to_cancel.cancel()
         with contextlib.suppress(asyncio.CancelledError):
-            self._loop.run_until_complete(task_to_cancel)
+            self.loop.run_until_complete(task_to_cancel)
 
     @typing.overload
     def timer(self, *, seconds: datetime.timedelta) -> typing.Callable[..., typing.Any]: ...

telegrinder/tools/magic.py

@@ -153,16 +153,16 @@ def get_impls(cls: type["Polymorphic"]) -> list[typing.Callable[..., typing.Any]
 
 
 __all__ = (
-    "TRANSLATIONS_KEY",
-    "cache_magic_value",
-    "cache_translation",
-    "get_annotations",
-    "get_cached_translation",
-    "get_default_args",
-    "get_default_args",
-    "get_impls",
-    "impl",
-    "magic_bundle",
-    "resolve_arg_names",
+    "TRANSLATIONS_KEY",
+    "cache_magic_value",
+    "cache_translation",
+    "get_annotations",
+    "get_cached_translation",
+    "get_default_args",
+    "get_default_args",
+    "get_impls",
+    "impl",
+    "magic_bundle",
+    "resolve_arg_names",
     "to_str",
 )