telegrinder 0.3.4.post1__py3-none-any.whl → 0.4.0__py3-none-any.whl

telegrinder/{bot/rules → tools}/adapter/node.py

@@ -3,20 +3,18 @@ from fntypes.result import Error, Ok, Result
 
 from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.adapter.abc import ABCAdapter, Event
-from telegrinder.bot.rules.adapter.errors import AdapterError
 from telegrinder.msgspec_utils import repr_type
 from telegrinder.node.composer import NodeSession, compose_nodes
+from telegrinder.tools.adapter.abc import ABCAdapter, Event
+from telegrinder.tools.adapter.errors import AdapterError
 from telegrinder.types.objects import Update
 
 if typing.TYPE_CHECKING:
-    from telegrinder.node.base import Node
+    from telegrinder.node.base import IsNode
 
-Ts = typing.TypeVarTuple("Ts", default=typing.Unpack[tuple[type["Node"], ...]])
 
-
-class NodeAdapter(typing.Generic[*Ts], ABCAdapter[Update, Event[tuple[*Ts]]]):
-    def __init__(self, *nodes: *Ts) -> None:
+class NodeAdapter(ABCAdapter[Update, Event[tuple["IsNode", ...]]]):
+    def __init__(self, *nodes: "IsNode") -> None:
         self.nodes = nodes
 
     def __repr__(self) -> str:
@@ -30,9 +28,9 @@ class NodeAdapter(typing.Generic[*Ts], ABCAdapter[Update, Event[tuple[*Ts]]]):
         api: API,
         update: Update,
         context: Context,
-    ) -> Result[Event[tuple[*Ts]], AdapterError]:
+    ) -> Result[Event[tuple[NodeSession, ...]], AdapterError]:
         result = await compose_nodes(
-            nodes={str(i): typing.cast(type["Node"], node) for i, node in enumerate(self.nodes)},
+            nodes={f"node_{i}": typing.cast("IsNode", node) for i, node in enumerate(self.nodes)},
             ctx=context,
             data={Update: update, API: api},
         )
@@ -40,7 +38,7 @@ class NodeAdapter(typing.Generic[*Ts], ABCAdapter[Update, Event[tuple[*Ts]]]):
         match result:
             case Ok(collection):
                 sessions: list[NodeSession] = list(collection.sessions.values())
-                return Ok(Event(tuple(sessions)))  # type: ignore
+                return Ok(Event(tuple(sessions)))
             case Error(err):
                 return Error(AdapterError(f"Couldn't compose nodes, error: {err}."))
 

telegrinder/{bot/rules → tools}/adapter/raw_event.py

@@ -2,9 +2,9 @@ from fntypes.result import Error, Ok, Result
 
 from telegrinder.api.api import API
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.adapter.abc import ABCAdapter
-from telegrinder.bot.rules.adapter.errors import AdapterError
 from telegrinder.model import Model
+from telegrinder.tools.adapter.abc import ABCAdapter
+from telegrinder.tools.adapter.errors import AdapterError
 from telegrinder.types.objects import Update
 
 

telegrinder/{bot/rules → tools}/adapter/raw_update.py

@@ -3,8 +3,8 @@ from fntypes.result import Ok, Result
 from telegrinder.api.api import API
 from telegrinder.bot.cute_types.update import UpdateCute
 from telegrinder.bot.dispatch.context import Context
-from telegrinder.bot.rules.adapter.abc import ABCAdapter
-from telegrinder.bot.rules.adapter.errors import AdapterError
+from telegrinder.tools.adapter.abc import ABCAdapter
+from telegrinder.tools.adapter.errors import AdapterError
 from telegrinder.types.objects import Update
 
 

telegrinder/tools/buttons.py

@@ -3,9 +3,10 @@ import typing
 
 import msgspec
 
