telegrinder 0.2.0.post2__py3-none-any.whl → 0.2.2__py3-none-any.whl

telegrinder/model.py

@@ -16,17 +16,10 @@ if typing.TYPE_CHECKING:
 
 T = typing.TypeVar("T")
 
-
-def rename_field(name: str) -> str:
-    if name.endswith("_") and name.removesuffix("_") in keyword.kwlist:
-        return name.removesuffix("_")
-    return name if not keyword.iskeyword(name) else name + "_"
-
-
 MODEL_CONFIG: typing.Final[dict[str, typing.Any]] = {
     "omit_defaults": True,
     "dict": True,
-    "rename": rename_field,
+    "rename": {kw + "_": kw for kw in keyword.kwlist},
 }
 
 

telegrinder/modules.py

@@ -4,13 +4,6 @@ import typing
 from choicelib import choice_in_order
 
 
-@typing.runtime_checkable
-class JSONModule(typing.Protocol):
-    def loads(self, s: str | bytes) -> typing.Any: ...
-
-    def dumps(self, o: typing.Any) -> str: ...
-
-
 @typing.runtime_checkable
 class LoggerModule(typing.Protocol):
     def debug(self, __msg: object, *args: object, **kwargs: object) -> None: ...
@@ -25,25 +18,23 @@ class LoggerModule(typing.Protocol):
 
     def exception(self, __msg: object, *args: object, **kwargs: object) -> None: ...
 
-    def set_level(
-        self,
-        level: typing.Literal[
-            "DEBUG",
-            "INFO",
-            "WARNING",
-            "ERROR",
-            "CRITICAL",
-            "EXCEPTION",
-        ],
-    ) -> None: ...
+    if typing.TYPE_CHECKING:
+
+        def set_level(
+            self,
+            level: typing.Literal[
+                "DEBUG",
+                "INFO",
+                "WARNING",
+                "ERROR",
+                "CRITICAL",
+                "EXCEPTION",
+            ],
+            /,
+        ) -> None: ...
 
 
 logger: LoggerModule
-json: JSONModule = choice_in_order(
-    ["orjson", "ujson", "hyperjson"],
-    default="telegrinder.msgspec_json",
-    do_import=True,
-)
 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")
@@ -227,7 +218,7 @@ if asyncio_module == "uvloop":
     asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())  # type: ignore
 
 
-def _set_logger_level(level):
+def _set_logger_level(level, /):
     level = level.upper()
     if logging_module == "logging":
         import logging
@@ -243,4 +234,4 @@ def _set_logger_level(level):
 setattr(logger, "set_level", staticmethod(_set_logger_level))  # type: ignore
 
 
-__all__ = ("json", "logger")
+__all__ = ("LoggerModule", "logger")

telegrinder/msgspec_utils.py

@@ -29,7 +29,6 @@ else:
         def __instancecheck__(cls, __instance: typing.Any) -> bool:
             return isinstance(__instance, fntypes.option.Some | fntypes.option.Nothing)
 
-
     class Option(typing.Generic[Value], metaclass=OptionMeta):
         pass
 
@@ -63,9 +62,10 @@ def is_common_type(type_: typing.Any) -> typing.TypeGuard[type[typing.Any]]:
 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
+        if isinstance(t, type) and issubclass(t, msgspec.Struct)
+        else type(obj) in t
+        if isinstance(t, tuple)
+        else type(obj) is t
     )
 
 
@@ -344,8 +344,8 @@ __all__ = (
     "datetime",
     "decoder",
     "encoder",
-    "msgspec_convert",
     "get_class_annotations",
     "get_type_hints",
+    "msgspec_convert",
     "msgspec_to_builtins",
 )

telegrinder/node/base.py

