telegrinder 0.2.0__tar.gz → 0.2.0.post1__tar.gz

{telegrinder-0.2.0 → telegrinder-0.2.0.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: telegrinder
-Version: 0.2.0
+Version: 0.2.0.post1
 Summary: Modern visionary telegram bot framework.
 Home-page: https://github.com/timoniq/telegrinder
 License: MIT

{telegrinder-0.2.0 → telegrinder-0.2.0.post1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "telegrinder"
-version = "0.2.0"
+version = "0.2.0.post1"
 description = "Modern visionary telegram bot framework."
 authors = ["timoniq <tesseradecades@mail.ru>"]
 maintainers = ["luwqz1 <howluwqz1@gmail.com>"]

{telegrinder-0.2.0 → telegrinder-0.2.0.post1}/telegrinder/bot/cute_types/base.py

@@ -55,22 +55,21 @@ if typing.TYPE_CHECKING:
             ...
 
 else:
-    from fntypes.co import Some, Variative
+    from fntypes.co import Nothing, Some, Variative
 
     from telegrinder.msgspec_utils import Option, decoder
     from telegrinder.msgspec_utils import get_class_annotations as _get_class_annotations
 
-    def _get_cute_from_args(args):
-        for hint in args:
-            if not isinstance(hint, type):
-                hint = typing.get_origin(hint) or hint
-                if not isinstance(hint, type):
-                    continue
+    def _get_cute_from_generic(generic_args):
+        for arg in generic_args:
+            orig_arg = typing.get_origin(arg) or arg
 
-            if hint in (Variative, Some, Option):
-                return _get_cute_from_args(typing.get_args(hint))
-            if issubclass(hint, BaseCute):
-                return hint
+            if not isinstance(orig_arg, type):
+                continue
+            if orig_arg in (Variative, Some, Option):
+                return _get_cute_from_generic(typing.get_args(arg))
+            if issubclass(arg, BaseCute):
+                return arg
 
         return None
 
@@ -79,8 +78,8 @@ else:
 
         for key, hint in annotations.items():
             if not isinstance(hint, type):
-                if (val := _get_cute_from_args(typing.get_args(hint))) is not None:
-                    cute_annotations[key] = val
+                if (cute := _get_cute_from_generic(typing.get_args(hint))) is not None:
+                    cute_annotations[key] = cute
 
             elif issubclass(hint, BaseCute):
                 cute_annotations[key] = hint
@@ -120,7 +119,7 @@ else:
                         cls.__cute_annotations__[field].from_update(_get_value(value), bound_api=bound_api),
                         type=cls.__annotations__[field],
                     )
-                    if field in cls.__cute_annotations__ and value
+                    if field in cls.__cute_annotations__ and not isinstance(value, Nothing)
                     else value
                     for field, value in update.to_dict().items()
                 },

{telegrinder-0.2.0 → telegrinder-0.2.0.post1}/telegrinder/bot/cute_types/update.py

@@ -1,8 +1,9 @@
 import typing
+from functools import cached_property
 
 from fntypes.co import Nothing, Some
 
-from telegrinder.api import API
+from telegrinder.api.api import API
 from telegrinder.bot.cute_types.base import BaseCute
 from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
 from telegrinder.bot.cute_types.chat_join_request import ChatJoinRequestCute
@@ -10,9 +11,9 @@ from telegrinder.bot.cute_types.chat_member_updated import ChatMemberUpdatedCute
 from telegrinder.bot.cute_types.inline_query import InlineQueryCute
 from telegrinder.bot.cute_types.message import MessageCute
 from telegrinder.msgspec_utils import Option
-from telegrinder.types import Model, Update
+from telegrinder.types.objects import Model, Update
 
-ModelT = typing.TypeVar("ModelT", bound=Model)
+EventModel = typing.TypeVar("EventModel", bound=Model)
 
 
 class UpdateCute(BaseCute[Update], Update, kw_only=True):