-from telegrinder.msgspec_utils import DataclassInstance, encoder
+from telegrinder.msgspec_utils import encoder
 from telegrinder.types.objects import (
     CallbackGame,
+    CopyTextButton,
     KeyboardButtonPollType,
     KeyboardButtonRequestChat,
     KeyboardButtonRequestUsers,
@@ -14,20 +15,21 @@ from telegrinder.types.objects import (
     WebAppInfo,
 )
 
-KeyboardButton = typing.TypeVar("KeyboardButton", bound="BaseButton")
+from .callback_data_serilization import ABCDataSerializer, JSONSerializer
+
+if typing.TYPE_CHECKING:
+    from _typeshed import DataclassInstance
+
+type CallbackData = str | bytes | dict[str, typing.Any] | DataclassInstance | msgspec.Struct
 
 
 @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
-        }
+        return {k: v for k, v in dataclasses.asdict(self).items() if v is not None}
 
 
-class RowButtons(typing.Generic[KeyboardButton]):
+class RowButtons[KeyboardButton: BaseButton]:
     buttons: list[KeyboardButton]
     auto_row: bool
 
@@ -39,45 +41,69 @@ class RowButtons(typing.Generic[KeyboardButton]):
         return [b.get_data() for b in self.buttons]
 
 
-@dataclasses.dataclass(slots=True)
+@dataclasses.dataclass
 class Button(BaseButton):
     text: str
     request_contact: bool = dataclasses.field(default=False, kw_only=True)
     request_location: bool = dataclasses.field(default=False, kw_only=True)
