telegrinder 1.0.0rc1__py3-none-any.whl

telegrinder/tools/serialization/msgpack_ser.py

@@ -0,0 +1,197 @@
+import base64
+import binascii
+import dataclasses
+import typing
+from collections import deque
+from contextlib import suppress
+from functools import cached_property
+
+import msgspec
+from kungfu.library.monad.result import Error, Ok, Result
+
+from telegrinder.msgspec_utils import decoder, encoder, get_class_annotations
+from telegrinder.tools.serialization.abc import ABCDataSerializer, ModelType
+from telegrinder.tools.serialization.utils import get_model_ident_key
+
+try:
+    import brotli  # type: ignore
+
+except ImportError:
+    brotli = None
+
+DESERIALIZE_EXCEPTIONS: typing.Final[frozenset[type[BaseException]]] = frozenset(
+    filter(
+        None,
+        (
+            msgspec.DecodeError,
+            msgspec.ValidationError,
+            binascii.Error,
+            ValueError,
+            brotli.error if brotli is not None else None,  # type: ignore
+        ),
+    ),
+)
+
+
+@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 _inspect_annotation(self, annotation: typing.Any, /) -> tuple[type[ModelType], bool] | None:
+        is_iter_of_model = False
+        type_args: tuple[msgspec.inspect.Type, ...] = tuple()
+        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,)
+
+        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 (inspected := self._inspect_annotation(annotation)):
+                    model_type, is_iter_of_model = inspected
+
+                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 = ident_key or get_model_ident_key(model_t)
+        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:
+        return msgspec.msgpack.encode(super().key) if self.ident_key else b""
+
+    def serialize(self, data: Model, /) -> str:
+        encoded = self.key + msgspec.msgpack.encode(self._model_parser.parse(data), enc_hook=encoder.enc_hook)
+        if brotli is not None:
+            return base64.b85encode(brotli.compress(encoded, quality=11)).decode()  # type: ignore
+        return base64.urlsafe_b64encode(encoded).decode()
+
+    def deserialize(self, serialized_data: str, /) -> Result[Model, str]:
+        with suppress(*DESERIALIZE_EXCEPTIONS):
+            if brotli is not None:
+                ser_data = typing.cast("bytes", brotli.decompress(base64.b85decode(serialized_data)))
+            else:
+                ser_data = base64.urlsafe_b64decode(serialized_data)
+
+            if 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/serialization/utils.py

@@ -0,0 +1,18 @@
+import typing
+
+if typing.TYPE_CHECKING:
+    from telegrinder.tools.serialization.abc import ABCDataSerializer
+
+IDENT_KEY: typing.Final = "__key__"
+SERIALIZER_KEY: typing.Final = "__serializer__"
+
+
+def get_model_ident_key(model: typing.Any, /) -> str | None:
+    return getattr(model, IDENT_KEY, None)
+
+
+def get_model_serializer(model: typing.Any, /) -> type[ABCDataSerializer[typing.Any]] | None:
+    return getattr(model, SERIALIZER_KEY, None)
+
+
+__all__ = ("get_model_ident_key", "get_model_serializer")

telegrinder/tools/singleton/__init__.py

@@ -0,0 +1,4 @@
+from telegrinder.tools.singleton.abc import ABCSingleton, ABCSingletonMeta
+from telegrinder.tools.singleton.singleton import Singleton, SingletonMeta
+
+__all__ = ("ABCSingleton", "ABCSingletonMeta", "Singleton", "SingletonMeta")

telegrinder/tools/singleton/abc.py

@@ -0,0 +1,14 @@
+import abc
+
+from telegrinder.tools.singleton.singleton import SingletonMeta
+
+
+class ABCSingletonMeta(abc.ABCMeta, SingletonMeta):
+    pass
+
+
+class ABCSingleton(metaclass=ABCSingletonMeta):
+    pass
+
+
+__all__ = ("ABCSingleton", "ABCSingletonMeta")

telegrinder/tools/singleton/singleton.py

@@ -0,0 +1,18 @@
+import typing
+
+
+class SingletonMeta(type):
+    if not typing.TYPE_CHECKING:
+        __instance = None
+
+        def __call__(cls, *args, **kwargs):
+            if cls.__instance is None:
+                cls.__instance = super().__call__(*args, **kwargs)
+            return cls.__instance
+
+
+class Singleton(metaclass=SingletonMeta):
+    pass
+
+
+__all__ = ("Singleton", "SingletonMeta")

telegrinder/tools/state_mutator/__init__.py

@@ -0,0 +1,4 @@
+from telegrinder.node import State, StateMutator
+from telegrinder.tools.state_mutator.mutation import mutation
+
+__all__ = ("State", "StateMutator", "mutation")

telegrinder/tools/state_mutator/mutation.py

