TypeDAL 4.9.8b2__tar.gz → 4.9.9__tar.gz

{typedal-4.9.8b2 → typedal-4.9.9}/CHANGELOG.md

@@ -2,17 +2,18 @@
 
 <!--next-version-placeholder-->
 
-## v4.9.8-beta.2 (2026-07-14)
+## v4.9.9 (2026-07-17)
 
 ### Fix
 
-* **core:** Fully detach tables and fields when closing TypeDAL ([`469e0cb`](https://github.com/trialandsuccess/TypeDAL/commit/469e0cbc5b4f1584849040735ced0232adc18b65))
+* **typing:** Support dynamic fields in relationship callbacks ([`60c3921`](https://github.com/trialandsuccess/TypeDAL/commit/60c39214ba448d6a4b96fde21055a1f7a08263be))
 
-## v4.9.8-beta.1 (2026-07-14)
+## v4.9.8 (2026-07-14)
 
 ### Fix
 
-* **core:** Purge dialect expressions when closing TypeDAL ([`d848cf7`](https://github.com/trialandsuccess/TypeDAL/commit/d848cf72ca0ecee24ba857d6b5e03d3cacce7693))
+* **core:** Properly clean up all TypeDAL tables, fields, hooks, validators, and dialect expressions when closing the database ([`3a3fe7b`](https://github.com/trialandsuccess/TypeDAL/commit/3a3fe7b3387476a9ee50f85d492dea067f218069), [`469e0cb`](https://github.com/trialandsuccess/TypeDAL/commit/469e0cbc5b4f1584849040735ced0232adc18b65), [`d848cf7`](https://github.com/trialandsuccess/TypeDAL/commit/d848cf72ca0ecee24ba857d6b5e03d3cacce7693))
+
 
 ## v4.9.7 (2026-07-14)
 

{typedal-4.9.8b2 → typedal-4.9.9}/PKG-INFO

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

{typedal-4.9.8b2 → typedal-4.9.9}/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.9.8-beta.2"
+__version__ = "4.9.9"

{typedal-4.9.8b2 → typedal-4.9.9}/src/typedal/core.py

@@ -342,16 +342,28 @@ class TypeDAL(_TypeDALBase):
                 _purge_dialect_expressions(adapter)
 
             for table_name in tuple(getattr(self, "tables", ())):
-                table = getattr(self, table_name, None)
-                if table is None:
+                table: Table | None = getattr(self, table_name, None)
+                if table is None:  # pragma: no cover
                     continue
 
+                for hook_name in (
+                    "_before_insert",
+                    "_after_insert",
+                    "_before_update",
+                    "_after_update",
+                    "_before_delete",
+                    "_after_delete",
+                ):
+                    hooks = getattr(table, hook_name, None)
+                    if isinstance(hooks, list):
+                        hooks.clear()
+
                 if hasattr(table, "_db"):
                     table._db = None
 
                 for field_name in getattr(table, "fields", ()):
-                    field: Field = getattr(table, field_name, None)
-                    if field is None:
+                    field: Field | None = getattr(table, field_name, None)
+                    if field is None:  # pragma: no cover
                         continue
 
                     if hasattr(field, "_db"):
@@ -362,6 +374,8 @@ class TypeDAL(_TypeDALBase):
                         field.table = None
                     if hasattr(field, "_table"):
                         field._table = None
+                    if hasattr(field, "requires"):
+                        field.requires = []
 
     def try_define[T: t.Any](self, model: t.Type[T], verbose: bool = False) -> t.Type[T]:
         """

{typedal-4.9.8b2 → typedal-4.9.9}/src/typedal/types.py

@@ -97,6 +97,19 @@ class TableProtocol(t.Protocol):  # pragma: no cover
 
     id: "TypedField[int]"
 
+    def __getattr__(self, name: str) -> t.Any:
+        """
+        Allow model-specific fields in relationship callbacks.
+
+        Type checkers cannot infer the owning table from a relationship's
+        class-body assignment, and forward references can also obscure the
+        related table. PyDAL exposes table fields dynamically, so arbitrary
+        field access must remain permissive here. Because ``__getattr__``
+        returns ``Any``, type checkers do not validate field names in
+        relationship callbacks; for example, ``self.fakefield`` is accepted
+        even when no such field exists.
+        """
+
     def __getitem__(self, item: str) -> "Field":
         """
         Tables have table[field] syntax.
@@ -399,9 +412,9 @@ type T_Query = t.Union[
 
 type T_Field = t.Union["TypedField[t.Any]", "Table", t.Type["TypedTable"]]
 
-# table-ish parameter:
-# Use protocol typing so checkers know `.id` exists in relationship callbacks.
-type P_Table = t.Union[t.Type["_TypedTable"], TableProtocol]
+# Table-like callback parameter. The protocol keeps common table operations
+# checked while its dynamic attribute fallback covers model-specific fields.
+type P_Table = TableProtocol
 
 type QueryLike = Query | _Query | bool
 

{typedal-4.9.8b2 → typedal-4.9.9}/tests/test_main.py

@@ -3,12 +3,15 @@ import gc
 import re
 import sys
 import typing
+import types
 import weakref
+from contextlib import contextmanager
 from copy import copy
 from sqlite3 import IntegrityError
 from typing import ForwardRef
 
 import pytest
+from pydal.validators import IS_NOT_IN_DB
 
 from src.typedal import TypeDAL, TypedRows
 from src.typedal.__about__ import __version__
@@ -48,6 +51,47 @@ def test_database_is_garbage_collected_after_close():
     assert db_ref() is None
 
 
+def test_database_is_garbage_collected_after_context_manager():
+
+    @contextmanager
+    def typedal_context():
+        db = TypeDAL("sqlite:memory", enable_typedal_caching=False)
+        try:
+            yield db
+            db.commit()
+        except:
+            db.rollback()
+        finally:
+            db.close()
+
+    def in_scope():
+        with typedal_context() as db:
+            @db.define
+            class RelatedTable(TypedTable):
+                value = TypedField(str)
+
+            @db.define
+            class TemporaryTable(TypedTable):
+                related: RelatedTable
+                value = TypedField(str)
+
+                @classmethod
+                def __on_define__(cls, db):
+                    cls.id.requires = IS_NOT_IN_DB(db, cls.id)
+                    cls.after_insert(lambda _row, _id, db=db: None)
+
+            query = TemporaryTable.where(id=0)
+            assert not query.paginate(limit=1)
+
+            return weakref.ref(db)
+
+    db_ref = in_scope()
+
+    gc.collect()
+
+    assert db_ref() is None
+
+
 def test_database_with_auth_user_is_garbage_collected_after_close():
     db = TypeDAL("sqlite:memory", enable_typedal_caching=False)
     db.define(AuthUser, redefine=True)