-    request_chat: dict[str, typing.Any] | KeyboardButtonRequestChat | None = dataclasses.field(
-        default=None, kw_only=True
+    request_chat: KeyboardButtonRequestChat | None = dataclasses.field(
+        default=None,
+        kw_only=True,
     )
-    request_user: dict[str, typing.Any] | KeyboardButtonRequestUsers | None = dataclasses.field(
-        default=None, kw_only=True
+    request_user: KeyboardButtonRequestUsers | None = dataclasses.field(default=None, kw_only=True)
+    request_poll: KeyboardButtonPollType | None = dataclasses.field(
+        default=None,
+        kw_only=True,
     )
-    request_poll: dict[str, typing.Any] | KeyboardButtonPollType | None = dataclasses.field(
-        default=None, kw_only=True
-    )
-    web_app: dict[str, typing.Any] | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
+    web_app: WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
 
 
-@dataclasses.dataclass(slots=True)
+@dataclasses.dataclass
 class InlineButton(BaseButton):
     text: str
     url: str | None = dataclasses.field(default=None, kw_only=True)
-    login_url: dict[str, typing.Any] | LoginUrl | None = dataclasses.field(default=None, kw_only=True)
+    login_url: LoginUrl | None = dataclasses.field(default=None, kw_only=True)
     pay: bool | None = dataclasses.field(default=None, kw_only=True)
-    callback_data: str | dict[str, typing.Any] | DataclassInstance | msgspec.Struct | None = (
-        dataclasses.field(default=None, kw_only=True)
+    callback_data: CallbackData | None = dataclasses.field(default=None, kw_only=True)
+    callback_data_serializer: dataclasses.InitVar[ABCDataSerializer[typing.Any] | None] = dataclasses.field(
+        default=None,
+        kw_only=True,
     )
-    callback_game: dict[str, typing.Any] | CallbackGame | None = dataclasses.field(default=None, kw_only=True)
+    callback_game: CallbackGame | None = dataclasses.field(default=None, kw_only=True)
+    copy_text: str | CopyTextButton | None = dataclasses.field(default=None, kw_only=True)
     switch_inline_query: str | None = dataclasses.field(default=None, kw_only=True)
     switch_inline_query_current_chat: str | None = dataclasses.field(default=None, kw_only=True)
-    switch_inline_query_chosen_chat: dict[str, typing.Any] | SwitchInlineQueryChosenChat | None = (
-        dataclasses.field(default=None, kw_only=True)
+    switch_inline_query_chosen_chat: SwitchInlineQueryChosenChat | None = dataclasses.field(
+        default=None,
+        kw_only=True,
     )
-    web_app: dict[str, typing.Any] | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
+    web_app: str | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
+
+    def __post_init__(self, callback_data_serializer: ABCDataSerializer[typing.Any] | None) -> None:
+        if (
+            callback_data_serializer is None
+            and isinstance(self.callback_data, msgspec.Struct | dict)
+            or dataclasses.is_dataclass(self.callback_data)
+        ):
+            callback_data_serializer = callback_data_serializer or JSONSerializer(
+                self.callback_data.__class__,
+            )
+
+        if callback_data_serializer is not None:
+            self.callback_data = callback_data_serializer.serialize(self.callback_data)
+        elif self.callback_data is not None and not isinstance(self.callback_data, str | bytes):
+            self.callback_data = encoder.encode(self.callback_data)
+
+        if isinstance(self.copy_text, str):
+            self.copy_text = CopyTextButton(text=self.copy_text)
+
+        if isinstance(self.web_app, str):
+            self.web_app = WebAppInfo(url=self.web_app)
 
 
 __all__ = (
     "BaseButton",
     "Button",
-    "DataclassInstance",
     "InlineButton",
     "RowButtons",
 )

telegrinder/tools/callback_data_serilization/__init__.py

@@ -0,0 +1,5 @@
+from .abc import ABCDataSerializer
+from .json_ser import JSONSerializer
+from .msgpack_ser import MsgPackSerializer
+
+__all__ = ("ABCDataSerializer", "JSONSerializer", "MsgPackSerializer")

telegrinder/tools/callback_data_serilization/abc.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import abc
+import typing
+from functools import cached_property
+
+import msgspec
+from fntypes.result import Result
+
+if typing.TYPE_CHECKING:
+    from dataclasses import Field
+
+    from _typeshed import DataclassInstance
+
+type ModelType = DataclassWithIdentKey | ModelWithIdentKey | msgspec.Struct | DataclassInstance
+
+
+@typing.runtime_checkable
+class DataclassWithIdentKey(typing.Protocol):
+    __key__: str
+    __dataclass_fields__: typing.ClassVar[dict[str, Field[typing.Any]]]
+
+
+@typing.runtime_checkable
+class ModelWithIdentKey(typing.Protocol):
+    __key__: str
+    __struct_fields__: typing.ClassVar[tuple[str, ...]]
+    __struct_config__: typing.ClassVar[msgspec.structs.StructConfig]
+
+
+class ABCDataSerializer[Data](abc.ABC):
+    ident_key: str | None = None
+
+    @abc.abstractmethod
+    def __init__(self, data_type: type[Data], /) -> None:
+        pass
+
+    @cached_property
+    def key(self) -> str:
+        return self.ident_key + "_" if self.ident_key else ""
+
+    @abc.abstractmethod
+    def serialize(self, data: Data) -> str:
+        pass
+
+    @abc.abstractmethod
+    def deserialize(self, serialized_data: str) -> Result[Data, str]:
+        pass
+
+
+__all__ = ("ABCDataSerializer",)

telegrinder/tools/callback_data_serilization/json_ser.py

@@ -0,0 +1,60 @@
+import typing
+
+import msgspec
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.modules import json
+from telegrinder.msgspec_utils import decoder
+
+from .abc import ABCDataSerializer, ModelType
+
+type Json = dict[str, typing.Any] | ModelType
+
+
+class JSONSerializer[JsonT: Json](ABCDataSerializer[JsonT]):
+    @typing.overload
+    def __init__(self, model_t: type[JsonT]) -> None: ...
+
+    @typing.overload
+    def __init__(self, model_t: type[JsonT], *, ident_key: str | None = ...) -> None: ...
+
+    def __init__(
+        self,
+        model_t: type[JsonT] = dict[str, typing.Any],
+        *,
+        ident_key: str | None = None,
+    ) -> None:
+        self.model_t = model_t
+        self.ident_key: str | None = ident_key or getattr(model_t, "__key__", None)
+
+    @classmethod
+    def serialize_from_json(cls, data: JsonT, *, ident_key: str | None = None) -> str:
+        return cls(data.__class__, ident_key=ident_key).serialize(data)
+
+    @classmethod
+    def deserialize_to_json(cls, serialized_data: str, model_t: type[JsonT]) -> Result[JsonT, str]:
+        return cls(model_t).deserialize(serialized_data)
+
+    def serialize(self, data: JsonT) -> str:
+        return self.key + json.dumps(data)
+
+    def deserialize(self, serialized_data: str) -> Result[JsonT, str]:
+        if self.ident_key and not serialized_data.startswith(self.key):
+            return Error("Data is not corresponding to key.")
+
+        data = serialized_data.removeprefix(self.key)
+        try:
+            data_obj = json.loads(data)
+        except (msgspec.ValidationError, msgspec.DecodeError):
+            return Error("Cannot decode json.")
+
+        if not issubclass(self.model_t, dict):
+            try:
+                return Ok(decoder.convert(data_obj, type=self.model_t))
+            except (msgspec.ValidationError, msgspec.DecodeError):
+                return Error("Incorrect data.")
+
+        return Ok(data_obj)
+
+
+__all__ = ("JSONSerializer",)

telegrinder/tools/callback_data_serilization/msgpack_ser.py

@@ -0,0 +1,172 @@
+import base64
+import binascii
+import dataclasses
+import typing
+from collections import deque
+from contextlib import suppress
+from functools import cached_property
+
+import msgspec
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.msgspec_utils import decoder, encoder, get_class_annotations
+
+from .abc import ABCDataSerializer, ModelType
+
+
+@dataclasses.dataclass(frozen=True, slots=True)
+class ModelParser[Model: ModelType]:
+    model_type: type[Model]
+
+    def _is_model(self, obj: typing.Any, /) -> typing.TypeGuard[ModelType]:
+        return dataclasses.is_dataclass(obj) or isinstance(obj, msgspec.Struct)
+
+    def _model_to_dict(self, model: ModelType) -> dict[str, typing.Any]:
+        if dataclasses.is_dataclass(model):
+            return dataclasses.asdict(model)
+        return msgspec.structs.asdict(model)  # type: ignore
+
+    def _is_union(self, inspected_type: msgspec.inspect.Type, /) -> typing.TypeGuard[msgspec.inspect.UnionType]:
+        return isinstance(inspected_type, msgspec.inspect.UnionType)
+
+    def _is_model_type(
+        self,
+        inspected_type: msgspec.inspect.Type,
+        /,
+    ) -> typing.TypeGuard[msgspec.inspect.DataclassType | msgspec.inspect.StructType]:
+        return isinstance(inspected_type, msgspec.inspect.DataclassType | msgspec.inspect.StructType)
+
+    def _is_iter_of_model(
+        self, inspected_type: msgspec.inspect.Type, /
+    ) -> typing.TypeGuard[msgspec.inspect.ListType]:
+        return isinstance(
+            inspected_type,
+            msgspec.inspect.ListType | msgspec.inspect.SetType | msgspec.inspect.FrozenSetType,
+        ) and self._is_model_type(inspected_type.item_type)
+
+    def _validate_annotation(self, annotation: typing.Any, /) -> tuple[type[ModelType], bool] | None:
+        is_iter_of_model = False
+        type_args: tuple[msgspec.inspect.Type, ...] | None = None
+        inspected_type = msgspec.inspect.type_info(annotation)
+
+        if self._is_union(inspected_type):
+            type_args = inspected_type.types
+        elif self._is_iter_of_model(inspected_type):
+            type_args = (inspected_type.item_type,)
+            is_iter_of_model = True
+        elif self._is_model_type(inspected_type):
+            type_args = (inspected_type,)
+
+        if type_args is not None:
+            for arg in type_args:
+                if self._is_union(arg):
+                    type_args += arg.types
+                if self._is_model_type(arg):
+                    return (arg.cls, is_iter_of_model)
+                if self._is_iter_of_model(arg):
+                    return (arg.item_type.cls, True)  # type: ignore
+
+        return None
+
+    def parse(self, model: Model) -> list[typing.Any]:
+        """Returns a parsed model as linked list."""
+        linked: list[typing.Any] = []
+        stack: list[typing.Any] = [(list(self._model_to_dict(model).values()), linked)]
+
+        while stack:
+            current_obj, current = stack.pop()
+
+            for item in current_obj:
+                if self._is_model(item):
+                    item = self._model_to_dict(item)
+                if isinstance(item, dict):
+                    new_list = []
+                    current.append(new_list)
+                    stack.append((list(item.values()), new_list))
+                elif isinstance(item, list | tuple):
+                    new_list = []
+                    current.append(new_list)
+                    stack.append((item, new_list))
+                else:
+                    current.append(item)
+
+        return encoder.to_builtins(linked)
+
+    def compose(self, linked: list[typing.Any]) -> dict[str, typing.Any]:
+        """Compose linked list to dictionary based on the model class annotations `(without validation)`."""
+        root_converted_data: dict[str, typing.Any] = {}
+        stack: deque[typing.Any] = deque([(linked, self.model_type, root_converted_data)])
+
+        while stack:
+            current_data, current_model, converted_data = stack.pop()
+
+            for index, (field, annotation) in enumerate(get_class_annotations(current_model).items()):
+                obj, model_type, is_iter_of_model = current_data[index], None, False
+
+                if isinstance(obj, list) and (validated := self._validate_annotation(annotation)):
+                    model_type, is_iter_of_model = validated
+
+                if model_type is not None:
+                    if is_iter_of_model:
+                        converted_data[field] = []
+                        for item in obj:
+                            new_converted_data = {}
+                            converted_data[field].append(new_converted_data)
+                            stack.append((item, model_type, new_converted_data))
+                    else:
+                        new_converted_data = {}
+                        converted_data[field] = new_converted_data
+                        stack.append((obj, model_type, new_converted_data))
+                else:
+                    converted_data[field] = obj
+
+        return root_converted_data
+
+
+class MsgPackSerializer[Model: ModelType](ABCDataSerializer[Model]):
+    @typing.overload
+    def __init__(self, model_t: type[Model], /) -> None: ...
+
+    @typing.overload
+    def __init__(self, model_t: type[Model], /, *, ident_key: str | None = ...) -> None: ...
+
+    def __init__(self, model_t: type[Model], /, *, ident_key: str | None = None) -> None:
+        self.model_t = model_t
+        self.ident_key: str | None = ident_key or getattr(model_t, "__key__", None)
+        self._model_parser = ModelParser(model_t)
+
+    @classmethod
+    def serialize_from_model(cls, model: Model, *, ident_key: str | None = None) -> str:
+        return cls(model.__class__, ident_key=ident_key).serialize(model)
+
+    @classmethod
+    def deserialize_to_json(cls, serialized_data: str, model_t: type[Model]) -> Result[Model, str]:
+        return cls(model_t).deserialize(serialized_data)
+
+    @cached_property
+    def key(self) -> bytes:
+        if self.ident_key:
+            return msgspec.msgpack.encode(super().key)
+        return b""
+
+    def serialize(self, data: Model) -> str:
+        return base64.urlsafe_b64encode(
+            self.key + msgspec.msgpack.encode(self._model_parser.parse(data), enc_hook=encoder.enc_hook),
+        ).decode()
+
+    def deserialize(self, serialized_data: str) -> Result[Model, str]:
+        with suppress(msgspec.DecodeError, msgspec.ValidationError, binascii.Error):
+            ser_data = base64.urlsafe_b64decode(serialized_data)
+            if self.ident_key and not ser_data.startswith(self.key):
+                return Error("Data is not corresponding to key.")
+
+            data: list[typing.Any] = msgspec.msgpack.decode(
+                ser_data.removeprefix(self.key),
+                dec_hook=decoder.dec_hook(),
+            )
+            return Ok(decoder.convert(self._model_parser.compose(data), type=self.model_t))
+
+        return Error("Incorrect data.")
+
+
+__all__ = ("MsgPackSerializer",)

telegrinder/tools/error_handler/abc.py

@@ -1,16 +1,13 @@
 import typing
 from abc import ABC, abstractmethod
 
-from fntypes.result import Result
-
 from telegrinder.api import API
 from telegrinder.bot.dispatch.context import Context
 
-Event = typing.TypeVar("Event")
-Handler = typing.Callable[..., typing.Awaitable[typing.Any]]
+type Handler = typing.Callable[..., typing.Awaitable[typing.Any]]
 
 
-class ABCErrorHandler(ABC, typing.Generic[Event]):
+class ABCErrorHandler[Event](ABC):
     @abstractmethod
     def __call__(
         self,
@@ -22,11 +19,11 @@ class ABCErrorHandler(ABC, typing.Generic[Event]):
     @abstractmethod
     async def run(
         self,
-        handler: Handler,
+        exception: BaseException,
         event: Event,
         api: API,
         ctx: Context,
-    ) -> Result[typing.Any, typing.Any]:
+    ) -> typing.Any:
         """Run the error handler."""