telegrinder 0.1.dev20__py3-none-any.whl → 0.1.dev159__py3-none-any.whl

telegrinder/node/composer.py

@@ -0,0 +1,71 @@
+import typing
+
+from telegrinder.bot.cute_types import UpdateCute
+from telegrinder.node import Node
+
+
+class NodeSession:
+    def __init__(
+        self, 
+        value: typing.Any,
+        subnodes: dict[str, typing.Self],
+        generator: typing.AsyncGenerator[typing.Any, None] | None = None,
+    ):
+        self.value = value
+        self.subnodes = subnodes
+        self.generator = generator
+    
+    async def close(self, with_value: typing.Any | None = None) -> None:
+        for subnode in self.subnodes.values():
+            await subnode.close()
+        
+        if self.generator is None:
+            return
+        try:
+            await self.generator.asend(with_value)
+        except StopAsyncIteration:
+            self.generator = None
+
+    def __repr__(self) -> str:
+        return f"<NodeSession {self.value}" + ("ACTIVE>" if self.generator else ">")
+
+
+class NodeCollection:
+    def __init__(self, sessions: dict[str, NodeSession]) -> None:
+        self.sessions = sessions
+
+    def values(self) -> dict[str, typing.Any]:
+        return {name: session.value for name, session in self.sessions.items()}
+    
+    async def close_all(self, with_value: typing.Any | None = None) -> None:
+        for session in self.sessions.values():
+            await session.close(with_value)
+
+
+async def compose_node(
+    node: type[Node],
+    update: UpdateCute,
+    ready_context: dict[str, NodeSession] | None = None,
+) -> NodeSession:
+    _node = node.as_node()
+    context = NodeCollection(ready_context.copy() if ready_context else {})
+
+    for name, subnode in _node.get_sub_nodes().items():
+        if subnode is UpdateCute:
+            context.sessions[name] = NodeSession(update, {})
+        else:
+            context.sessions[name] = await compose_node(subnode, update)
+
+    generator: typing.AsyncGenerator | None
+
+    if _node.is_generator():
+        generator = typing.cast(typing.AsyncGenerator, _node.compose(**context.values()))
+        value = await generator.asend(None)
+    else:
+        generator = None
+        value = await _node.compose(**context.values())  # type: ignore
+    
+    return NodeSession(value, context.sessions, generator)
+
+
+__all__ = ("NodeCollection", "NodeSession", "compose_node")

telegrinder/node/container.py

@@ -0,0 +1,22 @@
+import typing
+
+from .base import Node
+
+
+class ContainerNode(Node):
+    linked_nodes: typing.ClassVar[list[type[Node]]]
+
+    @classmethod
+    async def compose(cls, **kw) -> tuple["Node", ...]:
+        return tuple(t[1] for t in sorted(kw.items(), key=lambda t: t[0]))
+
+    @classmethod
+    def get_sub_nodes(cls) -> dict[str, type["Node"]]:
+        return {f"node_{i}": node_t for i, node_t in enumerate(cls.linked_nodes)}
+    
+    @classmethod
+    def link_nodes(cls, linked_nodes: list[type[Node]]) -> type["ContainerNode"]:
+        return type("_ContainerNode", (cls,), {"linked_nodes": linked_nodes})
+
+
+__all__ = ("ContainerNode",)

telegrinder/node/message.py

@@ -0,0 +1,18 @@
+import typing
+
+from telegrinder.bot.cute_types import MessageCute
+
+from .base import ComposeError, ScalarNode
+from .update import UpdateNode
+
+
+class MessageNode(ScalarNode, MessageCute):
+    @classmethod
+    async def compose(cls, update: UpdateNode) -> typing.Self:
+        return cls(
+            **update.message.expect(ComposeError).to_dict(),
+            api=update.api,
+        )
+
+
+__all__ = ("MessageNode",)

telegrinder/node/rule.py

