TypeDAL 4.9.7__tar.gz → 4.9.8__tar.gz

{typedal-4.9.7 → typedal-4.9.8}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 <!--next-version-placeholder-->
 
+## v4.9.8 (2026-07-14)
+
+### Fix
+
+* **core:** Clear table hooks and field validators on close ([`3a3fe7b`](https://github.com/trialandsuccess/TypeDAL/commit/3a3fe7b3387476a9ee50f85d492dea067f218069))
+
+## v4.9.8-beta.2 (2026-07-14)
+
+### Fix
+
+* **core:** Fully detach tables and fields when closing TypeDAL ([`469e0cb`](https://github.com/trialandsuccess/TypeDAL/commit/469e0cbc5b4f1584849040735ced0232adc18b65))
+
+## v4.9.8-beta.1 (2026-07-14)
+
+### Fix
+
+* **core:** Purge dialect expressions when closing TypeDAL ([`d848cf7`](https://github.com/trialandsuccess/TypeDAL/commit/d848cf72ca0ecee24ba857d6b5e03d3cacce7693))
+
 ## v4.9.7 (2026-07-14)
 
 ### Fix

{typedal-4.9.7 → typedal-4.9.8}/PKG-INFO

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

{typedal-4.9.7 → typedal-4.9.8}/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.7"
+__version__ = "4.9.8"

{typedal-4.9.7 → typedal-4.9.8}/src/typedal/core.py

@@ -40,6 +40,53 @@ if t.TYPE_CHECKING:
     from .types import AnyDict, DefineKwargs, Expression, Rows, Set, T_Query, Table
 
 
+def _expression_subclasses() -> t.Iterator[type]:
+    """
+    Yield pydal.objects.Expression and every (nested) subclass currently loaded, e.g. Field and TypedField.
+    """
+    seen = {pydal.objects.Expression}
+    stack = [pydal.objects.Expression]
+    while stack:
+        for subclass in stack.pop().__subclasses__():
+            if subclass not in seen:
+                seen.add(subclass)
+                stack.append(subclass)
+
+    return iter(seen)
+
+
+def _purge_dialect_expressions(adapter: t.Any) -> None:
+    """
+    Undo pydal's global dialect-expression registration for a closed adapter.
+
+    Some dialects (currently Postgres and Snowflake) register extra Expression methods
+    (e.g. `.dow`, `.doy`) by stashing a wrapper per name in the process-wide, class-level
+    `Expression._dialect_expressions_` dict. `Expression.__new__` then copies each wrapper
+    onto every instantiated Expression subclass (Field, TypedField, ...) as a bound method.
+    Both of those are permanent references living outside of any object graph tied to a
+    specific db, so they are not reference cycles: closing the adapter and even running
+    `gc.collect()` will not free it, and with it the entire db (tables, fields, models)
+    it belongs to, for the lifetime of the process, unless explicitly undone here.
+    """
+    expressions = pydal.objects.Expression._dialect_expressions_
+    stale = [
+        name
+        for name, wrapper in expressions.items()
+        if getattr(getattr(wrapper, "dialect", None), "adapter", None) is adapter
+    ]
+
+    if not stale:
+        return
+
+    for name in stale:
+        del expressions[name]
+
+    for cls in _expression_subclasses():
+        for name in stale:
+            if name in cls.__dict__:
+                delattr(cls, name)
+
+
 # note: these functions can not be moved to a different file,
 #  because then they will have different globals and it breaks!
 
@@ -282,6 +329,7 @@ class TypeDAL(_TypeDALBase):
 
     def close(self) -> None:
         """Close the database connection and unbind all defined TypedTable models."""
+        adapter = self._adapter
         try:
             super().close()
         finally:
@@ -289,6 +337,46 @@ class TypeDAL(_TypeDALBase):
                 model.unbind()
             self._builder.class_map.clear()
 
+            if adapter is not None:
+                adapter.db = None
+                _purge_dialect_expressions(adapter)
+
+            for table_name in tuple(getattr(self, "tables", ())):
+                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 | None = getattr(table, field_name, None)
+                    if field is None:  # pragma: no cover
+                        continue
+
+                    if hasattr(field, "_db"):
+                        field._db = None
+                    if hasattr(field, "db"):
+                        field.db = None
+                    if hasattr(field, "table"):
+                        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]:
         """
         Try to define a model with migrate or fall back to fake migrate.

{typedal-4.9.7 → typedal-4.9.8}/src/typedal/fields.py

@@ -206,6 +206,7 @@ class TypedField[T_Value](Expression):  # pragma: no cover
                 self.requires = []
 
         self._table = None
+        self._db = None
         self._field = None
 
     def __getattr__(self, key: str) -> t.Any:

{typedal-4.9.7 → typedal-4.9.8}/tests/conftest.py

@@ -21,10 +21,12 @@ def psql(request):
     request.addfinalizer(postgres.stop)
     postgres.start()
 
-
 @pytest.fixture
-def dal_psql(psql):
+def dal_psql_uri(psql) -> str:
     conn_str = postgres.get_connection_url()
-    uri = "postgres://" + conn_str.split("://")[-1]
+    return "postgres://" + conn_str.split("://")[-1]
+
+@pytest.fixture
+def dal_psql(dal_psql_uri: str):
     with tempfile.TemporaryDirectory() as d:
-        yield TypeDAL(uri, attempts=1, migrate=True, enable_typedal_caching=False, folder=d)
+        yield TypeDAL(dal_psql_uri, attempts=1, migrate=True, enable_typedal_caching=False, folder=d)

{typedal-4.9.7 → typedal-4.9.8}/tests/test_main.py

@@ -3,14 +3,17 @@ 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 TypedRows
+from src.typedal import TypeDAL, TypedRows
 from src.typedal.__about__ import __version__
 from src.typedal.enum_helpers import InvalidEnumValue
 from src.typedal.fields import *
@@ -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)
@@ -67,6 +111,37 @@ def test_database_with_auth_user_is_garbage_collected_after_close():
     assert db_ref() is None
 
 
+def test_database_is_garbage_collected_after_close_postgres(dal_psql_uri, tmp_path):
+    # Postgres (and Snowflake) dialects register extra Expression methods (e.g. `.dow`) in the
+    # process-wide, class-level `Expression._dialect_expressions_` dict. That's a permanent
+    # reference living outside of any db-specific object graph, so unlike the sqlite case above,
+    # gc.collect() alone can't free it - close() has to explicitly undo the registration.
+    # (built directly from the conftest `postgres` container, not the `dal_psql` fixture: a
+    # suspended fixture generator would itself keep `db` alive for the duration of the test)
+
+    db = TypeDAL(dal_psql_uri, attempts=1, migrate=True, enable_typedal_caching=False, folder=str(tmp_path))
+
+    @db.define
+    class TemporaryPsqlTable(TypedTable):
+        value = TypedField(str)
+
+    db_ref = weakref.ref(db)
+    adapter_ref = weakref.ref(db._adapter)
+
+    db.close()
+
+    assert TemporaryPsqlTable._db is None
+    assert TemporaryPsqlTable._table is None
+
+    del db
+    gc.collect()
+
+    assert db_ref() is None
+    # the adapter itself is allowed to leak (pydal has no public API to fully undo the global
+    # dialect registration) as long as it no longer drags the rest of the db graph with it:
+    assert adapter_ref() is None or adapter_ref().db is None
+
+
 def test_mixed_defines(capsys):
     ### DEFINE