telegrinder 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

telegrinder/node/i18n.py

@@ -0,0 +1,108 @@
+import abc
+import dataclasses
+import gettext
+import os
+import pathlib
+import typing
+from functools import cached_property
+
+from telegrinder.node.base import DataNode, GlobalNode
+from telegrinder.node.source import Locale
+
+type Separator = KeySeparator
+
+DEFAULT_SEPARATOR: typing.Final[str] = "-"
+
+
+@dataclasses.dataclass(frozen=True)
+class KeySeparator(GlobalNode[Separator], DataNode):
+    value: str
+
+    @classmethod
+    def set(cls, value: str, /) -> None:
+        super().set(cls(value))
+
+    @classmethod
+    def compose(cls) -> Separator:
+        return cls.get(default=cls(DEFAULT_SEPARATOR))
+
+
+@dataclasses.dataclass(kw_only=True)
+class ABCTranslator(DataNode, abc.ABC):
+    locale: str
+    separator: str
+    _keys: list[str] = dataclasses.field(default_factory=list[str], init=False)
+
+    @typing.overload
+    def __call__(self, **context: typing.Any) -> str: ...
+
+    @typing.overload
+    def __call__(self, message_id: str, /, **context: typing.Any) -> str: ...
+
+    def __call__(self, message_id: str | None = None, **context: typing.Any) -> str:
+        result = self.translate(message_id or self.message_id, **context)
+        if not message_id:
+            self._keys.clear()
+        return result
+
+    def __getattr__(self, __key: str) -> typing.Self:
+        self._keys.append(__key)
+        return self
+
+    @property
+    def message_id(self) -> str:
+        return self.separator.join(self._keys)
+
+    @abc.abstractmethod
+    def translate(self, message_id: str, **context: typing.Any) -> str:
+        pass
+
+    @classmethod
+    def compose(cls, locale: Locale, separator: KeySeparator) -> typing.Self:
+        return cls(locale=locale, separator=separator.value)
+
+
+@dataclasses.dataclass
+class I18NConfig:
+    domain: str
+    folder: str | pathlib.Path
+    default_locale: str = dataclasses.field(default="en")
+
+    @cached_property
+    def translators(self) -> dict[str, gettext.GNUTranslations]:
+        result = {}
+
+        for name in os.listdir(self.folder):
+            if not os.path.isdir(os.path.join(self.folder, name)):
+                continue
+
+            mo_path = os.path.join(self.folder, name, "LC_MESSAGES", f"{self.domain}.mo")
+
+            if os.path.exists(mo_path):
+                with open(mo_path, "rb") as f:
+                    result[name] = gettext.GNUTranslations(f)
+            elif os.path.exists(mo_path[:-2] + "po"):
+                raise FileNotFoundError(".po files should be compiled first")
+
+        return result
+
+    def get_translator(self, locale: str, /) -> gettext.GNUTranslations:
+        locale = locale if locale in self.translators else self.default_locale
+        return self.translators[locale]
+
+
+class BaseTranslator(ABCTranslator):
+    config: typing.ClassVar[I18NConfig]
+
+    def __class_getitem__(cls, config: I18NConfig, /) -> typing.Any:
+        return type(cls.__name__, (cls,), dict(config=config))
+
+    @classmethod
+    def configure(cls, config: I18NConfig, /) -> None:
+        cls.config = config
+
+    def translate(self, message_id: str, **context: typing.Any) -> str:
+        return self.config.get_translator(self.locale).gettext(message_id).format(**context)
+
+
+__all__ = ("ABCTranslator", "BaseTranslator", "I18NConfig", "KeySeparator")

telegrinder/node/me.py

@@ -1,10 +1,11 @@
 from telegrinder.api.api import API
 from telegrinder.node.base import ComposeError, scalar_node
-from telegrinder.node.scope import GLOBAL
+from telegrinder.node.scope import global_node
 from telegrinder.types.objects import User
 
 