@@ -0,0 +1,56 @@
+import dataclasses
+import typing
+
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.bot.dispatch.process import check_rule
+from telegrinder.bot.rules.abc import ABCRule
+from telegrinder.node.base import ComposeError, Node
+from telegrinder.node.update import UpdateNode
+
+
+class RuleContext(dict):
+    dataclass = dict
+    rules: tuple[ABCRule, ...] = ()
+
+    @classmethod
+    async def compose(cls, update: UpdateNode):
+        ctx = Context()
+        for rule in cls.rules:
+            if not await check_rule(update.api, rule, update, ctx):
+                raise ComposeError
+        try:
+            return cls.dataclass(**ctx)  # type: ignore
+        except Exception as exc:
+            raise ComposeError(f"Dataclass validation error: {exc}")
+
+    @classmethod
+    def as_node(cls) -> type[typing.Self]:
+        return cls
+    
+    @classmethod
+    def get_sub_nodes(cls) -> dict:
+        return {"update": UpdateNode}
+
+    @classmethod
+    def is_generator(cls) -> typing.Literal[False]:
+        return False
+
+    def __new__(cls, *rules: ABCRule) -> type[Node]:
+        return type("_RuleNode", (cls,), {"dataclass": dict, "rules": rules})  # type: ignore
+    
+    def __class_getitem__(cls, item: tuple[ABCRule, ...]) -> typing.Self:
+        if not isinstance(item, tuple):
+            item = (item,)
+        return cls(*item)
+    
+    @staticmethod
+    def generate_dataclass(cls_: type["RuleContext"]):  # noqa: ANN205
+        return dataclasses.dataclass(type(cls_.__name__, (object,), dict(cls_.__dict__)))
+    
+    def __init_subclass__(cls) -> None:
+        if cls.__name__ == "_RuleNode":
+            return
+        cls.dataclass = cls.generate_dataclass(cls)
+
+
+__all__ = ("RuleContext",)

telegrinder/node/source.py

@@ -0,0 +1,31 @@
+import dataclasses
+import typing
+
+from telegrinder.api import API
+from telegrinder.msgspec_utils import Nothing, Option
+from telegrinder.types import Chat, Message
+
+from .base import DataNode
+from .message import MessageNode
+
+
+@dataclasses.dataclass
+class Source(DataNode):
+    api: API
+    chat: Chat
+    thread_id: Option[int] = dataclasses.field(default_factory=lambda: Nothing)
+
+    @classmethod
+    async def compose(cls, message: MessageNode) -> typing.Self:
+        return cls(
+            api=message.ctx_api,
+            chat=message.chat,
+            thread_id=message.message_thread_id,
+        )
+    
+    async def send(self, text: str) -> Message:
+        result = await self.api.send_message(self.chat.id, message_thread_id=self.thread_id, text=text)
+        return result.unwrap()
+
+
+__all__ = ("Source",)

telegrinder/node/text.py

@@ -0,0 +1,13 @@
+import typing
+
+from .base import ComposeError, ScalarNode
+from .message import MessageNode
+
+
+class Text(ScalarNode, str):
+    @classmethod
+    async def compose(cls, message: MessageNode) -> typing.Self:
+        return cls(message.text.expect(ComposeError("Message has no text")))
+
+
+__all__ = ("Text",)

telegrinder/node/tools/__init__.py

@@ -0,0 +1,3 @@
+from .generator import generate
+
+__all__ = ("generate",)

telegrinder/node/tools/generator.py

@@ -0,0 +1,40 @@
+import inspect
+import typing
+
+from telegrinder.node.base import ComposeError, Node
+from telegrinder.node.container import ContainerNode
+
+T = typing.TypeVar("T")
+
+
+def cast_false_to_none(value: T) -> T | None:
+    if value is False:
+        return None
+    return value
+
+
+def error_on_none(value: T | None) -> T:
+    if value is None:
+        raise ComposeError
+    return value
+
+
+def generate(
+    subnodes: tuple[type[Node], ...], 
+    func: typing.Callable[..., typing.Any],
+    casts: tuple[typing.Callable, ...] = (cast_false_to_none, error_on_none),
+) -> type[ContainerNode]:
+    async def compose(**kw: typing.Any) -> typing.Any:
+        args = await ContainerNode.compose(**kw)
+        result = func(*args)
+        if inspect.isawaitable(result):
+            result = await result
+        for cast in casts:
+            result = cast(result)
+        return result
+
+    container = ContainerNode.link_nodes(list(subnodes))
+    return type("_ContainerNode", (container,), {"compose": compose})
+
+
+__all__ = ("generate",)

telegrinder/node/update.py

@@ -0,0 +1,12 @@
+from telegrinder.bot.cute_types import UpdateCute
+
+from .base import ScalarNode
+
+
+class UpdateNode(ScalarNode, UpdateCute):
+    @classmethod
+    async def compose(cls, update: UpdateCute) -> UpdateCute:
+        return update
+
+
+__all__ = ("UpdateNode",)

telegrinder/rules.py

@@ -1 +1 @@
-from .bot.rules import *
+from .bot.rules import *  # noqa: F403

telegrinder/tools/__init__.py