@@ -61,11 +62,11 @@ class UpdateCute(BaseCute[Update], Update, kw_only=True):
     """Optional. A request to join the chat has been sent. The bot must have the can_invite_users
     administrator right in the chat to receive these updates."""
 
-    @property
+    @cached_property
     def incoming_update(self) -> Model:
         return getattr(self, self.update_type.value).unwrap()
 
-    def get_event(self, event_model: type[ModelT]) -> Option[ModelT]:
+    def get_event(self, event_model: type[EventModel]) -> Option[EventModel]:
         if isinstance(self.incoming_update, event_model):
             return Some(self.incoming_update)
         return Nothing()

{telegrinder-0.2.0 → telegrinder-0.2.0.post1}/telegrinder/bot/rules/callback_data.py

@@ -135,12 +135,18 @@ class CallbackDataJsonEq(CallbackQueryDataRule):
 
 
 class CallbackDataJsonModel(CallbackQueryDataRule):
-    def __init__(self, model: type[msgspec.Struct] | type[DataclassInstance], /) -> None:
+    def __init__(
+        self,
+        model: type[msgspec.Struct] | type[DataclassInstance],
+        *,
+        alias: str | None = None,
+    ) -> None:
         self.model = model
+        self.alias = alias or "data"
 
     async def check(self, event: CallbackQuery, ctx: Context) -> bool:
         with suppress(BaseException):
-            ctx.data = decoder.decode(event.data.unwrap().encode(), type=self.model)
+            ctx.set(self.alias, decoder.decode(event.data.unwrap().encode(), type=self.model))
             return True
         return False
 

{telegrinder-0.2.0 → telegrinder-0.2.0.post1}/telegrinder/model.py

@@ -16,10 +16,17 @@ 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": {kw + "_": kw for kw in keyword.kwlist},
+    "rename": rename_field,
 }
 
 
@@ -58,11 +65,6 @@ def get_params(params: dict[str, typing.Any]) -> dict[str, typing.Any]:
     return validated_params
 
 
-def encode_name(name: str) -> str:
-    # TODO
-    return MODEL_CONFIG.get("rename", {}).get(name, name)
-
-
 class Model(msgspec.Struct, **MODEL_CONFIG):
     @classmethod
     def from_data(cls, data: dict[str, typing.Any]) -> typing.Self:

{telegrinder-0.2.0 → telegrinder-0.2.0.post1}/telegrinder/node/base.py

@@ -33,7 +33,9 @@ def is_generator(function: typing.Callable[..., typing.Any]) -> typing.TypeGuard
 
 
 def get_node_calc_lst(node: type["Node"]) -> list[type["Node"]]:
-    """ Returns flattened list of node types in ordering required to calculate given node. Provides caching for passed node type """
+    """Returns flattened list of node types in ordering required to calculate given node.
+    Provides caching for passed node type"""
+
     if calc_lst := getattr(node, "__nodes_calc_lst__", None):
         return calc_lst
     nodes_lst: list[type["Node"]] = []
@@ -101,6 +103,10 @@ if typing.TYPE_CHECKING:
         pass
 
 else:
+    def __init_subclass__(cls, *args, **kwargs):  # noqa: N807
+        if any(issubclass(base, ScalarNode) for base in cls.__bases__ if base is not ScalarNode):
+            raise RuntimeError("Scalar nodes do not support inheritance.")
+
     def create_node(cls, bases, dct):
         dct.update(cls.__dict__)
         return type(cls.__name__, bases, dct)
@@ -112,6 +118,7 @@ else:
             {
                 "as_node": classmethod(lambda cls: create_node(cls, bases, dct)),
                 "scope": Node.scope,
+                "__init_subclass__": __init_subclass__,
             },
         )
 

{telegrinder-0.2.0 → telegrinder-0.2.0.post1}/telegrinder/node/command.py

@@ -1,10 +1,10 @@
 import typing
 from dataclasses import dataclass, field
 
-from fntypes import Nothing, Option, Some
+from fntypes.option import Nothing, Option, Some
 
