Feature/msgspec

pyproject.toml

@@ -39,6 +39,7 @@ sqlalchemy = ['sqlalchemy >= 2.0.0']
 sqlalchemy-strict = ['sqlalchemy >= 2.0.0, <= 2.0.36']
 pydantic = ['pydantic >= 2.0.0']
 pydantic-strict = ['pydantic >= 2.0.0, <= 2.10.3']
+msgspec = ["msgspec >= 0.14.0"]
 
 [project.urls]
 'Homepage' = 'https://github.com/reagento/adaptix'

src/adaptix/_internal/feature_requirement.py

@@ -171,6 +171,9 @@ def fail_reason(self) -> str:
 HAS_SUPPORTED_ATTRS_PKG = DistributionVersionRequirement("attrs", "21.3.0")
 HAS_ATTRS_PKG = DistributionRequirement("attrs")
 
+HAS_SUPPORTED_MSGSPEC_PKG = DistributionVersionRequirement("msgspec", "0.14.0")
+HAS_MSGSPEC_PKG = DistributionRequirement("msgspec")
+
 HAS_SUPPORTED_SQLALCHEMY_PKG = DistributionVersionRequirement("sqlalchemy", "2.0.0")
 HAS_SQLALCHEMY_PKG = DistributionRequirement("sqlalchemy")
 

src/adaptix/_internal/integrations/msgspec/native.py

@@ -0,0 +1,81 @@
+from typing import Any, Callable, Iterable, Mapping, Optional, TypedDict, TypeVar
+
+from adaptix import Dumper, Loader, Mediator, Omittable, Omitted, Provider
+from adaptix._internal.morphing.load_error import LoadError
+from adaptix._internal.morphing.provider_template import DumperProvider, LoaderProvider
+from adaptix._internal.morphing.request_cls import DumperRequest, LoaderRequest
+from adaptix._internal.provider.facade.provider import bound_by_any
+from adaptix._internal.provider.loc_stack_filtering import Pred
+
+try:
+    from msgspec import ValidationError, convert, to_builtins
+except ImportError:
+    pass
+
+T = TypeVar("T")
+
+
+class Convert(TypedDict, total=False):
+    builtin_types: Iterable[type]
+    str_keys: bool
+    strict: bool
+    from_attributes: bool
+    dec_hook: Callable[[Any], Any]
+
+
+class ToBuiltins(TypedDict, total=False):
+    builtin_types: Iterable[type]
+    str_keys: bool
+    enc_hook: Callable[[Any], Any]
+
+
+class NativeMsgspecProvider(LoaderProvider, DumperProvider):
+    def __init__(
+        self,
+        conversion_params: Optional[Convert],
+        to_builtins_params: Optional[ToBuiltins],
+    ):
+        self.conversion_params = conversion_params
+        self.to_builtins_params = to_builtins_params
+
+    def provide_loader(self, mediator: Mediator[Loader], request: LoaderRequest) -> Loader:
+        tp = request.last_loc.type
+        if conversion_params := self.conversion_params:
+            def native_msgspec_loader(data):
+                try:
+                    return convert(data, type=tp, **conversion_params)
+                except ValidationError as e:
+                    raise LoadError() from e
+
+            return native_msgspec_loader
+
+        def native_msgspec_loader_no_params(data):
+            try:
+                return convert(data, type=tp)
+            except ValidationError as e:
+                raise LoadError() from e
+
+        return native_msgspec_loader_no_params
+
+    def provide_dumper(self, mediator: Mediator[Dumper], request: DumperRequest) -> Dumper:
+        if to_builtins_params := self.to_builtins_params:
+            def native_msgspec_dumper_with_params(data):
+                return to_builtins(data, **to_builtins_params)
+
+            return native_msgspec_dumper_with_params
+
+        return to_builtins
+
+
+def native_msgspec(
+    *preds: Pred,
+    convert: Optional[Convert] = None,
+    to_builtins: Optional[Convert] = None,
+) -> Provider:
+    return bound_by_any(
+        preds,
+        NativeMsgspecProvider(
+            conversion_params=convert,
+            to_builtins_params=to_builtins,
+        ),
+    )

