TypeDAL 4.6.1__tar.gz → 4.6.3__tar.gz

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

@@ -2,6 +2,18 @@
 
 <!--next-version-placeholder-->
 
+## v4.6.3 (2026-03-19)
+
+### Fix
+
+* `as_dict()` and similar changed behavior after doing `.render()` ([`8241503`](https://github.com/trialandsuccess/TypeDAL/commit/8241503073c5a9fd76cc898048f6c7796de3ce7a))
+
+## 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.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypeDAL
-Version: 4.6.1
+Version: 4.6.3
 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.3}/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.3}/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.3"

{typedal-4.6.1 → typedal-4.6.3}/src/typedal/cli.py

@@ -390,8 +390,7 @@ def fake_migrations(
 
     previously_migrated = (
         db(
-            db.ewh_implemented_features.name.belongs(to_fake)
-            & (db.ewh_implemented_features.installed == True)  # noqa E712
+            db.ewh_implemented_features.name.belongs(to_fake) & (db.ewh_implemented_features.installed == True)  # noqa E712
         )
         .select(db.ewh_implemented_features.name)
         .column("name")

{typedal-4.6.1 → typedal-4.6.3}/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.3}/src/typedal/fields.py

@@ -373,9 +373,7 @@ def UploadField(**kw: t.Unpack[FieldSettings]) -> TypedField[str]:
 Upload = UploadField
 
 
-def ReferenceField[
-    T_subclass: (TypedTable, Table)
-](
+def ReferenceField[T_subclass: (TypedTable, Table)](
     other_table: str | t.Type[TypedTable] | TypedTable | Table | T_subclass,
     **kw: t.Unpack[FieldSettings],
 ) -> TypedField[int]:

{typedal-4.6.1 → typedal-4.6.3}/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.3}/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.3}/src/typedal/tables.py

@@ -1104,6 +1104,7 @@ class TypedTable(_TypedTable, metaclass=TableMeta):
         # then create a new (more empty) row object:
         state["_row"] = Row(json.loads(state["_row"]))
         self.__dict__ |= state
+        self._setup_instance_methods()
 
     @classmethod
     def _sql(cls) -> str:

{typedal-4.6.1 → typedal-4.6.3}/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.3}/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"))

{typedal-4.6.1 → typedal-4.6.3}/tests/test_row.py

@@ -266,6 +266,15 @@ def test_render():
     assert rendered_two.normal == "123"
     assert rendered_two.list_field == "abc, def"
     assert rendered_two.related.also_normal == "321"
+    assert json.loads(rendered_two.as_json()) == {
+        "id": rendered_two.id,
+        "normal": "123",
+        "list_field": "abc, def",
+        "related": {
+            "id": rendered_two.related.id,
+            "also_normal": "321",
+        },
+    }
 
     # test list:
 
@@ -287,3 +296,14 @@ def test_render():
     assert rendered_four.normal == "123"
     assert rendered_four.list_field == "abc, def"
     assert rendered_four.related_list[0].also_normal == "321"
+    assert json.loads(rendered_four.as_json()) == {
+        "id": rendered_four.id,
+        "normal": "123",
+        "list_field": "abc, def",
+        "related_list": [
+            {
+                "id": rendered_four.related_list[0].id,
+                "also_normal": "321",
+            }
+        ],
+    }