dbzero 0.5.0__tar.gz → 0.5.2__tar.gz

{dbzero-0.5.0 → dbzero-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbzero
-Version: 0.5.0
+Version: 0.5.2
 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.5.0 → dbzero-0.5.2}/dbzero/setup.py

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

{dbzero-0.5.0 → dbzero-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ['meson-python']
 
 [project]
 name = 'dbzero'
-version = '0.5.0'
+version = '0.5.2'
 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.5.0 → dbzero-0.5.2}/python_tests/test_enum.py

@@ -191,6 +191,14 @@ def test_enum_value_as_default_param(db0_fixture):
     assert func_to_test() == ColorsEnum.RED
     assert func_to_test(ColorsEnum.GREEN) == ColorsEnum.GREEN
     assert func_to_test(ColorsEnum.BLUE) == ColorsEnum.BLUE
+
+
+def test_enum_value_repr_can_be_added_as_tag(db0_fixture):
+    obj = MemoTestClass(1)
+
+    db0.tags(obj).add(func_to_test())
+
+    assert list(db0.find(ColorsEnum.RED)) == [obj]
     
     
 def test_enum_value_value_repr_compare(db0_fixture):

{dbzero-0.5.0 → dbzero-0.5.2}/python_tests/test_tag_fields.py

@@ -1,14 +1,34 @@
 # 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
 import dbzero as db0
+from dataclasses import dataclass
 from dbzero.dbzero import _get_tag_fields
 from .memo_test_types import MemoTestClass, KVTestClass
 
 
 _TAG_FIELDS_ATTR = "__DBZERO_TAG_FIELDS_ATTR"
 
+TagFieldDataclassDefaultStatus = db0.enum(
+    "TagFieldDataclassDefaultStatus",
+    values=["lead", "archived"],
+)
+TagFieldDataclassDefaultStatusValue = type(TagFieldDataclassDefaultStatus.lead)
+
+
+@db0.memo
+@db0.tag_fields("status")
+@dataclass(eq=False)
+class DataclassEnumDefaultTag:
+    name: str
+    status: TagFieldDataclassDefaultStatusValue = TagFieldDataclassDefaultStatus.lead
+
 
 def _query_names(memo_type, *tags):
     return {obj.name for obj in db0.find(memo_type, *tags)}
@@ -151,6 +171,81 @@ def test_initial_tag_is_hidden_until_init_completes(db0_fixture):
     assert list(db0.find(BufferedInitialTag, "open")) == [obj]
 
 
+def test_dataclass_enum_default_is_valid_initial_tag(db0_fixture):
+    obj = DataclassEnumDefaultTag("Avery")
+
+    assert obj.status == TagFieldDataclassDefaultStatus.lead
+    assert list(db0.find(DataclassEnumDefaultTag, TagFieldDataclassDefaultStatus.lead)) == [obj]
+
+
+@pytest.mark.parametrize(
+    "manual_tag_operation",
+    [
+        "db0.tags(self).add(db0.as_tag(self.agent))",
+        'db0.tags(self).add("TAG_X")',
+    ],
+)
+def test_manual_tag_during_dataclass_tag_field_post_init_does_not_crash(tmp_path, manual_tag_operation):
+    script = textwrap.dedent(
+        f"""
+        from dataclasses import dataclass
+        import os
+
+        import dbzero as db0
+
+        @db0.memo
+        class Agent:
+            def __init__(self, role):
+                self.role = role
+
+        @db0.memo
+        @db0.tag_fields("agent")
+        @dataclass
+        class JobDef:
+            agent: Agent
+
+            def __post_init__(self):
+                {manual_tag_operation}
+
+        db_path = {str(tmp_path / "db0")!r}
+        os.mkdir(db_path)
+        db0.init(db_path, read_write=True)
+        db0.open("test", "rw")
+
+        agent = Agent("test-agent")
+        job_def = JobDef(agent=agent)
+        assert job_def.agent.role == "test-agent"
+        db0.close()
+        """
+    )
+
+    env = os.environ.copy()
+    env["PYTHONDONTWRITEBYTECODE"] = "1"
+    env["PYTHONFAULTHANDLER"] = "1"
+    try:
+        result = subprocess.run(
+            [sys.executable, "-c", script],
+            check=False,
+            env=env,
+            text=True,
+            capture_output=True,
+            timeout=10,
+        )
+    except subprocess.TimeoutExpired as exc:
+        pytest.fail(
+            f"manual tag during tag_fields post-init timed out for {manual_tag_operation!r}\n"
+            f"stdout:\n{exc.stdout or ''}\n"
+            f"stderr:\n{exc.stderr or ''}"
+        )
+
+    assert result.returncode == 0, (
+        f"manual tag during tag_fields post-init failed for {manual_tag_operation!r} "
+        f"with code {result.returncode}\n"
+        f"stdout:\n{result.stdout}\n"
+        f"stderr:\n{result.stderr}"
+    )
+
+
 def test_initial_tags_use_final_values_and_flush_together(db0_fixture):
     @db0.memo
     @db0.tag_fields("status", "owner")

{dbzero-0.5.0 → dbzero-0.5.2}/src/dbzero/bindings/python/PyInternalAPI.cpp

@@ -969,7 +969,7 @@ namespace db0::python
 
         db0::FixtureLock lock(memo_obj->ext().getFixture());
         // materialize by calling postInit
-        memo_obj->modifyExt().postInit(lock);
+        memo_obj->modifyExt().postInit(lock, reinterpret_cast<PyObject *>(memo_obj));
         if (!memo_obj->ext().getType().isNoCache()) {
             memo_obj->ext().getFixture()->getLangCache().add(memo_obj->ext().getAddress(), memo_obj);
         }

{dbzero-0.5.0 → dbzero-0.5.2}/src/dbzero/object_model/tags/TagIndex.cpp

@@ -260,6 +260,7 @@ namespace db0::object_model
             case TypeId::MEMO_IMMUTABLE_OBJECT:
             case TypeId::DB0_TAG:
             case TypeId::DB0_ENUM_VALUE:
+            case TypeId::DB0_ENUM_VALUE_REPR:
             case TypeId::DB0_FIELD_DEF:
             case TypeId::DB0_CLASS:
                 return;
@@ -1295,6 +1296,8 @@ namespace db0::object_model
             return tryAddShortTagFromTag(py_arg);
         } else if (type_id == TypeId::DB0_ENUM_VALUE) {
             return getShortTagFromEnumValue(py_arg);
+        } else if (type_id == TypeId::DB0_ENUM_VALUE_REPR) {
+            return getShortTagFromEnumValueRepr(py_arg);
         } else if (type_id == TypeId::DB0_FIELD_DEF) {
             return getShortTagFromFieldDef(py_arg);
         } else if (type_id == TypeId::DB0_CLASS) {