dbzero 0.3.6__tar.gz → 0.4.0__tar.gz

{dbzero-0.3.6 → dbzero-0.4.0}/.github/workflows/build-mac-wheel.yml

@@ -43,6 +43,8 @@ jobs:
   build-macos:
     runs-on: macos-latest
     timeout-minutes: ${{ fromJSON(inputs.timeout-minutes) }}
+    env:
+      MACOSX_DEPLOYMENT_TARGET: '11.0'
     steps:
       - uses: actions/checkout@v4
       

{dbzero-0.3.6 → dbzero-0.4.0}/AGENTS.md

@@ -20,7 +20,7 @@ All tests must pass before a change is considered complete.
 - Release build: `./scripts/build.sh -r`
 - Release build with C++ unit test binary: `./scripts/build.sh -r -t`
 - For regular development and focused Python-side test runs, prefer the release build because it is significantly faster. Unless C++ tests are important for the current change, build without `-t`; skipping the C++ test binary is much faster.
-- Use a debug build when tracking a specific deep bug that needs assertions or debug-level checks, and before final handoff only when the user explicitly asks for handoff validation.
+- Use debug builds only when tracking a specific deep bug that needs assertions/debug-level checks, or when the user explicitly asks for debug validation. Do not run debug validation as a default final handoff step.
 
 ### Running tests
 
@@ -28,7 +28,7 @@ All tests must pass before a change is considered complete.
 - Final Python test checks: `./scripts/run_tests.sh -j 6`
 - C++ tests after a `-t` build: `./build/release/tests.x`
 - Broad debug/release builds and full-suite checks are final handoff validation only; run them when the user explicitly asks for handoff.
-- Before final handoff, also verify the code in debug mode with a debug build (`./scripts/build.sh -d`) and the relevant Python tests against that debug build. Debug assertions are part of the required validation, not optional diagnostics.
+- For normal development and handoff, validate against release builds. Run debug-mode tests only when debugging a hard-to-locate problem or when the user explicitly requests them.
 - During development, do not run stress tests by default; they are intentionally slow. Run focused tests specific to the feature or refactor being worked on before finalization.
 - If any C++ source under the native/core part of the project was modified, also run the C++ test suite during final handoff validation (do not rely on the Python tests alone to cover native changes).
 
@@ -40,10 +40,6 @@ Never mark a task done while tests are failing.
 
 Never make cosmetic changes unless they are explicitly requested by the task.
 
-### Temporary immutable objects design
-
-When working on immutable objects, use `design/IMMUTABLE_OBJECTS_DESIGN.md` as the implementation design reference. This file is temporary and should be removed after the feature is complete.
-
 ### v_object constructor conventions
 
 Types derived from `v_object` should follow the project-wide constructor pattern:

