starddb 1.0.0__tar.gz

starddb-1.0.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: starddb
+Version: 1.0.0
+Summary: A lightweight JSON document database with field-level operation queuing and concurrency support
+Author: 
+License: MIT
+Project-URL: Homepage, https://github.com/obama/stardb
+Project-URL: Repository, https://github.com/obama/stardb
+Keywords: json,database,document-db,queue,concurrency,lightweight,embedded
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: filelock>=3.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+# StarDDB (Star Document-database)
+
+> "Shoot for the moon. Even if you miss, you'll land among the stars." - Norman Vincent Peale
+
+StarDDB is a simple to use, lightweight (single file implementation) DB for efficient JSON-like storage management.
+
+## Features
+
+- Concurrency support via field-level operation queuing
+- Easy-to-use API
+- Automatic background persistence
+- Nested document support
+- Thread-safe (Python) / Event-loop safe (Node.js)
+
+## Installation
+
+```bash
+pip install starddb
+```
+
+## Quick Start
+
+```python
+from stardb import StarDDBField, StarDDB
+
+# Create a field and queue operations
+field = StarDDBField(0)
+field.update("set", 1)
+field.update("mult", 5)
+field.update("div", 0.5)
+field.flush()
+print(field.value)  # 10.0
+
+# Use with a database file
+db = StarDDB("data.json", save_time=5)
+hook = db.db()
+hook["health"].update("sub", 30)
+hook["mana"].update("mult", 2)
+db.close()
+```
+
+## API
+
+### StarDDBField(value, max_queue_size=10000)
+
+- `value` — Initial value (any JSON-serializable type)
+- `max_queue_size` — Maximum queued operations (default: 10000)
+
+**Methods:**
+- `update(method, value)` — Queue an operation. Methods: `set`, `add`, `sub`, `mult`, `div`
+- `flush()` — Block until all queued operations are processed
+
+### StarDDB(database, save_time, database_hook=None, safe_root=None)
+
+- `database` — Path to the JSON database file
+- `save_time` — Seconds between automatic saves
+- `database_hook` — Optional pre-loaded dict (skips file read)
+- `safe_root` — Optional root directory to restrict path traversal
+
+**Methods:**
+- `db()` — Get the database hook (dict of StarDDBField instances)
+- `flush()` — Block until all field operations are processed
+- `close()` — Flush, save, and stop the background save thread

starddb-1.0.0/README.md

@@ -0,0 +1,63 @@
+# StarDDB (Star Document-database)
+
+> "Shoot for the moon. Even if you miss, you'll land among the stars." - Norman Vincent Peale
+
+StarDDB is a simple to use, lightweight (single file implementation) DB for efficient JSON-like storage management.
+
+## Features
+
+- Concurrency support via field-level operation queuing
+- Easy-to-use API
+- Automatic background persistence
+- Nested document support
+- Thread-safe (Python) / Event-loop safe (Node.js)
+
+## Installation
+
+```bash
+pip install starddb
+```
+
+## Quick Start
+
+```python
+from stardb import StarDDBField, StarDDB
+
+# Create a field and queue operations
+field = StarDDBField(0)
+field.update("set", 1)
+field.update("mult", 5)
+field.update("div", 0.5)
+field.flush()
+print(field.value)  # 10.0
+
+# Use with a database file
+db = StarDDB("data.json", save_time=5)
+hook = db.db()
+hook["health"].update("sub", 30)
+hook["mana"].update("mult", 2)
+db.close()
+```
+
+## API
+
+### StarDDBField(value, max_queue_size=10000)
+
+- `value` — Initial value (any JSON-serializable type)
+- `max_queue_size` — Maximum queued operations (default: 10000)
+
+**Methods:**
+- `update(method, value)` — Queue an operation. Methods: `set`, `add`, `sub`, `mult`, `div`
+- `flush()` — Block until all queued operations are processed
+
+### StarDDB(database, save_time, database_hook=None, safe_root=None)
+
+- `database` — Path to the JSON database file
+- `save_time` — Seconds between automatic saves
+- `database_hook` — Optional pre-loaded dict (skips file read)
+- `safe_root` — Optional root directory to restrict path traversal
+
+**Methods:**
+- `db()` — Get the database hook (dict of StarDDBField instances)
+- `flush()` — Block until all field operations are processed
+- `close()` — Flush, save, and stop the background save thread

