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

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

@@ -1,65 +1,63 @@
-import typing
-
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.api.api import API
-from telegrinder.bot.cute_types.base import BaseCute
-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.bot.rules.adapter.raw_update import RawUpdateAdapter
-from telegrinder.types.enums import UpdateType
-from telegrinder.types.objects import Model, Update
-
-ToCute = typing.TypeVar("ToCute", bound=BaseCute)
-
-
-class EventAdapter(ABCAdapter[Update, ToCute]):
-    ADAPTED_VALUE_KEY: str = "_adapted_cute_event"
-
-    def __init__(self, event: UpdateType | type[Model], cute_model: type[ToCute]) -> None:
-        self.event = event
-        self.cute_model = cute_model
-
-    def __repr__(self) -> str:
-        raw_update_type = (
-            f"Update -> {self.event.__name__}"
-            if isinstance(self.event, type)
-            else f"Update.{self.event.value}"
-        )
-        return "<{}: adapt {} -> {}>".format(
-            self.__class__.__name__,
-            raw_update_type,
-            self.cute_model.__name__,
-        )
-
-    def get_event(self, update: UpdateCute) -> Model | None:
-        if isinstance(self.event, UpdateType) and self.event == update.update_type:
-            return update.incoming_update
-
-        if not isinstance(self.event, UpdateType) and (event := update.get_event(self.event)):
-            return event.unwrap()
-
-        return None
-
-    def adapt(self, api: API, update: Update, context: Context) -> Result[ToCute, AdapterError]:
-        match RawUpdateAdapter().adapt(api, update, context):
-            case Ok(update_cute) if event := self.get_event(update_cute):
-                if self.ADAPTED_VALUE_KEY in context:
-                    return Ok(context[self.ADAPTED_VALUE_KEY])
-
-                adapted = (
-                    typing.cast(ToCute, event)
-                    if isinstance(event, BaseCute)
-                    else self.cute_model.from_update(event, bound_api=api)
-                )
-                context[self.ADAPTED_VALUE_KEY] = adapted
-                return Ok(adapted)
-            case Error(_) as err:
-                return err
-            case _:
-                return Error(AdapterError(f"Update is not an {self.event!r}."))
-
-
-__all__ = ("EventAdapter",)
+import typing
+
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.api import API
+from telegrinder.bot.cute_types.base import BaseCute
+from telegrinder.bot.cute_types.update import UpdateCute
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.tools.adapter.abc import ABCAdapter
+from telegrinder.tools.adapter.errors import AdapterError
+from telegrinder.tools.adapter.raw_update import RawUpdateAdapter
+from telegrinder.types.enums import UpdateType
+from telegrinder.types.objects import Model, Update
+
+
+class EventAdapter[ToEvent: BaseCute](ABCAdapter[Update, ToEvent]):
+    ADAPTED_VALUE_KEY: str = "_adapted_cute_event"
+
+    def __init__(self, event: UpdateType | type[Model], cute_model: type[ToEvent]) -> None:
+        self.event = event
+        self.cute_model = cute_model
+
+    def __repr__(self) -> str:
+        raw_update_type = (
+            f"Update -> {self.event.__name__}"
+            if isinstance(self.event, type)
+            else f"Update.{self.event.value}"  # type: ignore
+        )
+        return "<{}: adapt {} -> {}>".format(
+            self.__class__.__name__,
+            raw_update_type,
+            self.cute_model.__name__,
+        )
+
+    def get_event(self, update: UpdateCute) -> Model | None:
+        if isinstance(self.event, UpdateType) and self.event == update.update_type:
+            return update.incoming_update
+
+        if not isinstance(self.event, UpdateType) and (event := update.get_event(self.event)):
+            return event.unwrap()
+
+        return None
+
+    def adapt(self, api: API, update: Update, context: Context) -> Result[ToEvent, AdapterError]:
+        match RawUpdateAdapter().adapt(api, update, context):
+            case Ok(update_cute) if event := self.get_event(update_cute):
+                if self.ADAPTED_VALUE_KEY in context:
+                    return Ok(context[self.ADAPTED_VALUE_KEY])
+
+                adapted = (
+                    typing.cast(ToEvent, event)
+                    if isinstance(event, BaseCute)
+                    else self.cute_model.from_update(event, bound_api=api)
+                )
+                context[self.ADAPTED_VALUE_KEY] = adapted
+                return Ok(adapted)
+            case Error(_) as err:
+                return err
+            case _:
+                return Error(AdapterError(f"Update is not an {self.event!r}."))
+
+
+__all__ = ("EventAdapter",)

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