src/adaptix/_internal/model_tools/introspection/msgspec.py

@@ -0,0 +1,108 @@
+import inspect
+from types import MappingProxyType
+from typing import Mapping
+
+try:
+    from msgspec import NODEFAULT
+    from msgspec.structs import FieldInfo, fields
+except ImportError:
+    pass
+from ...feature_requirement import HAS_MSGSPEC_PKG, HAS_SUPPORTED_MSGSPEC_PKG
+from ...type_tools import get_all_type_hints, is_class_var, normalize_type
+from ..definitions import (
+    Default,
+    DefaultFactory,
+    DefaultValue,
+    FullShape,
+    InputField,
+    InputShape,
+    IntrospectionError,
+    NoDefault,
+    NoTargetPackageError,
+    OutputField,
+    OutputShape,
+    Param,
+    ParamKind,
+    TooOldPackageError,
+    create_attr_accessor,
+)
+
+
+def _get_default_from_field_info(fi: "FieldInfo") -> Default:
+    if fi.default is not NODEFAULT:
+        return DefaultValue(fi.default)
+    if fi.default_factory is not NODEFAULT:
+        return DefaultFactory(fi.default_factory)
+    return NoDefault()
+
+
+def _create_input_field_from_structs_field_info(fi: "FieldInfo", type_hints: Mapping[str, type]) -> InputField:
+    default = _get_default_from_field_info(fi)
+    return InputField(
+        id=fi.name,
+        type=type_hints[fi.name],
+        default=default,
+        is_required=fi.required,
+        original=fi,
+        metadata=MappingProxyType({}),
+    )
+
+
+def get_struct_shape(tp) -> FullShape:
+    if not HAS_SUPPORTED_MSGSPEC_PKG:
+        if not HAS_MSGSPEC_PKG:
+            raise NoTargetPackageError(HAS_MSGSPEC_PKG)
+        raise TooOldPackageError(HAS_SUPPORTED_MSGSPEC_PKG)
+
+    try:
+        fields_info = fields(tp)
+    except TypeError:
+        raise IntrospectionError
+
+    type_hints = get_all_type_hints(tp)
+    init_fields = tuple(
+        field_name
+        for field_name in type_hints
+        if not is_class_var(normalize_type(type_hints[field_name]))
+    )
+    input_param_kind = ParamKind.KW_ONLY if "*" in inspect.signature(tp) else ParamKind.POS_OR_KW
+    return FullShape(
+        InputShape(
+            constructor=tp,
+            fields=tuple(
+                _create_input_field_from_structs_field_info(fi, type_hints)
+                for fi in fields_info if fi.name in init_fields
+            ),
+            params=tuple(
+                Param(
+                    field_id=field_id,
+                    name=field_id,
+                    kind=input_param_kind,
+                )
+                for field_id in type_hints
+                if field_id in init_fields
+        ),
+            kwargs=None,
+            overriden_types=frozenset(
+                annotation
+                for annotation in tp.__annotations__
+                if annotation in init_fields
+            ),
+        ),
+        OutputShape(
+            fields=tuple(
+                OutputField(
+                    id=fi.name,
+                    type=type_hints[fi.name],
+                    original=fi,
+                    metadata=MappingProxyType({}),
+                    default=_get_default_from_field_info(fi),
+                    accessor=create_attr_accessor(attr_name=fi.name, is_required=True),
+                ) for fi in fields_info),
+            overriden_types=frozenset(
+                annotation
+                for annotation in tp.__annotations__.keys()
+                if annotation in init_fields
+            ),
+        ),
+    )

src/adaptix/_internal/provider/shape_provider.py