starddb-1.0.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "starddb"
+version = "1.0.0"
+description = "A lightweight JSON document database with field-level operation queuing and concurrency support"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = ""}
+]
+keywords = ["json", "database", "document-db", "queue", "concurrency", "lightweight", "embedded"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Database",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+requires-python = ">=3.8"
+dependencies = [
+    "filelock>=3.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+]
+
+[project.urls]
+Homepage = "https://github.com/obama/stardb"
+Repository = "https://github.com/obama/stardb"
+
+[tool.setuptools]
+py-modules = ["stardb"]

starddb-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

starddb-1.0.0/stardb.py

@@ -0,0 +1,199 @@
+import json
+import threading
+import os
+import logging
+import time
+from filelock import FileLock
+
+logger = logging.getLogger("stardb")
+
+VALID_METHODS = frozenset({"set", "add", "sub", "mult", "div"})
+MAX_QUEUE_SIZE = 10000
+MAX_RECURSION_DEPTH = 100
+
+
+class StarDDBField:
+    def __init__(self, value=None, max_queue_size=MAX_QUEUE_SIZE):
+        self.value = value
+        self.queue = []
+        self._lock = threading.RLock()
+        self._running = False
+        self._done_event = threading.Event()
+        self._done_event.set()  # initially "done" — nothing queued
+        self._max_queue_size = max_queue_size
+
+    def update(self, method, value):
+        if method not in VALID_METHODS:
+            raise ValueError(
+                f'Invalid operation "{method}". Valid operations: {", ".join(sorted(VALID_METHODS))}'
+            )
+        if method == "div" and value == 0:
+            raise ZeroDivisionError("Division by zero is not allowed")
+        with self._lock:
+            self.queue.append({"method": method, "value": value})
+            if len(self.queue) > self._max_queue_size:
+                self.queue.pop()
+                raise RuntimeError(
+                    f"Queue is full (max size: {self._max_queue_size}). "
+                    "Wait for pending operations to complete."
+                )
+            self._done_event.clear()
+            if not self._running:
+                self._running = True
+                self._run_list()
+
+    def _run_list(self):
+        while True:
+            with self._lock:
+                if not self.queue:
+                    self._running = False
+                    self._done_event.set()
+                    return
+                item = self.queue.pop(0)
+
+            if item["method"] == "set":
+                self.value = item["value"]
+            elif item["method"] == "add":
+                self.value += item["value"]
+            elif item["method"] == "sub":
+                self.value -= item["value"]
+            elif item["method"] == "mult":
+                self.value *= item["value"]
+            elif item["method"] == "div":
+                if item["value"] == 0:
+                    logger.warning("[StarDDB] Division by zero skipped")
+                    continue
+                self.value /= item["value"]
+            else:
+                logger.error('[StarDDB] Unknown method "%s" dropped', item["method"])
+
+    def flush(self):
+        """Block until all queued operations have been processed."""
+        self._done_event.wait()
+
+
+def _crawl_db(hook, depth=0):
+    if depth > MAX_RECURSION_DEPTH:
+        raise RecursionError(
+            f"Max recursion depth ({MAX_RECURSION_DEPTH}) exceeded. "
+            "Nested objects are too deep."
+        )
+    for key in hook:
+        if isinstance(hook[key], dict):
+            _crawl_db(hook[key], depth + 1)
+        else:
+            hook[key] = StarDDBField(hook[key])
+    return hook
+
+
+def _serialize_db(hook, depth=0):
+    if depth > MAX_RECURSION_DEPTH:
+        raise RecursionError(
+            f"Max recursion depth ({MAX_RECURSION_DEPTH}) exceeded during serialization."
+        )
+    result = {}
+    for key in hook:
+        if isinstance(hook[key], StarDDBField):
+            result[key] = hook[key].value
+        elif isinstance(hook[key], dict):
+            result[key] = _serialize_db(hook[key], depth + 1)
+        else:
+            result[key] = hook[key]
+    return result
+
+
+def _sanitize_path(db_path, safe_root=None):
+    resolved = os.path.abspath(db_path)
+    if safe_root is not None:
+        root = os.path.abspath(safe_root)
+        if not (resolved.startswith(root + os.sep) or resolved == root):
+            raise ValueError(
+                f'Database path escapes safe root "{root}". '
+                f'Resolved path: "{resolved}"'
+            )
+    return resolved
+
+
+def _save_db_loop(db_path, hook, interval, stop_event, safe_root=None):
+    lock_path = db_path + ".lock"
+    while not stop_event.is_set():
+        stop_event.wait(interval)
+        if stop_event.is_set():
+            break
+        try:
+            data = _serialize_db(hook)
+            with FileLock(lock_path, timeout=10):
+                with open(db_path, "w") as f:
+                    json.dump(data, f)
+        except Exception as e:
+            logger.error("[StarDDB] Failed to save database to %s: %s", db_path, e)
+            # Do NOT raise — this runs in a daemon thread.
+            # Logging the error is enough; we keep trying on the next interval.
+
+
+def _flush_all_fields(node):
+    """Recursively flush every StarDDBField in the hook tree."""
+    for key in node:
+        if isinstance(node[key], StarDDBField):
+            node[key].flush()
+        elif isinstance(node[key], dict):
+            _flush_all_fields(node[key])
+
+
+class StarDDB:
+    def __init__(self, database, save_time, database_hook=None, safe_root=None):
+        self.database = _sanitize_path(database, safe_root)
+
+        if database_hook is None:
+            if not os.path.exists(self.database):
+                raise FileNotFoundError(
+                    f"Database file does not exist: {self.database}"
+                )
+            try:
+                with open(self.database, "r") as f:
+                    database_hook = json.load(f)
+            except json.JSONDecodeError as e:
+                logger.error(
+                    "[StarDDB] Failed to parse database file %s: %s", self.database, e
+                )
+                raise
+
+        self.database_hook = _crawl_db(database_hook)
+
+        self._stop_event = threading.Event()
+        self._save_thread = threading.Thread(
+            target=_save_db_loop,
+            args=(
+                self.database,
+                self.database_hook,
+                save_time,
+                self._stop_event,
+                safe_root,
+            ),
+            daemon=True,
+        )
+        self._save_thread.start()
+
+    def db(self):
+        return self.database_hook
+
+    def flush(self):
+        """Block until all queued field operations have been processed."""
+        _flush_all_fields(self.database_hook)
+
+    def close(self):
+        """Flush pending ops, do a final save, then stop the background thread."""
+        self.flush()
+        lock_path = self.database + ".lock"
+        try:
+            data = _serialize_db(self.database_hook)
+            with FileLock(lock_path, timeout=10):
+                with open(self.database, "w") as f:
+                    json.dump(data, f)
+        except Exception as e:
+            logger.error(
+                "[StarDDB] Failed final save on close to %s: %s", self.database, e
+            )
+            raise
+        self._stop_event.set()
+        self._save_thread.join()

starddb-1.0.0/starddb.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: starddb
+Version: 1.0.0
+Summary: A lightweight JSON document database with field-level operation queuing and concurrency support
+Author: 
+License: MIT
+Project-URL: Homepage, https://github.com/obama/stardb
+Project-URL: Repository, https://github.com/obama/stardb
+Keywords: json,database,document-db,queue,concurrency,lightweight,embedded
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: filelock>=3.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+# StarDDB (Star Document-database)
+
+> "Shoot for the moon. Even if you miss, you'll land among the stars." - Norman Vincent Peale
+
+StarDDB is a simple to use, lightweight (single file implementation) DB for efficient JSON-like storage management.
+
+## Features
+
+- Concurrency support via field-level operation queuing
+- Easy-to-use API
+- Automatic background persistence
+- Nested document support
+- Thread-safe (Python) / Event-loop safe (Node.js)
+
+## Installation
+
+```bash
+pip install starddb
+```
+
+## Quick Start
+
+```python
+from stardb import StarDDBField, StarDDB
+
+# Create a field and queue operations
+field = StarDDBField(0)
+field.update("set", 1)
+field.update("mult", 5)
+field.update("div", 0.5)
+field.flush()
+print(field.value)  # 10.0
+
+# Use with a database file
+db = StarDDB("data.json", save_time=5)
+hook = db.db()
+hook["health"].update("sub", 30)
+hook["mana"].update("mult", 2)
+db.close()
+```
+
+## API
+
+### StarDDBField(value, max_queue_size=10000)
+
+- `value` — Initial value (any JSON-serializable type)
+- `max_queue_size` — Maximum queued operations (default: 10000)
+
+**Methods:**
+- `update(method, value)` — Queue an operation. Methods: `set`, `add`, `sub`, `mult`, `div`
+- `flush()` — Block until all queued operations are processed
+
+### StarDDB(database, save_time, database_hook=None, safe_root=None)
+
+- `database` — Path to the JSON database file
+- `save_time` — Seconds between automatic saves
+- `database_hook` — Optional pre-loaded dict (skips file read)
+- `safe_root` — Optional root directory to restrict path traversal
+
+**Methods:**
+- `db()` — Get the database hook (dict of StarDDBField instances)
+- `flush()` — Block until all field operations are processed
+- `close()` — Flush, save, and stop the background save thread

starddb-1.0.0/starddb.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+stardb.py
+starddb.egg-info/PKG-INFO
+starddb.egg-info/SOURCES.txt
+starddb.egg-info/dependency_links.txt
+starddb.egg-info/requires.txt
+starddb.egg-info/top_level.txt
+tests/test_crawl.py
+tests/test_errors.py

starddb-1.0.0/starddb.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

starddb-1.0.0/starddb.egg-info/requires.txt

@@ -0,0 +1,4 @@
+filelock>=3.0
+
+[dev]
+pytest

starddb-1.0.0/starddb.egg-info/top_level.txt

@@ -0,0 +1 @@
+stardb

starddb-1.0.0/tests/test_crawl.py

@@ -0,0 +1,148 @@
+import sys
+import os
+import json
+sys.path.append("..")
+from stardb import StarDDBField, StarDDB
+
+# ── Test 1: crawl_db via StarDDB with nested structures ──
+
+print("--- crawl_db: nested structures ---")
+
+db_path = os.path.join(os.path.dirname(__file__), "test_db_crawl.json")
+
+initial = {
+    "player": {
+        "name": "Hero",
+        "stats": {
+            "hp": 100,
+            "mp": 50,
+            "atk": 25
+        },
+        "inventory": {
+            "gold": 300,
+            "gems": 12
+        }
+    },
+    "world": {
+        "level": 1,
+        "difficulty": 0.5
+    },
+    "debug": True,
+    "version": 2
+}
+
+with open(db_path, "w") as f:
+    json.dump(initial, f)
+
+db = StarDDB(db_path, save_time=1)
+hook = db.db()
+
+# Walk every level and verify every leaf is a StarDDBField
+def assert_crawled(path, node):
+    if isinstance(node, dict):
+        for key in node:
+            assert_crawled(f"{path}.{key}", node[key])
+    else:
+        assert isinstance(node, StarDDBField), f"{path} is {type(node)}, expected StarDDBField"
+
+# Check all leaves are StarDDBField
+assert_crawled("root", hook)
+print("All leaf nodes are StarDDBField instances: PASS")
+
+# Verify values survived crawling
+assert hook["player"]["stats"]["hp"].value == 100
+assert hook["player"]["inventory"]["gold"].value == 300
+assert hook["world"]["level"].value == 1
+assert hook["world"]["difficulty"].value == 0.5
+assert hook["debug"].value is True
+assert hook["version"].value == 2
+print("Crawled values match original: PASS")
+
+# Update deeply nested fields
+hook["player"]["stats"]["atk"].update("mult", 2)   # 50
+hook["player"]["inventory"]["gems"].update("add", 3)  # 15
+hook["world"]["difficulty"].update("mult", 2)       # 1.0
+
+assert hook["player"]["stats"]["atk"].value == 50
+assert hook["player"]["inventory"]["gems"].value == 15
+assert hook["world"]["difficulty"].value == 1.0
+print("Nested field updates work: PASS")
+
+# Persist and verify
+import time
+time.sleep(1.5)
+
+with open(db_path, "r") as f:
+    saved = json.load(f)
+
+expected_saved = {
+    "player": {
+        "name": "Hero",
+        "stats": {"hp": 100, "mp": 50, "atk": 50},
+        "inventory": {"gold": 300, "gems": 15}
+    },
+    "world": {"level": 1, "difficulty": 1.0},
+    "debug": True,
+    "version": 2
+}
+
+assert saved == expected_saved, f"Persisted data mismatch:\n  got:      {saved}\n  expected: {expected_saved}"
+print("Nested data persistence: PASS")
+
+db.close()
+
+# ── Test 2: edge cases ──
+
+print("\n--- crawl_db: edge cases ---")
+
+edge_path = os.path.join(os.path.dirname(__file__), "test_db_edge.json")
+
+# Empty dicts, None values, empty strings, zero, lists (left as-is)
+edge_data = {
+    "empty_section": {},
+    "null_val": None,
+    "empty_str": "",
+    "zero": 0,
+    "negative": -42,
+    "float": 3.14159
+}
+
+with open(edge_path, "w") as f:
+    json.dump(edge_data, f)
+
+db2 = StarDDB(edge_path, save_time=1)
+hook2 = db2.db()
+
+assert hook2["null_val"].value is None
+assert hook2["empty_str"].value == ""
+assert hook2["zero"].value == 0
+assert hook2["negative"].value == -42
+assert hook2["float"].value == 3.14159
+print("Edge values crawled correctly: PASS")
+
+assert hook2["empty_section"] == {}, "Empty dict should remain a dict"
+print("Empty dict preserved: PASS")
+
+hook2["null_val"].update("set", "now set")
+assert hook2["null_val"].value == "now set"
+hook2["zero"].update("add", 100)
+assert hook2["zero"].value == 100
+print("Edge field updates work: PASS")
+
+time.sleep(1.5)
+
+with open(edge_path, "r") as f:
+    saved2 = json.load(f)
+
+assert saved2["null_val"] == "now set"
+assert saved2["zero"] == 100
+assert saved2["empty_section"] == {}
+print("Edge data persistence: PASS")
+
+db2.close()
+
+# Cleanup
+os.remove(db_path)
+os.remove(edge_path)
+
+print("\n--- All crawl_db tests PASSED ---")

starddb-1.0.0/tests/test_errors.py

@@ -0,0 +1,119 @@
+import sys
+import os
+import json
+sys.path.append("..")
+from stardb import StarDDBField, StarDDB
+
+# ── Test 1: Invalid operation names ──
+
+print("--- Error path: invalid operations ---")
+
+field = StarDDBField(0)
+
+try:
+    field.update("sett", 1)
+    print("FAIL: Should have thrown for invalid operation 'sett'")
+except ValueError as e:
+    print(f"PASS: Invalid operation rejected: {e}")
+
+try:
+    field.update("addx", 5)
+    print("FAIL: Should have thrown for invalid operation 'addx'")
+except ValueError as e:
+    print(f"PASS: Invalid operation rejected: {e}")
+
+# ── Test 2: Division by zero ──
+
+print("\n--- Error path: division by zero ---")
+
+field2 = StarDDBField(100)
+
+try:
+    field2.update("div", 0)
+    print("FAIL: Should have thrown for division by zero")
+except ZeroDivisionError as e:
+    print(f"PASS: Division by zero rejected: {e}")
+
+assert field2.value == 100, "Value should be unchanged after failed div"
+print(f"Value unchanged after failed div: {'PASS' if field2.value == 100 else 'FAIL'}")
+
+# ── Test 3: Queue overflow ──
+
+print("\n--- Error path: queue overflow ---")
+
+# In Python, _run_list drains synchronously in the calling thread, so we need
+# to hold the lock to prevent draining while we flood the queue from another thread.
+field3 = StarDDBField(0, max_queue_size=5)
+
+# Hold the lock so _run_list can't drain
+field3._lock.acquire()
+overflow_caught = False
+try:
+    for i in range(10):
+        field3.queue.append({"method": "add", "value": 1})
+        field3._running = True  # prevent _run_list from thinking it's done
+except Exception:
+    pass
+field3._lock.release()
+
+# Now call update — queue is already over the limit
+try:
+    field3.update("add", 1)
+except RuntimeError as e:
+    if "Queue is full" in str(e):
+        overflow_caught = True
+
+print(f"PASS: Queue overflow rejected: {overflow_caught}")
+
+# ── Test 4: Corrupted JSON file ──
+
+print("\n--- Error path: corrupted database file ---")
+
+corrupt_path = os.path.join(os.path.dirname(__file__), "test_corrupt.json")
+with open(corrupt_path, "w") as f:
+    f.write("{ this is not valid json !!!")
+
+try:
+    db = StarDDB(corrupt_path, save_time=1)
+    print("FAIL: Should have thrown for corrupted JSON")
+except json.JSONDecodeError as e:
+    print(f"PASS: Corrupted file rejected: {e}")
+
+if os.path.exists(corrupt_path):
+    os.remove(corrupt_path)
+
+# ── Test 5: Missing database file ──
+
+print("\n--- Error path: missing database file ---")
+
+missing_path = os.path.join(os.path.dirname(__file__), "does_not_exist.json")
+
+try:
+    db = StarDDB(missing_path, save_time=1)
+    print("FAIL: Should have thrown for missing file")
+except FileNotFoundError as e:
+    print(f"PASS: Missing file rejected: {e}")
+
+# ── Test 6: Path traversal protection ──
+
+print("\n--- Error path: path traversal ---")
+
+try:
+    db = StarDDB("../../etc/passwd", save_time=1, safe_root=os.path.dirname(__file__))
+    print("FAIL: Should have thrown for path traversal")
+except ValueError as e:
+    print(f"PASS: Path traversal rejected: {e}")
+
+# ── Test 7: Valid operation after error ──
+
+print("\n--- Error path: recovery after errors ---")
+
+field4 = StarDDBField(10)
+field4.update("add", 5)
+field4.update("mult", 3)
+field4.flush()
+
+print(f"Field value after valid ops: {field4.value} (expect 45)")
+print(f"Recovery test: {'PASS' if field4.value == 45 else 'FAIL'}")
+
+print("\n--- All error path tests completed ---")