@@ -1,48 +1,46 @@
-import typing_extensions as typing
-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.types.objects import Update
-
-if typing.TYPE_CHECKING:
-    from telegrinder.node.base import Node
-
-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:
-        self.nodes = nodes
-
-    def __repr__(self) -> str:
-        return "<{}: adapt Update -> ({})>".format(
-            self.__class__.__name__,
-            ", ".join(repr_type(node) for node in self.nodes),
-        )
-
-    async def adapt(
-        self,
-        api: API,
-        update: Update,
-        context: Context,
-    ) -> Result[Event[tuple[*Ts]], AdapterError]:
-        result = await compose_nodes(
-            nodes={str(i): typing.cast(type["Node"], node) for i, node in enumerate(self.nodes)},
-            ctx=context,
-            data={Update: update, API: api},
-        )
-
-        match result:
-            case Ok(collection):
-                sessions: list[NodeSession] = list(collection.sessions.values())
-                return Ok(Event(tuple(sessions)))  # type: ignore
-            case Error(err):
-                return Error(AdapterError(f"Couldn't compose nodes, error: {err}."))
-
-
-__all__ = ("NodeAdapter",)
+import typing_extensions as typing
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+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 IsNode
+
+
+class NodeAdapter(ABCAdapter[Update, Event[tuple["IsNode", ...]]]):
+    def __init__(self, *nodes: "IsNode") -> None:
+        self.nodes = nodes
+
+    def __repr__(self) -> str:
+        return "<{}: adapt Update -> ({})>".format(
+            self.__class__.__name__,
+            ", ".join(repr_type(node) for node in self.nodes),
+        )
+
+    async def adapt(
+        self,
+        api: API,
+        update: Update,
+        context: Context,
+    ) -> Result[Event[tuple[NodeSession, ...]], AdapterError]:
+        result = await compose_nodes(
+            nodes={f"node_{i}": typing.cast("IsNode", node) for i, node in enumerate(self.nodes)},
+            ctx=context,
+            data={Update: update, API: api},
+        )
+
+        match result:
+            case Ok(collection):
+                sessions: list[NodeSession] = list(collection.sessions.values())
+                return Ok(Event(tuple(sessions)))
+            case Error(err):
+                return Error(AdapterError(f"Couldn't compose nodes, error: {err}."))
+
+
+__all__ = ("NodeAdapter",)

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

@@ -1,27 +1,27 @@
-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.types.objects import Update
-
-
-class RawEventAdapter(ABCAdapter[Update, Model]):
-    def __init__(self, event_model: type[Model], /) -> None:
-        self.event_model = event_model
-
-    def __repr__(self) -> str:
-        return "<{}: adapt Update -> {}>".format(
-            self.__class__.__name__,
-            self.event_model.__name__,
-        )
-
-    def adapt(self, api: API, update: Update, context: Context) -> Result[Model, AdapterError]:
-        if isinstance(update.incoming_update, self.event_model):
-            return Ok(update.incoming_update)
-        return Error(AdapterError(f"Update is not an {self.event_model.__name__!r}."))
-
-
-__all__ = ("RawEventAdapter",)
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+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
+
+
+class RawEventAdapter(ABCAdapter[Update, Model]):
+    def __init__(self, event_model: type[Model], /) -> None:
+        self.event_model = event_model
+
+    def __repr__(self) -> str:
+        return "<{}: adapt Update -> {}>".format(
+            self.__class__.__name__,
+            self.event_model.__name__,
+        )
+
+    def adapt(self, api: API, update: Update, context: Context) -> Result[Model, AdapterError]:
+        if isinstance(update.incoming_update, self.event_model):
+            return Ok(update.incoming_update)
+        return Error(AdapterError(f"Update is not an {self.event_model.__name__!r}."))
+
+
+__all__ = ("RawEventAdapter",)

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

