kvgit 0.2.0__tar.gz → 0.2.1__tar.gz

{kvgit-0.2.0 → kvgit-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kvgit
-Version: 0.2.0
+Version: 0.2.1
 Summary: Versioned key-value store with git-like commit, branch, and merge semantics.
 Author: ashenfad
 License: MIT

{kvgit-0.2.0 → kvgit-0.2.1}/kvgit/staged.py

@@ -140,6 +140,7 @@ class Staged(MutableMapping[str, Any]):
     def commit(
         self,
         *,
+        keys: set[str] | None = None,
         on_conflict: str = "raise",
         merge_fns: dict[str, MergeFn] | None = None,
         default_merge: MergeFn | None = None,
@@ -148,20 +149,36 @@ class Staged(MutableMapping[str, Any]):
         """Flush staged changes to the underlying Versioned store.
 
         Encodes staged values to bytes, wraps merge functions, and
-        calls ``Versioned.commit()``. On success, clears the staging
-        buffer.
+        calls ``Versioned.commit()``. On success, clears the committed
+        entries from the staging buffer.
+
+        Args:
+            keys: If provided, only commit these specific keys.
+                Keys not in ``_updates`` or ``_removals`` are silently
+                ignored. Uncommitted keys remain staged for a future
+                commit. When ``None`` (default), all staged changes
+                are committed.
 
         Returns:
             A MergeResult (truthy when committed).
         """
-        # Encode staged updates to bytes
+        # Encode staged updates to bytes — scoped to keys if provided
         encoded_updates: dict[str, bytes] | None = None
-        if self._updates:
-            encoded_updates = {
-                key: self._encoder(value) for key, value in self._updates.items()
-            }
-
-        removals = self._removals if self._removals else None
+        if keys is not None:
+            # Iterate the (typically small) keys set, not the full _updates dict
+            matched_updates = {k: self._updates[k] for k in keys if k in self._updates}
+            if matched_updates:
+                encoded_updates = {
+                    k: self._encoder(v) for k, v in matched_updates.items()
+                }
+            # .intersection() accepts any iterable, not just sets
+            removals = self._removals.intersection(keys) or None
+        else:
+            if self._updates:
+                encoded_updates = {
+                    key: self._encoder(value) for key, value in self._updates.items()
+                }
+            removals = self._removals if self._removals else None
 
         # Build effective merge fns and wrap to bytes-level
         effective_fns = dict(self._merge_fns)
@@ -188,8 +205,16 @@ class Staged(MutableMapping[str, Any]):
             info=info,
         )
         if result.merged:
-            self._updates.clear()
-            self._removals.clear()
+            if keys is not None:
+                # Only clear the committed keys from staging
+                for k in keys:
+                    self._updates.pop(k, None)
+                    self._removals.discard(k)
+            else:
+                self._updates.clear()
+                self._removals.clear()
+            # Always clear the full read cache — HEAD moved, so cached
+            # values from other keys may be stale after a merge.
             self._cache.clear()
         return result
 

{kvgit-0.2.0 → kvgit-0.2.1}/kvgit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kvgit
-Version: 0.2.0
+Version: 0.2.1
 Summary: Versioned key-value store with git-like commit, branch, and merge semantics.
 Author: ashenfad
 License: MIT

{kvgit-0.2.0 → kvgit-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kvgit"
-version = "0.2.0"
+version = "0.2.1"
 description = "Versioned key-value store with git-like commit, branch, and merge semantics."
 authors = [{ name = "ashenfad" }]
 requires-python = ">=3.10"

{kvgit-0.2.0 → kvgit-0.2.1}/tests/test_staged.py

@@ -173,6 +173,117 @@ class TestStagedCommit:
         assert s.versioned.commit_info() == {"author": "test"}
 
 
+class TestStagedPartialCommit:
+    """Tests for commit(keys=...) partial commit support."""
+
+    def test_partial_commit_only_flushes_specified_keys(self):
+        store = Memory()
+        v = Versioned(store)
+        s = Staged(v)
+        s["a"] = 1
+        s["b"] = 2
+        result = s.commit(keys={"a"})
+        assert result.merged
+
+        # "a" is committed and no longer staged
+        assert not s.is_staged("a")
+        # "b" is still staged
+        assert s.is_staged("b")
+        assert s["b"] == 2
+
+    def test_partial_commit_persists_committed_keys(self):
+        store = Memory()
+        v = Versioned(store)
+        s = Staged(v)
+        s["a"] = 1
+        s["b"] = 2
+        s.commit(keys={"a"})
+
+        # Verify "a" is persisted (visible from a fresh Staged)
+        s2 = Staged(Versioned(store))
+        assert s2.get("a") == 1
+        # "b" is NOT persisted (still only in s's staging buffer)
+        assert s2.get("b") is None
+
+    def test_partial_commit_with_info(self):
+        s = Staged(Versioned())
+        s["a"] = 1
+        s["b"] = 2
+        result = s.commit(keys={"a"}, info={"message": "just a"})
+        assert result.merged
+        assert s.versioned.commit_info()["message"] == "just a"
+
+    def test_partial_commit_ignores_unknown_keys(self):
+        s = Staged(Versioned())
+        s["a"] = 1
+        # "ghost" is not staged — should be silently ignored
+        result = s.commit(keys={"a", "ghost"})
+        assert result.merged
+        assert not s.is_staged("a")
+
+    def test_partial_commit_with_removals(self):
+        s = Staged(Versioned())
+        s["a"] = 1
+        s["b"] = 2
+        s.commit()
+
+        del s["a"]
+        s["c"] = 3
+        # Partial commit: only the removal of "a"
+        s.commit(keys={"a"})
+        assert s.get("a") is None  # deleted
+        assert s.is_staged("c")  # still pending
+
+    def test_partial_commit_clears_full_cache(self):
+        """Regression test: after a partial commit, the entire read cache
+        must be cleared because HEAD moved. Cached values from non-committed
+        keys could be stale if a concurrent writer modified them.
+        """
+        store = Memory()
+        v = Versioned(store)
+        s = Staged(v)
+
+        s["x"] = "original_x"
+        s["y"] = "original_y"
+        s.commit()
+
+        # Read "y" to populate the cache
+        assert s["y"] == "original_y"
+
+        # Simulate a concurrent writer updating "y" on the same branch
+        v2 = Versioned(store)
+        v2.commit({"y": s._encoder("updated_by_other")})
+
+        # Partial commit of "x" — HEAD moves to include the concurrent write
+        s["x"] = "new_x"
+        s.commit(keys={"x"})
+
+        # After partial commit, "y" should reflect the concurrent update,
+        # NOT the stale cached value.  Before the fix, only "x" was evicted
+        # from cache, leaving "y" stale as "original_y".
+        s.refresh()
+        assert s["y"] == "updated_by_other"
+
+    def test_keys_accepts_non_set_iterable(self):
+        """keys parameter should accept any iterable, not just sets."""
+        s = Staged(Versioned())
+        s["a"] = 1
+        s["b"] = 2
+        # Pass a list instead of a set
+        result = s.commit(keys=["a"])
+        assert result.merged
+        assert not s.is_staged("a")
+        assert s.is_staged("b")
+
+    def test_full_commit_unchanged_when_keys_is_none(self):
+        """Without keys, commit flushes everything (backwards compatible)."""
+        s = Staged(Versioned())
+        s["a"] = 1
+        s["b"] = 2
+        s.commit()
+        assert not s.has_changes
+
+
 class TestStagedReset:
     def test_reset_clears_staging(self):
         s = Staged(Versioned())