TypeDAL 4.6.0__tar.gz → 4.6.2__tar.gz

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

@@ -2,6 +2,18 @@
 
 <!--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
+
+* **pydantic:** Exclude fields with 'readable=False' similar to pydal/py4web/web2py behavior ([`e47cc44`](https://github.com/trialandsuccess/TypeDAL/commit/e47cc442aa7736ba1177bc32a7dc6de58c2551aa))
+
 ## v4.6.0 (2026-03-13)
 
 ### Documentation

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypeDAL
-Version: 4.6.0
+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.0 → typedal-4.6.2}/docs/8_mixins.md

@@ -56,7 +56,7 @@ or use them with `pydantic.TypeAdapter`.
 Add the mixin to enable `model_dump()` for serialization, including support for relationships and computed properties:
 
 ```python
-from typedal import TypedTable
+from typedal import TypedField, TypedTable
 from typedal.mixins import PydanticMixin
 
 
@@ -67,6 +67,7 @@ class Author(TypedTable, PydanticMixin):
 class Book(TypedTable, PydanticMixin):
     title: str
     author: Author
+    private_notes = TypedField(str, readable=False)
 
     @property
     def display_title(self) -> str:
@@ -79,6 +80,12 @@ book = Book.where(id=1).join("author").first()
 # model_dump() serializes the full object graph
 data = book.model_dump()
 # -> {"id": 1, "title": "...", "author": {"id": 1, "name": "..."}, "display_title": "..."}
+# (private_notes is omitted because readable=False)
+
+# Runtime readability flags are also respected by model_dump()
+Book.title.readable = False
+data = book.model_dump()
+# -> {"id": 1, "author": {"id": 1, "name": "..."}, "display_title": "..."}
 
 # Use mode="json" for JSON-serializable output (dates as ISO strings, etc.)
 data = book.model_dump(mode="json")

{typedal-4.6.0 → 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.0 → 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.0"
+__version__ = "4.6.2"

{typedal-4.6.0 → typedal-4.6.2}/src/typedal/caching.py

@@ -203,6 +203,7 @@ def _remove_cache(s: Set, tablename: str) -> None:
     indeces = s.select("id").column("id")
     remove_cache(indeces, tablename)
 
+
 def get_expire(
     expires_at: t.Optional[dt.datetime] = None,
     ttl: t.Optional[int | dt.timedelta] = None,
@@ -419,6 +420,7 @@ class Stats[T](t.TypedDict):
     valid: T
     expired: T
 
+
 RowStats = t.TypedDict(
     "RowStats",
     {

{typedal-4.6.0 → 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.0 → 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()}
 
@@ -585,13 +599,19 @@ 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."""
-        data = {
-            field_name: getattr(self, field_name, None)
-            for field_name in self._pydantic_fields(
-                include_relationships=not _shallow,
-                include_properties=not _shallow,
-            )
-        }
+        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,
+        ):
+            # 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)
 
         if mode == "json":
             return dump_pydantic(data, _shallow_nested=True)

{typedal-4.6.0 → 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.0 → 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.0 → typedal-4.6.2}/tests/test_mixins.py

@@ -232,6 +232,16 @@ class PydanticTupleAndLiteralSchema(TypedTable, PydanticMixin):
     status: typing.Literal["draft", "published"]
 
 
+class PydanticHiddenTypedField(TypedTable, PydanticMixin):
+    visible = TypedField(str)
+    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")
@@ -241,6 +251,8 @@ def pydantic_db():
     db.define(PydanticStringRelationship)
     db.define(PydanticGenericResolvedRelationship)
     db.define(PydanticGenericUnresolvedRelationship)
+    db.define(PydanticHiddenTypedField)
+    db.define(PydanticHiddenRelationshipHost)
     db.define(NonPydanticAuthor)
     yield db
 
@@ -443,6 +455,57 @@ def test_pydantic_fields_include_typedfield_and_skip_no_getter_property(pydantic
     assert "empty_prop" not in property_fields
 
 
+def test_pydantic_skips_unreadable_typedfield_in_model_dump(pydantic_db):
+    row = PydanticHiddenTypedField.insert(visible="show", hidden="hide")
+    data = row.model_dump()
+    assert data == {"id": row.id, "visible": "show"}
+
+    PydanticHiddenTypedField.visible.readable = False
+    row = PydanticHiddenTypedField.insert(visible="show-2", hidden="hide-2")
+    data = row.model_dump()
+    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"))