@@ -1,30 +1,30 @@
-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.types.objects import Update
-
-
-class RawUpdateAdapter(ABCAdapter[Update, UpdateCute]):
-    ADAPTED_VALUE_KEY: str = "_adapted_update_cute"
-
-    def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}: adapt Update -> UpdateCute>"
-
-    def adapt(
-        self,
-        api: API,
-        update: Update,
-        context: Context,
-    ) -> Result[UpdateCute, AdapterError]:
-        if self.ADAPTED_VALUE_KEY not in context:
-            context[self.ADAPTED_VALUE_KEY] = (
-                UpdateCute.from_update(update, api) if not isinstance(update, UpdateCute) else update
-            )
-        return Ok(context[self.ADAPTED_VALUE_KEY])
-
-
-__all__ = ("RawUpdateAdapter",)
+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.tools.adapter.abc import ABCAdapter
+from telegrinder.tools.adapter.errors import AdapterError
+from telegrinder.types.objects import Update
+
+
+class RawUpdateAdapter(ABCAdapter[Update, UpdateCute]):
+    ADAPTED_VALUE_KEY: str = "_adapted_update_cute"
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}: adapt Update -> UpdateCute>"
+
+    def adapt(
+        self,
+        api: API,
+        update: Update,
+        context: Context,
+    ) -> Result[UpdateCute, AdapterError]:
+        if self.ADAPTED_VALUE_KEY not in context:
+            context[self.ADAPTED_VALUE_KEY] = (
+                UpdateCute.from_update(update, api) if not isinstance(update, UpdateCute) else update
+            )
+        return Ok(context[self.ADAPTED_VALUE_KEY])
+
+
+__all__ = ("RawUpdateAdapter",)

telegrinder/tools/buttons.py

@@ -1,83 +1,109 @@
-import dataclasses
-import typing
-
-import msgspec
-
-from telegrinder.msgspec_utils import DataclassInstance, encoder
-from telegrinder.types.objects import (
-    CallbackGame,
-    KeyboardButtonPollType,
-    KeyboardButtonRequestChat,
-    KeyboardButtonRequestUsers,
-    LoginUrl,
-    SwitchInlineQueryChosenChat,
-    WebAppInfo,
-)
-
-KeyboardButton = typing.TypeVar("KeyboardButton", bound="BaseButton")
-
-
-@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[KeyboardButton]):
-    buttons: list[KeyboardButton]
-    auto_row: bool
-
-    def __init__(self, *buttons: KeyboardButton, 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(slots=True)
-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_user: dict[str, typing.Any] | KeyboardButtonRequestUsers | 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)
-
-
-@dataclasses.dataclass(slots=True)
-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)
-    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_game: dict[str, typing.Any] | CallbackGame | 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)
-    )
-    web_app: dict[str, typing.Any] | WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
-
-
-__all__ = (
+import dataclasses
+import typing
+
+import msgspec
+
+from telegrinder.msgspec_utils import encoder
+from telegrinder.types.objects import (
+    CallbackGame,
+    CopyTextButton,
+    KeyboardButtonPollType,
+    KeyboardButtonRequestChat,
+    KeyboardButtonRequestUsers,
+    LoginUrl,
+    SwitchInlineQueryChosenChat,
+    WebAppInfo,
+)
+
+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 for k, v in dataclasses.asdict(self).items() if v is not None}
+
+
+class RowButtons[KeyboardButton: BaseButton]:
+    buttons: list[KeyboardButton]
+    auto_row: bool
+
+    def __init__(self, *buttons: KeyboardButton, 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
+    request_contact: bool = dataclasses.field(default=False, kw_only=True)
+    request_location: bool = dataclasses.field(default=False, kw_only=True)
+    request_chat: KeyboardButtonRequestChat | 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,
+    )
+    web_app: WebAppInfo | None = dataclasses.field(default=None, kw_only=True)
+
+
+@dataclasses.dataclass
+class InlineButton(BaseButton):
+    text: str
+    url: str | 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: 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: 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: SwitchInlineQueryChosenChat | 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",
-)
+    "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",)