sqlcrucible 0.4.0__tar.gz → 0.4.1__tar.gz

{sqlcrucible-0.4.0 → sqlcrucible-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlcrucible
-Version: 0.4.0
+Version: 0.4.1
 Summary: Define a single model that works as both Pydantic and SQLAlchemy, with explicit conversion between the two
 Project-URL: Homepage, https://sqlcrucible.rdrj.uk
 Project-URL: Issues, https://github.com/RichardDRJ/sqlcrucible/issues

{sqlcrucible-0.4.0 → sqlcrucible-0.4.1}/src/sqlcrucible/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.4.0'
-__version_tuple__ = version_tuple = (0, 4, 0)
+__version__ = version = '0.4.1'
+__version_tuple__ = version_tuple = (0, 4, 1)
 
 __commit_id__ = commit_id = None

{sqlcrucible-0.4.0 → sqlcrucible-0.4.1}/src/sqlcrucible/entity/core.py

@@ -278,7 +278,11 @@ class SQLCrucibleEntity:
 
         This method converts a SQLAlchemy model instance into the corresponding
         entity class. For polymorphic models, it automatically selects the most
-        specific entity subclass that matches the model type.
+        specific entity subclass that matches the model type — searching the
+        whole subclass subtree, not just ``cls``'s direct children, so that a
+        polymorphic query through a *generic* STI root reaches the named
+        concrete subclasses rather than only the transparent ``Foo[X]``
+        parameterisations that share the root's automodel.
 
         Args:
             sa_model: A SQLAlchemy model instance to convert.
@@ -302,15 +306,18 @@ class SQLCrucibleEntity:
                 f"Hint: Make sure you're passing a SQLAlchemy model that was created from "
                 f"this entity class or one of its subclasses."
             )
-        best_subclasses = sorted(
-            cls.__subclasses__(),
-            key=lambda it: mro_distance(sa_model.__class__, it.__sqlalchemy_type__),
-        )
-        if best_subclasses:
-            best_match = best_subclasses[0]
-        else:
-            best_match = cls
+        sa_class = sa_model.__class__
+
+        def subtree(entity: type[Any]) -> Iterator[type[Any]]:
+            yield entity
+            for subclass in entity.__subclasses__():
+                yield from subtree(subclass)
 
+        best_match = min(
+            (entity for entity in subtree(cls) if issubclass(sa_class, entity.__sqlalchemy_type__)),
+            key=lambda entity: mro_distance(sa_class, entity.__sqlalchemy_type__),
+            default=cls,
+        )
         return best_match._from_sa_model(sa_model)
 
     @classmethod

{sqlcrucible-0.4.0 → sqlcrucible-0.4.1}/tests/entity/test_generic_sti.py

@@ -100,6 +100,37 @@ def test_polymorphic_query_through_root_dispatches_to_subclass(engine):
     assert isinstance(row, SAType[Single])
 
 
+def test_from_sa_model_through_generic_root_yields_the_named_subclass(engine):
+    """A heterogeneous polymorphic query through the generic STI root, fed
+    back through ``Release.from_sa_model`` (not ``Single``/``Album``
+    directly), yields the named concrete subclass for each row — with its
+    ``details`` re-validated to that subclass's parameterised type. The
+    search has to walk past the transparent ``Release[SingleDetails]`` /
+    ``Release[AlbumDetails]`` parameterisations (which share the root's
+    automodel) to reach ``Single`` / ``Album``."""
+    with Session(engine) as session:
+        session.add(
+            Single(details=SingleDetails(a_side="Heroes", b_side="V-2 Schneider")).to_sa_model()
+        )
+        session.add(
+            Album(
+                details=AlbumDetails(track_titles=["Speed of Life", "Breaking Glass"])
+            ).to_sa_model()
+        )
+        session.commit()
+
+        rows = session.execute(select(SAType[Release])).scalars().all()
+
+    by_kind = {row.kind: Release.from_sa_model(row) for row in rows}
+
+    assert isinstance(by_kind["single"], Single)
+    assert by_kind["single"].details == SingleDetails(a_side="Heroes", b_side="V-2 Schneider")
+    assert isinstance(by_kind["album"], Album)
+    assert by_kind["album"].details == AlbumDetails(
+        track_titles=["Speed of Life", "Breaking Glass"]
+    )
+
+
 def test_stub_generation_is_well_formed(tmp_path: Path):
     """No bracket-named automodel class is created, so the generated
     stubs contain no class whose name has ``[`` ``]``; the parameterised