telegrinder 0.1.dev171__py3-none-any.whl → 0.2.0__py3-none-any.whl

telegrinder/node/event.py

@@ -2,9 +2,11 @@ import typing
 
 import msgspec
 
+from telegrinder.api import API
+from telegrinder.bot.cute_types import BaseCute
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.msgspec_utils import DataclassInstance
-from telegrinder.node.base import BaseNode, ComposeError, DataNode
+from telegrinder.node.base import ComposeError, DataNode, Node
 from telegrinder.node.update import UpdateNode
 
 if typing.TYPE_CHECKING:
@@ -15,45 +17,52 @@ if typing.TYPE_CHECKING:
 EVENT_NODE_KEY = "_event_node"
 
 
-if typing.TYPE_CHECKING:
-    EventNode: typing.TypeAlias = typing.Annotated["Dataclass", ...]
+from telegrinder.msgspec_utils import decoder
 
-else:
-    from telegrinder.msgspec_utils import decoder
 
-    class EventNode(BaseNode):
-        dataclass: type["DataclassType"]
+class _EventNode(Node):
+    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 __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)
 
-        def __class_getitem__(cls, dataclass: type["DataclassType"], /) -> type[typing.Self]:
-            return cls(dataclass)
+    @classmethod
+    async def compose(cls, raw_update: UpdateNode, ctx: Context, api: API) -> "DataclassType":
+        dataclass_type = typing.get_origin(cls.dataclass) or cls.dataclass
 
-        @classmethod
-        async def compose(cls, raw_update: UpdateNode, ctx: Context) -> "DataclassType":
-            dataclass_type = typing.get_origin(cls.dataclass) or cls.dataclass
+        try:
+            if issubclass(dataclass_type, dict):
+                dataclass = cls.dataclass(**raw_update.incoming_update.to_full_dict())
 
-            try:
-                if issubclass(dataclass_type, dict):
-                    dataclass = cls.dataclass(**raw_update.incoming_update.to_full_dict())
+            elif issubclass(dataclass_type, BaseCute):
+                dataclass = dataclass_type.from_update(raw_update.incoming_update, bound_api=api)
 
-                elif issubclass(dataclass_type, msgspec.Struct | DataclassInstance):
-                    dataclass = decoder.convert(
-                        raw_update.incoming_update.to_full_dict(),
-                        type=cls.dataclass,
-                    )
+            elif issubclass(dataclass_type, (msgspec.Struct, DataclassInstance)): # type: ignore
+                # FIXME: must be used with encode_name
+                dataclass = decoder.convert(
+                    raw_update.incoming_update.to_full_dict(),
+                    type=cls.dataclass,
+                )
 
-                else:
-                    dataclass = cls.dataclass(**raw_update.incoming_update.to_dict())
+            else:
+                dataclass = cls.dataclass(**raw_update.incoming_update.to_dict())
 
-                ctx[EVENT_NODE_KEY] = cls
-                return dataclass
-            except Exception:
-                raise ComposeError(f"Cannot parse update to {cls.dataclass.__name__!r}.")
+            ctx[EVENT_NODE_KEY] = cls
+            return dataclass
+        except Exception as exc:
+            raise ComposeError(f"Cannot parse update into {cls.dataclass.__name__!r}, error: {exc}")
 
 
+if typing.TYPE_CHECKING:
+    EventNode: typing.TypeAlias = typing.Annotated["Dataclass", ...]
+else:
+    class EventNode(_EventNode):
+        pass
+
 __all__ = ("EventNode",)

telegrinder/node/polymorphic.py

@@ -2,32 +2,37 @@ import inspect
 import typing
 
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.node.base import BaseNode, ComposeError
+from telegrinder.modules import logger
+from telegrinder.node.base import ComposeError, Node
 from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, Composition, NodeSession
 from telegrinder.node.scope import NodeScope
 from telegrinder.node.update import UpdateNode
-from telegrinder.tools.magic import IMPL_MARK, get_impls_by_key, impl
+from telegrinder.tools.magic import get_impls, impl
 
 
-class Polymorphic(BaseNode):
+class Polymorphic(Node):
     @classmethod
     async def compose(cls, update: UpdateNode, context: Context) -> typing.Any:
+        logger.debug(f"Composing polimorphic node {cls.__name__}")
         scope = getattr(cls, "scope", None)
         node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
 
-        for i, impl in enumerate(get_impls_by_key(cls, IMPL_MARK).values()):
-            composition = Composition(impl, True, node_class=cls)
+        for i, impl in enumerate(get_impls(cls)):
+            logger.debug("Checking impl {}", impl.__name__)
+            composition = Composition(impl, True)
             node_collection = await composition.compose_nodes(update, context)
             if node_collection is None:
+                logger.debug("Impl {} 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 {} succeeded", impl.__name__)
                 res: NodeSession = node_ctx[(cls, i)]
                 await node_collection.close_all()
                 return res.value
 
-            result = composition.func(cls, **node_collection.values())
+            result = composition.func(cls, **node_collection.values)
             if inspect.isawaitable(result):
                 result = await result
 
@@ -35,6 +40,7 @@ class Polymorphic(BaseNode):
                 node_ctx[(cls, i)] = NodeSession(cls, result, {})
 
             await node_collection.close_all(with_value=result)
+            logger.debug("Impl {} succeeded with value {}", impl.__name__, result)
             return result
 
         raise ComposeError("No implementation found.")

telegrinder/node/rule.py

@@ -63,17 +63,9 @@ class RuleChain(dict[str, typing.Any]):
         return cls
 
     @classmethod
-    def get_sub_nodes(cls) -> dict:
+    def get_subnodes(cls) -> dict:
         return {"update": UpdateNode}
 
-    @classmethod
-    def get_compose_annotations(cls) -> dict[str, typing.Any]:
-        return {}
-
-    @classmethod
-    def get_node_impls(cls) -> dict[str, typing.Callable[..., typing.Any]]:
-        return {}
-
     @classmethod
     def is_generator(cls) -> typing.Literal[False]:
         return False

telegrinder/node/scope.py

@@ -33,4 +33,12 @@ def global_node(node: T) -> T:
     return node
 
 
-__all__ = ("NodeScope", "PER_EVENT", "PER_CALL", "per_call", "per_event", "global_node", "GLOBAL")
+__all__ = (
+    "NodeScope",
+    "PER_EVENT",
+    "PER_CALL",
+    "per_call",
+    "per_event",
+    "global_node",
+    "GLOBAL",
+)

telegrinder/node/source.py

@@ -4,8 +4,10 @@ import typing
 from fntypes.option import Nothing, Option
 
 from telegrinder.api.api import API
+from telegrinder.bot.cute_types import ChatJoinRequestCute
 from telegrinder.node.base import ComposeError, DataNode, ScalarNode
 from telegrinder.node.callback_query import CallbackQueryNode
+from telegrinder.node.event import EventNode
 from telegrinder.node.message import MessageNode
 from telegrinder.node.polymorphic import Polymorphic, impl
 from telegrinder.types.objects import Chat, Message, User
@@ -36,6 +38,15 @@ class Source(Polymorphic, DataNode):
             thread_id=callback_query.message_thread_id,
         )
 
+    @impl
+    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,
+            from_user=chat_join_request.from_user,
+            thread_id=Nothing(),
+        )
+
     async def send(self, text: str) -> Message:
         result = await self.api.send_message(
             chat_id=self.chat.id,

telegrinder/node/update.py

@@ -1,11 +1,15 @@
+from telegrinder.api import API
 from telegrinder.bot.cute_types import UpdateCute
 from telegrinder.node.base import ScalarNode
+from telegrinder.types import Update
 
 
 class UpdateNode(ScalarNode, UpdateCute):
     @classmethod
-    async def compose(cls, update: UpdateCute) -> UpdateCute:
-        return update
+    async def compose(cls, update: Update, api: API) -> UpdateCute:
+        if isinstance(update, UpdateCute):
+            return update
+        return UpdateCute.from_update(update, api)
 
 
 __all__ = ("UpdateNode",)

telegrinder/rules.py

@@ -1 +1,60 @@
 from .bot.rules import *  # noqa: F403
+
+__all__ = (
+    "ABCRule",
+    "AndRule",
+    "Argument",
+    "CallbackDataEq",
+    "CallbackDataJsonEq",
+    "CallbackDataJsonModel",
+    "CallbackDataMap",
+    "CallbackDataMarkup",
+    "CallbackQueryDataRule",
+    "CallbackQueryRule",
+    "ChatJoinRequestRule",
+    "Command",
+    "EnumTextRule",
+    "FuncRule",
+    "FuzzyText",
+    "HasData",
+    "HasEntities",
+    "HasInviteLink",
+    "HasLocation",
+    "HasMention",
+    "HasText",
+    "InlineQueryChatType",
+    "InlineQueryMarkup",
+    "InlineQueryRule",
+    "InlineQueryText",
+    "IsInteger",
+    "IntegerInRange",
+    "InviteLinkByCreator",
+    "InviteLinkName",
+    "IsBot",
+    "IsChat",
+    "IsChatId",
+    "IsDice",
+    "IsDiceEmoji",
+    "IsForum",
+    "IsForward",
+    "IsForwardType",
+    "IsGroup",
+    "IsLanguageCode",
+    "IsPremium",
+    "IsPrivate",
+    "IsReply",
+    "IsSuperGroup",
+    "IsUpdateType",
+    "IsUser",
+    "IsUserId",
+    "Markup",
+    "MessageEntities",
+    "MessageRule",
+    "NotRule",
+    "OrRule",
+    "Regex",
+    "RuleEnum",
+    "StartCommand",
+    "Text",
+    "NodeRule",
+)

telegrinder/tools/error_handler/abc.py

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 
 from fntypes.result import Result
 
-from telegrinder.api import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
 
 EventT = typing.TypeVar("EventT")
@@ -24,7 +24,7 @@ class ABCErrorHandler(ABC, typing.Generic[EventT]):
         self,
         handler: Handler[EventT],
         event: EventT,
-        api: ABCAPI,
+        api: API,
         ctx: Context,
     ) -> Result[typing.Any, typing.Any]:
         """Run error handler."""