@@ -18,6 +18,7 @@
 from ..model_tools.introspection.attrs import get_attrs_shape
 from ..model_tools.introspection.class_init import get_class_init_shape
 from ..model_tools.introspection.dataclass import get_dataclass_shape
+from ..model_tools.introspection.msgspec import get_struct_shape
 from ..model_tools.introspection.named_tuple import get_named_tuple_shape
 from ..model_tools.introspection.pydantic import get_pydantic_shape
 from ..model_tools.introspection.sqlalchemy import get_sqlalchemy_shape
@@ -77,6 +78,7 @@ def _provide_output_shape(self, mediator: Mediator, request: OutputShapeRequest)
     ShapeProvider(get_named_tuple_shape),
     ShapeProvider(get_typed_dict_shape),
     ShapeProvider(get_dataclass_shape),
+    ShapeProvider(get_struct_shape),
     ShapeProvider(get_attrs_shape),
     ShapeProvider(get_sqlalchemy_shape),
     ShapeProvider(get_pydantic_shape),

src/adaptix/integrations/msgspec/__init__.py

@@ -0,0 +1,5 @@
+from adaptix._internal.integrations.msgspec.native import native_msgspec
+
+__all__ = (
+    "native_msgspec"
+)

tests/conftest.py

@@ -2,7 +2,13 @@
 from tests_helpers import ByTrailSelector, ModelSpecSchema, cond_list, parametrize_model_spec
 
 from adaptix import DebugTrail
-from adaptix._internal.feature_requirement import HAS_ATTRS_PKG, HAS_PY_312, HAS_PYDANTIC_PKG, HAS_SQLALCHEMY_PKG
+from adaptix._internal.feature_requirement import (
+    HAS_ATTRS_PKG,
+    HAS_MSGSPEC_PKG,
+    HAS_PY_312,
+    HAS_PYDANTIC_PKG,
+    HAS_SQLALCHEMY_PKG,
+)
 
 
 @pytest.fixture(params=[False, True], ids=lambda x: f"strict_coercion={x}")
@@ -46,4 +52,5 @@ def pytest_generate_tests(metafunc):
     *cond_list(not HAS_ATTRS_PKG, ["*_attrs.py", "*_attrs_*.py", "**/attrs/**"]),
     *cond_list(not HAS_PYDANTIC_PKG, ["*_pydantic.py", "*_pydantic_*.py", "**/pydantic/**"]),
     *cond_list(not HAS_SQLALCHEMY_PKG, ["*_sqlalchemy.py", "*_sqlalchemy_*.py", "**/sqlalchemy/**"]),
+    *cond_list(not HAS_MSGSPEC_PKG,["*_msgspec.py", "*_msgspec_*.py", "**/msgspec/**"]),
 ]

tests/integration/morphing/test_msgspec.py

@@ -0,0 +1,29 @@
+from typing import ClassVar, Generic, TypeVar
+
+from msgspec import Struct, field
+
+from adaptix import Retort
+
+
+def test_basic(accum):
+    class MyModel(Struct):
+        f1: int
+        f2: str
+
+    retort = Retort(recipe=[accum])
+    assert retort.load({"f1": 0, "f2": "a"}, MyModel) == MyModel(f1=0, f2="a")
+    assert retort.dump(MyModel(f1=0, f2="a")) == {"f1": 0, "f2": "a"}
+
+T = TypeVar("T")
+
+def test_all_field_kinds(accum):
+    class MyModel(Struct, Generic[T]):
+        a: int
+        b: T
+        c: str = field(default="c", name="_c")
+        d: ClassVar[float] = 2.11
+
+
+    retort = Retort(recipe=[accum])
+    assert retort.load({"a": 0, "b": 3}, MyModel[int]) == MyModel(a=0, b=3)
+    assert retort.dump(MyModel(a=0, b=True), MyModel[bool]) == {"a": 0, "b": True, "c": "c"}

