dbzero 0.3.5__tar.gz → 0.3.7__tar.gz

{dbzero-0.3.5 → dbzero-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbzero
-Version: 0.3.5
+Version: 0.3.7
 Summary: A state management system for Python 3.x that unifies your applications business logic, data persistence, and caching into a single, efficient layer.
 Author-Email: "DBZero Software sp. z o.o" <info@dbzero.io>
 License:                   GNU LESSER GENERAL PUBLIC LICENSE

{dbzero-0.3.5 → dbzero-0.3.7}/dbzero/dbzero/dbzero.py

@@ -10,7 +10,7 @@ def load_dynamic(name, path):
 
 def __bootstrap__():
     global __bootstrap__, __loader__, __file__
-    paths = [os.path.join(os.path.split(__file__)[0]), "/src/dev/build/release", "/usr/local/lib/python3/dist-packages/dbzero/"]
+    paths = [os.path.join(os.path.split(__file__)[0]), "/src/dev/build/debug", "/usr/local/lib/python3/dist-packages/dbzero/"]
     __file__ = None
     for path in paths:
         if os.path.isdir(path):

{dbzero-0.3.5 → dbzero-0.3.7}/dbzero/setup.py

@@ -10,7 +10,7 @@ if sys.byteorder == 'big':
 
 setup(
     name='dbzero',
-    version='0.3.5',
+    version='0.3.7',
     description='DBZero community edition',
     packages=['dbzero'],
     python_requires='>=3.9',

{dbzero-0.3.5 → dbzero-0.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ['meson-python']
 
 [project]
 name = 'dbzero'
-version = '0.3.5'
+version = '0.3.7'
 description = 'A state management system for Python 3.x that unifies your applications business logic, data persistence, and caching into a single, efficient layer.'
 readme = 'README.md'
 requires-python = '>=3.9'

dbzero-0.3.7/python_tests/test_issues_18.py

@@ -0,0 +1,165 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+# Copyright (c) 2025 DBZero Software sp. z o.o.
+
+import os
+import subprocess
+import sys
+import textwrap
+import pytest
+
+
+SHUTDOWN_LIFETIME_SKIP_REASON = (
+    "Known shutdown-lifetime crash in subprocesses that leave singleton-backed durable "
+    "collections with nested immutable memo references alive at interpreter teardown; "
+    "currently observed on Python 3.12/3.13 and macOS builds only."
+)
+
+
+@pytest.mark.skip(reason=SHUTDOWN_LIFETIME_SKIP_REASON)
+def test_unhandled_exception_with_nested_durable_list_does_not_segfault(tmp_path):
+    """Regression for SIGSEGV during interpreter shutdown after an exception."""
+    model_path = tmp_path / "repro_model.py"
+    model_path.write_text(
+        textwrap.dedent(
+            """
+            from __future__ import annotations
+
+            from dataclasses import dataclass, field
+
+            import dbzero as db0
+
+            DATA_PREFIX = "/issue-18/data"
+
+
+            @db0.memo(prefix=DATA_PREFIX, immutable=True)
+            @dataclass
+            class Metadata:
+                title: str
+                subtitle: str
+                parent: LegalExcerptRecord | int
+                url: str
+                source: str
+
+
+            @db0.memo(prefix=DATA_PREFIX, immutable=True)
+            @dataclass
+            class LegalExcerptRecord:
+                id: int
+                content: str
+                metadata: Metadata
+
+                @classmethod
+                def from_schema_data(cls, data, parent=None):
+                    metadata = Metadata.from_schema_data(data["metadata"], parent=parent)
+                    return cls(int(data["id"]), data["content"], metadata)
+
+
+            @classmethod
+            def metadata_from_schema_data(cls, data, parent=None):
+                parent_id = int(data["parentId"])
+                return cls(
+                    data["title"],
+                    data["subtitle"],
+                    parent_id if parent is None else parent,
+                    data["url"],
+                    data["source"],
+                )
+
+
+            Metadata.from_schema_data = metadata_from_schema_data
+
+
+            @db0.memo(prefix=DATA_PREFIX, singleton=True)
+            @dataclass
+            class Root:
+                records: list[LegalExcerptRecord] = field(default_factory=list)
+                records_by_id: dict[str, LegalExcerptRecord] = field(default_factory=dict)
+                record_positions_by_id: dict[str, int] = field(default_factory=dict)
+                unresolved_child_ids_by_parent_id: dict[str, list[str]] = field(default_factory=dict)
+
+                def add_record_from_schema_data(self, data):
+                    parent_id = int(data["metadata"]["parentId"])
+                    existing_parent = self.get_record(parent_id)
+                    parent = existing_parent if existing_parent is not None else parent_id
+                    record = LegalExcerptRecord.from_schema_data(data, parent=parent)
+                    self.store_record(record)
+                    return record
+
+                def store_record(self, record):
+                    record_key = str(record.id)
+                    self._remove_unresolved_child(record_key)
+                    if isinstance(record.metadata.parent, int):
+                        self._add_unresolved_child(record_key, record.metadata.parent)
+
+                    position = self.record_positions_by_id.get(record_key)
+                    if position is None:
+                        self.record_positions_by_id[record_key] = len(self.records)
+                        self.records.append(record)
+                    else:
+                        self.records[position] = record
+                    self.records_by_id[record_key] = record
+
+                def get_record(self, record_id):
+                    return self.records_by_id.get(str(record_id))
+
+                def _add_unresolved_child(self, child_key, parent_id):
+                    parent_key = str(parent_id)
+                    child_ids = self.unresolved_child_ids_by_parent_id.setdefault(parent_key, [])
+                    if child_key not in child_ids:
+                        child_ids.append(child_key)
+
+                def _remove_unresolved_child(self, child_key):
+                    for _parent_key, child_ids in self.unresolved_child_ids_by_parent_id.items():
+                        child_ids.discard(child_key)
+            """
+        ),
+        encoding="utf-8",
+    )
+
+    script = textwrap.dedent(
+        f"""
+        import sys
+        import tempfile
+
+        import dbzero as db0
+
+        sys.path.insert(0, {str(tmp_path)!r})
+
+        from repro_model import DATA_PREFIX, Root
+
+        def record_data(record_id):
+            return {{
+                "id": str(record_id),
+                "content": "Legal text excerpt body.",
+                "metadata": {{
+                    "title": "Legal act title",
+                    "subtitle": "Legal act subtitle",
+                    "parentId": "14",
+                    "url": "data/html/DU_1919_364.html",
+                    "source": "Art. 1.",
+                }},
+            }}
+
+        db0.init(tempfile.mkdtemp() + "/dbzero", prefix=DATA_PREFIX, autocommit=True)
+        root = Root()
+        root.add_record_from_schema_data(record_data(19458))
+        root.add_record_from_schema_data(record_data(19459))
+        """
+    )
+
+    env = os.environ.copy()
+    env["PYTHONDONTWRITEBYTECODE"] = "1"
+    result = subprocess.run(
+        [sys.executable, "-c", script],
+        check=False,
+        env=env,
+        text=True,
+        capture_output=True,
+    )
+
+    assert result.returncode == 1, (
+        f"subprocess exited with {result.returncode}; expected ordinary AttributeError exit\n"
+        f"stdout:\n{result.stdout}\n"
+        f"stderr:\n{result.stderr}"
+    )
+    assert "AttributeError" in result.stderr

{dbzero-0.3.5 → dbzero-0.3.7}/python_tests/test_memo_intern.py

@@ -2,7 +2,11 @@
 # Copyright (c) 2025 DBZero Software sp. z o.o.
 
 import gc
+import os
 import random
+import subprocess
+import sys
+import textwrap
 import time
 from dataclasses import dataclass
 from dataclasses import field
@@ -15,6 +19,33 @@ import dbzero as db0
 from .conftest import DB0_DIR
 
 
+SHUTDOWN_LIFETIME_SKIP_REASON = (
+    "Known shutdown-lifetime crash in subprocesses that leave singleton-backed durable "
+    "collections with nested immutable memo references alive at interpreter teardown; "
+    "currently observed on Python 3.12/3.13 and macOS builds only."
+)
+
+
+def run_intern_script(script):
+    env = os.environ.copy()
+    env["PYTHONDONTWRITEBYTECODE"] = "1"
+    return subprocess.run(
+        [sys.executable, "-c", textwrap.dedent(script)],
+        check=False,
+        env=env,
+        text=True,
+        capture_output=True,
+    )
+
+
+def assert_intern_script_exits_cleanly(result):
+    assert result.returncode == 0, (
+        f"subprocess exited with {result.returncode}; expected clean shutdown\n"
+        f"stdout:\n{result.stdout}\n"
+        f"stderr:\n{result.stderr}"
+    )
+
+
 def get_memo_class_object(obj):
     return db0.get_memo_class(obj).get_class()
 
@@ -31,6 +62,13 @@ class MemoInternLeafSibling:
     name: str
 
 
+@db0.memo(immutable=True, intern=True)
+@dataclass
+class MemoInternSourceNode:
+    parent: Optional["MemoInternSourceNode"]
+    contents: str
+
+
 @db0.memo(immutable=True)
 @dataclass
 class MemoNonInternImmutableLeaf:
@@ -346,6 +384,205 @@ def test_embedded_interned_object_inside_container_reuses_embedded_instance(
     assert second.name == "container embedded"
 
 
+def test_hierarchical_interned_immutable_sources_dedupe_and_preserve_parents(db0_fixture):
+    def make_source(parts):
+        source = None
+        for part in parts:
+            source = db0.materialized(MemoInternSourceNode(source, part))
+        return source
+
+    def source_parts(source):
+        parts = []
+        while source is not None:
+            parts.append(source.contents)
+            source = source.parent
+        return tuple(reversed(parts))
+
+    paths = []
+    for index in range(120):
+        depth = index % 4 + 1
+        paths.append((
+            f"title-{index % 6}",
+            f"section-{index % 5}",
+            f"chapter-{index % 4}",
+            f"article-{index % 3}",
+        )[:depth])
+    assert len(paths) >= 100
+
+    expected_prefixes = {
+        path[:prefix_len]
+        for path in paths
+        for prefix_len in range(1, len(path) + 1)
+    }
+    expected_leaf_paths = set(paths)
+
+    objects = [db0.materialized(make_source(path)) for path in paths]
+    uuids_by_path = {}
+    for path, source in zip(paths, objects):
+        source_uuid = db0.uuid(source)
+        uuids_by_path.setdefault(path, source_uuid)
+        assert source_uuid == uuids_by_path[path]
+        assert source_parts(source) == path
+
+    db0.clear_cache()
+    duplicates = [db0.materialized(make_source(path)) for path in paths]
+    for path, source in zip(paths, duplicates):
+        assert db0.uuid(source) == uuids_by_path[path]
+        assert source_parts(source) == path
+
+    assert len(uuids_by_path) == len(expected_leaf_paths)
+    assert len({db0.uuid(source) for source in objects + duplicates}) == len(expected_leaf_paths)
+    assert db0.get_type_stats(MemoInternSourceNode)["content_index"]["size"] == len(expected_prefixes)
+
+
+@pytest.mark.skip(reason=SHUTDOWN_LIFETIME_SKIP_REASON)
+def test_nested_interned_immutable_references_in_singleton_list_exit_cleanly():
+    result = run_intern_script(
+        """
+        from __future__ import annotations
+
+        from dataclasses import dataclass, field
+        from pathlib import Path
+        import tempfile
+
+        import dbzero as db0
+
+        DATA_PREFIX = "/tests/intern/nested-singleton-list"
+
+
+        @db0.memo(prefix=DATA_PREFIX, immutable=True, intern=True)
+        @dataclass
+        class Source:
+            parent: Source | None
+            contents: str
+
+
+        @db0.memo(prefix=DATA_PREFIX, immutable=True, intern=True)
+        @dataclass
+        class Metadata:
+            title: Source
+            source: Source
+
+
+        @db0.memo(prefix=DATA_PREFIX, immutable=True, intern=True)
+        @dataclass
+        class Record:
+            metadata: Metadata
+
+
+        @db0.memo(prefix=DATA_PREFIX, singleton=True)
+        @dataclass
+        class Root:
+            records: list[Record | None] = field(default_factory=list)
+
+
+        db0.init(str(Path(tempfile.mkdtemp()) / "dbzero"), prefix=DATA_PREFIX, autocommit=True)
+
+        root = Root()
+        title = Source(None, "Legal act title")
+        section = Source(title, "Dzial dziewiaty")
+        chapter = Source(section, "Rozdzial I")
+        article = Source(chapter, "Art. 1.")
+        record = Record(Metadata(title=title, source=article))
+
+        root.records.extend([None, record])
+        print("stored", flush=True)
+        db0.close()
+        print("closed", flush=True)
+        """
+    )
+
+    assert_intern_script_exits_cleanly(result)
+    assert "stored" in result.stdout
+    assert "closed" in result.stdout
+
+
+@pytest.mark.skip(reason=SHUTDOWN_LIFETIME_SKIP_REASON)
+def test_nested_interned_immutable_keyword_factory_record_gets_uuid():
+    result = run_intern_script(
+        """
+        from __future__ import annotations
+
+        from dataclasses import dataclass
+        from pathlib import Path
+        import tempfile
+
+        import dbzero as db0
+
+        DATA_PREFIX = "/tests/intern/keyword-factory-record"
+
+
+        @db0.memo(prefix=DATA_PREFIX, immutable=True, intern=True)
+        @dataclass
+        class Source:
+            parent: Source | None
+            contents: str
+
+            @classmethod
+            def root(cls, contents: str) -> Source:
+                return cls(parent=None, contents=contents)
+
+            @classmethod
+            def from_path(cls, root: Source, path: str) -> Source:
+                source = root
+                for part in path.split("/"):
+                    source = cls(parent=source, contents=part)
+                return source
+
+
+        @db0.memo(prefix=DATA_PREFIX, immutable=True, intern=True)
+        @dataclass
+        class Metadata:
+            title: Source
+            subtitle: str
+            source: Source
+
+
+        @db0.memo(prefix=DATA_PREFIX, immutable=True, intern=True)
+        @dataclass
+        class Record:
+            id: int
+            content: str
+            metadata: Metadata
+
+            @classmethod
+            def from_schema_data(cls, data):
+                title = Source.root(data["title"])
+                source = Source.from_path(title, data["source"])
+                return cls(
+                    id=int(data["id"]),
+                    content=data["content"],
+                    metadata=Metadata(
+                        title=title,
+                        subtitle=data["subtitle"],
+                        source=source,
+                    ),
+                )
+
+
+        db0.init(str(Path(tempfile.mkdtemp()) / "dbzero"), prefix=DATA_PREFIX, autocommit=True)
+
+        record = Record.from_schema_data(
+            {
+                "id": "2",
+                "content": "Legal text excerpt body.",
+                "title": "Legal act title",
+                "subtitle": "Legal act subtitle",
+                "source": "Dzial dziewiaty/Rozdzial I/Art. 1.",
+            }
+        )
+        print("uuid-start", flush=True)
+        print(db0.uuid(record), flush=True)
+        db0.close()
+        print("closed", flush=True)
+        """
+    )
+
+    assert_intern_script_exits_cleanly(result)
+    assert "uuid-start" in result.stdout
+    assert "closed" in result.stdout
+
+
 def test_standalone_interned_object_reuses_existing_instance(db0_fixture):
     first = db0.materialized(MemoInternLeaf("dedupe"))
     db0.clear_cache()

{dbzero-0.3.5 → dbzero-0.3.7}/python_tests/test_memo_no_cache.py

@@ -66,7 +66,7 @@ def test_excluding_no_cache_instances_from_P0_cache(db0_fixture):
     gc.collect()        
     final_cache_size = db0.get_cache_stats()["P_size"]["P0"]
     # make sure cache utilization is low
-    assert abs(final_cache_size - initial_cache_size) < (350 << 10)
+    assert abs(final_cache_size - initial_cache_size) < (400 << 10)
 
 
 def test_fetching_no_cache_objects(db0_fixture):

{dbzero-0.3.5 → dbzero-0.3.7}/python_tests/test_memo_singleton.py

@@ -61,8 +61,8 @@ def test_find_singleton_static_scope(db0_fixture):
     assert db0.find_singleton(MemoDataPxSingleton) is None
     obj_1 = MemoDataPxSingleton(789)
     assert db0.find_singleton(MemoDataPxSingleton) is obj_1
-    
-    
+
+
 def test_find_singleton(db0_fixture):
     assert db0.find_singleton(MemoTestSingleton) is None    
     # create on default prefix
@@ -81,4 +81,4 @@ def test_singleton_with_migrations(db0_fixture):
 def test_assembling_dyn_prefix_function(db0_fixture):
     assert __dyn_prefix(MemoTestSingleton) is None
     assert __dyn_prefix(MemoScopedSingleton) is not None
-    
+    

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/Memo.cpp

@@ -226,15 +226,11 @@ namespace db0::python
     template <typename MemoImplT>
     void PyAPI_MemoObject_del(MemoImplT *memo_obj)
     {
+        PY_DEALLOC_GUARD();
         PY_API_FUNC
-        if (Py_IsInitialized())
-        {
-            // destroy associated db0 Object instance
-            memo_obj->destroy();
-            // Skip deallocation during/after Python finalization
-            // Python Garbage Collector might be finalized (i.e. destroyed) at this point
-            Py_TYPE(memo_obj)->tp_free((PyObject*)memo_obj);
-        }
+        // destroy associated db0 Object instance
+        memo_obj->destroy();
+        Py_TYPE(memo_obj)->tp_free((PyObject*)memo_obj);
     }
     
     template <typename MemoImplT>

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/PyAtomic.cpp

@@ -26,6 +26,7 @@ namespace db0::python
     
     void PyAPI_PyAtomic_del(PyAtomic* self)
     {
+        PY_DEALLOC_GUARD();
         PY_API_FUNC
         self->destroy();
         Py_TYPE(self)->tp_free((PyObject*)self);

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/PyLocked.cpp

@@ -29,6 +29,7 @@ namespace db0::python
     
     void PyAPI_PyLocked_del(PyLocked* self)
     {
+        PY_DEALLOC_GUARD();
         PY_API_FUNC
         self->destroy();
         Py_TYPE(self)->tp_free((PyObject*)self);

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/PyLocks.hpp

@@ -24,6 +24,26 @@ namespace db0::python
 
 {
 
+    inline bool isPythonFinalizing()
+    {
+#if PY_VERSION_HEX >= 0x030D0000
+        return Py_IsFinalizing();
+#else
+        return _Py_IsFinalizing();
+#endif
+    }
+
+// Avoid running dbzero/Python cleanup from tp_dealloc while the interpreter is
+// finalizing. This surfaced as a shutdown SIGSEGV after an unhandled Python
+// exception left nested durable objects alive; deallocators tried to enter the
+// dbzero API lock / Python C API after finalization had started.
+#define PY_DEALLOC_GUARD() \
+    do { \
+        if (!Py_IsInitialized() || db0::python::isPythonFinalizing()) { \
+            return; \
+        } \
+    } while (false)
+
     struct GIL_Lock
     {
         PyGILState_STATE m_state;

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/PyObjectTagManager.cpp

@@ -32,6 +32,7 @@ namespace db0::python
 
     void PyAPI_PyObjectTagManager_del(PyObjectTagManager* tags_obj)
     {
+        PY_DEALLOC_GUARD();
         PY_API_FUNC
         // destroy associated DB0 instance
         tags_obj->destroy();

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/PyReadOnly.cpp

@@ -277,6 +277,7 @@ namespace db0::python
 
     void PyAPI_PyReadOnly_del(PyReadOnly* self)
     {
+        PY_DEALLOC_GUARD();
         PY_API_FUNC
         self->destroy();
         Py_TYPE(self)->tp_free((PyObject*)self);

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/PySnapshot.cpp

@@ -18,7 +18,8 @@ namespace db0::python
     }
     
     void PyAPI_PySnapshot_del(PySnapshotObject* snapshot_obj)
-    {        
+    {
+        PY_DEALLOC_GUARD();
         // NOTE: it's safe to destroy without API lock (not a v_object)
         // also API lock here would result in a deadlock        
         snapshot_obj->destroy();

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/PyTagSet.cpp

@@ -21,7 +21,8 @@ namespace db0::python
     };
     
     void PyAPI_PyTagSet_del(PyTagSet *py_tag_set)
-    {      
+    {
+        PY_DEALLOC_GUARD();
         py_tag_set->m_tag_set.~TagSet();
         PyObject_Del(py_tag_set);
     }

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/PyToolkit.cpp

@@ -1380,8 +1380,8 @@ namespace db0::python
             return {};            
         } 
 
-        if (!Py_IsInitialized()) {
-            // Simply return the lock after python instance was finalized
+        if (!Py_IsInitialized() || isPythonFinalizing()) {
+            // Simply return the lock after Python is finalizing/finalized.
             // This is safe because fixture threads should be stopped at this point
             return SafeRLock(m_api_mutex);
         }
@@ -1453,7 +1453,7 @@ namespace db0::python
     }
 
     bool PyToolkit::isValid() {
-        return Py_IsInitialized();
+        return Py_IsInitialized() && !isPythonFinalizing();
     }
         
     bool PyToolkit::hasTagRefs(ObjectPtr obj_ptr)

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/PyWeakProxy.cpp

@@ -14,6 +14,7 @@ namespace db0::python
     
     void PyAPI_PyWeakProxy_del(PyWeakProxy *py_weak_proxy)
     {
+        PY_DEALLOC_GUARD();
         PY_API_FUNC
         if (py_weak_proxy->m_py_object) {
             Py_DECREF(py_weak_proxy->m_py_object);            

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/collections/PyByteArray.cpp

@@ -279,6 +279,7 @@ namespace db0::python
     
     void PyAPI_ByteArrayObject_del(ByteArrayObject* bytearray_obj)
     {
+        PY_DEALLOC_GUARD();
         PY_API_FUNC
         // destroy associated DB0 ByteArray instance
         bytearray_obj->destroy();

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/collections/PyDict.cpp

@@ -126,6 +126,7 @@ namespace db0::python
     
     void PyAPI_DictObject_del(DictObject* dict_obj)
     {
+        PY_DEALLOC_GUARD();
         PY_API_FUNC
         // destroy associated DB0 Dict instance
         dict_obj->destroy();

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/collections/PyDictView.cpp

@@ -77,6 +77,7 @@ namespace db0::python
     
     void PyAPI_DictViewObject_del(DictViewObject* dict_obj)
     {
+        PY_DEALLOC_GUARD();
         PY_API_FUNC
         // destroy associated DB0 Dict instance
         dict_obj->ext().~DictView();

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/collections/PyIndex.cpp

@@ -51,6 +51,7 @@ namespace db0::python
     
     void PyAPI_IndexObject_del(IndexObject* index_obj)
     {
+        PY_DEALLOC_GUARD();
         PY_API_FUNC
         // destroy associated DB0 Index instance
         index_obj->destroy();

{dbzero-0.3.5 → dbzero-0.3.7}/src/dbzero/bindings/python/collections/PyIterator.hpp

@@ -19,6 +19,7 @@ namespace db0::python
     template <typename IteratorObjectT> 
     void IteratorObject_del(IteratorObjectT* self)
     {
+        PY_DEALLOC_GUARD();
         PY_API_FUNC
         // destroy associated DB0 instance
         // calls destructor of ext object