telegrinder/tools/error_handler/error_handler.py

@@ -3,7 +3,7 @@ import typing
 
 from fntypes.result import Error, Ok, Result
 
-from telegrinder.api import ABCAPI
+from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
 from telegrinder.modules import logger
 from telegrinder.tools.magic import magic_bundle
@@ -39,7 +39,7 @@ class Catcher(typing.Generic[EventT]):
         self,
         handler: Handler[EventT],
         event: EventT,
-        api: ABCAPI,
+        api: API,
         ctx: Context,
     ) -> Result[typing.Any, BaseException]:
         try:
@@ -49,7 +49,7 @@ class Catcher(typing.Generic[EventT]):
 
     async def process_exception(
         self,
-        api: ABCAPI,
+        api: API,
         event: EventT,
         ctx: Context,
         exception: BaseException,
@@ -125,7 +125,7 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         self,
         handler: Handler[EventT],
         event: EventT,
-        api: ABCAPI,
+        api: API,
         ctx: Context,
     ) -> Result[typing.Any, BaseException]:
         assert self.catcher is not None
@@ -159,7 +159,7 @@ class ErrorHandler(ABCErrorHandler[EventT]):
         self,
         handler: Handler[EventT],
         event: EventT,
-        api: ABCAPI,
+        api: API,
         ctx: Context,
     ) -> Result[typing.Any, BaseException]:
         if not self.catcher:

telegrinder/tools/global_context/global_context.py

@@ -334,7 +334,7 @@ class GlobalContext(ABCGlobalContext, typing.Generic[CtxValueT], dict[str, Globa
     def get(self, var_name, var_value_type=object):  # type: ignore
         """Get context variable by name."""
 
-        var_value_type = typing.Any if var_value_type is object else type
+        var_value_type = typing.Any if var_value_type is object else var_value_type
         generic_types = typing.get_args(get_orig_class(self))
         if generic_types and var_value_type is object:
             var_value_type = generic_types[0]

telegrinder/tools/keyboard.py

@@ -94,7 +94,7 @@ class Keyboard(ABCMarkup[Button], KeyboardModel):
         self.keyboard = [row for row in self.keyboard if row]
         return {
             k: v.unwrap() if v and isinstance(v, Some) else v
-            for k, v in self.__dict__.items()
+            for k, v in dataclasses.asdict(self).items()
             if type(v) not in (NoneType, Nothing)
         }
 

telegrinder/tools/loop_wrapper/loop_wrapper.py

@@ -61,23 +61,23 @@ class DelayedTask(typing.Generic[CoroFunc]):
             self._cancelled = True
 
 
-@dataclasses.dataclass(kw_only=True, slots=True)
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
 class Lifespan:
     startup_tasks: list[CoroutineTask[typing.Any]] = dataclasses.field(default_factory=lambda: [])
     shutdown_tasks: list[CoroutineTask[typing.Any]] = dataclasses.field(default_factory=lambda: [])
 
-    def on_startup(self, task_or_func: Task) -> Task:
-        self.startup_tasks.append(to_coroutine_task(task_or_func))
-        return task_or_func
+    def on_startup(self, task: Task, /) -> Task:
+        self.startup_tasks.append(to_coroutine_task(task))
+        return task
 
-    def on_shutdown(self, task_or_func: Task) -> Task:
-        self.shutdown_tasks.append(to_coroutine_task(task_or_func))
-        return task_or_func
+    def on_shutdown(self, task: Task, /) -> Task:
+        self.shutdown_tasks.append(to_coroutine_task(task))
+        return task
 
-    def start(self, loop: asyncio.AbstractEventLoop) -> None:
+    def start(self, loop: asyncio.AbstractEventLoop, /) -> None:
         run_tasks(self.startup_tasks, loop)
 
-    def shutdown(self, loop: asyncio.AbstractEventLoop) -> None:
+    def shutdown(self, loop: asyncio.AbstractEventLoop, /) -> None:
         run_tasks(self.shutdown_tasks, loop)
 
 

telegrinder/tools/magic.py

@@ -15,16 +15,15 @@ if typing.TYPE_CHECKING:
     )
 
 Impl: typing.TypeAlias = type[classmethod]
-NodeImpl: typing.TypeAlias = Impl
 FuncType: typing.TypeAlias = types.FunctionType | typing.Callable[..., typing.Any]
 
 TRANSLATIONS_KEY: typing.Final[str] = "_translations"
 IMPL_MARK: typing.Final[str] = "_is_impl"
-NODE_IMPL_MARK: typing.Final[str] = "_is_node_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__:
@@ -32,7 +31,6 @@ def cache_magic_value(mark_key: str, /):
             return args[0].__dict__[mark_key]
 
         return wrapper  # type: ignore
-
     return inner
 
 
@@ -49,9 +47,10 @@ def get_default_args(func: FuncType) -> dict[str, typing.Any]:
 
 
 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__:
-        del func.__annotations__["return"]
-    return func.__annotations__
+       annotations.pop("return")
+    return annotations
 
 
 def to_str(s: str | enum.Enum) -> str:
@@ -60,13 +59,64 @@ def to_str(s: str | enum.Enum) -> str:
     return s
 
 
+@typing.overload
+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]:
+    ...
+
+
+@typing.overload
+def magic_bundle(
+    handler: FuncType,
+    kw: dict[str, typing.Any],
+    *,
+    start_idx: int = 1,
+    bundle_ctx: bool = True,
+) -> dict[str, typing.Any]:
+    ...
+
+
+@typing.overload
+def magic_bundle(
+    handler: FuncType,
+    kw: dict[enum.Enum, typing.Any],
+    *,
+    start_idx: int = 1,
+    bundle_ctx: bool = True,
+) -> dict[str, typing.Any]:
+    ...
+
+
+@typing.overload
 def magic_bundle(
     handler: FuncType,
-    kw: dict[str | enum.Enum, typing.Any],
+    kw: dict[type, typing.Any],
+    *,
+    typebundle: typing.Literal[True] = True,
+) -> dict[str, typing.Any]:
+    ...
+
+
+def magic_bundle(
+    handler: FuncType,
+    kw: dict[typing.Any, typing.Any],
     *,
     start_idx: int = 1,
     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] = {}