@@ -1,5 +1,139 @@
-from .keyboard import Keyboard, Button, InlineButton, InlineKeyboard, AnyMarkup
-from .magic import VarUnset, resolve_arg_names, magic_bundle
+from .buttons import BaseButton
+from .error_handler import ABCErrorHandler, Catcher, ErrorHandler
+from .formatting import (
+    BaseSpecFormat,
+    ChannelBoostLink,
+    FormatString,
+    HTMLFormatter,
+    InviteChatLink,
+    Link,
+    Mention,
+    PreCode,
+    ResolveDomain,
+    SpecialFormat,
+    StartBotLink,
+    StartGroupLink,
+    TgEmoji,
+    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,
+)
+from .global_context import (
+    ABCGlobalContext,
+    CtxVar,
+    GlobalContext,
+    GlobalCtxVar,
+    TelegrinderCtx,
+    ctx_var,
+)
+from .i18n import (
+    ABCI18n,
+    ABCTranslator,
+    ABCTranslatorMiddleware,
+    I18nEnum,
+    SimpleI18n,
+    SimpleTranslator,
+)
 from .kb_set import KeyboardSetBase, KeyboardSetYAML
-from .parse_mode import ParseMode, get_mention_link
-from .formatting import ABCFormatter, HTMLFormatter, MarkdownFormatter
+from .keyboard import (
+    AnyMarkup,
+    Button,
+    InlineButton,
+    InlineKeyboard,
+    Keyboard,
+    RowButtons,
+    keyboard_remove,
+)
+from .loop_wrapper import ABCLoopWrapper, DelayedTask, LoopWrapper
+from .magic import magic_bundle, resolve_arg_names
+from .parse_mode import ParseMode
+
+__all__ = (
+    "ABCErrorHandler",
+    "ABCGlobalContext",
+    "ABCI18n",
+    "ABCLoopWrapper",
+    "ABCTranslator",
+    "ABCTranslatorMiddleware",
+    "AnyMarkup",
+    "BaseButton",
+    "BaseSpecFormat",
+    "Button",
+    "Catcher",
+    "ChannelBoostLink",
+    "CtxVar",
+    "DelayedTask",
+    "ErrorHandler",
+    "FormatString",
+    "GlobalContext",
+    "GlobalCtxVar",
+    "HTMLFormatter",
+    "I18nEnum",
+    "InlineButton",
+    "InlineKeyboard",
+    "InviteChatLink",
+    "Keyboard",
+    "KeyboardSetBase",
+    "KeyboardSetYAML",
+    "Link",
+    "LoopWrapper",
+    "Mention",
+    "ParseMode",
+    "PreCode",
+    "ResolveDomain",
+    "RowButtons",
+    "SimpleI18n",
+    "SimpleTranslator",
+    "SpecialFormat",
+    "StartBotLink",
+    "StartGroupLink",
+    "TelegrinderCtx",
+    "TgEmoji",
+    "block_quote",
+    "bold",
+    "channel_boost_link",
+    "code_inline",
+    "ctx_var",
+    "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",
+    "keyboard_remove",
+    "link",
+    "magic_bundle",
+    "mention",
+    "pre_code",
+    "resolve_arg_names",
+    "resolve_domain",
+    "spoiler",
+    "start_bot_link",
+    "start_group_link",
+    "strike",
+    "tg_emoji",
+    "underline",
+)

telegrinder/tools/buttons.py