-@scalar_node(scope=GLOBAL)
+@scalar_node
+@global_node
 class Me:
     @classmethod
     async def compose(cls, api: API) -> User:

telegrinder/node/payload.py

@@ -8,7 +8,7 @@ from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.bot.cute_types.pre_checkout_query import PreCheckoutQueryCute
 from telegrinder.node.base import ComposeError, DataNode, FactoryNode, GlobalNode, scalar_node
 from telegrinder.node.polymorphic import Polymorphic, impl
-from telegrinder.tools.callback_data_serilization import ABCDataSerializer, JSONSerializer
+from telegrinder.tools.callback_data_serialization import ABCDataSerializer, JSONSerializer
 
 
 @scalar_node[str]

telegrinder/node/polymorphic.py

@@ -1,4 +1,3 @@
-import inspect
 import typing
 
 from fntypes.result import Error, Ok
@@ -9,16 +8,48 @@ from telegrinder.bot.dispatch.context import Context
 from telegrinder.modules import logger
 from telegrinder.node.base import ComposeError, Node, get_nodes
 from telegrinder.node.composer import CONTEXT_STORE_NODES_KEY, NodeSession, compose_nodes
-from telegrinder.node.scope import NodeScope
-from telegrinder.tools.magic import get_polymorphic_implementations, impl, magic_bundle
+from telegrinder.node.scope import NodeScope, get_scope
+from telegrinder.tools.aio import maybe_awaitable
+from telegrinder.tools.fullname import fullname
+from telegrinder.tools.magic.function import bundle
 from telegrinder.types.objects import Update
 
+type Impl = type[classmethod]
+
+MORPH_IMPLEMENTATIONS_KEY: typing.Final[str] = "__morph_implementations__"
+IMPL_MARK_KEY: typing.Final[str] = "_is_impl"
+
+
+@typing.cast("typing.Callable[..., Impl]", lambda f: f)
+def impl(method: typing.Callable[..., typing.Any]):
+    setattr(method, IMPL_MARK_KEY, True)
+    return classmethod(method)
+
+
+def get_polymorphic_implementations(
+    cls: type["Polymorphic"],
+    /,
+) -> list[typing.Callable[typing.Concatenate[type["Polymorphic"], ...], typing.Any]]:
+    moprh_impls = getattr(cls, MORPH_IMPLEMENTATIONS_KEY, None)
+    if moprh_impls is not None:
+        return moprh_impls
+
+    impls = []
+    for cls_ in cls.mro():
+        impls += [
+            obj.__func__
+            for obj in vars(cls_).values()
+            if isinstance(obj, classmethod) and getattr(obj.__func__, IMPL_MARK_KEY, False)
+        ]
+
+    setattr(cls, MORPH_IMPLEMENTATIONS_KEY, impls)
+    return impls
+
 
 class Polymorphic(Node):
     @classmethod
     async def compose(cls, raw_update: Update, update: UpdateCute, context: Context) -> typing.Any:
-        logger.debug(f"Composing polymorphic node {cls.__name__!r}...")
-        scope = getattr(cls, "scope", None)
+        scope = get_scope(cls)
         node_ctx = context.get_or_set(CONTEXT_STORE_NODES_KEY, {})
         data = {
             API: update.ctx_api,
@@ -27,39 +58,43 @@ class Polymorphic(Node):
         }
 
         for i, impl_ in enumerate(get_polymorphic_implementations(cls)):
-            logger.debug("Checking impl {!r}...", impl_.__name__)
-            node_collection = None
+            # 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:
+                return node_ctx[(cls, i)].value
 
             match await compose_nodes(get_nodes(impl_), context, data=data):
                 case Ok(col):
                     node_collection = col
                 case Error(err):
-                    logger.debug(f"Composition failed with error: {err!r}")
+                    logger.debug(
+                        "Impl `{}` composition failed with error: {!r}",
+                        fullname(impl_),
+                        err,
+                    )
+                    continue
 
