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

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/__init__.py

@@ -1,10 +1,10 @@
-from .abc import ABCErrorHandler
-from .error import CatcherError
-from .error_handler import Catcher, ErrorHandler
-
-__all__ = (
+from .abc import ABCErrorHandler
+from .error import CatcherError
+from .error_handler import Catcher, ErrorHandler
+
+__all__ = (
     "ABCErrorHandler",
     "Catcher",
     "CatcherError",
-    "ErrorHandler",
-)
+    "ErrorHandler",
+)

telegrinder/tools/error_handler/abc.py

@@ -1,33 +1,30 @@
-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]]
-
-
-class ABCErrorHandler(ABC, typing.Generic[Event]):
-    @abstractmethod
-    def __call__(
-        self,
-        *args: typing.Any,
-        **kwargs: typing.Any,
-    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
-        """Decorator for registering callback as a catcher for the error handler."""
-
-    @abstractmethod
-    async def run(
-        self,
-        handler: Handler,
-        event: Event,
-        api: API,
-        ctx: Context,
-    ) -> Result[typing.Any, typing.Any]:
-        """Run the error handler."""
-
-
-__all__ = ("ABCErrorHandler",)
+import typing
+from abc import ABC, abstractmethod
+
+from telegrinder.api import API
+from telegrinder.bot.dispatch.context import Context
+
+type Handler = typing.Callable[..., typing.Awaitable[typing.Any]]
+
+
+class ABCErrorHandler[Event](ABC):
+    @abstractmethod
+    def __call__(
+        self,
+        *args: typing.Any,
+        **kwargs: typing.Any,
+    ) -> typing.Callable[[typing.Callable[..., typing.Any]], typing.Callable[..., typing.Any]]:
+        """Decorator for registering callback as a catcher for the error handler."""
+
+    @abstractmethod
+    async def run(
+        self,
+        exception: BaseException,
+        event: Event,
+        api: API,
+        ctx: Context,
+    ) -> typing.Any:
+        """Run the error handler."""
+
+
+__all__ = ("ABCErrorHandler",)

telegrinder/tools/error_handler/error.py

@@ -1,9 +1,9 @@
-class CatcherError(BaseException):
-    __slots__ = ("exc", "message")
-
-    def __init__(self, exc: BaseException, message: str) -> None:
-        self.exc = exc
-        self.message = message
-
-
-__all__ = ("CatcherError",)
+class CatcherError(BaseException):
+    __slots__ = ("exc", "message")
+
+    def __init__(self, exc: BaseException, message: str) -> None:
+        self.exc = exc
+        self.message = message
+
+
+__all__ = ("CatcherError",)

telegrinder/tools/error_handler/error_handler.py

@@ -1,193 +1,179 @@
-import dataclasses
-import typing
-
-from fntypes.result import Error, Ok, Result
-
-from telegrinder.api.api import API
-from telegrinder.bot.dispatch.context import Context
-from telegrinder.modules import logger
-from telegrinder.node.base import is_node
-from telegrinder.tools.error_handler.abc import ABCErrorHandler, Event, Handler
-from telegrinder.tools.error_handler.error import CatcherError
-from telegrinder.tools.magic import get_annotations, magic_bundle
-
-F = typing.TypeVar("F", bound="FuncCatcher[typing.Any]")
-ExceptionT = typing.TypeVar("ExceptionT", bound=BaseException, contravariant=True)
-FuncCatcher = typing.Callable[typing.Concatenate[ExceptionT, ...], typing.Awaitable[typing.Any]]
-
-
-async def run_handler(
-    handler: Handler,
-    event: typing.Any,
-    ctx: dict[str, typing.Any],
-) -> typing.Any:
-    annotations = tuple(get_annotations(handler).values())
-    start_idx = 0 if is_node(None if not annotations else annotations[0]) else 1
-    context = magic_bundle(handler, ctx, start_idx=start_idx)
-    return await (handler(event, **context) if start_idx == 1 else handler(**context))
-
-
-@dataclasses.dataclass(frozen=True, repr=False, slots=True)
-class Catcher(typing.Generic[Event]):
-    func: FuncCatcher[BaseException]
-    exceptions: list[type[BaseException] | BaseException] = dataclasses.field(
-        default_factory=lambda: [],
-        kw_only=True,
-    )
-    logging: bool = dataclasses.field(default=False, kw_only=True)
-    raise_exception: bool = dataclasses.field(default=False, kw_only=True)
-    ignore_errors: bool = dataclasses.field(default=False, kw_only=True)
-
-    def __repr__(self) -> str:
-        return "<Catcher: function={!r}, logging={}, raise_exception={}, ignore_errors={}>".format(
-            self.func.__name__,
-            self.logging,
-            self.raise_exception,
-            self.ignore_errors,
-        )
-
-    async def __call__(
-        self,
-        handler: Handler,
-        event: Event,
-        api: API,
-        ctx: Context,
-    ) -> Result[typing.Any, BaseException]:
-        try:
-            return Ok(await run_handler(handler, event, ctx))
-        except BaseException as exc:
-            return await self.run(api, event, ctx, exc, handler.__name__)
-
-    def match_exception(self, exception: BaseException) -> bool:
-        for exc in self.exceptions:
-            if isinstance(exc, type) and type(exception) is exc:
-                return True
-            if isinstance(exc, object) and type(exception) is type(exc):
-                return True if not exc.args else exc.args == exception.args
-
-        return False
-
-    async def run(
-        self,
-        api: API,
-        event: Event,
-        ctx: Context,
-        exception: BaseException,
-        handler_name: str,
-    ) -> Result[typing.Any, BaseException]:
-        if self.match_exception(exception):
-            logger.debug(
-                "Error handler caught an exception {!r} in handler {!r}, running catcher {!r}...".format(
-                    exception, handler_name, self.func.__name__
-                )
-            )
-            return Ok(await run_handler(self.func, event, {"event": event, "api": api} | ctx))
-
-        logger.debug("Failed to match exception {!r}.", exception.__class__.__name__)
-        return Error(exception)
-
-
-class ErrorHandler(ABCErrorHandler[Event]):
-    def __init__(self, catcher: Catcher[Event] | None = None, /) -> None:
-        self.catcher = catcher
-
-    def __repr__(self) -> str:
-        return (
-            "<{}: exceptions_handled=[{}], catcher={!r}>".format(
-                self.__class__.__name__,
-                ", ".join(e.__name__ if isinstance(e, type) else repr(e) for e in self.catcher.exceptions),
-                self.catcher,
-            )
-            if self.catcher is not None
-            else "<{}()>".format(self.__class__.__name__)
-        )
-
-    def __call__(
-        self,
-        *exceptions: type[BaseException] | BaseException,
-        logging: bool = False,
-        raise_exception: bool = False,
-        ignore_errors: bool = False,
-    ):
-        """Register the catcher.
-
-        :param logging: Logging the result of the catcher at the level `DEBUG`.
-        :param raise_exception: Raise an exception if the catcher has not started.
-        :param ignore_errors: Ignore errors that may occur.
-        """
-
-        def decorator(func: F) -> F:
-            if not self.catcher:
-                self.catcher = Catcher(
-                    func,
-                    exceptions=list(exceptions),
-                    logging=logging,
-                    raise_exception=raise_exception,
-                    ignore_errors=ignore_errors,
-                )
-            return func
-
-        return decorator
-
-    def _process_catcher_error(self, error: CatcherError) -> Result[None, BaseException]:
-        assert self.catcher is not None
-
-        if self.catcher.raise_exception:
-            raise error.exc from None
-        if self.catcher.logging:
-            logger.error(error.message)
-        if not self.catcher.ignore_errors:
-            return Error(error.exc)
-
-        return Ok(None)
-
-    async def process(
-        self,
-        handler: Handler,
-        event: Event,
-        api: API,
-        ctx: Context,
-    ) -> Result[typing.Any, BaseException]:
-        assert self.catcher is not None
-        logger.debug("Processing the error handler for handler {!r}...", handler.__name__)
-
-        try:
-            return await self.catcher(handler, event, api, ctx)
-        except BaseException as exc:
-            return Error(
-                CatcherError(
-                    exc,
-                    "Exception {} was occurred during the running catcher {!r}.".format(
-                        repr(exc), self.catcher.func.__name__
-                    ),
-                )
-            )
-
-    async def run(
-        self,
-        handler: Handler,
-        event: Event,
-        api: API,
-        ctx: Context,
-    ) -> Result[typing.Any, BaseException]:
-        if not self.catcher:
-            return Ok(await run_handler(handler, event, ctx))
-
-        match await self.process(handler, event, api, ctx):
-            case Ok(value) as ok:
-                if self.catcher.logging:
-                    logger.debug(
-                        "Catcher {!r} returned: {!r}",
-                        self.catcher.func.__name__,
-                        value,
-                    )
-                return ok
-            case Error(exc) as err:
-                if isinstance(exc, CatcherError):
-                    return self._process_catcher_error(exc)
-                if self.catcher.ignore_errors:
-                    return Ok(None)
-                return err
-
-
-__all__ = ("Catcher", "ErrorHandler")
+import dataclasses
+import typing
+
+from fntypes.result import Error, Ok, Result
+
+from telegrinder.api.api import API
+from telegrinder.bot.dispatch.context import Context
+from telegrinder.modules import logger
+from telegrinder.tools.error_handler.abc import ABCErrorHandler
+from telegrinder.tools.error_handler.error import CatcherError
+from telegrinder.tools.magic import magic_bundle
+
+type FuncCatcher[Exc: BaseException] = typing.Callable[
+    typing.Concatenate[Exc, ...],
+    typing.Awaitable[typing.Any],
+]
+
+
+@dataclasses.dataclass(frozen=True, repr=False, slots=True)
+class Catcher[Event]:
+    func: FuncCatcher[BaseException]
+    exceptions: list[type[BaseException] | BaseException] = dataclasses.field(
+        default_factory=lambda: [],
+        kw_only=True,
+    )
+    logging: bool = dataclasses.field(default=False, kw_only=True)
+    raise_exception: bool = dataclasses.field(default=False, kw_only=True)
+    ignore_errors: bool = dataclasses.field(default=False, kw_only=True)
+
+    def __repr__(self) -> str:
+        return "<Catcher: function={!r}, logging={}, raise_exception={}, ignore_errors={}>".format(
+            self.func.__name__,
+            self.logging,
+            self.raise_exception,
+            self.ignore_errors,
+        )
+
+    async def __call__(
+        self,
+        exception: BaseException,
+        event: Event,
+        api: API,
+        ctx: Context,
+    ) -> Result[typing.Any, BaseException]:
+        return await self.run(api, event, ctx, exception)
+
+    def match_exception(self, exception: BaseException) -> bool:
+        for exc in self.exceptions:
+            if isinstance(exc, type) and type(exception) is exc:
+                return True
+            if isinstance(exc, object) and type(exception) is type(exc):
+                return True if not exc.args else exc.args == exception.args
+
+        return False
+
+    async def run(
+        self,
+        api: API,
+        event: Event,
+        ctx: Context,
+        exception: BaseException,
+    ) -> Result[typing.Any, BaseException]:
+        if self.match_exception(exception):
+            logger.debug(
+                "Error handler caught an exception {!r}, running catcher {!r}...".format(
+                    exception,
+                    self.func.__name__,
+                )
+            )
+            return Ok(await self.func(exception, **magic_bundle(self.func, {"event": event, "api": api} | ctx)))
+
+        logger.debug("Failed to match exception {!r}.", exception.__class__.__name__)
+        return Error(exception)
+
+
+class ErrorHandler[Event](ABCErrorHandler[Event]):
+    def __init__(self, catcher: Catcher[Event] | None = None, /) -> None:
+        self.catcher = catcher
+
+    def __repr__(self) -> str:
+        return (
+            "<{}: exceptions=[{}], catcher={!r}>".format(
+                self.__class__.__name__,
+                ", ".join(e.__name__ if isinstance(e, type) else repr(e) for e in self.catcher.exceptions),
+                self.catcher,
+            )
+            if self.catcher is not None
+            else "<{}()>".format(self.__class__.__name__)
+        )
+
+    def __call__(
+        self,
+        *exceptions: type[BaseException] | BaseException,
+        logging: bool = False,
+        raise_exception: bool = False,
+        ignore_errors: bool = False,
+    ):
+        """Register the catcher.
+
+        :param logging: Logging the result of the catcher at the level `DEBUG`.
+        :param raise_exception: Raise an exception if the catcher has not started.
+        :param ignore_errors: Ignore errors that may occur.
+        """
+
+        def decorator[Func: FuncCatcher](catcher: Func, /) -> Func:
+            if not self.catcher:
+                self.catcher = Catcher(
+                    catcher,
+                    exceptions=list(exceptions),
+                    logging=logging,
+                    raise_exception=raise_exception,
+                    ignore_errors=ignore_errors,
+                )
+            return catcher
+
+        return decorator
+
+    def _process_catcher_error(self, error: CatcherError) -> Result[None, BaseException]:
+        assert self.catcher is not None
+
+        if self.catcher.raise_exception:
+            raise error.exc from None
+        if self.catcher.logging:
+            logger.error(error.message)
+        if not self.catcher.ignore_errors:
+            return Error(error.exc)
+
+        return Ok(None)
+
+    async def suppress(
+        self,
+        exception: BaseException,
+        event: Event,
+        api: API,
+        ctx: Context,
+    ) -> Result[typing.Any, BaseException]:
+        assert self.catcher is not None
+
+        try:
+            return await self.catcher(exception, event, api, ctx)
+        except BaseException as exc:
+            return Error(
+                CatcherError(
+                    exc,
+                    "{!r} was occurred during the running catcher {!r}.".format(
+                        exc,
+                        self.catcher.func.__name__,
+                    ),
+                )
+            )
+
+    async def run(
+        self,
+        exception: BaseException,
+        event: Event,
+        api: API,
+        ctx: Context,
+    ) -> typing.Any:
+        if not self.catcher:
+            raise exception from None
+
+        match await self.suppress(exception, event, api, ctx):
+            case Ok(value):
+                if self.catcher.logging:
+                    logger.debug(
+                        "Catcher {!r} returned: {!r}",
+                        self.catcher.func.__name__,
+                        value,
+                    )
+                return value
+            case Error(exc):
+                if isinstance(exc, CatcherError):
+                    return self._process_catcher_error(exc).unwrap()
+                if self.catcher.ignore_errors:
+                    return None
+                raise exc from None
+
+
+__all__ = ("Catcher", "ErrorHandler")