@@ -0,0 +1,85 @@
+import typing
+
+from telegrinder.tools.aio import maybe_awaitable
+
+if typing.TYPE_CHECKING:
+    from telegrinder.node import State, StateMutator
+
+    class BoundMethod[**P, T, R](typing.Protocol):
+        @staticmethod
+        def __call__(self: T, *args: P.args, **kwargs: P.kwargs) -> typing.Coroutine[typing.Any, typing.Any, R] | R: ...
+
+    @typing.runtime_checkable
+    class NotBoundFunction[**P, R](typing.Protocol):
+        def __call__(self, *args: P.args, **kwargs: P.kwargs) -> typing.Coroutine[typing.Any, typing.Any, R] | R: ...
+
+
+class mutation[**P, IntoState: State, BoundState: State | None]:  # noqa: N801
+    from_state: State | None
+
+    @typing.overload
+    def __init__(
+        self: mutation[P, IntoState, BoundState],  # type: ignore
+        construct_mutation: BoundMethod[P, BoundState, IntoState],
+    ) -> None: ...
+
+    @typing.overload
+    def __init__(
+        self: mutation[P, IntoState, None],  # type: ignore
+        construct_mutation: NotBoundFunction[P, IntoState],
+    ) -> None: ...
+
+    def __init__(
+        self,
+        construct_mutation: typing.Callable[..., typing.Coroutine[typing.Any, typing.Any, IntoState] | IntoState],
+    ) -> None:
+        self.construct_mutation = construct_mutation
+        self.from_state = None
+
+    @typing.overload
+    async def __call__(
+        self: mutation[P, IntoState, None],
+        mutator: StateMutator,
+        /,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> IntoState: ...
+
+    @typing.overload
+    async def __call__(
+        self: mutation[P, IntoState, State],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> IntoState: ...
+
+    async def __call__(self, *args: typing.Any, **kwargs: typing.Any) -> IntoState:
+        mutator: StateMutator
+
+        if self.from_state is not None:
+            if self.from_state.__mutator__ is None:
+                raise RuntimeError("State is not bound. Bind state with .bind(mutator) before mutating")
+
+            await self.from_state.exit()
+
+            new_state = await maybe_awaitable(self.construct_mutation(self.from_state, *args, **kwargs))
+            mutator = self.from_state.__mutator__
+        else:
+            mutator, args = args[0], args[1:]
+
+            if (state := await mutator.get()) is not None:
+                await state.exit()
+
+            new_state = await maybe_awaitable(self.construct_mutation(*args, **kwargs))
+
+        new_state.bind(mutator)
+        await new_state.enter()
+
+        return new_state
+
+    def __get__(self, instance: State, owner: typing.Any) -> typing.Self:
+        if instance is not None:
+            self.from_state = instance
+        return self
+
+
+__all__ = ("mutation",)

telegrinder/tools/state_storage/__init__.py

@@ -0,0 +1,4 @@
+from telegrinder.tools.state_storage.abc import ABCStateStorage, StateData
+from telegrinder.tools.state_storage.memory import MemoryStateStorage
+
+__all__ = ("ABCStateStorage", "MemoryStateStorage", "StateData")

telegrinder/tools/state_storage/abc.py

@@ -0,0 +1,38 @@
+import abc
+import dataclasses
+import enum
+import typing
+
+from kungfu.library.monad.option import Option
+
+if typing.TYPE_CHECKING:
+    from telegrinder.bot.rules.state import State, StateMeta
+
+
+@dataclasses.dataclass
+class StateData[Payload]:
+    key: str | enum.Enum
+    payload: Payload
+
+    async def save(self, user_id: int, storage: ABCStateStorage[Payload]) -> None:
+        await storage.set(user_id, key=self.key, payload=self.payload)
+
+
+class ABCStateStorage[Payload](abc.ABC):
+    @abc.abstractmethod
+    async def get(self, user_id: int) -> Option[StateData[Payload]]: ...
+
+    @abc.abstractmethod
+    async def delete(self, user_id: int) -> None: ...
+
+    @abc.abstractmethod
+    async def set(self, user_id: int, key: str | enum.Enum, payload: Payload) -> None: ...
+
+    def State(self, key: str | StateMeta | enum.Enum | None = None, /) -> State[Payload]:  # noqa: N802
+        """Can be used as a shortcut to get a state rule dependant on current storage."""
+        from telegrinder.bot.rules.state import State, StateMeta
+
+        return State(storage=self, key=key or StateMeta.ANY)
+
+
+__all__ = ("ABCStateStorage", "StateData")

telegrinder/tools/state_storage/memory.py

@@ -0,0 +1,27 @@
+import typing
+
+from kungfu.library.misc import from_optional
+from kungfu.library.monad.option import Option
+
+from telegrinder.tools.state_storage.abc import ABCStateStorage, StateData
+
+type Payload = dict[str, typing.Any]
+
+
+class MemoryStateStorage[T = Payload](ABCStateStorage[T]):
+    storage: dict[int, StateData[T]]
+
+    def __init__(self) -> None:
+        self.storage = {}
+
+    async def get(self, user_id: int) -> Option[StateData[T]]:
+        return from_optional(self.storage.get(user_id))
+
+    async def set(self, user_id: int, key: str, payload: T) -> None:
+        self.storage[user_id] = StateData(key, payload)
+
+    async def delete(self, user_id: int) -> None:
+        self.storage.pop(user_id)
+
+
+__all__ = ("MemoryStateStorage",)

telegrinder/tools/strings.py

@@ -0,0 +1,22 @@
+def to_utf16_map(s: str, /) -> list[int]:
+    utf16_map = list[int]()
+    utf16_pos = 0
+
+    for char in s:
+        utf16_map.append(utf16_pos)
+        utf16_len = len(char.encode("utf-16-le")) // 2
+        utf16_pos += utf16_len
+
+    utf16_map.append(utf16_pos)
+    return utf16_map
+
+
+def utf16_to_py_index(utf16_map: list[int], utf16_index: int, /) -> int:
+    for index, u in enumerate(utf16_map):
+        if u >= utf16_index:
+            return index
+
+    return len(utf16_map) - 1
+
+
+__all__ = ("to_utf16_map", "utf16_to_py_index")