TypeDAL 4.6.1__tar.gz → 4.6.2__tar.gz

{typedal-4.6.1 → typedal-4.6.2}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 <!--next-version-placeholder-->
 
+## v4.6.2 (2026-03-13)
+
+### Fix
+
+* Move pydantic visibility/lazy-load filtering into schema-converter path used by FastAPI ([`63c2e2c`](https://github.com/trialandsuccess/TypeDAL/commit/63c2e2c2e3c78f8aa817911dd269f650f5ba3d7d))
+
 ## v4.6.1 (2026-03-13)
 
 ### Fix

{typedal-4.6.1 → typedal-4.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypeDAL
-Version: 4.6.1
+Version: 4.6.2
 Summary: Typing support for PyDAL
 Project-URL: Documentation, https://typedal.readthedocs.io/
 Project-URL: Issues, https://github.com/trialandsuccess/TypeDAL/issues

{typedal-4.6.1 → typedal-4.6.2}/pyproject.toml

@@ -183,6 +183,7 @@ select = [
     # "COM", # comma's - NO: annoying
     # "PTH", # use pathlib - NO: annoying
     "RUF", # ruff rules
+    # "D", # docs
 ]
 unfixable = [
     # Don't touch unused imports
@@ -191,13 +192,19 @@ unfixable = [
 extend-ignore = [
     # db.field == None should NOT be fixed to db.field is None
     "E711",
+    "D200",
+    "D212",
+    "D418",
 ]
 
-
 ignore = [
     "RUF013" # implicit optional
 ]
 
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
 [tool.bandit]
 # bandit -c pyproject.toml -r .
 exclude_dirs = [".bak", "venv"]

{typedal-4.6.1 → typedal-4.6.2}/src/typedal/__about__.py

@@ -5,4 +5,4 @@ This file contains the Version info for this package.
 # SPDX-FileCopyrightText: 2023-present Robin van der Noord <robinvandernoord@gmail.com>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "4.6.1"
+__version__ = "4.6.2"

{typedal-4.6.1 → typedal-4.6.2}/src/typedal/core.py

@@ -4,6 +4,7 @@ Core functionality of TypeDAL.
 
 from __future__ import annotations
 
+# noinspection PyUnusedImports
 import datetime as dt
 import sys
 import typing as t
@@ -21,7 +22,9 @@ from .helpers import (
     sql_expression,
     to_snake,
 )
-from .types import CacheStatus, Field, Template  # noqa: F401
+
+# noinspection PyUnusedImports
+from .types import CacheStatus, Field, Template
 
 try:
     # python 3.14+

{typedal-4.6.1 → typedal-4.6.2}/src/typedal/mixins.py

@@ -376,6 +376,12 @@ class PydanticMixin(Mixin):
             field_name: cls._unwrap_pydantic_field_type(field_type) for field_name, field_type in annotations.items()
         }
 
+        # Respect pyDAL visibility: unreadable DB fields should not be part of pydantic output/schema.
+        for field_name in list(fields):
+            model_attr = full_dict.get(field_name, getattr(cls, field_name, None))
+            if hasattr(model_attr, "readable") and not getattr(model_attr, "readable"):
+                fields.pop(field_name, None)
+
         for field_name, field_type in fields.items():
             cls._ensure_pydantic_compatible_type(field_name, field_type)
 
@@ -420,8 +426,9 @@ class PydanticMixin(Mixin):
         )
 
     @staticmethod
-    def _make_instance_converter(_: type, fields: dict[str, t.Any]) -> t.Callable[[t.Any], t.Any]:
+    def _make_instance_converter(model_cls: type, fields: dict[str, t.Any]) -> t.Callable[[t.Any], t.Any]:
         _PRIMITIVES = (str, float, bool, bytes)
+        relationship_names = set(model_cls.get_relationships()) if hasattr(model_cls, "get_relationships") else set()
 
         def convert(value: t.Any) -> t.Any:
             if isinstance(value, dict):
@@ -432,7 +439,16 @@ class PydanticMixin(Mixin):
             if isinstance(value, _PRIMITIVES) or value is None:
                 return value
             # Handles both TypedTable instances and raw pydal Row objects
-            return {k: getattr(value, k, None) for k in fields}
+            values_dict = getattr(value, "__dict__", {})
+            result: dict[str, t.Any] = {}
+            for field_name in fields:
+                # Never trigger lazy-loads during pydantic conversion.
+                if field_name in relationship_names and field_name not in values_dict:
+                    continue
+
+                result[field_name] = getattr(value, field_name, None)
+
+            return result
 
         return convert
 
@@ -529,11 +545,9 @@ class PydanticMixin(Mixin):
             if field_name in _required_fields:
                 # Always computed — keep required and non-nullable for clean TS types
                 return core_schema.typed_dict_field(inner, required=True)
-            # DB fields / relationships: TypeDAL can return partial rows, so allow None
-            return core_schema.typed_dict_field(
-                core_schema.with_default_schema(core_schema.nullable_schema(inner), default=None),
-                required=False,
-            )
+            # DB fields / relationships: TypeDAL can return partial rows, so allow None when present,
+            # but keep missing fields absent (don't auto-fill null/default values).
+            return core_schema.typed_dict_field(core_schema.nullable_schema(inner), required=False)
 
         schema_fields = {field_name: make_field(field_name, field_type) for field_name, field_type in fields.items()}
 
@@ -586,14 +600,15 @@ class PydanticMixin(Mixin):
     def model_dump(self, mode: str = "python", *, _shallow: bool = False) -> dict[str, t.Any]:
         """Serialize this model to a dict, with optional shallow nested output."""
         cls = type(self)
+        relationship_names = set(cls.get_relationships())
         data: dict[str, t.Any] = {}
         for field_name in self._pydantic_fields(
             include_relationships=not _shallow,
             include_properties=not _shallow,
         ):
-            # Match web2py/pyDAL behavior: unreadable db fields are excluded from serialized output.
-            model_attr = getattr(cls, field_name, None)
-            if hasattr(model_attr, "readable") and not getattr(model_attr, "readable"):
+            # Only include relationship data that was already selected/joined.
+            # This prevents model_dump from triggering lazy-loading queries.
+            if field_name in relationship_names and field_name not in self.__dict__:
                 continue
 
             data[field_name] = getattr(self, field_name, None)

{typedal-4.6.1 → typedal-4.6.2}/src/typedal/rows.py

@@ -421,8 +421,8 @@ class TypedRows(t.Collection[T_MetaInstance], Rows):
         fields: list[Field] | None = None,
     ) -> t.Generator[T_MetaInstance, None, None] | T_MetaInstance:
         """
-        Takes an index and returns a copy of the indexed row with values \
-            transformed via the "represent" attributes of the associated fields.
+        Takes an index and returns a copy of the indexed row with values
+        transformed via the "represent" attributes of the associated fields.
 
         Args:
             i: index. If not specified, a generator is returned for iteration

{typedal-4.6.1 → typedal-4.6.2}/src/typedal/types.py

@@ -35,7 +35,9 @@ except ImportError:
 # Internal references
 if t.TYPE_CHECKING:
     from .fields import TypedField
-    from .tables import TypedTable, _TypedTable  # noqa: F401
+
+    # noinspection PyUnusedImports
+    from .tables import TypedTable, _TypedTable
 
 # ---------------------------------------------------------------------------
 # Aliases

{typedal-4.6.1 → typedal-4.6.2}/tests/test_mixins.py

@@ -237,6 +237,11 @@ class PydanticHiddenTypedField(TypedTable, PydanticMixin):
     hidden = TypedField(str, readable=False)
 
 
+class PydanticHiddenRelationshipHost(TypedTable, PydanticMixin):
+    name: str
+    with_hidden = relationship(list[PydanticHiddenTypedField], lambda self, other: self.id == other.id, lazy="allow")
+
+
 @pytest.fixture
 def pydantic_db():
     db = TypeDAL("sqlite:memory")
@@ -247,6 +252,7 @@ def pydantic_db():
     db.define(PydanticGenericResolvedRelationship)
     db.define(PydanticGenericUnresolvedRelationship)
     db.define(PydanticHiddenTypedField)
+    db.define(PydanticHiddenRelationshipHost)
     db.define(NonPydanticAuthor)
     yield db
 
@@ -460,6 +466,46 @@ def test_pydantic_skips_unreadable_typedfield_in_model_dump(pydantic_db):
     assert data == {"id": row.id}
 
 
+def test_pydantic_skips_unreadable_typedfield_in_nested_list_relationship_dump(pydantic_db):
+    hidden = PydanticHiddenTypedField.insert(visible="show", hidden="hide")
+    host = PydanticHiddenRelationshipHost.insert(name="Host")
+    assert hidden.id == host.id
+
+    joined = PydanticHiddenRelationshipHost.where(id=host.id).join("with_hidden").first()
+    assert joined is not None
+
+    data = joined.model_dump(mode="json")
+    assert data["with_hidden"] == [{"id": hidden.id, "visible": "show"}]
+    assert joined.with_hidden[0].hidden == "hide"
+    assert [item.model_dump() for item in joined.with_hidden] == [{"id": hidden.id, "visible": "show"}]
+
+
+def test_pydantic_model_dump_never_lazy_loads_unjoined_relationships(pydantic_db):
+    hidden = PydanticHiddenTypedField.insert(visible="show", hidden="hide")
+    host = PydanticHiddenRelationshipHost.insert(name="Host")
+    assert hidden.id == host.id
+
+    data = host.model_dump(mode="json")
+    assert "with_hidden" not in data
+
+
+def test_pydantic_type_adapter_skips_unreadable_fields(pydantic_db):
+    row = PydanticHiddenTypedField.insert(visible="show", hidden="hide")
+    ta = pydantic.TypeAdapter(PydanticHiddenTypedField)
+    data = ta.validate_python(row)
+    assert data == {"id": row.id, "visible": "show"}
+
+
+def test_pydantic_type_adapter_never_lazy_loads_unjoined_relationships(pydantic_db):
+    hidden = PydanticHiddenTypedField.insert(visible="show", hidden="hide")
+    host = PydanticHiddenRelationshipHost.insert(name="Host")
+    assert hidden.id == host.id
+
+    ta = pydantic.TypeAdapter(PydanticHiddenRelationshipHost)
+    data = ta.validate_python(host)
+    assert "with_hidden" not in data
+
+
 def test_pydantic_compatibility_non_type_and_missing_relationship_type():
     # ForwardRef is not a runtime type; this should be a no-op, not a crash.
     PydanticMixin._ensure_pydantic_compatible_type("x", typing.ForwardRef("Anything"))