dbzero 0.4.2__tar.gz → 0.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbzero
-Version: 0.4.2
+Version: 0.5.0
 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.4.2 → dbzero-0.5.0}/dbzero/dbzero/dbzero.pyi

@@ -31,6 +31,7 @@ def open(prefix_name: str, open_mode: str = "rw", **kwargs: Any) -> None:
         * autocommit (bool) to disable automatic commits for this prefix
         * restricted (bool) to restrict memo reflection access for this prefix
         * restricted_context (ContextVar) to dynamically restrict memo reflection access for this prefix
+        * no_auto_migrate (bool) to disable automatic tag-field schema migration
         * slab_size (int) for memory slab allocation size in bytes
         * meta_io_step_size (int) for metadata I/O operation chunk size
         * lock_flags (dict) to change locking behavior when opening the prefix for read-write
@@ -56,6 +57,10 @@ def open(prefix_name: str, open_mode: str = "rw", **kwargs: Any) -> None:
     """
     ...
 
+def migrate(memo_type: type) -> None:
+    """Apply pending schema migration for a memo type."""
+    ...
+
 def set_restricted(*, restricted: Optional[bool] = None, restricted_context: Any = None,
                    prefix: Optional[str] = None) -> None:
     """Increase memo restricted-access mode globally or for an open prefix.

{dbzero-0.4.2 → dbzero-0.5.0}/dbzero/dbzero/initialization.py

@@ -42,7 +42,10 @@ def init(dbzero_root: str, **kwargs: Any) -> None:
 
     init_kwargs = {}
     
-    config_keys = ("autocommit", "autocommit_interval", "cache_size", "lang_cache_size")
+    if "no_auto_migration" in kwargs and "no_auto_migrate" not in kwargs:
+        kwargs["no_auto_migrate"] = kwargs["no_auto_migration"]
+
+    config_keys = ("autocommit", "autocommit_interval", "cache_size", "lang_cache_size", "no_auto_migrate")
     config = {}
     for key in config_keys:
         if key in kwargs:

{dbzero-0.4.2 → dbzero-0.5.0}/dbzero/dbzero/memo.py

@@ -7,6 +7,44 @@ from typing import Callable, Optional
 from .dbzero import _wrap_memo_type, set_prefix
 
 
+__DBZERO_TAG_FIELDS_ATTR = "__DBZERO_TAG_FIELDS_ATTR"
+
+
+def _normalize_tag_fields(field_names):
+    tag_fields = []
+    seen = set()
+    for field_name in field_names:
+        if not isinstance(field_name, str):
+            raise TypeError("tag_fields arguments must be strings")
+        if field_name not in seen:
+            seen.add(field_name)
+            tag_fields.append(field_name)
+    return tuple(tag_fields)
+
+
+def _merge_tag_field_declarations(*declarations):
+    tag_fields = []
+    seen = set()
+    for declaration in declarations:
+        for field_name in declaration:
+            if field_name not in seen:
+                seen.add(field_name)
+                tag_fields.append(field_name)
+    return tuple(tag_fields)
+
+
+def tag_fields(*field_names):
+    new_fields = _normalize_tag_fields(field_names)
+
+    def wrap(cls):
+        existing_fields = getattr(cls, __DBZERO_TAG_FIELDS_ATTR, ())
+        merged_fields = _merge_tag_field_declarations(existing_fields, new_fields)
+        setattr(cls, __DBZERO_TAG_FIELDS_ATTR, merged_fields)
+        return cls
+
+    return wrap
+
+
 def migration(func: Callable) -> Callable:
     """Decorator for marking a function as a migration function"""
     func._db0_migration = None
@@ -271,9 +309,12 @@ def memo(cls: Optional[type] = None, **kwargs) -> type:
             dyn_prefix = None
             init_vars = []
         
+        tag_field_names = list(getattr(cls_, __DBZERO_TAG_FIELDS_ATTR, ()))
+
         wrapped = _wrap_memo_type(cls_, py_file = getfile(cls_), py_init_vars = init_vars, py_dyn_prefix = dyn_prefix, \
-            py_migrations = list(find_migrations(cls_)) if is_singleton else None, **kwargs
+            py_migrations = list(find_migrations(cls_)) if is_singleton else None, py_tag_fields = tag_field_names, **kwargs
         )
+        setattr(wrapped, __DBZERO_TAG_FIELDS_ATTR, tuple(tag_field_names))
         
         # Call __init_subclass__ on the wrapped class for any base that defines it.
         # Python normally calls __init_subclass__ before the decorator runs, so the 

