dbzero 0.4.0__tar.gz → 0.4.2__tar.gz

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

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

@@ -29,6 +29,8 @@ def open(prefix_name: str, open_mode: str = "rw", **kwargs: Any) -> None:
         Additional keyword arguments to configure the prefix's behavior:
         
         * 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
         * 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
@@ -54,6 +56,14 @@ def open(prefix_name: str, open_mode: str = "rw", **kwargs: Any) -> None:
     """
     ...
 
+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.
+
+    The restriction level can only increase: unrestricted -> restricted_context -> restricted.
+    """
+    ...
+
 def close(prefix_name: Optional[str] = None) -> None:
     """Gracefully shut down dbzero, persisting changes and releasing resources.
 
@@ -119,7 +129,11 @@ def get_type_stats(type: type, prefix: Optional[str] = None) -> Dict[str, Any]:
     ...
 
 def get_prefix_stats(prefix: Optional[str] = None) -> Dict[str, Any]:
-    """Retrieve statistics for a prefix."""
+    """Retrieve statistics for a prefix.
+
+    The returned dictionary includes ``restricted`` indicating whether the opened
+    prefix is currently in restricted memo-access mode.
+    """
     ...
 
 # Object retrieval and management
@@ -1540,6 +1554,7 @@ def get_config() -> Dict[str, Any]:
         
         * autocommit (bool): True if autocommit enabled. Defaults to True.
         * autocommit_interval (int): Milliseconds between commits. Defaults to 250.
+        * restricted (bool): True if future opened prefixes default to static restricted mode.
 
     Raises
     ------

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

@@ -25,6 +25,8 @@ def init(dbzero_root: str, **kwargs: Any) -> None:
         * read_write (bool, default True) set the open mode for the prefix
         
         Configure global dbzero behavior:
+        * restricted (bool, default False) to restrict memo reflection access for future opened prefixes
+        * restricted_context (ContextVar) to dynamically restrict memo reflection access
         * autocommit (bool, default True) to enable automatic commits
         * autocommit_interval (int, default 367) for commit interval in milliseconds
         * cache_size (int, default 2 GiB) for main object cache size in bytes
@@ -52,6 +54,12 @@ def init(dbzero_root: str, **kwargs: Any) -> None:
     if "lock_flags" in kwargs:
         init_kwargs["lock_flags"] = kwargs["lock_flags"]
 
+    if "restricted" in kwargs:
+        init_kwargs["restricted"] = kwargs["restricted"]
+
+    if "restricted_context" in kwargs:
+        init_kwargs["restricted_context"] = kwargs["restricted_context"]
+
     rpc = kwargs.get("rpc")
     if rpc is not None and not isinstance(rpc, Mapping):
         raise TypeError("rpc must be a mapping")
@@ -64,4 +72,9 @@ 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)
+        open_kwargs = {}
+        if "restricted" in kwargs:
+            open_kwargs["restricted"] = kwargs["restricted"]
+        if "restricted_context" in kwargs:
+            open_kwargs["restricted_context"] = kwargs["restricted_context"]
+        dbzero_open(kwargs["prefix"], open_mode=open_mode, **open_kwargs)

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

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

{dbzero-0.4.0 → dbzero-0.4.2}/meson.build

@@ -1,4 +1,4 @@
-project('dbzero', 'cpp', default_options :['buildtype=release', 'b_ndebug=if-release'])
+project('dbzero', 'cpp', default_options :['buildtype=release', 'b_ndebug=if-release', 'optimization=2'])
 
 cc = meson.get_compiler('cpp')
 compiler_id = cc.get_id()
@@ -7,6 +7,8 @@ message('Compiler ID: ' + compiler_id)
 message('Build system: ' + build_machine.system())
 
 if build_machine.system() == 'linux' or  build_machine.system() == 'darwin'
+    cpp_std_option = 'cpp_std=c++17'
+
     # Common flags for both GCC and Clang on Linux/Darwin
     common_args = [
         '-Wno-unused-result',
@@ -61,14 +63,8 @@ if build_machine.system() == 'linux' or  build_machine.system() == 'darwin'
         # Linux-specific: add address-of-packed-member warning suppression
         add_project_arguments('-Wno-address-of-packed-member', language : 'cpp')
     endif
-    
-    add_project_arguments('-std=c++17', language : 'cpp')  
 else 
-    if compiler_id == 'msvc'
-        add_project_arguments('/std:c++20', language : 'cpp')
-    else
-        add_project_arguments('-std=c++20', language : 'cpp')
-    endif
+    cpp_std_option = 'cpp_std=c++20'
 endif
 
 enable_debug_exceptions = get_option('enable_debug_exceptions')
@@ -93,9 +89,7 @@ endif
 
 buildtype = get_option('buildtype')
 build_suffix = ''
-if buildtype.startswith('release')
-    add_project_arguments('-O2',  language : 'cpp')
-elif buildtype.startswith('debug')
+if buildtype.startswith('debug')
     build_suffix='D'
 endif
 
@@ -130,7 +124,12 @@ tests_sources = []
 
 
 
-dbzero_lib = static_library('pyzero', [all_srcs], include_directories:include_dirs, dependencies: [deps], install : true, install_dir: install_dir)
+dbzero_lib = static_library('pyzero', [all_srcs],
+    include_directories:include_dirs,
+    dependencies: [deps],
+    override_options: [cpp_std_option],
+    install : true,
+    install_dir: install_dir)
 all_deps = [deps]
 build_tests = get_option('build_tests')
 if build_tests
@@ -151,8 +150,9 @@ if build_tests
     all_deps += gmock_dep
     message('Building C++ tests')
     subdir('tests')
-    e = executable('tests' + build_suffix + '.x', [all_srcs,tests_sources], dependencies: [deps, gtest_dep, gmock_dep], 
-                   link_with: [dbzero_lib, link_with], include_directories:include_dirs_test, link_language : 'cpp',)
+    e = executable('tests' + build_suffix + '.x', [all_srcs,tests_sources], dependencies: [deps, gtest_dep, gmock_dep],
+                   link_with: [dbzero_lib, link_with], include_directories:include_dirs_test, link_language : 'cpp',
+                   override_options: [cpp_std_option],)
     test('gtest tests', e)
 else
     message('Skipping C++ tests build')
@@ -166,6 +166,7 @@ py3avlw = py3_inst.extension_module('dbzero',
     link_language : 'cpp',
     override_options: [
         'cpp_rtti=true',
+        cpp_std_option,
     ],
     install: true,
     subdir: 'dbzero',

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

@@ -4,7 +4,7 @@ requires = ['meson-python']
 
 [project]
 name = 'dbzero'
-version = '0.4.0'
+version = '0.4.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.4.2/python_tests/test_restricted_memo_access.py

@@ -0,0 +1,408 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+# Copyright (c) 2025 DBZero Software sp. z o.o.
+
+import gc
+import os
+import shutil
+import subprocess
+import sys
+import textwrap
+from contextvars import ContextVar
+
+import pytest
+import dbzero as db0
+
+from .conftest import DB0_DIR
+
+
+@db0.memo
+class RestrictedMemoAccessData:
+    def __init__(self, value):
+        self.value = value
+
+    def get_value(self):
+        return self.value
+
+    def set_value(self, value):
+        self.value = value
+
+
+def _clean_db0_dir():
+    if os.path.exists(DB0_DIR):
+        shutil.rmtree(DB0_DIR)
+    os.mkdir(DB0_DIR)
+
+
+@pytest.fixture()
+def db0_restricted_root():
+    if "D" in db0.build_flags():
+        db0.reset_test_params()
+    _clean_db0_dir()
+    yield
+    gc.collect()
+    db0.close()
+    if os.path.exists(DB0_DIR):
+        shutil.rmtree(DB0_DIR)
+
+
+def _assert_restricted(obj, *, writable=True):
+    assert obj.value == 123
+    if writable:
+        obj.value = 456
+        assert obj.value == 456
+        obj.new_value = 789
+        assert obj.new_value == 789
+
+    for attr_name in (
+        "__class__",
+        "__dict__",
+        "__mro__",
+        "__subclasses__",
+        "_private",
+    ):
+        with pytest.raises(AttributeError):
+            getattr(obj, attr_name)
+
+
+def _assert_restricted_method_not_introspectable(method):
+    assert callable(method)
+    with pytest.raises(AttributeError):
+        dir(method)
+    for attr_name in ("__class__", "__dict__", "__func__", "__self__", "__globals__", "__closure__"):
+        with pytest.raises(AttributeError):
+            getattr(method, attr_name)
+
+
+def test_restricted_memo_methods_can_be_called(db0_restricted_root):
+    db0.init(DB0_DIR)
+    db0.open("restricted-method-prefix", restricted=True)
+    obj = RestrictedMemoAccessData(123)
+
+    assert obj.get_value() == 123
+    obj.set_value(456)
+    assert obj.value == 456
+    assert obj.get_value() == 456
+    _assert_restricted_method_not_introspectable(obj.get_value)
+    _assert_restricted_method_not_introspectable(obj.set_value)
+
+
+def test_init_restricted_applies_to_future_prefixes(db0_restricted_root):
+    db0.init(DB0_DIR, restricted=True)
+    assert db0.get_config()["restricted"] is True
+    db0.open("restricted-by-init")
+    assert db0.get_prefix_stats()["restricted"] is True
+
+    _assert_restricted(RestrictedMemoAccessData(123))
+
+
+def test_open_restricted_is_scoped_to_prefix(db0_restricted_root):
+    db0.init(DB0_DIR)
+    assert db0.get_config()["restricted"] is False
+
+    db0.open("restricted-prefix", restricted=True)
+    assert db0.get_prefix_stats("restricted-prefix")["restricted"] is True
+    restricted = RestrictedMemoAccessData(123)
+    _assert_restricted(restricted)
+
+    db0.open("unrestricted-prefix")
+    assert db0.get_prefix_stats("unrestricted-prefix")["restricted"] is False
+    unrestricted = RestrictedMemoAccessData(123)
+    assert unrestricted.get_value() == 123
+    assert unrestricted.__class__ is RestrictedMemoAccessData
+    assert unrestricted.get_value.__self__ is unrestricted
+
+
+def test_unrestricted_memo_access_before_restricted_mode_is_ever_used():
+    code = textwrap.dedent(
+        """
+        import gc
+        import os
+        import shutil
+
+        import dbzero as db0
+
+        from python_tests.conftest import DB0_DIR
+        from python_tests.test_restricted_memo_access import (
+            RestrictedMemoAccessData,
+            _clean_db0_dir,
+        )
+
+        if "D" in db0.build_flags():
+            db0.reset_test_params()
+        _clean_db0_dir()
+        try:
+            db0.init(DB0_DIR)
+            db0.open("never-restricted-prefix")
+            obj = RestrictedMemoAccessData(123)
+
+            assert obj.value == 123
+            assert obj.get_value() == 123
+            assert obj.__class__ is RestrictedMemoAccessData
+            assert obj.get_value.__self__ is obj
+        finally:
+            gc.collect()
+            db0.close()
+            if os.path.exists(DB0_DIR):
+                shutil.rmtree(DB0_DIR)
+        """
+    )
+    result = subprocess.run(
+        [sys.executable, "-c", code],
+        cwd=os.getcwd(),
+        capture_output=True,
+        text=True,
+        timeout=20,
+        check=False,
+    )
+    assert result.returncode == 0, (
+        "restricted memo fast-path fresh-process child failed with code "
+        f"{result.returncode}\nstdout:\n{result.stdout}\nstderr:\n{result.stderr}"
+    )
+
+
+def test_unrestricted_prefix_stays_unrestricted_after_default_restricted_was_enabled(db0_restricted_root):
+    db0.init(DB0_DIR, restricted=True)
+    assert db0.get_config()["restricted"] is True
+    db0.open("explicitly-unrestricted-prefix", restricted=False)
+    assert db0.get_prefix_stats("explicitly-unrestricted-prefix")["restricted"] is False
+
+    obj = RestrictedMemoAccessData(123)
+    assert obj.value == 123
+    assert obj.get_value() == 123
+    assert obj.__class__ is RestrictedMemoAccessData
+    assert obj.get_value.__self__ is obj
+
+
+def test_prefix_can_be_reopened_as_restricted(db0_restricted_root):
+    db0.init(DB0_DIR)
+    db0.open("reopen-prefix", restricted=False)
+    obj = RestrictedMemoAccessData(123)
+    obj_uuid = db0.uuid(obj)
+    assert obj.get_value() == 123
+    db0.commit()
+    db0.close("reopen-prefix")
+
+    db0.open("reopen-prefix", "r", restricted=True)
+    assert db0.get_prefix_stats("reopen-prefix")["restricted"] is True
+    reopened = db0.fetch(obj_uuid)
+    _assert_restricted(reopened, writable=False)
+
+
+def test_global_restricted_applies_to_auto_opened_prefix(db0_restricted_root):
+    db0.init(DB0_DIR)
+    db0.open("auto-open-prefix")
+    obj = RestrictedMemoAccessData(123)
+    obj_uuid = db0.uuid(obj)
+    db0.commit()
+    db0.close()
+
+    db0.init(DB0_DIR, restricted=True)
+    fetched = db0.fetch(obj_uuid)
+    assert db0.get_config()["restricted"] is True
+    assert db0.get_prefix_stats("auto-open-prefix")["restricted"] is True
+    _assert_restricted(fetched, writable=False)
+
+
+def test_global_restricted_context_controls_existing_objects(db0_restricted_root):
+    restricted_context = ContextVar("restricted_context", default=False)
+    db0.init(DB0_DIR, restricted_context=restricted_context)
+    assert db0.get_config()["restricted"] is False
+    db0.open("dynamic-global-prefix")
+    assert db0.get_prefix_stats("dynamic-global-prefix")["restricted"] is False
+    obj = RestrictedMemoAccessData(123)
+
+    assert obj.__class__ is RestrictedMemoAccessData
+    assert obj.get_value.__self__ is obj
+
+    token = restricted_context.set(True)
+    try:
+        _assert_restricted(obj)
+    finally:
+        restricted_context.reset(token)
+
+    assert obj.__class__ is RestrictedMemoAccessData
+    assert obj.get_value.__self__ is obj
+
+
+def test_prefix_restricted_context_overrides_global_context(db0_restricted_root):
+    global_context = ContextVar("global_context", default=True)
+    prefix_context = ContextVar("prefix_context", default=False)
+    db0.init(DB0_DIR, restricted_context=global_context)
+
+    db0.open("global-dynamic-prefix")
+    global_obj = RestrictedMemoAccessData(123)
+
+    db0.open("prefix-dynamic-prefix", restricted_context=prefix_context)
+    prefix_obj = RestrictedMemoAccessData(123)
+
+    _assert_restricted(global_obj)
+    assert prefix_obj.__class__ is RestrictedMemoAccessData
+    assert prefix_obj.get_value.__self__ is prefix_obj
+
+    token = prefix_context.set(True)
+    try:
+        _assert_restricted(prefix_obj)
+    finally:
+        prefix_context.reset(token)
+
+
+def test_prefix_restricted_context_none_cannot_replace_existing_context(db0_restricted_root):
+    global_context = ContextVar("global_context", default=True)
+    prefix_context = ContextVar("prefix_context", default=False)
+    db0.init(DB0_DIR, restricted_context=global_context)
+    db0.open("prefix-reset-dynamic-prefix", restricted_context=prefix_context)
+    obj = RestrictedMemoAccessData(123)
+
+    assert obj.__class__ is RestrictedMemoAccessData
+    assert obj.get_value.__self__ is obj
+
+    with pytest.raises(RuntimeError):
+        db0.open("prefix-reset-dynamic-prefix", restricted_context=None)
+
+    assert obj.__class__ is RestrictedMemoAccessData
+
+
+def test_static_restricted_without_restricted_context_remains_restricted(db0_restricted_root):
+    db0.init(DB0_DIR)
+    db0.open("static-restricted-prefix", restricted=True)
+    assert db0.get_prefix_stats("static-restricted-prefix")["restricted"] is True
+
+    _assert_restricted(RestrictedMemoAccessData(123))
+
+
+def test_static_restricted_object_does_not_resolve_later_restricted_context(db0_restricted_root):
+    class ExplodingContext:
+        def get(self):
+            raise AssertionError("restricted_context should not be resolved")
+
+    db0.init(DB0_DIR)
+    db0.open("static-no-context-prefix", restricted=True)
+    obj = RestrictedMemoAccessData(123)
+
+    with pytest.raises(RuntimeError):
+        db0.open("static-no-context-prefix", restricted_context=ExplodingContext())
+
+    _assert_restricted(obj)
+
+
+def test_unset_restricted_context_is_treated_as_false(db0_restricted_root):
+    restricted_context = ContextVar("restricted_context")
+    db0.init(DB0_DIR, restricted_context=restricted_context)
+    db0.open("unset-dynamic-prefix")
+    obj = RestrictedMemoAccessData(123)
+
+    assert obj.__class__ is RestrictedMemoAccessData
+    assert obj.get_value.__self__ is obj
+
+
+def test_restricted_context_uses_python_truthiness(db0_restricted_root):
+    restricted_context = ContextVar("restricted_context", default=[])
+    db0.init(DB0_DIR, restricted_context=restricted_context)
+    db0.open("truthy-dynamic-prefix")
+    obj = RestrictedMemoAccessData(123)
+
+    assert obj.__class__ is RestrictedMemoAccessData
+
+    token = restricted_context.set([object()])
+    try:
+        _assert_restricted(obj)
+    finally:
+        restricted_context.reset(token)
+
+
+def test_init_prefix_shortcut_forwards_restricted_context(db0_restricted_root):
+    restricted_context = ContextVar("restricted_context", default=True)
+    db0.init(DB0_DIR, prefix="shortcut-dynamic-prefix", restricted_context=restricted_context)
+    assert db0.get_prefix_stats("shortcut-dynamic-prefix")["restricted"] is False
+
+    _assert_restricted(RestrictedMemoAccessData(123))
+
+
+def test_set_restricted_context_upgrades_existing_and_future_prefixes(db0_restricted_root):
+    restricted_context = ContextVar("restricted_context", default=False)
+    db0.init(DB0_DIR)
+    db0.open("dynamic-upgrade-prefix")
+    obj = RestrictedMemoAccessData(123)
+
+    assert obj.__class__ is RestrictedMemoAccessData
+    db0.set_restricted(restricted_context=restricted_context)
+    assert db0.get_config()["restricted"] is False
+
+    assert obj.__class__ is RestrictedMemoAccessData
+    token = restricted_context.set(True)
+    try:
+        _assert_restricted(obj)
+        db0.open("future-dynamic-upgrade-prefix")
+        _assert_restricted(RestrictedMemoAccessData(123))
+    finally:
+        restricted_context.reset(token)
+
+
+def test_set_restricted_static_upgrades_dynamic_context(db0_restricted_root):
+    restricted_context = ContextVar("restricted_context", default=False)
+    db0.init(DB0_DIR)
+    db0.set_restricted(restricted_context=restricted_context)
+    db0.open("dynamic-to-static-prefix")
+    obj = RestrictedMemoAccessData(123)
+
+    assert obj.__class__ is RestrictedMemoAccessData
+    db0.set_restricted(restricted=True)
+
+    _assert_restricted(obj)
+    db0.open("future-static-upgrade-prefix")
+    assert db0.get_prefix_stats("future-static-upgrade-prefix")["restricted"] is True
+    _assert_restricted(RestrictedMemoAccessData(123))
+
+
+def test_set_restricted_rejects_context_after_static_restricted(db0_restricted_root):
+    restricted_context = ContextVar("restricted_context", default=False)
+    db0.init(DB0_DIR, restricted=True)
+    db0.open("static-terminal-prefix")
+    obj = RestrictedMemoAccessData(123)
+
+    with pytest.raises(RuntimeError):
+        db0.set_restricted(restricted_context=restricted_context)
+
+    _assert_restricted(obj)
+
+
+def test_set_restricted_rejects_context_replacement(db0_restricted_root):
+    first_context = ContextVar("first_context", default=False)
+    second_context = ContextVar("second_context", default=True)
+    db0.init(DB0_DIR)
+    db0.set_restricted(restricted_context=first_context)
+    db0.open("context-replacement-prefix")
+    obj = RestrictedMemoAccessData(123)
+
+    with pytest.raises(RuntimeError):
+        db0.set_restricted(restricted_context=second_context)
+
+    assert obj.__class__ is RestrictedMemoAccessData
+    token = first_context.set(True)
+    try:
+        _assert_restricted(obj)
+    finally:
+        first_context.reset(token)
+
+
+def test_set_restricted_rejects_false(db0_restricted_root):
+    db0.init(DB0_DIR)
+
+    with pytest.raises(RuntimeError):
+        db0.set_restricted(restricted=False)
+
+
+def test_set_restricted_prefix_only_upgrades_target_prefix(db0_restricted_root):
+    restricted_context = ContextVar("restricted_context", default=True)
+    db0.init(DB0_DIR)
+
+    db0.open("target-prefix")
+    target = RestrictedMemoAccessData(123)
+    db0.open("other-prefix")
+    other = RestrictedMemoAccessData(123)
+
+    db0.set_restricted(prefix="target-prefix", restricted_context=restricted_context)
+
+    _assert_restricted(target)
+    assert other.__class__ is RestrictedMemoAccessData
+    assert other.get_value.__self__ is other