tests/tests_helpers/tests_helpers/model_spec.py

@@ -10,6 +10,7 @@
 
 from adaptix._internal.feature_requirement import (
     HAS_ATTRS_PKG,
+    HAS_MSGSPEC_PKG,
     HAS_PY_311,
     HAS_PYDANTIC_PKG,
     HAS_SQLALCHEMY_PKG,
@@ -38,13 +39,15 @@ class ModelSpec(Enum):
     ATTRS = "attrs"
     SQLALCHEMY = "sqlalchemy"
     PYDANTIC = "pydantic"
+    MSGSPEC = "msgspec"
 
     @classmethod
     def default_requirements(cls):
         return {
             cls.ATTRS: HAS_ATTRS_PKG,
             cls.SQLALCHEMY: HAS_SQLALCHEMY_PKG,
             cls.PYDANTIC: HAS_PYDANTIC_PKG,
+            cls.MSGSPEC: HAS_MSGSPEC_PKG,
         }
 
 
@@ -105,6 +108,9 @@ class CustomBaseModel(BaseModel):
             model_config = ConfigDict(arbitrary_types_allowed=True)
 
         return ModelSpecSchema(decorator=lambda x: x, bases=(CustomBaseModel, ), get_field=getattr, kind=spec)
+    if spec == ModelSpec.MSGSPEC:
+        from msgspec import Struct
+        return ModelSpecSchema(decorator=lambda x: x, bases=(Struct,), get_field=getattr, kind=spec)
     raise ValueError
 
 

tests/unit/integrations/msgspec/test_native.py

@@ -0,0 +1,69 @@
+from msgspec import Struct, ValidationError
+from tests_helpers import raises_exc, with_cause
+
+from adaptix import Retort
+from adaptix._internal.integrations.msgspec.native import native_msgspec
+from adaptix._internal.morphing.load_error import LoadError
+
+
+def create_stub_validation_error():
+    error = ValidationError()
+    error.args = ["Expected `int`, got `str` - at `$.a`"]
+    return error
+
+
+def test_validation_without_params():
+    class MyModel(Struct):
+        a: int
+        b: str
+
+    retort = Retort(
+        recipe=[native_msgspec(MyModel)],
+    )
+
+    loader_ = retort.get_loader(MyModel)
+    assert loader_({"a": 1, "b": "value"}) == MyModel(a=1, b="value")
+    raises_exc(
+        with_cause(LoadError(), create_stub_validation_error()),
+        lambda: loader_({"a": "abc", "b": "value"}),
+    )
+
+
+def test_with_conversion_params():
+    class MyModel(Struct):
+        a: int
+        b: str
+
+    retort = Retort(
+        recipe=[native_msgspec(MyModel, convert={"strict": True})],
+    )
+
+    loader_ = retort.get_loader(MyModel)
+    assert loader_({"a": 1, "b": "value"}) == MyModel(a=1, b="value")
+    raises_exc(
+        with_cause(LoadError(), create_stub_validation_error()),
+        lambda: loader_({"a": "1", "b": "value"}),
+    )
+
+    dumper_ = retort.get_dumper(MyModel)
+    assert dumper_(MyModel(a=1, b="value")) == {"a": 1, "b": "value"}
+
+
+def test_to_builtins_with_params():
+    class MyModel(Struct):
+        a: int
+        b: str
+
+    retort = Retort(
+        recipe=[native_msgspec(MyModel, to_builtins={"str_keys": False})],
+    )
+
+    loader_ = retort.get_loader(MyModel)
+    assert loader_({"a": 1, "b": "value"}) == MyModel(a=1, b="value")
+    raises_exc(
+        with_cause(LoadError(), create_stub_validation_error()),
+        lambda: loader_({"a": "1", "b": "value"}),
+    )
+
+    dumper_ = retort.get_dumper(MyModel)
+    assert dumper_(MyModel(a=1, b="value")) == {"a": 1, "b": "value"}