{dbzero-0.4.2 → dbzero-0.5.0}/dbzero/setup.py

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

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

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

@@ -47,6 +47,26 @@ def test_enum_tags_are_distinguished_from_string_values(db0_fixture):
     assert set([x.value for x in db0.find(Colors.RED)]) == set([1])
 
 
+def test_enum_tags_are_not_treated_as_passive_tags(db0_fixture):
+    Colors = db0.enum("Colors", ["RED", "GREEN", "BLUE"])
+    db0.tags(MemoTestClass(1)).add(Colors.RED)
+    db0.tags(MemoTestClass(2), passive=True).add("passive-tag")
+
+    assert set([x.value for x in db0.find(Colors.RED)]) == {1}
+    with pytest.raises(Exception):
+        list(db0.find("passive-tag"))
+
+
+def test_enum_tag_can_anchor_passive_tag_query(db0_fixture):
+    Colors = db0.enum("Colors", ["RED", "GREEN", "BLUE"])
+    obj = MemoTestClass(1)
+    db0.tags(obj).add(Colors.RED)
+    db0.tags(obj, passive=True).add("passive-tag")
+    db0.tags(MemoTestClass(2), passive=True).add("passive-tag")
+
+    assert set([x.value for x in db0.find(Colors.RED, "passive-tag")]) == {1}
+
+
 def test_enum_type_defines_values_method(db0_fixture):
     Colors = db0.enum("Colors", ["RED", "GREEN", "BLUE"])
     assert len(Colors.values()) == 3

{dbzero-0.4.2 → dbzero-0.5.0}/python_tests/test_find.py

@@ -237,31 +237,43 @@ def test_remove_tags_then_find_typed(db0_fixture):
     assert len(list(db0.find(MemoTestClass, "one"))) == 0
 
 
-def test_query_result_cannot_be_used_as_tag_target(db0_fixture):
-    objects = [MemoTestClass(i) for i in range(4)]
-    db0.tags(objects[0]).add("source")
-    db0.tags(objects[1]).add("source")
+def test_add_tags_to_query_result(db0_fixture):
+    objects = [MemoTestClass(i) for i in range(6)]
+    db0.tags(objects[0]).add(["token-a", "token-b"])
+    db0.tags(objects[1]).add("token-a")
+    db0.tags(objects[2]).add(["token-a", "token-b"])
+    db0.tags(objects[3]).add("token-b")
 
-    with pytest.raises(RuntimeError, match="memo objects"):
-        db0.tags(db0.find("source"))
+    db0.tags(db0.find("token-a", "token-b")).add("token-c")
 
-    with pytest.raises(RuntimeError, match="memo objects"):
-        db0.tags(objects[2], db0.find("source"))
+    assert {item.value for item in db0.find("token-c")} == {0, 2}
 
-    db0.tags(objects[2]).add("batch")
-    assert {item.value for item in db0.find("batch")} == {2}
 
+def test_remove_tags_from_query_result(db0_fixture):
+    objects = [MemoTestClass(i) for i in range(5)]
+    db0.tags(objects[0]).add(["token-a", "keep"])
+    db0.tags(objects[1]).add("token-a")
+    db0.tags(objects[2]).add(["token-a", "other"])
+    db0.tags(objects[3]).add("other")
 
-def test_snapshot_query_cannot_be_used_as_tag_target(db0_fixture):
-    obj = MemoTestClass(1)
-    db0.tags(obj).add("source")
-    db0.commit()
+    db0.tags(db0.find("token-a")).remove("token-a")
 
-    with db0.snapshot() as snap:
-        with pytest.raises(RuntimeError, match="memo objects"):
-            db0.tags(snap.find("source"))
+    assert list(db0.find("token-a")) == []
+    assert {item.value for item in db0.find("keep")} == {0}
+    assert {item.value for item in db0.find("other")} == {2, 3}
+
+
+def test_query_tag_target_can_be_empty_or_mixed_with_memo_target(db0_fixture):
+    objects = [MemoTestClass(i) for i in range(4)]
+    db0.tags(objects[0]).add("source")
+    db0.tags(objects[1]).add("source")
+
+    db0.tags(db0.find("missing")).add("batch")
+    assert list(db0.find("batch")) == []
 
-    assert list(db0.find("source")) == [obj]
+    db0.tags(objects[2], db0.find("source")).add(["batch", "extra"])
+    assert {item.value for item in db0.find("batch")} == {0, 1, 2}
+    assert {item.value for item in db0.find("extra")} == {0, 1, 2}
 
     
 def test_query_by_non_existing_tag(db0_fixture):