@@ -12,8 +12,8 @@ from telegrinder.tools.magic import (
 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
+def is_node(maybe_node: typing.Any) -> typing.TypeGuard[type["Node"]]:
+    maybe_node = maybe_node if isinstance(maybe_node, type) else typing.get_origin(maybe_node)
     return (
         isinstance(maybe_node, type)
         and issubclass(maybe_node, Node)

telegrinder/node/composer.py

@@ -4,7 +4,7 @@ import typing
 from fntypes import Error, Ok, Result
 from fntypes.error import UnwrapError
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types.update import Update, UpdateCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.modules import logger
@@ -41,7 +41,7 @@ async def compose_node(
 async def compose_nodes(
     nodes: dict[str, type[Node]],
     ctx: Context,
-    data: dict[type, typing.Any] | None = None,
+    data: dict[type[typing.Any], typing.Any] | None = None,
 ) -> Result["NodeCollection", ComposeError]:
     logger.debug("Composing nodes: {!r}...", nodes)
 
@@ -67,11 +67,7 @@ async def compose_nodes(
                 local_nodes[node_t] = getattr(node_t, GLOBAL_VALUE_KEY)
                 continue
 
-            subnodes = {
-                k: session.value
-                for k, session in
-                (local_nodes | event_nodes).items()
-            }
+            subnodes = {k: session.value for k, session in (local_nodes | event_nodes).items()}
 
             try:
                 local_nodes[node_t] = await compose_node(node_t, subnodes | data)
@@ -175,11 +171,11 @@ class Composition:
             case Ok(col):
                 return col
             case Error(err):
-                logger.debug(f"Composition failed with error: {err}")
+                logger.debug(f"Composition failed with error: {err!r}")
                 return None
 
     async def __call__(self, **kwargs: typing.Any) -> typing.Any:
-        return await self.func(**magic_bundle(self.func, kwargs, start_idx=0, bundle_ctx=False))  # type: ignore
+        return await self.func(**magic_bundle(self.func, kwargs, start_idx=0, bundle_ctx=False))
 
 
 __all__ = ("Composition", "NodeCollection", "NodeSession", "compose_node", "compose_nodes")

telegrinder/node/container.py

@@ -12,7 +12,12 @@ class ContainerNode(Node):
 
     @classmethod
     def get_subnodes(cls) -> dict[str, type[Node]]:
-        return {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
+        subnodes = getattr(cls, "subnodes", None)
+        if subnodes is None:
+            subnodes_dct = {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
+            setattr(cls, "subnodes", subnodes_dct)
+            return subnodes_dct
+        return subnodes
 
     @classmethod
     def link_nodes(cls, linked_nodes: list[type[Node]]) -> type["ContainerNode"]:

telegrinder/node/polymorphic.py

@@ -13,21 +13,21 @@ from telegrinder.tools.magic import get_impls, impl
 class Polymorphic(Node):
     @classmethod
     async def compose(cls, update: UpdateNode, context: Context) -> typing.Any:
-        logger.debug(f"Composing polimorphic node {cls.__name__}")
+        logger.debug(f"Composing polimorphic node {cls.__name__!r}...")
         scope = getattr(cls, "scope", None)
         node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
 
-        for i, impl in enumerate(get_impls(cls)):
-            logger.debug("Checking impl {}", impl.__name__)
-            composition = Composition(impl, True)
+        for i, impl_ in enumerate(get_impls(cls)):
+            logger.debug("Checking impl {!r}...", impl_.__name__)
+            composition = Composition(impl_, True)
             node_collection = await composition.compose_nodes(update, context)
             if node_collection is None:
-                logger.debug("Impl {!r} composition failed", impl.__name__)
+                logger.debug("Impl {!r} composition failed!", impl_.__name__)
                 continue
 
             # To determine whether this is a right morph, all subnodes must be resolved
             if scope is NodeScope.PER_EVENT and (cls, i) in node_ctx:
-                logger.debug("Morph is already cached as per_event node, using its value. Impl {!r} succeeded", impl.__name__)
+                logger.debug("Morph is already cached as per_event node, using its value. Impl {!r} succeeded!", impl_.__name__)
                 res: NodeSession = node_ctx[(cls, i)]
                 await node_collection.close_all()
                 return res.value
@@ -40,7 +40,7 @@ class Polymorphic(Node):
                 node_ctx[(cls, i)] = NodeSession(cls, result, {})
 
             await node_collection.close_all(with_value=result)
-            logger.debug("Impl {!r} succeeded with value {}", impl.__name__, result)
+            logger.debug("Impl {!r} succeeded with value: {}", impl_.__name__, result)
             return result
 
         raise ComposeError("No implementation found.")

telegrinder/node/rule.py

@@ -11,7 +11,7 @@ if typing.TYPE_CHECKING:
     from telegrinder.bot.rules.abc import ABCRule
 
 
-class RuleChain(dict[str, typing.Any]):
+class RuleChain(dict[str, typing.Any], Node):
     dataclass = dict
     rules: tuple["ABCRule", ...] = ()
 
@@ -28,7 +28,6 @@ class RuleChain(dict[str, typing.Any]):
     def __class_getitem__(cls, items: "ABCRule | tuple[ABCRule, ...]", /) -> typing.Self:
         if not isinstance(items, tuple):
             items = (items,)
-        assert all(isinstance(rule, "ABCRule") for rule in items), "All items must be instances of 'ABCRule'."
         return cls(*items)
 
     @staticmethod
@@ -37,6 +36,7 @@ class RuleChain(dict[str, typing.Any]):
 
     @classmethod
     async def compose(cls, update: UpdateNode) -> typing.Any:
+        # Hack to avoid circular import
         globalns = globals()
         if "check_rule" not in globalns:
             globalns.update(
@@ -54,7 +54,9 @@ class RuleChain(dict[str, typing.Any]):
                 raise ComposeError(f"Rule {rule!r} failed!")
 
         try:
-            return cls.dataclass(**ctx)  # type: ignore
+            if dataclasses.is_dataclass(cls.dataclass):
+                return cls.dataclass(**{k: ctx[k] for k in cls.__annotations__})
+            return cls.dataclass(**ctx)
         except Exception as exc:
             raise ComposeError(f"Dataclass validation error: {exc}")
 
@@ -63,7 +65,7 @@ class RuleChain(dict[str, typing.Any]):
         return cls
 
     @classmethod
-    def get_subnodes(cls) -> dict:
+    def get_subnodes(cls) -> dict[typing.Literal["update"], type[UpdateNode]]:
         return {"update": UpdateNode}
 
     @classmethod

telegrinder/node/scope.py

@@ -34,11 +34,11 @@ def global_node(node: T) -> T:
 
 
 __all__ = (
+    "GLOBAL",
     "NodeScope",
-    "PER_EVENT",
     "PER_CALL",
+    "PER_EVENT",
+    "global_node",
     "per_call",
     "per_event",
-    "global_node",
-    "GLOBAL",
 )

telegrinder/node/source.py

@@ -39,7 +39,9 @@ class Source(Polymorphic, DataNode):
         )
 
     @impl
-    async def compose_chat_join_request(cls, chat_join_request: EventNode[ChatJoinRequestCute]) -> typing.Self:
+    async def compose_chat_join_request(
+        cls, chat_join_request: EventNode[ChatJoinRequestCute]
+    ) -> typing.Self:
         return cls(
             api=chat_join_request.ctx_api,
             chat=chat_join_request.chat,
@@ -68,4 +70,4 @@ class UserSource(ScalarNode, User):
         return source.from_user
 
 
-__all__ = ("Source", "ChatSource", "UserSource")
+__all__ = ("ChatSource", "Source", "UserSource")

telegrinder/node/tools/generator.py

@@ -20,13 +20,13 @@ def error_on_none(value: T | None) -> T:
 
 
 def generate_node(
-    subnodes: tuple[type["Node"], ...],
-    func: typing.Callable[..., T],
+    subnodes: tuple[type[Node], ...],
+    func: typing.Callable[..., typing.Any],
     casts: tuple[typing.Callable[[typing.Any], typing.Any], ...] = (cast_false_to_none, error_on_none),
-) -> type["Node"]:
-    async def compose(**kw: typing.Any) -> typing.Any:
+) -> type[Node]:
+    async def compose(cls, **kw) -> typing.Any:
         args = await ContainerNode.compose(**kw)
-        result = func(*args)
+        result = func(*args)  # type: ignore
         if inspect.isawaitable(result):
             result = await result
         for cast in casts:
@@ -34,7 +34,8 @@ def generate_node(
         return result
 
     container = ContainerNode.link_nodes(list(subnodes))
-    return type("_ContainerNode", (container,), {"compose": compose})
+    compose.__annotations__ = container.get_subnodes()
+    return type("_ContainerNode", (container,), {"compose": classmethod(compose)})
 
 
 __all__ = ("generate_node",)

telegrinder/rules.py

@@ -26,7 +26,6 @@ __all__ = (
     "InlineQueryMarkup",
     "InlineQueryRule",
     "InlineQueryText",
-    "IsInteger",
     "IntegerInRange",
     "InviteLinkByCreator",
     "InviteLinkName",
@@ -39,6 +38,7 @@ __all__ = (
     "IsForward",
     "IsForwardType",
     "IsGroup",
+    "IsInteger",
     "IsLanguageCode",
     "IsPremium",
     "IsPrivate",
@@ -50,11 +50,11 @@ __all__ = (
     "Markup",
     "MessageEntities",
     "MessageRule",
+    "NodeRule",
     "NotRule",
     "OrRule",
     "Regex",
     "RuleEnum",
     "StartCommand",
     "Text",
-    "NodeRule",
 )

telegrinder/tools/__init__.py

@@ -67,12 +67,14 @@ from .limited_dict import LimitedDict
 from .loop_wrapper import ABCLoopWrapper, DelayedTask, Lifespan, LoopWrapper
 from .magic import impl, magic_bundle, resolve_arg_names
 from .parse_mode import ParseMode
+from .state_storage import ABCStateStorage, MemoryStateStorage, StateData
 
 __all__ = (
     "ABCErrorHandler",
     "ABCGlobalContext",
     "ABCI18n",
     "ABCLoopWrapper",
+    "ABCStateStorage",
     "ABCTranslator",
     "ABCTranslatorMiddleware",
     "AnyMarkup",
@@ -100,6 +102,7 @@ __all__ = (
     "LimitedDict",
     "Link",
     "LoopWrapper",
+    "MemoryStateStorage",
     "Mention",
     "ParseMode",
     "PreCode",
@@ -110,8 +113,14 @@ __all__ = (
     "SpecialFormat",
     "StartBotLink",
     "StartGroupLink",
+    "StateData",
     "TelegrinderContext",
     "TgEmoji",
+    "block_quote",
+    "bold",
+    "channel_boost_link",
+    "code_inline",
+    "ctx_var",
     "escape",
     "get_channel_boost_link",
     "get_invite_chat_link",
@@ -119,12 +128,14 @@ __all__ = (
     "get_resolve_domain_link",
     "get_start_bot_link",
     "get_start_group_link",
+    "impl",
     "invite_chat_link",
     "italic",
     "link",
     "magic_bundle",
     "mention",
     "pre_code",
+    "resolve_arg_names",
     "resolve_domain",
     "spoiler",
     "start_bot_link",
@@ -132,11 +143,4 @@ __all__ = (
     "strike",
     "tg_emoji",
     "underline",
-    "bold",
-    "channel_boost_link",
-    "code_inline",
-    "ctx_var",
-    "block_quote",
-    "impl",
-    "resolve_arg_names",
 )

telegrinder/tools/loop_wrapper/loop_wrapper.py

@@ -44,17 +44,16 @@ class DelayedTask(typing.Generic[CoroFunc]):
     def is_cancelled(self) -> bool:
         return self._cancelled
 
-    async def __call__(self, *args, **kwargs) -> None:
+    async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> None:
         while not self.is_cancelled:
             await asyncio.sleep(self.seconds)
             if self.is_cancelled:
                 break
             try:
                 await self.handler(*args, **kwargs)
-            except Exception as e:
-                logger.exception("Error in delayed task: {}", str(e))
-            if not self.repeat:
-                break
+            finally:
+                if not self.repeat:
+                    break
 
     def cancel(self) -> None:
         if not self._cancelled:

telegrinder/tools/magic.py

@@ -6,7 +6,7 @@ from functools import wraps
 
 if typing.TYPE_CHECKING:
     from telegrinder.bot.rules.abc import ABCRule
-    from telegrinder.node.base import Node
+    from telegrinder.node.polymorphic import Polymorphic
 
     T = typing.TypeVar("T", bound=ABCRule)
     F = typing.TypeVar(
@@ -23,7 +23,6 @@ IMPL_MARK: typing.Final[str] = "_is_impl"
 
 def cache_magic_value(mark_key: str, /):
     def inner(func: "F") -> "F":
-
         @wraps(func)
         def wrapper(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
             if mark_key not in args[0].__dict__:
@@ -31,6 +30,7 @@ def cache_magic_value(mark_key: str, /):
             return args[0].__dict__[mark_key]
 
         return wrapper  # type: ignore
+
     return inner
 
 
@@ -43,13 +43,13 @@ def get_default_args(func: FuncType) -> dict[str, typing.Any]:
     fspec = inspect.getfullargspec(func)
     if not fspec.defaults:
         return {}
-    return dict(zip(fspec.args[-len(fspec.defaults):], fspec.defaults))
+    return dict(zip(fspec.args[-len(fspec.defaults) :], fspec.defaults))
 
 
 def get_annotations(func: FuncType, *, return_type: bool = False) -> dict[str, typing.Any]:
     annotations = func.__annotations__
     if not return_type and "return" in func.__annotations__:
-       annotations.pop("return")
+        annotations.pop("return")
     return annotations
 
 
@@ -60,13 +60,11 @@ def to_str(s: str | enum.Enum) -> str:
 
 
 @typing.overload
-def magic_bundle(handler: FuncType, kw: dict[str, typing.Any]) -> dict[str, typing.Any]:
-    ...
+def magic_bundle(handler: FuncType, kw: dict[str, typing.Any]) -> dict[str, typing.Any]: ...
 
 
 @typing.overload
-def magic_bundle(handler: FuncType, kw: dict[enum.Enum, typing.Any]) -> dict[str, typing.Any]:
-    ...
+def magic_bundle(handler: FuncType, kw: dict[enum.Enum, typing.Any]) -> dict[str, typing.Any]: ...
 
 
 @typing.overload
@@ -76,8 +74,7 @@ def magic_bundle(
     *,
     start_idx: int = 1,
     bundle_ctx: bool = True,
-) -> dict[str, typing.Any]:
-    ...
+) -> dict[str, typing.Any]: ...
 
 
 @typing.overload
@@ -87,8 +84,7 @@ def magic_bundle(
     *,
     start_idx: int = 1,
     bundle_ctx: bool = True,
-) -> dict[str, typing.Any]:
-    ...
+) -> dict[str, typing.Any]: ...
 
 
 @typing.overload
@@ -97,8 +93,7 @@ def magic_bundle(
     kw: dict[type, typing.Any],
     *,
     typebundle: typing.Literal[True] = True,
-) -> dict[str, typing.Any]:
-    ...
+) -> dict[str, typing.Any]: ...
 
 
 def magic_bundle(
@@ -109,7 +104,6 @@ def magic_bundle(
     bundle_ctx: bool = True,
     typebundle: bool = False,
 ) -> dict[str, typing.Any]:
-
     if typebundle:
         types = get_annotations(handler, return_type=False)
         bundle: dict[str, typing.Any] = {}
@@ -141,13 +135,17 @@ def impl(method: typing.Callable[..., typing.Any]):
     return classmethod(method)
 
 
-def get_impls(cls: type["Node"]) -> list[typing.Callable[..., typing.Any]]:
-    return [
+def get_impls(cls: type["Polymorphic"]) -> list[typing.Callable[..., typing.Any]]:
+    moprh_impls = getattr(cls, "__morph_impls__", None)
+    if moprh_impls is not None:
+        return moprh_impls
+    impls = [
         func.__func__
         for func in vars(cls).values()
         if isinstance(func, classmethod) and getattr(func.__func__, IMPL_MARK, False)
     ]
-
+    setattr(cls, "__morph_impls__", impls)
+    return impls
 
 
 __all__ = (
@@ -158,8 +156,8 @@ __all__ = (
     "get_cached_translation",
     "get_default_args",
     "get_default_args",
-    "impl",
     "get_impls",
+    "impl",
     "magic_bundle",
     "resolve_arg_names",
     "to_str",

telegrinder/tools/state_storage/__init__.py

@@ -0,0 +1,4 @@
+from telegrinder.tools.state_storage.abc import ABCStateStorage, StateData
+from telegrinder.tools.state_storage.memory import MemoryStateStorage
+
+__all__ = ("ABCStateStorage", "MemoryStateStorage", "StateData")

telegrinder/tools/state_storage/abc.py

@@ -0,0 +1,35 @@
+import abc
+import enum
+import typing
+from dataclasses import dataclass
+
+from fntypes import Option
+
+from telegrinder.bot.rules.state import State, StateMeta
+
+Payload = typing.TypeVar("Payload")
+
+
+@dataclass(frozen=True, slots=True)
+class StateData(typing.Generic[Payload]):
+    key: str | enum.Enum
+    payload: Payload
+
+
+class ABCStateStorage(abc.ABC, typing.Generic[Payload]):
+    @abc.abstractmethod
+    async def get(self, user_id: int) -> Option[StateData[Payload]]: ...
+
+    @abc.abstractmethod
+    async def delete(self, user_id: int) -> None: ...
+
+    @abc.abstractmethod
+    async def set(self, user_id: int, key: str | enum.Enum, payload: Payload) -> None: ...
+
+    def State(self, key: str | StateMeta | enum.Enum = StateMeta.ANY, /) -> State[Payload]:  # noqa: N802
+        """Can be used as a shortcut to get a state rule dependant on current storage."""
+
+        return State(storage=self, key=key)
+
+
+__all__ = ("ABCStateStorage", "StateData")

telegrinder/tools/state_storage/memory.py

@@ -0,0 +1,25 @@
+import typing
+
+from fntypes import Nothing, Option, Some
+
+from telegrinder.tools.state_storage.abc import ABCStateStorage, StateData
+
+Payload: typing.TypeAlias = dict[str, typing.Any]
+
+
+class MemoryStateStorage(ABCStateStorage[Payload]):
+    def __init__(self) -> None:
+        self.storage: dict[int, StateData[Payload]] = {}
+
+    async def get(self, user_id: int) -> Option[StateData[Payload]]:
+        state = self.storage.get(user_id)
+        return Some(state) if state is not None else Nothing()
+
+    async def set(self, user_id: int, key: str, payload: Payload) -> None:
+        self.storage[user_id] = StateData(key, payload)
+
+    async def delete(self, user_id: int) -> None:
+        self.storage.pop(user_id)
+
+
+__all__ = ("MemoryStateStorage",)

telegrinder/types/__init__.py

@@ -178,6 +178,7 @@ __all__ = (
     "PaidMediaInfo",
     "PaidMediaPhoto",
     "PaidMediaPreview",
+    "PaidMediaPurchased",
     "PaidMediaVideo",
     "PassportData",
     "PassportElementError",