-            if node_collection is None:
-                logger.debug("Impl {!r} composition failed!", impl_.__name__)
-                continue
+            result = None
 
-            # 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__,
+            try:
+                result = await maybe_awaitable(
+                    bundle(impl_, data, typebundle=True)(
+                        cls,
+                        **node_collection.values,
+                    ),
                 )
-                res: NodeSession = node_ctx[(cls, i)]
-                await node_collection.close_all()
-                return res.value
-
-            result = impl_(cls, **node_collection.values | magic_bundle(impl_, data, typebundle=True))
-            if inspect.isawaitable(result):
-                result = await result
 
-            if scope is NodeScope.PER_EVENT:
-                node_ctx[(cls, i)] = NodeSession(cls, result, {})
+                if scope is NodeScope.PER_EVENT:
+                    node_ctx[(cls, i)] = NodeSession(cls, result)
 
-            await node_collection.close_all(with_value=result)
-            logger.debug("Impl {!r} succeeded with value: {!r}", impl_.__name__, result)
-            return result
+                return result
+            except ComposeError as compose_error:
+                logger.debug(
+                    "Failed to compose morph impl `{}`, error: {!r}",
+                    fullname(impl_),
+                    compose_error.message,
+                )
+            finally:
+                await node_collection.close_all(with_value=result)
 
         raise ComposeError("No implementation found.")
 

telegrinder/node/reply_message.py

@@ -0,0 +1,12 @@
+from telegrinder.bot.cute_types.message import MessageCute
+from telegrinder.node.base import ComposeError, scalar_node
+
+
+@scalar_node
+class ReplyMessage:
+    @classmethod
+    def compose(cls, message: MessageCute) -> MessageCute:
+        return message.reply_to_message.expect(ComposeError("Message doesn't have reply"))
+
+
+__all__ = ("ReplyMessage",)

telegrinder/node/rule.py

@@ -1,5 +1,4 @@
 import dataclasses
-import importlib
 import typing
 
 from telegrinder.bot.cute_types.update import UpdateCute
@@ -9,6 +8,12 @@ from telegrinder.node.base import ComposeError, Node
 if typing.TYPE_CHECKING:
     from telegrinder.bot.dispatch.process import check_rule
     from telegrinder.bot.rules.abc import ABCRule
+else:
+
+    def check_rule(*args, **kwargs):
+        from telegrinder.bot.dispatch.process import check_rule
+
+        return check_rule(*args, **kwargs)
 
 
 class RuleChain(dict[str, typing.Any], Node):
@@ -36,18 +41,6 @@ class RuleChain(dict[str, typing.Any], Node):
 
     @classmethod
     async def compose(cls, update: UpdateCute) -> typing.Any:
-        # Hack to avoid circular import
-        globalns = globals()
-        if "check_rule" not in globalns:
-            globalns.update(
-                {
-                    "check_rule": getattr(
-                        importlib.import_module("telegrinder.bot.dispatch.process"),
-                        "check_rule",
-                    ),
-                },
-            )
-
         ctx = Context()
         for rule in cls.rules:
             if not await check_rule(update.api, rule, update, ctx):

telegrinder/node/scope.py

@@ -1,8 +1,12 @@
+from __future__ import annotations
+
 import enum
 import typing
 
 if typing.TYPE_CHECKING:
-    from .base import IsNode
+    from telegrinder.node.base import Composable
+
+NODE_SCOPE_KEY: typing.Final[str] = "scope"
 
 
 class NodeScope(enum.Enum):
@@ -16,26 +20,31 @@ PER_CALL = NodeScope.PER_CALL
 GLOBAL = NodeScope.GLOBAL
 
 
-def per_call[T: IsNode](node: type[T]) -> type[T]:
+def per_call[T: Composable[typing.Any]](node: type[T]) -> type[T]:
     setattr(node, "scope", PER_CALL)
     return node
 
 
