fix: recursively convert nested dicts in model_from_dict (#637)

 Fixed regression where service.create() failed when passing nested
dictionaries for relationship data. The model_from_dict() function
now uses SQLAlchemy's class_mapper to detect relationships and
recursively converts nested dicts to model instances.

---------

Signed-off-by: Cody Fincher <204685+cofin@users.noreply.github.com>
Co-authored-by: Jacob Coffee <jacob@z7x.org>

Author: cofin

.github/workflows/ci.yml

@@ -96,7 +96,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
     uses: ./.github/workflows/test.yml
     with:
       coverage: ${{ matrix.python-version == '3.13' }}

.pre-commit-config.yaml

@@ -22,7 +22,7 @@ repos:
       - id: unasyncd
         additional_dependencies: ["ruff"]
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: "v0.14.9"
+    rev: "v0.14.13"
     hooks:
       # Run the linter.
       - id: ruff

advanced_alchemy/extensions/sanic/config.py

@@ -189,14 +189,14 @@ async def on_shutdown(_: Any) -> None:  # pyright: ignore[reportUnusedFunction]
             if hasattr(self.app.ctx, self.session_maker_key):  # pyright: ignore[reportUnknownMemberType,reportUnknownArgumentType,reportOptionalMemberAccess]
                 delattr(self.app.ctx, self.session_maker_key)  # pyright: ignore[reportUnknownMemberType,reportUnknownArgumentType,reportOptionalMemberAccess]
 
-        @self.app.middleware("request")  # pyright: ignore[reportUnknownMemberType]
+        @self.app.middleware("request")  # type: ignore[misc,untyped-decorator]  # pyright: ignore[reportUnknownMemberType]
         async def on_request(request: Request) -> None:  # pyright: ignore[reportUnusedFunction]
             session = cast("Optional[AsyncSession]", getattr(request.ctx, self.session_key, None))
             if session is None:
                 setattr(request.ctx, self.session_key, self.get_session())
                 set_async_context(True)
 
-        @self.app.middleware("response")  # type: ignore[arg-type]
+        @self.app.middleware("response")  # type: ignore[misc,untyped-decorator]
         async def on_response(request: Request, response: HTTPResponse) -> None:  # pyright: ignore[reportUnusedFunction]
             session = cast("Optional[AsyncSession]", getattr(request.ctx, self.session_key, None))
             if session is not None:
@@ -397,14 +397,14 @@ async def on_startup(_: Any) -> None:  # pyright: ignore[reportUnusedFunction]
         async def on_shutdown(_: Any) -> None:  # pyright: ignore[reportUnusedFunction]
             await self.on_shutdown()
 
-        @self.app.middleware("request")  # pyright: ignore[reportUnknownMemberType]
+        @self.app.middleware("request")  # type: ignore[misc,untyped-decorator]  # pyright: ignore[reportUnknownMemberType]
         async def on_request(request: Request) -> None:  # pyright: ignore[reportUnusedFunction]
             session = cast("Optional[Session]", getattr(request.ctx, self.session_key, None))
             if session is None:
                 setattr(request.ctx, self.session_key, self.get_session())
                 set_async_context(False)
 
-        @self.app.middleware("response")  # type: ignore[arg-type]
+        @self.app.middleware("response")  # type: ignore[misc,untyped-decorator]
         async def on_response(request: Request, response: HTTPResponse) -> None:  # pyright: ignore[reportUnusedFunction]
             session = cast("Optional[Session]", getattr(request.ctx, self.session_key, None))
             if session is not None:

advanced_alchemy/repository/_util.py

@@ -12,6 +12,7 @@
     InstrumentedAttribute,
     MapperProperty,
     RelationshipProperty,
+    class_mapper,
     joinedload,
     lazyload,
     selectinload,
@@ -88,22 +89,98 @@ def get_instrumented_attr(
     return key
 
 
+def _convert_relationship_value(
+    value: Any,
+    related_model: type[ModelT],
+    is_collection: bool,
+) -> Any:
+    """Convert a relationship value, handling dicts, lists, and instances.
+
+    Args:
+        value: The value to convert (dict, list, model instance, or None).
+        related_model: The SQLAlchemy model class for the relationship.
+        is_collection: Whether this is a collection relationship (uselist=True).
+
+    Returns:
+        Converted value appropriate for the relationship type.
+    """
+    if value is None:
+        return None
+
+    if is_collection:
+        # One-to-many or many-to-many: expect a list
+        if not isinstance(value, (list, tuple)):
+            # Single item provided for collection - wrap in list
+            value = [value]
+        return [
+            model_from_dict(related_model, **item) if isinstance(item, dict) else item
+            for item in value  # pyright: ignore[reportUnknownVariableType]
+        ]
+    # One-to-one or many-to-one: expect single value
+    if isinstance(value, dict):
+        return model_from_dict(related_model, **value)
+    return value
+
+
 def model_from_dict(model: type[ModelT], **kwargs: Any) -> ModelT:
     """Create an ORM model instance from a dictionary of attributes.
 
+    This function recursively converts nested dictionaries into their
+    corresponding SQLAlchemy model instances for relationship attributes.
+
     Args:
         model: The SQLAlchemy model class to instantiate.
         **kwargs: Keyword arguments containing model attribute values.
+            For relationship attributes, values can be:
+            - None: Sets the relationship to None
+            - dict: Recursively converted to the related model instance
+            - list[dict]: Each dict converted to related model instances
+            - Model instance: Passed through unchanged
 
     Returns:
         ModelT: A new instance of the model populated with the provided values.
+
+    Example:
+        Basic usage with nested relationships::
+
+            data = {
+                "name": "John Doe",
+                "profile": {"bio": "Developer"},
+                "addresses": [
+                    {"street": "123 Main St"},
+                    {"street": "456 Oak Ave"},
+                ],
+            }
+            user = model_from_dict(User, **data)
+            # user.profile is a Profile instance
+            # user.addresses is a list of Address instances
     """
-    data = {
-        attr_name: kwargs[attr_name]
-        for attr_name in model.__mapper__.attrs.keys()  # noqa: SIM118  # pyright: ignore[reportUnknownMemberType]
-        if attr_name in kwargs
-    }
-    return model(**data)
+    mapper = class_mapper(model)
+    mapper_attrs = mapper.attrs
+    converted_data: dict[str, Any] = {}
+
+    # Iterate over kwargs instead of mapper.attrs for better performance
+    # when only a subset of attributes is provided (O(InputKeys) vs O(TotalColumns))
+    for key, value in kwargs.items():
+        # Skip keys that aren't mapped attributes (e.g., extra fields)
+        if key not in mapper_attrs:
+            continue
+
+        attr = mapper_attrs[key]
+
+        # Check if this attribute is a relationship
+        if isinstance(attr, RelationshipProperty):
+            related_model: type[ModelT] = attr.mapper.class_
+            converted_data[key] = _convert_relationship_value(
+                value=value,
+                related_model=related_model,
+                is_collection=attr.uselist or False,
+            )
+        else:
+            # Regular column attribute - pass through
+            converted_data[key] = value
+
+    return model(**converted_data)
 
 
 def get_abstract_loader_options(

pyproject.toml

@@ -16,6 +16,7 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Programming Language :: Python",
   "Topic :: Software Development",
   "Typing :: Typed",

tests/integration/test_file_object.py

@@ -1,4 +1,5 @@
 import logging
+import sys
 from collections.abc import AsyncGenerator, Generator
 from contextlib import suppress
 from pathlib import Path
@@ -222,6 +223,10 @@ async def async_session(
 
 
 @pytest.mark.xdist_group("file_object")
+@pytest.mark.xfail(
+    sys.version_info < (3, 10),
+    reason="s3fs endpoint_url parameter incompatible with Python 3.9",
+)
 async def test_fsspec_s3_basic_operations_async(
     storage_registry: StorageRegistry,
     minio_client: "Minio",
@@ -300,6 +305,10 @@ async def test_fsspec_s3_basic_operations_async(
 
 
 @pytest.mark.xdist_group("file_object")
+@pytest.mark.xfail(
+    sys.version_info < (3, 10),
+    reason="s3fs endpoint_url parameter incompatible with Python 3.9",
+)
 def test_fsspec_s3_basic_operations_sync(
     storage_registry: StorageRegistry,
     minio_client: "Minio",

tests/unit/test_extensions/test_sanic.py

@@ -80,7 +80,7 @@ def test_infer_types_from_config(async_config: SQLAlchemyAsyncConfig, sync_confi
 
 
 def test_inject_engine(app: Sanic[Any, Any], alchemy: AdvancedAlchemy) -> None:
-    @app.get("/")
+    @app.get("/")  # type: ignore[misc]
     async def handler(request: Request) -> HTTPResponse:
         assert isinstance(getattr(request.app.ctx, alchemy.get_config().engine_key), (Engine, AsyncEngine))
         return HTTPResponse(status=200)