dbzero 0.4.0__tar.gz → 0.4.1__tar.gz

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

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

@@ -29,6 +29,7 @@ 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
         * 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
@@ -119,7 +120,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 +1545,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 restricted mode.
 
     Raises
     ------

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

@@ -25,6 +25,7 @@ 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
         * 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 +53,9 @@ 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"]
+
     rpc = kwargs.get("rpc")
     if rpc is not None and not isinstance(rpc, Mapping):
         raise TypeError("rpc must be a mapping")
@@ -64,4 +68,7 @@ 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"]
+        dbzero_open(kwargs["prefix"], open_mode=open_mode, **open_kwargs)

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

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

{dbzero-0.4.0 → dbzero-0.4.1}/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.1}/pyproject.toml

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

@@ -0,0 +1,202 @@
+# 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
+
+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)

dbzero-0.4.1/python_tests/test_restricted_statek_repros.py

@@ -0,0 +1,202 @@
+# SPDX-License-Identifier: LGPL-2.1-or-later
+# Copyright (c) 2025 DBZero Software sp. z o.o.
+
+from dataclasses import dataclass, field
+import gc
+import os
+import shutil
+from typing import Optional
+
+import pytest
+import dbzero as db0
+
+from .conftest import DB0_DIR
+
+
+@db0.memo
+@dataclass
+class RestrictedDataclassWithPostInit:
+    value: int
+    initialized: bool = False
+
+    def __post_init__(self):
+        self.initialized = True
+
+
+@db0.memo
+@dataclass
+class RestrictedMemoWithProperty:
+    local_state: dict = field(default_factory=dict)
+
+    @property
+    def perm_ctx(self):
+        return self.local_state.get("_PERM_CTX")
+
+
+@db0.memo
+@dataclass
+class RestrictedMemoWithLeakyProperty:
+    @property
+    def class_object(self):
+        return self.__class__
+
+
+@db0.memo
+@dataclass
+class RestrictedMemoWithProtectedPostInitHelper:
+    value: int
+    synced: bool = False
+
+    def __post_init__(self):
+        self._sync_identity_hash_tag()
+
+    def _sync_identity_hash_tag(self):
+        self.synced = True
+
+
+@db0.memo
+@dataclass
+class RestrictedMemoWithPostInitPublicFieldRead:
+    role: str
+    role_seen_in_post_init: Optional[str] = None
+
+    def __post_init__(self):
+        self.role_seen_in_post_init = self.role
+
+
+@db0.memo
+@dataclass
+class RestrictedMemoWithProtectedMethodHelper:
+    status: str = "READY"
+
+    def set_status(self, status):
+        self._set_status(status)
+
+    def _set_status(self, status):
+        self.status = status
+
+
+@db0.memo
+@dataclass
+class RestrictedMemoWithProtectedPropertyHelper:
+    metadata: dict = field(default_factory=dict)
+
+    @property
+    def model(self):
+        return self._model_from_metadata()
+
+    def _model_from_metadata(self):
+        return self.metadata.get("MODEL")
+
+
+@db0.memo
+@dataclass
+class RestrictedMemoWithLeakyProtectedHelper:
+    def reveal_class(self):
+        return self._class_object()
+
+    def _class_object(self):
+        return self.__class__
+
+
+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 test_restricted_memo_dataclass_post_init_runs_during_construction(db0_restricted_root):
+    db0.init(DB0_DIR, restricted=True)
+    db0.open("statek-post-init-repro")
+
+    obj = RestrictedDataclassWithPostInit(123)
+
+    assert obj.value == 123
+    assert obj.initialized is True
+    with pytest.raises(AttributeError):
+        obj.__post_init__
+
+
+def test_restricted_memo_public_property_can_be_read(db0_restricted_root):
+    db0.init(DB0_DIR, restricted=True)
+    db0.open("statek-property-repro")
+    ctx = {"last_example_id": 1}
+    obj = RestrictedMemoWithProperty(local_state={"_PERM_CTX": ctx})
+
+    assert obj.perm_ctx == ctx
+
+
+def test_restricted_memo_property_cannot_bypass_restricted_attribute_access(db0_restricted_root):
+    db0.init(DB0_DIR, restricted=True)
+    db0.open("statek-property-security-repro")
+    obj = RestrictedMemoWithLeakyProperty()
+
+    with pytest.raises(AttributeError):
+        obj.class_object
+
+
+def test_restricted_memo_post_init_can_call_protected_self_helper(db0_restricted_root):
+    db0.init(DB0_DIR, restricted=True)
+    db0.open("statek-post-init-protected-helper-repro")
+
+    obj = RestrictedMemoWithProtectedPostInitHelper(123)
+
+    assert obj.value == 123
+    assert obj.synced is True
+    with pytest.raises(AttributeError):
+        obj._sync_identity_hash_tag
+
+
+def test_restricted_memo_post_init_can_read_constructor_public_field(db0_restricted_root):
+    db0.init(DB0_DIR, restricted=True)
+    db0.open("statek-post-init-public-field-read-repro")
+
+    obj = RestrictedMemoWithPostInitPublicFieldRead("sandbox-agent")
+
+    assert obj.role == "sandbox-agent"
+    assert obj.role_seen_in_post_init == "sandbox-agent"
+    with pytest.raises(AttributeError):
+        obj.__post_init__
+
+
+def test_restricted_memo_public_method_can_call_protected_self_helper(db0_restricted_root):
+    db0.init(DB0_DIR, restricted=True)
+    db0.open("statek-method-protected-helper-repro")
+    obj = RestrictedMemoWithProtectedMethodHelper()
+
+    obj.set_status("STARTED")
+
+    assert obj.status == "STARTED"
+    with pytest.raises(AttributeError):
+        obj._set_status
+
+
+def test_restricted_memo_public_property_can_call_protected_self_helper(db0_restricted_root):
+    db0.init(DB0_DIR, restricted=True)
+    db0.open("statek-property-protected-helper-repro")
+    obj = RestrictedMemoWithProtectedPropertyHelper(metadata={"MODEL": "test-model"})
+
+    assert obj.model == "test-model"
+    with pytest.raises(AttributeError):
+        obj._model_from_metadata
+
+
+def test_restricted_memo_protected_helper_cannot_leak_dunder_access(db0_restricted_root):
+    db0.init(DB0_DIR, restricted=True)
+    db0.open("statek-protected-helper-security-repro")
+    obj = RestrictedMemoWithLeakyProtectedHelper()
+
+    with pytest.raises(AttributeError):
+        obj.reveal_class()