-def per_event[T: IsNode](node: type[T]) -> type[T]:
+def per_event[T: Composable[typing.Any]](node: type[T]) -> type[T]:
     setattr(node, "scope", PER_EVENT)
     return node
 
 
-def global_node[T: IsNode](node: type[T]) -> type[T]:
+def global_node[T: Composable[typing.Any]](node: type[T]) -> type[T]:
     setattr(node, "scope", GLOBAL)
     return node
 
 
+def get_scope(node: Composable[typing.Any], /) -> NodeScope:
+    return getattr(node, NODE_SCOPE_KEY, PER_EVENT)
+
+
 __all__ = (
     "GLOBAL",
-    "NodeScope",
     "PER_CALL",
     "PER_EVENT",
+    "NodeScope",
+    "get_scope",
     "global_node",
     "per_call",
     "per_event",

telegrinder/node/session.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import dataclasses
+import typing
+
+from telegrinder.modules import logger
+from telegrinder.node.exceptions import ComposeError
+from telegrinder.node.scope import NodeScope, get_scope
+from telegrinder.tools.aio import Generator, stop_generator
+from telegrinder.tools.fullname import fullname
+
+if typing.TYPE_CHECKING:
+    from telegrinder.node.base import IsNode
+
+
+@dataclasses.dataclass(slots=True, repr=False)
+class NodeSession:
+    node: IsNode
+    value: typing.Any
+    generator: Generator[typing.Any, typing.Any, typing.Any] | None = None
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__}: {self.value!r}" + (" (ACTIVE)>" if self.generator else ">")
+
+    async def close(
+        self,
+        with_value: typing.Any | None = None,
+        scopes: tuple[NodeScope, ...] = (NodeScope.PER_CALL,),
+    ) -> typing.Any | None:
+        result = None
+
+        if self.generator is not None and get_scope(self.node) in scopes:
+            try:
+                await stop_generator(self.generator, with_value)
+            except ComposeError as compose_error:
+                logger.debug(
+                    "Caught compose error when closing session for node `{}`: {}",
+                    fullname(self.node),
+                    compose_error.message,
+                )
+            except BaseException as exception:
+                logger.debug(
+                    "Uncaught {!r} was occurred when closing session for node `{}`",
+                    exception,
+                    fullname(self.node),
+                )
+            finally:
+                self.generator = None
+
+        return result
+
+
+__all__ = ("NodeSession",)

telegrinder/node/source.py

@@ -4,7 +4,13 @@ import typing
 from fntypes.option import Nothing, Option, Some
 
 from telegrinder.api.api import API
-from telegrinder.bot.cute_types import CallbackQueryCute, ChatJoinRequestCute, MessageCute, PreCheckoutQueryCute
+from telegrinder.bot.cute_types import (
+    CallbackQueryCute,
+    ChatJoinRequestCute,
+    ChatMemberUpdatedCute,
+    MessageCute,
+    PreCheckoutQueryCute,
+)
 from telegrinder.node.base import ComposeError, DataNode, scalar_node
 from telegrinder.node.polymorphic import Polymorphic, impl
 from telegrinder.types.objects import Chat, Message, User