+        for name, type in types.items():
+            bundle[name] = kw[type]
+        return bundle
+
     names = resolve_arg_names(handler, start_idx=start_idx)
     args = get_default_args(handler)
     args.update({to_str(k): v for k, v in kw.items() if to_str(k) in names})
@@ -85,24 +135,19 @@ def cache_translation(base_rule: "T", locale: str, translated_rule: "T") -> None
     setattr(base_rule, TRANSLATIONS_KEY, translations)
 
 
-def get_impls_by_key(cls: type["Node"], mark_key: str) -> dict[str, typing.Callable[..., typing.Any]]:
-    return {
-        name: func.__func__
-        for name, func in vars(cls).items()
-        if isinstance(func, classmethod) and getattr(func.__func__, mark_key, False)
-    }
-
-
 @typing.cast(typing.Callable[..., Impl], lambda f: f)
 def impl(method: typing.Callable[..., typing.Any]):
     setattr(method, IMPL_MARK, True)
     return classmethod(method)
 
 
-@typing.cast(typing.Callable[..., NodeImpl], lambda f: f)
-def node_impl(method: typing.Callable[..., typing.Any]):
-    setattr(method, NODE_IMPL_MARK, True)
-    return classmethod(method)
+def get_impls(cls: type["Node"]) -> list[typing.Callable[..., typing.Any]]:
+    return [
+        func.__func__
+        for func in vars(cls).values()
+        if isinstance(func, classmethod) and getattr(func.__func__, IMPL_MARK, False)
+    ]
+
 
 
 __all__ = (
@@ -114,8 +159,8 @@ __all__ = (
     "get_default_args",
     "get_default_args",
     "impl",
+    "get_impls",
     "magic_bundle",
-    "node_impl",
     "resolve_arg_names",
     "to_str",
 )

telegrinder/types/__init__.py

@@ -205,6 +205,7 @@ __all__ = (
     "ReactionType",
     "ReactionTypeCustomEmoji",
     "ReactionTypeEmoji",
+    "ReactionTypePaid",
     "ReactionTypeType",
     "RefundedPayment",
     "ReplyKeyboardMarkup",

telegrinder/types/enums.py

@@ -443,6 +443,7 @@ class ChatType(str, enum.Enum):
     GROUP = "group"
     SUPERGROUP = "supergroup"
     CHANNEL = "channel"
+    SENDER = "sender"
 
 
 class ChatMemberStatus(str, enum.Enum):