{dbzero-0.3.6 → dbzero-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbzero
-Version: 0.3.6
+Version: 0.4.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
@@ -517,10 +517,9 @@ Requires-Python: >=3.9
 Requires-Dist: fasteners==0.19
 Description-Content-Type: text/markdown
 
-<picture align="center">
-  <source media="(prefers-color-scheme: dark)" srcset="https://dbzero.io/images/white-01.svg">
-  <img alt="Dbzero logo" src="https://dbzero.io/images/dbzero-logo.png">
-</picture>
+<p align="center">
+  <img alt="dbzero logo" src="assets/dbzero-logo.png" width="420">
+</p>
 
 
 **A state management system for Python 3.x that unifies your application's business logic, data persistence, and caching into a single, efficient layer.**
@@ -605,6 +604,22 @@ if __name__ == "__main__":
 
 The application state is persisted automatically; the same data will be available the next time the app starts. All objects are automatically managed by dbzero and there's no need for explicit conversions, fetching, or saving — dbzero handles persistence transparently for the entire object graph.
 
+## Example Project and Utilities
+
+### Simple CRM
+
+[simple-crm](https://github.com/dbzero-software/simple-crm) is a small tutorial app that shows how to build a persistent Python internal tool with dbzero and NiceGUI. It tracks companies, contacts, notes, tags, and follow-up tasks using dbzero-backed Python objects instead of a separate REST API, ORM, cache layer, or database server.
+
+<p>
+  <a href="https://github.com/dbzero-software/simple-crm">
+    <img alt="Simple CRM browser interface" src="https://github.com/dbzero-software/simple-crm/raw/master/docs/simple-crm-screenshot.png" width="520">
+  </a>
+</p>
+
+### dbzero-modelkit
+
+[dbzero-modelkit](https://github.com/dbzero-software/dbzero-modelkit) is an open-source package of reusable model primitives for dbzero-friendly Python apps. It includes utilities for sparse calendars, active date windows, month-indexed storage, multilingual strings, FIFO queues, and tag-based object locks.
+
 ## Core Concepts
 
 ### Memo Classes

{dbzero-0.3.6 → dbzero-0.4.0}/README.md

@@ -1,7 +1,6 @@
-<picture align="center">
-  <source media="(prefers-color-scheme: dark)" srcset="https://dbzero.io/images/white-01.svg">
-  <img alt="Dbzero logo" src="https://dbzero.io/images/dbzero-logo.png">
-</picture>
+<p align="center">
+  <img alt="dbzero logo" src="assets/dbzero-logo.png" width="420">
+</p>
 
 
 **A state management system for Python 3.x that unifies your application's business logic, data persistence, and caching into a single, efficient layer.**
@@ -86,6 +85,22 @@ if __name__ == "__main__":
 
 The application state is persisted automatically; the same data will be available the next time the app starts. All objects are automatically managed by dbzero and there's no need for explicit conversions, fetching, or saving — dbzero handles persistence transparently for the entire object graph.
 
+## Example Project and Utilities
+
+### Simple CRM
+
+[simple-crm](https://github.com/dbzero-software/simple-crm) is a small tutorial app that shows how to build a persistent Python internal tool with dbzero and NiceGUI. It tracks companies, contacts, notes, tags, and follow-up tasks using dbzero-backed Python objects instead of a separate REST API, ORM, cache layer, or database server.
+
+<p>
+  <a href="https://github.com/dbzero-software/simple-crm">
+    <img alt="Simple CRM browser interface" src="https://github.com/dbzero-software/simple-crm/raw/master/docs/simple-crm-screenshot.png" width="520">
+  </a>
+</p>
+
+### dbzero-modelkit
+
+[dbzero-modelkit](https://github.com/dbzero-software/dbzero-modelkit) is an open-source package of reusable model primitives for dbzero-friendly Python apps. It includes utilities for sparse calendars, active date windows, month-indexed storage, multilingual strings, FIFO queues, and tag-based object locks.
+
 ## Core Concepts
 
 ### Memo Classes

{dbzero-0.3.6 → dbzero-0.4.0}/benchmarks/tagging.py

@@ -19,45 +19,24 @@ Observed on this workspace:
 - Build: release
 - Commands:
   python3 benchmarks/tagging.py --scenario fresh-tags --target-seconds 30
-  python3 benchmarks/tagging.py --scenario fresh-tags --target-seconds 30 --passive
   python3 benchmarks/tagging.py --scenario precreated-tags --target-seconds 30
-  python3 benchmarks/tagging.py --scenario precreated-tags --target-seconds 30 --passive
 - Current result, fresh-tags:
-  regular:
-    object_count=10000
-    batch_size=1000
-    tags_per_batch=1
-    batches=1442
-    elapsed_seconds=30.012787
-    tag_assignments=1442000
-    tag_assignments_per_second=48046.187
-  passive:
-    object_count=10000
-    batch_size=1000
-    tags_per_batch=1
-    batches=1546
-    elapsed_seconds=30.021849
-    tag_assignments=1546000
-    tag_assignments_per_second=51495.829
+  object_count=10000
+  batch_size=1000
+  tags_per_batch=1
+  batches=1442
+  elapsed_seconds=30.012787
+  tag_assignments=1442000
+  tag_assignments_per_second=48046.187
 - Current result, precreated-tags:
-  regular:
-    object_count=10000
-    batch_size=1000
-    tags_per_batch=1
-    precreated_tag_count=5000
-    batches=1334
-    elapsed_seconds=30.006962
-    tag_assignments=1334000
-    tag_assignments_per_second=44456.349
-  passive:
-    object_count=10000
-    batch_size=1000
-    tags_per_batch=1
-    precreated_tag_count=5000
-    batches=1484
-    elapsed_seconds=30.018302
-    tag_assignments=1484000
-    tag_assignments_per_second=49436.507
+  object_count=10000
+  batch_size=1000
+  tags_per_batch=1
+  precreated_tag_count=5000
+  batches=1334
+  elapsed_seconds=30.006962
+  tag_assignments=1334000
+  tag_assignments_per_second=44456.349
 """
 
 import argparse
@@ -96,27 +75,27 @@ def prepare_objects(object_count, batch_size):
     return objects, target_objects
 
 
-def prepare_precreated_tags(tag_count, passive):
+def prepare_precreated_tags(tag_count):
     tag_owner = TagBenchmarkMemo(-1)
     db0.commit()
     tags = [
-        f"{'passive' if passive else 'regular'}-precreated-tag-{index}"
+        f"precreated-tag-{index}"
         for index in range(tag_count)
     ]
-    db0.tags(tag_owner, passive=passive).add(tags)
+    db0.tags(tag_owner).add(tags)
     db0.commit()
     return tag_owner, tags
 
 
-def apply_tag_batch(target_objects, tags, passive):
-    db0.tags(*target_objects, passive=passive).add(tags)
+def apply_tag_batch(target_objects, tags):
+    db0.tags(*target_objects).add(tags)
     db0.commit()
     return len(target_objects) * len(tags)
 
 
-def fresh_tag_batch(passive, batch_index, tags_per_batch):
+def fresh_tag_batch(batch_index, tags_per_batch):
     return [
-        f"{'passive' if passive else 'regular'}-fresh-tag-{batch_index}-{index}"
+        f"fresh-tag-{batch_index}-{index}"
         for index in range(tags_per_batch)
     ]
 
@@ -129,7 +108,7 @@ def precreated_tag_batch(tags, batch_index, tags_per_batch):
     return tags[start:end]
 
 
-def measure(target_objects, passive, target_seconds, tags_per_batch, tag_batch_factory):
+def measure(target_objects, target_seconds, tags_per_batch, tag_batch_factory):
     total_assignments = 0
     batches = 0
     exhausted_tags = False
@@ -143,7 +122,7 @@ def measure(target_objects, passive, target_seconds, tags_per_batch, tag_batch_f
             if tags is None:
                 exhausted_tags = True
                 break
-            total_assignments += apply_tag_batch(target_objects, tags, passive)
+            total_assignments += apply_tag_batch(target_objects, tags)
             batches += 1
             if time.perf_counter() >= deadline:
                 break
@@ -161,7 +140,6 @@ def main():
         choices=("fresh-tags", "precreated-tags"),
         default="fresh-tags",
     )
-    parser.add_argument("--passive", action="store_true", help="assign passive tags")
     parser.add_argument("--target-seconds", type=float, default=30.0)
     parser.add_argument("--object-count", type=int, default=10000)
     parser.add_argument("--batch-size", type=int, default=1000)
@@ -193,13 +171,11 @@ def main():
             if args.precreated_tag_count < args.tags_per_batch:
                 parser.error("--precreated-tag-count must cover at least one measured batch")
             precreated_tag_owner, precreated_tags = prepare_precreated_tags(
-                args.precreated_tag_count,
-                args.passive,
+                args.precreated_tag_count
             )
 
         if args.scenario == "fresh-tags":
             tag_batch_factory = lambda batch: fresh_tag_batch(
-                args.passive,
                 batch,
                 args.tags_per_batch,
             )
@@ -212,7 +188,6 @@ def main():
 
         elapsed, assignments, batches, exhausted_tags = measure(
             target_objects,
-            args.passive,
             args.target_seconds,
             args.tags_per_batch,
             tag_batch_factory,
@@ -223,7 +198,6 @@ def main():
         print(f"build_flags={db0.build_flags()}")
         print(f"pid={os.getpid()}")
         print(f"scenario={args.scenario}")
-        print(f"passive={args.passive}")
         print(f"object_count={len(objects)}")
         print(f"batch_size={args.batch_size}")
         print(f"tags_per_batch={args.tags_per_batch}")

{dbzero-0.3.6 → dbzero-0.4.0}/dbzero/build_package.sh

@@ -1,3 +1,6 @@
+#!/bin/bash
+set -euo pipefail
+
 function show_help {
     echo "Build dbzero python package in the ./build directory and optionally install it"
     echo "Use: build_package.sh [options]"
@@ -7,7 +10,7 @@ function show_help {
 }
 
 while true ; do
-    case "$1" in
+    case "${1-}" in
         -h|--help) show_help ; shift ;;
         --install) INSTALL="1" ; shift ;;
         --) shift ; break ;;
@@ -15,18 +18,23 @@ while true ; do
     esac
 done
 
-mkdir .build
-mkdir .build/dbzero
-cp ./dbzero/* ./.build/dbzero
+if ! python3 -c 'import setuptools' >/dev/null 2>&1; then
+    exit 0
+fi
+
+package_root="$PWD"
+rm -rf .build
+trap 'rm -rf "$package_root/.build"' EXIT
+mkdir -p .build/dbzero
+find ./dbzero -maxdepth 1 -type f -exec cp {} ./.build/dbzero/ \;
 cp setup.py .build/setup.py
 cp LICENSE .build/LICENSE
 cp README.md .build/README.md
 cd .build
 python3 setup.py sdist
-install "$(ls dbzero_package/dist/*.whl | sort | tail -n 1)" --break-system-packages
 # Get the current Python3 version
 PYTHON3_VERSION=$(python3 -c 'import sys; print(f"{sys.version_info.minor}")')
-if [ "${INSTALL}" ] ; then
+if [ "${INSTALL-}" ] ; then
     if [ "$PYTHON3_VERSION" -ge 11 ]; then
         pip3 install "$(ls ./dist/*.tar.gz | sort | tail -n 1)" --break-system-packages
     else

{dbzero-0.3.6 → dbzero-0.4.0}/dbzero/dbzero/__init__.py

@@ -2,7 +2,6 @@
 # Copyright (c) 2025 DBZero Software sp. z o.o.
 
 from .dbzero import *
-from .dbzero import _check_interned, _in_read_only, _init_data_filter, _init_data_masking
 from .memo import *
 from .enum import *
 from .fast_query import *
@@ -10,7 +9,6 @@ from .reflection_api import *
 from .storage_api import *
 from .atomic import *
 from .locked import *
-from .read_only import *
 from .utilities import taggify
 from .decorators import *
 from .select import *

dbzero-0.4.0/dbzero/dbzero/atomic.py

@@ -0,0 +1,125 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+# Copyright (c) 2025 DBZero Software sp. z o.o.
+
+from __future__ import annotations
+
+from typing import Any, Dict
+from .interfaces import Memo
+from .dbzero import begin_atomic, assign
+
+
+class AtomicManager:
+    """Context manager that provides atomic context functionality for dbzero operations.
+
+    It is intended for use in a 'with' statement. 
+    """
+
+    def __init__(self):
+        self.__ctx = None
+
+    def __enter__(self) -> AtomicManager:
+        self.begin()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if exc_type is None:
+            self.close()
+        else:
+            self.cancel()
+
+    def begin(self):
+        """Begin the atomic context"""
+        if self.__ctx is None:
+            self.__ctx = begin_atomic()
+
+    def close(self):
+        """Close the atomic context, staging the changes for commit"""
+        if self.__ctx is None:
+            return
+
+        self.__ctx.close()
+        self.__ctx = None
+
+    def cancel(self):
+        """Cancel the atomic context, reverting all changes"""
+        if self.__ctx is None:
+            return
+
+        self.__ctx.cancel()
+        self.__ctx = None
+
+
+def atomic() -> AtomicManager:
+    """Open a context manager to group multiple mutating operations into a single indivisible transaction.
+
+    This function ensures that all modifications within  the `with` block are applied together, or none are applied at all.
+    If the block completes successfully, all changes are merged into the current 
+    transaction. If an exception occurs inside the block, or if the transaction is 
+    manually canceled, all changes are reverted, leaving the data in its previous state.
+
+    Returns
+    -------
+    AtomicManager
+        A context manager that provides atomic context functionality.
+
+    Examples
+    --------
+    Grouping successful operations:
+    
+    >>> obj1 = MyMemoClass("initial value")
+    >>> with dbzero.atomic():
+    ...     obj1.value = "updated value"
+    ...     obj2 = MyMemoClass("new object")
+    ...     dbzero.tags(obj2).add("new")
+    >>> # Both changes are now visible
+    >>> assert obj1.value == "updated value"
+
+    Automatic rollback on exception:
+    
+    >>> obj = MyMemoClass(value=100)
+    >>> try:
+    ...     with dbzero.atomic():
+    ...         obj.value = 200  # This change will be reverted
+    ...         raise ValueError("Something went wrong")
+    ... except ValueError:
+    ...     print("Caught expected error.")
+    >>> # The object's value is unchanged
+    >>> assert obj.value == 100
+
+    Manual rollback with cancel():
+    
+    >>> obj = MyMemoClass(value=100)
+    >>> with dbzero.atomic() as atomic:
+    ...     obj.value = 200
+    ...     if obj.value > 150:
+    ...         print("Value too high, canceling.")
+    ...         atomic.cancel()
+    >>> # The changes were discarded
+    >>> assert obj.value == 100
+
+    Notes
+    -----
+    An atomic() block does not immediately create a new, committed transaction or 
+    increment the global state number. Instead, the changes are staged 
+    and applied as part of the surrounding transaction, which is then committed 
+    either manually via dbzero.commit() or by the autocommit mechanism.
+    """
+    return AtomicManager()
+
+
+def atomic_assign(*objects: Memo, **attributes: Dict[str, Any]) -> None:
+    """Perform bulk attribute updates on one or more Memo objects within an atomic transaction.
+
+    This is a helper function that performs `dbzero.assign` operation in an atomic context.
+
+    Parameters
+    ----------
+    *objects : Any
+        A variable number of Memo objects to modify.
+    **attributes : Dict[str, Any]
+        The attributes to update, provided as name=value pairs where each key is 
+        the name of an attribute to update and the corresponding value is the new 
+        value to assign.
+    """
+    with atomic():
+        assign(*objects, **attributes)

{dbzero-0.3.6 → dbzero-0.4.0}/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/debug", "/usr/local/lib/python3/dist-packages/dbzero/"]
+    paths = [os.path.join(os.path.split(__file__)[0]), "/src/dev/build/release", "/usr/local/lib/python3/dist-packages/dbzero/"]
     __file__ = None
     for path in paths:
         if os.path.isdir(path):

{dbzero-0.3.6 → dbzero-0.4.0}/dbzero/dbzero/dbzero.pyi

@@ -2,7 +2,7 @@
 Type stubs for dbzero module.
 """
 
-from typing import Any, Optional, Iterable, Dict, List, Tuple, Union, Callable, Sequence, ContextManager
+from typing import Any, Optional, Iterable, Dict, List, Tuple, Union, Callable, Sequence
 from .interfaces import (
     Memo, MemoWeakProxy, QueryObject, Tag, TagSet, EnumValue,
     ListObject, IndexObject, TupleObject, SetObject, DictObject, ByteArrayObject,
@@ -11,18 +11,6 @@ from .interfaces import (
 
 # Core workspace management functions
 
-def read_only() -> ContextManager[Any]:
-    """Open a context manager that rejects dbzero mutations in its block."""
-    ...
-
-def _in_read_only() -> bool:
-    """Return whether the current execution is inside a dbzero read-only block."""
-    ...
-
-def in_read_only() -> bool:
-    """Return whether the current execution is inside a dbzero read-only block."""
-    ...
-
 def open(prefix_name: str, open_mode: str = "rw", **kwargs: Any) -> None:
     """Open a data prefix and set it as the current working context.
 
@@ -127,17 +115,11 @@ def commit(prefix_name: Optional[str] = None) -> None:
 def get_type_stats(type: type, prefix: Optional[str] = None) -> Dict[str, Any]:
     """Retrieve statistics for a memo type.
 
-    For interned types, the result includes ``content_index["size"]`` with the
-    number of currently indexed intern candidates.
     """
     ...
 
 def get_prefix_stats(prefix: Optional[str] = None) -> Dict[str, Any]:
-    """Retrieve statistics for a prefix.
-
-    The result includes ``data_masking["enabled"]`` and ``data_filter["enabled"]``
-    to report whether the opened prefix has those runtime states attached.
-    """
+    """Retrieve statistics for a prefix."""
     ...
 
 # Object retrieval and management
@@ -635,45 +617,6 @@ def rename_field(class_obj: type, from_name: str, to_name: str) -> None:
     """
     ...
 
-def set_field_access(class_obj: type, account_id: Union[int, Sequence[int]], mode: Tuple[EnumValue, ...], *fields: str) -> None:
-    """Set protected-field access flags for one or more fields of a memo class.
-
-    The memo class must be declared with ``protect_fields=True`` or inherit it
-    from a protected memo base. Pass an empty ``mode`` tuple to clear all access
-    flags for the specified account and fields.
-    """
-    ...
-
-def get_field_access(class_obj: type, account_id: int) -> Iterable[Tuple[str, Tuple[str, ...]]]:
-    """Return protected-field access flags for a memo class and account."""
-    ...
-
-def reset_protect_fields(class_obj: type) -> None:
-    """Clear the persisted protect_fields flag for a memo class.
-
-    The memo type must no longer be decorated with ``protect_fields=True`` and
-    must not inherit protected fields from a protected memo base. Remove the
-    argument or set it to ``False`` before calling this function.
-    """
-    ...
-
-def _init_data_masking(
-    context_var: Any,
-    prefix: Union[str, Any, Sequence[Any], None] = None,
-    missing_value_placeholder: Optional[Any] = None,
-    mode: str = "RELEASE",
-) -> None:
-    """Initialize workspace-wide or prefix-scoped data masking for the current process."""
-    ...
-
-def _init_data_filter(
-    context_var: Any,
-    prefix: Union[str, Any, Sequence[Any], None] = None,
-    mode: str = "RELEASE",
-) -> None:
-    """Initialize workspace-wide or prefix-scoped data filtering for the current process."""
-    ...
-
 # Cache management
 
 def clear_cache() -> None:
@@ -978,17 +921,13 @@ def bytearray(source: Union[bytes, Iterable[int]] = b'', /) -> ByteArrayObject:
 
 # Tag and query functions
 
-def tags(*objects: Union[Memo, QueryObject], passive: bool = False) -> ObjectTagManager:
+def tags(*objects: Memo) -> ObjectTagManager:
     """Get a tag manager interface for given Memo objects.
 
     Parameters
     ----------
-    *objects : Memo or QueryObject
-        One or more Memo objects or query result sets to manage tags for.
-    passive : bool, optional
-        Assign simple tags without extending the tagged object's lifetime. Passive tags require
-        another positive predicate when queried.
-
+    *objects : Memo
+        One or more Memo objects to manage tags for.
     Returns
     -------
     ObjectTagManager
@@ -1012,11 +951,6 @@ def tags(*objects: Union[Memo, QueryObject], passive: bool = False) -> ObjectTag
     >>> dbzero.tags(product1, product2).add("sale")
     >>> dbzero.tags(product1, product2).remove("sale")
 
-    Batch operations on query results:
-
-    >>> dbzero.tags(dbzero.find("token-a", "token-b")).add("token-c")
-    >>> dbzero.tags(dbzero.find("token-a")).remove("token-a")
-
     Chain operations:
     
     >>> dbzero.tags(obj).add("tag1").remove("old-tag").add("tag2")
@@ -1087,30 +1021,21 @@ def find(*query_criteria: Union[Tag, List[Tag], Tuple[Tag], QueryObject, TagSet]
     """
     ...
 
-def predicate(*query_criteria: Union[Tag, List[Tag], Tuple[Tag], QueryObject, TagSet], prefix: Optional[str] = None) -> QueryObject:
-    """Build a predicate-only query for composing filters.
-
-    Predicate queries use the same criteria grammar as ``find`` and can be used
-    as criteria in other queries or as data-filter predicates. They do not allow
-    direct iteration, counting, truth testing, indexing, or slicing.
-    """
-    ...
-
-def no(predicate: Union[str, QueryObject], /) -> TagSet:
-    """Create a negative predicate (NOT condition) for find queries.
+def no(condition: Union[str, QueryObject], /) -> TagSet:
+    """Create a negative condition (NOT condition) for find queries.
 
-    Allows to exclude objects that match the given predicate,
+    Allows to exclude objects that match the given condition,
     enabling filtering out unwanted objects based on tags or query results.
 
     Parameters
     ----------
-    predicate : str or QueryObject
+    condition : str or QueryObject
         The condition to negate.
 
     Returns
     -------
     TagSet
-        A predicate object representing logical NOT operation.
+        A tag set representing logical NOT operation.
 
     Examples
     --------

{dbzero-0.3.6 → dbzero-0.4.0}/dbzero/dbzero/initialization.py

@@ -4,7 +4,7 @@
 """dbzero initialization functions"""
 from collections.abc import Mapping
 from typing import Any
-from .dbzero import _init, _init_data_filter, _init_data_masking, open as dbzero_open
+from .dbzero import _init, open as dbzero_open
 
 def init(dbzero_root: str, **kwargs: Any) -> None:
     """Initialize the dbzero environment in a specified directory and apply global configurations.
@@ -31,8 +31,6 @@ def init(dbzero_root: str, **kwargs: Any) -> None:
         * lang_cache_size (int, default 1024) for language model data cache size
         * lock_flags (dict) to configure locking behavior when opening the prefix in read-write mode
         * rpc (dict) to initialize optional db0_rpc client configuration
-        * data_masking (dict) to initialize data masking via _init_data_masking
-        * data_filter (dict) to initialize data filtering via _init_data_filter
 
         Lock flags (dict):
         * blocking (bool, default False) wait when trying to acquire the lock
@@ -67,15 +65,3 @@ def init(dbzero_root: str, **kwargs: Any) -> None:
     if "prefix" in kwargs:
         open_mode = "rw" if kwargs.get("read_write", True) else "r"
         dbzero_open(kwargs["prefix"], open_mode=open_mode)
-
-    if "data_masking" in kwargs:
-        data_masking = kwargs["data_masking"]
-        if not isinstance(data_masking, Mapping):
-            raise TypeError("data_masking must be a mapping")
-        _init_data_masking(**data_masking)
-
-    if "data_filter" in kwargs:
-        data_filter = kwargs["data_filter"]
-        if not isinstance(data_filter, Mapping):
-            raise TypeError("data_filter must be a mapping")
-        _init_data_filter(**data_filter)

{dbzero-0.3.6 → dbzero-0.4.0}/dbzero/dbzero/interfaces.py

@@ -143,7 +143,7 @@ class ByteArrayObject(bytearray):
     ...
 
 class ObjectTagManager:
-    """Manages tags of one or more Memo instances or query result sets."""
+    """Manages tags of one or more Memo instances."""
 
     def add(self, *tag: Union[Tag, Iterable[Tag]]) -> None:
         """Add one or more tags to the managed objects.