-from .base import DataNode
-from .text import Text
+from telegrinder.node.base import DataNode
+from telegrinder.node.text import Text
 
 
 def single_split(s: str, separator: str) -> tuple[str, str]:

{telegrinder-0.2.0 → telegrinder-0.2.0.post1}/telegrinder/node/composer.py

@@ -46,7 +46,7 @@ async def compose_nodes(
     logger.debug("Composing nodes: {!r}...", nodes)
 
     parent_nodes: dict[type[Node], NodeSession] = {}
-    event_nodes: dict[type[Node], "NodeSession"] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
+    event_nodes: dict[type[Node], NodeSession] = ctx.get_or_set(CONTEXT_STORE_NODES_KEY, {})
     data = {Context: ctx} | (data or {})
 
     # Create flattened list of ordered nodes to be calculated

{telegrinder-0.2.0 → telegrinder-0.2.0.post1}/telegrinder/node/event.py

@@ -1,3 +1,4 @@
+import dataclasses
 import typing
 
 import msgspec
@@ -5,21 +6,18 @@ 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 ComposeError, DataNode, Node
+from telegrinder.msgspec_utils import DataclassInstance, decoder
+from telegrinder.node.base import ComposeError, Node
 from telegrinder.node.update import UpdateNode
 
 if typing.TYPE_CHECKING:
     Dataclass = typing.TypeVar("Dataclass", bound="DataclassType")
 
-    DataclassType: typing.TypeAlias = DataclassInstance | DataNode | msgspec.Struct | dict[str, typing.Any]
+    DataclassType: typing.TypeAlias = DataclassInstance | msgspec.Struct | dict[str, typing.Any]
 
 EVENT_NODE_KEY = "_event_node"
 
 
-from telegrinder.msgspec_utils import decoder
-
-
 class _EventNode(Node):
     dataclass: type["DataclassType"]
 
@@ -41,13 +39,17 @@ class _EventNode(Node):
                 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)
+                if isinstance(raw_update.incoming_update, dataclass_type):
+                    dataclass = raw_update.incoming_update
+                else:
+                    dataclass = dataclass_type.from_update(raw_update.incoming_update, bound_api=api)
 
-            elif issubclass(dataclass_type, (msgspec.Struct, DataclassInstance)): # type: ignore
-                # FIXME: must be used with encode_name
+            elif issubclass(dataclass_type, msgspec.Struct) or dataclasses.is_dataclass(dataclass_type):
+                # FIXME: must be used with rename_field
                 dataclass = decoder.convert(
                     raw_update.incoming_update.to_full_dict(),
                     type=cls.dataclass,
+                    str_keys=True,
                 )
 
             else:
@@ -61,6 +63,7 @@ class _EventNode(Node):
 
 if typing.TYPE_CHECKING:
     EventNode: typing.TypeAlias = typing.Annotated["Dataclass", ...]
+
 else:
     class EventNode(_EventNode):
         pass

{telegrinder-0.2.0 → telegrinder-0.2.0.post1}/telegrinder/node/me.py

@@ -1,8 +1,7 @@
 from telegrinder.api.api import API
-from telegrinder.types import User
-
-from .base import ComposeError, ScalarNode
-from .scope import GLOBAL
+from telegrinder.node.base import ComposeError, ScalarNode
+from telegrinder.node.scope import GLOBAL
+from telegrinder.types.objects import User
 
 
 class Me(ScalarNode, User):

{telegrinder-0.2.0 → telegrinder-0.2.0.post1}/telegrinder/node/polymorphic.py

@@ -22,12 +22,12 @@ class Polymorphic(Node):
             composition = Composition(impl, True)
             node_collection = await composition.compose_nodes(update, context)
             if node_collection is None:
-                logger.debug("Impl {} 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 {} 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 {} succeeded with value {}", impl.__name__, result)
+            logger.debug("Impl {!r} succeeded with value {}", impl.__name__, result)
             return result
 
         raise ComposeError("No implementation found.")