@@ -20,7 +26,7 @@ class Source(Polymorphic, DataNode):
     @impl
     def compose_message(cls, message: MessageCute) -> typing.Self:
         return cls(
-            api=message.ctx_api,
+            api=message.api,
             from_user=message.from_user,
             chat=Some(message.chat),
             thread_id=message.message_thread_id,
@@ -29,28 +35,33 @@ class Source(Polymorphic, DataNode):
     @impl
     def compose_callback_query(cls, callback_query: CallbackQueryCute) -> typing.Self:
         return cls(
-            api=callback_query.ctx_api,
+            api=callback_query.api,
             from_user=callback_query.from_user,
             chat=callback_query.chat,
             thread_id=callback_query.message_thread_id,
         )
 
+    @impl
+    def compose_chat_member_updated(cls, chat_member_updated: ChatMemberUpdatedCute) -> typing.Self:
+        return cls(
+            api=chat_member_updated.api,
+            from_user=chat_member_updated.from_user,
+            chat=Some(chat_member_updated.chat),
+        )
+
     @impl
     def compose_chat_join_request(cls, chat_join_request: ChatJoinRequestCute) -> typing.Self:
         return cls(
-            api=chat_join_request.ctx_api,
+            api=chat_join_request.api,
             from_user=chat_join_request.from_user,
             chat=Some(chat_join_request.chat),
-            thread_id=Nothing(),
         )
 
     @impl
     def compose_pre_checkout_query(cls, pre_checkout_query: PreCheckoutQueryCute) -> typing.Self:
         return cls(
-            api=pre_checkout_query.ctx_api,
+            api=pre_checkout_query.api,
             from_user=pre_checkout_query.from_user,
-            chat=Nothing(),
-            thread_id=Nothing(),
         )
 
     async def send(self, text: str, **kwargs: typing.Any) -> Message:
@@ -77,6 +88,13 @@ class UserSource:
         return source.from_user
 
 
+@scalar_node
+class ChatId:
+    @classmethod
+    def compose(cls, chat: ChatSource) -> int:
+        return chat.id
+
+
 @scalar_node
 class UserId:
     @classmethod
@@ -84,4 +102,18 @@ class UserId:
         return user.id
 
 
-__all__ = ("ChatSource", "Source", "UserId", "UserSource")
+@scalar_node
+class Locale:
+    @classmethod
+    def compose(cls, user: UserSource) -> str:
+        return user.language_code.expect(ComposeError("User has no language code."))
+
+
+__all__ = (
+    "ChatId",
+    "ChatSource",
+    "Locale",
+    "Source",
+    "UserId",
+    "UserSource",
+)

telegrinder/node/text.py

@@ -2,7 +2,6 @@ import typing
 
 from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.node.base import ComposeError, FactoryNode, scalar_node
-from telegrinder.node.either import Either
 
 
 @scalar_node
@@ -26,7 +25,7 @@ class Text:
 @scalar_node
 class TextInteger:
     @classmethod
-    def compose(cls, text: Either[Text, Caption]) -> int:
+    def compose(cls, text: Text | Caption) -> int:
         if not text.isdigit():
             raise ComposeError("Text is not digit.")
         return int(text)

telegrinder/node/tools/generator.py

@@ -1,8 +1,8 @@
-import inspect
 import typing
 
 from telegrinder.node.base import ComposeError, IsNode, Node
 from telegrinder.node.container import ContainerNode
+from telegrinder.tools.aio import maybe_awaitable
 
 
 def cast_false_to_none[Value](value: Value) -> Value | None:
@@ -22,10 +22,8 @@ def generate_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(cls, *args: typing.Any) -> typing.Any:
-        result = func(*args)
-        if inspect.isawaitable(result):
-            result = await result
+    async def compose(_, *args: typing.Any) -> typing.Any:
+        result = await maybe_awaitable(func(*args))
         for cast in casts:
             result = cast(result)
         return result

telegrinder/node/utility.py

@@ -0,0 +1,16 @@
+import typing
+
+from telegrinder.node.base import ComposeError, NodeClass, scalar_node
+from telegrinder.node.scope import per_call
+from telegrinder.tools.magic.annotations import TypeParameter, get_generic_parameters
+
+
+@scalar_node
+@per_call
+class TypeArgs:
+    @classmethod
+    def compose(cls, node_cls: NodeClass) -> dict[TypeParameter, typing.Any]:
+        return get_generic_parameters(node_cls).expect(ComposeError("No generic alias."))
+
+
+__all__ = ("TypeArgs",)