TypeDAL 4.9.7__tar.gz → 4.9.8b2__tar.gz

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

@@ -2,6 +2,18 @@
 
 <!--next-version-placeholder-->
 
+## 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.8b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypeDAL
-Version: 4.9.7
+Version: 4.9.8b2
 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.8b2}/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-beta.2"

{typedal-4.9.7 → typedal-4.9.8b2}/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,32 @@ 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 = getattr(self, table_name, None)
+                if table is None:
+                    continue
+
+                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:
+                        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
+
     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.8b2}/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.8b2}/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.8b2}/tests/test_main.py

@@ -10,7 +10,7 @@ from typing import ForwardRef
 
 import pytest
 
-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 *
@@ -67,6 +67,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