@@ -1,51 +1,89 @@
-from typing import Optional
-from abc import ABC, abstractmethod
-
-
-class ABCButton(ABC):
-    @abstractmethod
-    def __init__(self, **kwargs):
-        pass
-
-    def get_data(self) -> dict:
-        return {k: v for k, v in self.__dict__.items() if v is not None}
-
-
-class Button(ABCButton):
-    def __init__(
-        self,
-        text: str,
-        request_contact: Optional[bool] = False,
-        request_location: Optional[bool] = False,
-        request_poll: Optional[dict] = None,
-        web_app: Optional[dict] = None,
-    ):
-        self.text = text
-        self.request_contact = request_contact
-        self.request_location = request_location
-        self.request_poll = request_poll
-        self.web_app = web_app
-
-
-class InlineButton(ABCButton):
-    def __init__(
-        self,
-        text: str,
-        url: str = None,
-        login_url: dict = None,
-        pay: bool = None,
-        callback_data: str = None,
-        callback_game: dict = None,
-        switch_inline_query: str = None,
-        switch_inline_query_current_chat: str = None,
-        web_app: Optional[dict] = None,
-    ):
-        self.text = text
-        self.url = url
-        self.login_url = login_url
-        self.pay = pay
-        self.callback_data = callback_data
-        self.callback_game = callback_game
-        self.switch_inline_query = switch_inline_query
-        self.switch_inline_query_current_chat = switch_inline_query_current_chat
-        self.web_app = web_app
+import dataclasses
+import typing
+
+import msgspec
+
+from telegrinder.model import encoder
+from telegrinder.types import (
+    CallbackGame,
+    KeyboardButtonPollType,
+    KeyboardButtonRequestChat,
+    KeyboardButtonRequestUsers,
+    SwitchInlineQueryChosenChat,
+    WebAppInfo,
+)
+from telegrinder.types.objects import LoginUrl
+
+ButtonT = typing.TypeVar("ButtonT", bound="BaseButton")
+
+
+@typing.runtime_checkable
+class DataclassInstance(typing.Protocol):
+    __dataclass_fields__: typing.ClassVar[dict[str, dataclasses.Field[typing.Any]]]
+
+
+@dataclasses.dataclass
+class BaseButton:
+    def get_data(self) -> dict[str, typing.Any]:
+        return {
+            k: v
+            if k != "callback_data" or isinstance(v, str)
+            else encoder.encode(v)
+            for k, v in dataclasses.asdict(self).items()
+            if v is not None
+        }
+    
+
+class RowButtons(typing.Generic[ButtonT]):
+    buttons: list[ButtonT]
+    auto_row: bool
+
+    def __init__(self, *buttons: ButtonT, auto_row: bool = True) -> None:
+        self.buttons = list(buttons)
+        self.auto_row = auto_row
+
+    def get_data(self) -> list[dict[str, typing.Any]]:
+        return [b.get_data() for b in self.buttons]
+
+
+@dataclasses.dataclass
+class Button(BaseButton):
+    text: str
+    _: dataclasses.KW_ONLY
+    request_contact: bool = False
+    request_location: bool = False
+    request_chat: dict[str, typing.Any] | KeyboardButtonRequestChat | None = None
+    request_user: dict[str, typing.Any] | KeyboardButtonRequestUsers | None = None
+    request_poll: dict[str, typing.Any] | KeyboardButtonPollType | None = None
+    web_app: dict[str, typing.Any] | WebAppInfo | None = None
+
+
+@dataclasses.dataclass
+class InlineButton(BaseButton):
+    text: str
+    _: dataclasses.KW_ONLY
+    url: str | None = None
+    login_url: dict[str, typing.Any] | LoginUrl | None = None
+    pay: bool | None = None
+    callback_data: typing.Union[
+        str,
+        dict[str, typing.Any],
+        DataclassInstance,
+        msgspec.Struct,
+    ] | None = None
+    callback_game: dict[str, typing.Any] | CallbackGame | None = None
+    switch_inline_query: str | None = None
+    switch_inline_query_current_chat: str | None = None
+    switch_inline_query_chosen_chat: dict[
+        str, typing.Any
+    ] | SwitchInlineQueryChosenChat | None = None
+    web_app: dict[str, typing.Any] | WebAppInfo | None = None
+
+
+__all__ = (
+    "BaseButton",
+    "Button",
+    "DataclassInstance",
+    "InlineButton",
+    "RowButtons",
+)

telegrinder/tools/error_handler/__init__.py

@@ -0,0 +1,8 @@
+from .abc import ABCErrorHandler
+from .error_handler import Catcher, ErrorHandler
+
+__all__ = (
+    "ABCErrorHandler",
+    "Catcher",
+    "ErrorHandler",
+)

telegrinder/tools/error_handler/abc.py

@@ -0,0 +1,30 @@
+import typing
+from abc import ABC, abstractmethod
+
+from fntypes.result import Result
+
+from telegrinder.api import ABCAPI
+from telegrinder.bot.cute_types import BaseCute
+from telegrinder.bot.dispatch.context import Context
+
+EventT = typing.TypeVar("EventT", bound=BaseCute)
+Handler = typing.Callable[typing.Concatenate[EventT, ...], typing.Awaitable[typing.Any]]
+
+
+class ABCErrorHandler(ABC, typing.Generic[EventT]):
+    @abstractmethod
+    def catch(self) -> typing.Callable[[typing.Callable], typing.Callable]:
+        ...
+
+    @abstractmethod
+    async def run(
+        self,
+        handler: Handler[EventT],
+        event: EventT,
+        api: ABCAPI,
+        ctx: Context,
+    ) -> Result[typing.Any, typing.Any]:
+        ...
+
+
+__all__ = ("ABCErrorHandler",)