agmem 0.1.4__tar.gz → 0.1.5__tar.gz

{agmem-0.1.4/agmem.egg-info → agmem-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agmem
-Version: 0.1.4
+Version: 0.1.5
 Summary: Agentic Memory Version Control System - Git for AI agent memories
 Home-page: https://github.com/vivek-tiwari-vt/agmem
 Author: agmem Team

{agmem-0.1.4 → agmem-0.1.5/agmem.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agmem
-Version: 0.1.4
+Version: 0.1.5
 Summary: Agentic Memory Version Control System - Git for AI agent memories
 Home-page: https://github.com/vivek-tiwari-vt/agmem
 Author: agmem Team

{agmem-0.1.4 → agmem-0.1.5}/memvcs/commands/daemon.py

@@ -208,6 +208,7 @@ class DaemonCommand:
         health_check_interval = 3600  # default 1 hour
         try:
             from ..core.config_loader import load_agmem_config
+
             config = load_agmem_config(repo.root)
             daemon_cfg = config.get("daemon") or {}
             health_check_interval = int(daemon_cfg.get("health_check_interval_seconds", 3600))

{agmem-0.1.4 → agmem-0.1.5}/memvcs/commands/gc.py

@@ -62,5 +62,7 @@ class GcCommand:
                 dry_run=False,
             )
             if packed > 0:
-                print(f"Packed {packed} object(s) into pack file ({repack_freed} bytes from loose).")
+                print(
+                    f"Packed {packed} object(s) into pack file ({repack_freed} bytes from loose)."
+                )
         return 0

{agmem-0.1.4 → agmem-0.1.5}/memvcs/commands/prove.py

@@ -60,7 +60,9 @@ class ProveCommand:
             ok = prove_memory_freshness(path, args.value, out_path, mem_dir=repo.mem_dir)
 
         if not ok:
-            print("Proof generation failed (keyword not in file, or signing key not set for freshness).")
+            print(
+                "Proof generation failed (keyword not in file, or signing key not set for freshness)."
+            )
             return 1
         print(f"Proof written to {out_path}")
         return 0

{agmem-0.1.4 → agmem-0.1.5}/memvcs/commands/timeline.py

@@ -54,6 +54,7 @@ class TimelineCommand:
         if from_ts and to_ts:
             try:
                 from ..core.temporal_index import TemporalIndex
+
                 ti = TemporalIndex(repo.mem_dir, repo.object_store)
                 range_entries = ti.range_query(from_ts, to_ts)
                 commits_in_range = {ch for _, ch in range_entries}

{agmem-0.1.4 → agmem-0.1.5}/memvcs/commands/when.py

@@ -66,6 +66,7 @@ class WhenCommand:
         if from_ts and to_ts:
             try:
                 from ..core.temporal_index import TemporalIndex
+
                 ti = TemporalIndex(repo.mem_dir, repo.object_store)
                 range_entries = ti.range_query(from_ts, to_ts)
                 commits_in_range = {ch for _, ch in range_entries}

{agmem-0.1.4 → agmem-0.1.5}/memvcs/core/compression_pipeline.py

@@ -18,7 +18,9 @@ DEDUP_HASH_ALGO = "sha256"
 TIER_HOT_DAYS = 7
 
 
-def chunk_by_size(text: str, size: int = CHUNK_SIZE_DEFAULT, overlap: int = CHUNK_OVERLAP) -> List[str]:
+def chunk_by_size(
+    text: str, size: int = CHUNK_SIZE_DEFAULT, overlap: int = CHUNK_OVERLAP
+) -> List[str]:
     """Split text into chunks by character size with optional overlap."""
     if not text or size <= 0:
         return []
@@ -37,7 +39,7 @@ def chunk_by_sentences(text: str, max_chunk_chars: int = 512) -> List[str]:
     """Split text into chunks by sentence boundaries, up to max_chunk_chars per chunk."""
     if not text:
         return []
-    sentences = re.split(r'(?<=[.!?])\s+', text)
+    sentences = re.split(r"(?<=[.!?])\s+", text)
     chunks = []
     current = []
     current_len = 0
@@ -94,7 +96,10 @@ def dedup_by_similarity_threshold(
         embeddings = vector_store.embed(items)
         kept = [items[0]]
         for i in range(1, len(items)):
-            sims = [vector_store.similarity(embeddings[i], vector_store.embed([kept[j]])[0]) for j in range(len(kept))]
+            sims = [
+                vector_store.similarity(embeddings[i], vector_store.embed([kept[j]])[0])
+                for j in range(len(kept))
+            ]
             if not any(s >= threshold for s in sims):
                 kept.append(items[i])
         return kept
@@ -144,12 +149,15 @@ class CompressionPipeline:
         if self.dedup_hash:
             chunk_tuples = dedup_by_hash(chunks)
         else:
-            chunk_tuples = [(c, hashlib.new(DEDUP_HASH_ALGO, c.encode()).hexdigest()) for c in chunks]
+            chunk_tuples = [
+                (c, hashlib.new(DEDUP_HASH_ALGO, c.encode()).hexdigest()) for c in chunks
+            ]
         tier = None
         if self.tier_by_recency and path and path.exists():
             try:
                 mtime = path.stat().st_mtime
                 from datetime import datetime, timezone
+
                 age_days = (datetime.now(timezone.utc).timestamp() - mtime) / 86400
                 tier = "hot" if age_days <= TIER_HOT_DAYS else "cold"
             except Exception:

{agmem-0.1.4 → agmem-0.1.5}/memvcs/core/crypto_verify.py

@@ -239,7 +239,7 @@ def verify_commit(
     stored_sig = (commit.metadata or {}).get("signature")
     if not stored_root:
         return (False, "commit has no merkle_root (unverified)")
-    
+
     # Verify that blob objects can be loaded successfully (detects tampering in compressed/encrypted content)
     blob_hashes = _collect_blob_hashes_from_tree(store, commit.tree)
     for blob_hash in blob_hashes:
@@ -249,7 +249,7 @@ def verify_commit(
                 return (False, f"blob {blob_hash[:8]} corrupted or missing")
         except Exception as e:
             return (False, f"merkle_root mismatch (commit tampered)")
-    
+
     computed_root = build_merkle_root_for_commit(store, commit_hash)
     if not computed_root:
         return (False, "could not build Merkle tree (missing tree/blobs)")

{agmem-0.1.4 → agmem-0.1.5}/memvcs/core/distiller.py

@@ -164,9 +164,16 @@ class Distiller:
             out_path = self.target_dir / f"consolidated-{ts}.md"
 
         confidence_score = self.config.extraction_confidence_threshold
-        if self.config.use_dp and self.config.dp_epsilon is not None and self.config.dp_delta is not None:
+        if (
+            self.config.use_dp
+            and self.config.dp_epsilon is not None
+            and self.config.dp_delta is not None
+        ):
             from .privacy_budget import add_noise
-            confidence_score = add_noise(confidence_score, 0.1, self.config.dp_epsilon, self.config.dp_delta)
+
+            confidence_score = add_noise(
+                confidence_score, 0.1, self.config.dp_epsilon, self.config.dp_delta
+            )
             confidence_score = max(0.0, min(1.0, confidence_score))
         frontmatter = {
             "schema_version": "1.0",
@@ -277,12 +284,53 @@ class Distiller:
         clusters_processed = len(clusters)
         facts_extracted = facts_count
         episodes_archived = archived
-        if self.config.use_dp and self.config.dp_epsilon is not None and self.config.dp_delta is not None:
+        if (
+            self.config.use_dp
+            and self.config.dp_epsilon is not None
+            and self.config.dp_delta is not None
+        ):
             from .privacy_budget import add_noise
+
             sensitivity = 1.0
-            clusters_processed = max(0, int(round(add_noise(float(clusters_processed), sensitivity, self.config.dp_epsilon, self.config.dp_delta))))
-            facts_extracted = max(0, int(round(add_noise(float(facts_extracted), sensitivity, self.config.dp_epsilon, self.config.dp_delta))))
-            episodes_archived = max(0, int(round(add_noise(float(episodes_archived), sensitivity, self.config.dp_epsilon, self.config.dp_delta))))
+            clusters_processed = max(
+                0,
+                int(
+                    round(
+                        add_noise(
+                            float(clusters_processed),
+                            sensitivity,
+                            self.config.dp_epsilon,
+                            self.config.dp_delta,
+                        )
+                    )
+                ),
+            )
+            facts_extracted = max(
+                0,
+                int(
+                    round(
+                        add_noise(
+                            float(facts_extracted),
+                            sensitivity,
+                            self.config.dp_epsilon,
+                            self.config.dp_delta,
+                        )
+                    )
+                ),
+            )
+            episodes_archived = max(
+                0,
+                int(
+                    round(
+                        add_noise(
+                            float(episodes_archived),
+                            sensitivity,
+                            self.config.dp_epsilon,
+                            self.config.dp_delta,
+                        )
+                    )
+                ),
+            )
 
         return DistillerResult(
             success=True,

{agmem-0.1.4 → agmem-0.1.5}/memvcs/core/federated.py

@@ -48,6 +48,7 @@ def _extract_topic_from_md(path: Path, content: str) -> str:
         if end > 0:
             try:
                 import yaml
+
                 fm = yaml.safe_load(content[3:end])
                 if isinstance(fm, dict):
                     tags = fm.get("tags", [])
@@ -62,7 +63,11 @@ def _extract_topic_from_md(path: Path, content: str) -> str:
 
 
 def produce_local_summary(
-    repo_root: Path, memory_types: List[str], use_dp: bool = False, dp_epsilon: float = 0.1, dp_delta: float = 1e-5
+    repo_root: Path,
+    memory_types: List[str],
+    use_dp: bool = False,
+    dp_epsilon: float = 0.1,
+    dp_delta: float = 1e-5,
 ) -> Dict[str, Any]:
     """
     Produce a local summary from episodic/semantic data (no raw content).
@@ -101,10 +106,15 @@ def produce_local_summary(
 
     if use_dp and dp_epsilon and dp_delta:
         from .privacy_budget import add_noise
+
         for mtype in summary["topics"]:
             raw = summary["topics"][mtype]
-            summary["topics"][mtype] = max(0, int(round(add_noise(float(raw), 1.0, dp_epsilon, dp_delta))))
-        summary["fact_count"] = max(0, int(round(add_noise(float(summary["fact_count"]), 1.0, dp_epsilon, dp_delta))))
+            summary["topics"][mtype] = max(
+                0, int(round(add_noise(float(raw), 1.0, dp_epsilon, dp_delta)))
+            )
+        summary["fact_count"] = max(
+            0, int(round(add_noise(float(summary["fact_count"]), 1.0, dp_epsilon, dp_delta)))
+        )
 
     return summary
 

{agmem-0.1.4 → agmem-0.1.5}/memvcs/core/gardener.py

@@ -356,11 +356,26 @@ class Gardener:
 
         # Generate frontmatter (optionally noised for differential privacy)
         source_episodes = len(cluster.episodes)
-        if self.config.use_dp and self.config.dp_epsilon is not None and self.config.dp_delta is not None:
+        if (
+            self.config.use_dp
+            and self.config.dp_epsilon is not None
+            and self.config.dp_delta is not None
+        ):
             from .privacy_budget import add_noise
-            source_episodes = max(0, int(round(add_noise(
-                float(source_episodes), 1.0, self.config.dp_epsilon, self.config.dp_delta
-            ))))
+
+            source_episodes = max(
+                0,
+                int(
+                    round(
+                        add_noise(
+                            float(source_episodes),
+                            1.0,
+                            self.config.dp_epsilon,
+                            self.config.dp_delta,
+                        )
+                    )
+                ),
+            )
         frontmatter = {
             "schema_version": "1.0",
             "last_updated": datetime.utcnow().isoformat() + "Z",
@@ -499,12 +514,53 @@ class Gardener:
         clusters_found = len(clusters)
         insights_generated = insights_written
         episodes_archived = archived_count
-        if self.config.use_dp and self.config.dp_epsilon is not None and self.config.dp_delta is not None:
+        if (
+            self.config.use_dp
+            and self.config.dp_epsilon is not None
+            and self.config.dp_delta is not None
+        ):
             from .privacy_budget import add_noise
+
             sensitivity = 1.0
-            clusters_found = max(0, int(round(add_noise(float(clusters_found), sensitivity, self.config.dp_epsilon, self.config.dp_delta))))
-            insights_generated = max(0, int(round(add_noise(float(insights_generated), sensitivity, self.config.dp_epsilon, self.config.dp_delta))))
-            episodes_archived = max(0, int(round(add_noise(float(episodes_archived), sensitivity, self.config.dp_epsilon, self.config.dp_delta))))
+            clusters_found = max(
+                0,
+                int(
+                    round(
+                        add_noise(
+                            float(clusters_found),
+                            sensitivity,
+                            self.config.dp_epsilon,
+                            self.config.dp_delta,
+                        )
+                    )
+                ),
+            )
+            insights_generated = max(
+                0,
+                int(
+                    round(
+                        add_noise(
+                            float(insights_generated),
+                            sensitivity,
+                            self.config.dp_epsilon,
+                            self.config.dp_delta,
+                        )
+                    )
+                ),
+            )
+            episodes_archived = max(
+                0,
+                int(
+                    round(
+                        add_noise(
+                            float(episodes_archived),
+                            sensitivity,
+                            self.config.dp_epsilon,
+                            self.config.dp_delta,
+                        )
+                    )
+                ),
+            )
 
         return GardenerResult(
             success=True,

{agmem-0.1.4 → agmem-0.1.5}/memvcs/core/ipfs_remote.py

@@ -103,8 +103,7 @@ def _add_to_ipfs_gateway(bundle: bytes, gateway_url: str) -> Optional[str]:
     body = (
         b"--" + boundary.encode() + b"\r\n"
         b'Content-Disposition: form-data; name="file"; filename="agmem-bundle.bin"\r\n'
-        b"Content-Type: application/octet-stream\r\n\r\n"
-        + bundle + b"\r\n"
+        b"Content-Type: application/octet-stream\r\n\r\n" + bundle + b"\r\n"
         b"--" + boundary.encode() + b"--\r\n"
     )
     try:

{agmem-0.1.4 → agmem-0.1.5}/memvcs/core/knowledge_graph.py

@@ -326,7 +326,9 @@ class KnowledgeGraphBuilder:
                 common = file_entities.get(path1, set()) & file_entities.get(path2, set())
                 if common:
                     w = min(1.0, 0.3 + 0.1 * len(common))
-                    edge = GraphEdge(source=path1, target=path2, edge_type="co_occurrence", weight=w)
+                    edge = GraphEdge(
+                        source=path1, target=path2, edge_type="co_occurrence", weight=w
+                    )
                     edges.append(edge)
                     if self._graph is not None:
                         self._graph.add_edge(path1, path2, type="co_occurrence", weight=w)

{agmem-0.1.4 → agmem-0.1.5}/memvcs/core/objects.py

@@ -110,6 +110,7 @@ class ObjectStore:
         # Try pack file when loose object missing
         try:
             from .pack import retrieve_from_pack
+
             result = retrieve_from_pack(self.objects_dir, hash_id, expected_type=obj_type)
             if result is not None:
                 return result[1]
@@ -126,6 +127,7 @@ class ObjectStore:
             return True
         try:
             from .pack import retrieve_from_pack
+
             return retrieve_from_pack(self.objects_dir, hash_id, expected_type=obj_type) is not None
         except Exception:
             return False

{agmem-0.1.4 → agmem-0.1.5}/memvcs/core/pack.py

@@ -21,7 +21,12 @@ OBJ_TYPE_BLOB = 1
 OBJ_TYPE_TREE = 2
 OBJ_TYPE_COMMIT = 3
 OBJ_TYPE_TAG = 4
-TYPE_TO_BYTE = {"blob": OBJ_TYPE_BLOB, "tree": OBJ_TYPE_TREE, "commit": OBJ_TYPE_COMMIT, "tag": OBJ_TYPE_TAG}
+TYPE_TO_BYTE = {
+    "blob": OBJ_TYPE_BLOB,
+    "tree": OBJ_TYPE_TREE,
+    "commit": OBJ_TYPE_COMMIT,
+    "tag": OBJ_TYPE_TAG,
+}
 BYTE_TO_TYPE = {v: k for k, v in TYPE_TO_BYTE.items()}
 
 
@@ -152,7 +157,12 @@ def write_pack(
     if not index_entries:
         raise ValueError("No objects to pack")
 
-    pack_content = PACK_MAGIC + struct.pack(">I", PACK_VERSION) + struct.pack(">I", len(index_entries)) + bytes(pack_body)
+    pack_content = (
+        PACK_MAGIC
+        + struct.pack(">I", PACK_VERSION)
+        + struct.pack(">I", len(index_entries))
+        + bytes(pack_body)
+    )
     pack_hash = hashlib.sha256(pack_content).digest()
     pack_content += pack_hash
 
@@ -160,7 +170,9 @@ def write_pack(
     pack_path = pack_d / pack_name
     pack_path.write_bytes(pack_content)
 
-    index_content = bytearray(IDX_MAGIC + struct.pack(">I", IDX_VERSION) + struct.pack(">I", len(index_entries)))
+    index_content = bytearray(
+        IDX_MAGIC + struct.pack(">I", IDX_VERSION) + struct.pack(">I", len(index_entries))
+    )
     for hash_id, obj_type, off in index_entries:
         index_content.extend(bytes.fromhex(hash_id))
         index_content.append(TYPE_TO_BYTE[obj_type])
@@ -184,7 +196,9 @@ def _find_pack_index(objects_dir: Path) -> Optional[Path]:
     return None
 
 
-def retrieve_from_pack(objects_dir: Path, hash_id: str, expected_type: Optional[str] = None) -> Optional[Tuple[str, bytes]]:
+def retrieve_from_pack(
+    objects_dir: Path, hash_id: str, expected_type: Optional[str] = None
+) -> Optional[Tuple[str, bytes]]:
     """
     Retrieve object from pack by hash. Returns (obj_type, content) or None.
     If expected_type is set, only return if pack type matches.

{agmem-0.1.4 → agmem-0.1.5}/memvcs/core/remote.py

@@ -70,6 +70,7 @@ def _collect_objects_from_commit(store: ObjectStore, commit_hash: str) -> Set[st
 def _read_object_from_adapter(adapter: Any, hash_id: str) -> Optional[tuple]:
     """Read object from storage adapter. Returns (obj_type, content_bytes) or None."""
     import zlib
+
     for obj_type in ["commit", "tree", "blob", "tag"]:
         rel = f".mem/objects/{obj_type}/{hash_id[:2]}/{hash_id[2:]}"
         if not adapter.exists(rel):
@@ -78,7 +79,7 @@ def _read_object_from_adapter(adapter: Any, hash_id: str) -> Optional[tuple]:
             raw = adapter.read_file(rel)
             full = zlib.decompress(raw)
             null_idx = full.index(b"\0")
-            content = full[null_idx + 1:]
+            content = full[null_idx + 1 :]
             return (obj_type, content)
         except Exception:
             continue
@@ -240,7 +241,10 @@ class Remote:
                 adapter.write_file(f".mem/refs/tags/{t}", (ch + "\n").encode())
         try:
             from .audit import append_audit
-            append_audit(self.mem_dir, "push", {"remote": self.name, "branch": branch, "copied": copied})
+
+            append_audit(
+                self.mem_dir, "push", {"remote": self.name, "branch": branch, "copied": copied}
+            )
         except Exception:
             pass
         return f"Pushed {copied} object(s) to {self.name}"
@@ -290,7 +294,10 @@ class Remote:
                     break
         try:
             from .audit import append_audit
-            append_audit(self.mem_dir, "fetch", {"remote": self.name, "branch": branch, "copied": copied})
+
+            append_audit(
+                self.mem_dir, "fetch", {"remote": self.name, "branch": branch, "copied": copied}
+            )
         except Exception:
             pass
         return f"Fetched {copied} object(s) from {self.name}"
@@ -308,6 +315,7 @@ class Remote:
             try:
                 from .storage import get_adapter
                 from .storage.base import LockError
+
                 adapter = get_adapter(url, self._config)
                 lock_name = "agmem-push"
                 adapter.acquire_lock(lock_name, 30)
@@ -423,6 +431,7 @@ class Remote:
             try:
                 from .storage import get_adapter
                 from .storage.base import LockError
+
                 adapter = get_adapter(url, self._config)
                 lock_name = "agmem-fetch"
                 adapter.acquire_lock(lock_name, 30)

{agmem-0.1.4 → agmem-0.1.5}/memvcs/core/zk_proofs.py

@@ -79,6 +79,7 @@ def prove_memory_freshness(
         stat = memory_path.stat()
         ts = stat.st_mtime
         from datetime import datetime, timezone
+
         iso_ts = datetime.fromtimestamp(ts, tz=timezone.utc).isoformat()
     except Exception:
         return False
@@ -150,6 +151,7 @@ def verify_proof(proof_path: Path, statement_type: str, **kwargs: Any) -> bool:
             return False
         try:
             from datetime import datetime
+
             after_dt = datetime.fromisoformat(after_ts.replace("Z", "+00:00"))
             ts_dt = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
             return ts_dt >= after_dt

{agmem-0.1.4 → agmem-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agmem"
-version = "0.1.4"
+version = "0.1.5"
 description = "Agentic Memory Version Control System - Git for AI agent memories"
 readme = "README.md"
 license = {text = "MIT"}

{agmem-0.1.4 → agmem-0.1.5}/tests/test_federated.py

@@ -20,7 +20,9 @@ class TestProduceLocalSummary:
         with tempfile.TemporaryDirectory() as tmpdir:
             root = Path(tmpdir)
             (root / "current" / "semantic").mkdir(parents=True)
-            (root / "current" / "semantic" / "prefs.md").write_text("# User prefs\n- prefers dark mode")
+            (root / "current" / "semantic" / "prefs.md").write_text(
+                "# User prefs\n- prefers dark mode"
+            )
             summary = produce_local_summary(root, ["semantic"])
             assert "topics" in summary
             assert summary["topics"].get("semantic", 0) >= 1
@@ -34,7 +36,9 @@ class TestProduceLocalSummary:
             for i in range(3):
                 (root / "current" / "episodic" / f"e{i}.md").write_text(f"episode {i}")
             raw = produce_local_summary(root, ["episodic"], use_dp=False)
-            noised = produce_local_summary(root, ["episodic"], use_dp=True, dp_epsilon=0.5, dp_delta=1e-5)
+            noised = produce_local_summary(
+                root, ["episodic"], use_dp=True, dp_epsilon=0.5, dp_delta=1e-5
+            )
             assert "topics" in noised
             assert "fact_count" in noised
 

{agmem-0.1.4 → agmem-0.1.5}/tests/test_privacy_budget.py

@@ -97,10 +97,14 @@ class TestGardenerDistillerDPIntegration:
                     self.refs = None
 
             fake_repo = FakeRepo(root)
-            config = GardenerConfig(threshold=2, auto_commit=False, use_dp=True, dp_epsilon=0.1, dp_delta=1e-5)
+            config = GardenerConfig(
+                threshold=2, auto_commit=False, use_dp=True, dp_epsilon=0.1, dp_delta=1e-5
+            )
             gardener = Gardener(fake_repo, config)
 
-            with patch("memvcs.core.privacy_budget.add_noise", side_effect=lambda v, s, e, d: v + 1):
+            with patch(
+                "memvcs.core.privacy_budget.add_noise", side_effect=lambda v, s, e, d: v + 1
+            ):
                 result = gardener.run(force=True)
             assert result.success
             assert result.clusters_found >= 0
@@ -125,13 +129,25 @@ class TestGardenerDistillerDPIntegration:
                     self.current_dir = r / "current"
                     self.mem_dir = r / ".mem"
                     self.object_store = None
-                    self.refs = type("R", (), {"branch_exists": lambda n: True, "create_branch": lambda n: None, "get_current_branch": lambda: "main"})()
+                    self.refs = type(
+                        "R",
+                        (),
+                        {
+                            "branch_exists": lambda n: True,
+                            "create_branch": lambda n: None,
+                            "get_current_branch": lambda: "main",
+                        },
+                    )()
 
             fake_repo = FakeRepo(root)
-            config = DistillerConfig(create_safety_branch=False, use_dp=True, dp_epsilon=0.1, dp_delta=1e-5)
+            config = DistillerConfig(
+                create_safety_branch=False, use_dp=True, dp_epsilon=0.1, dp_delta=1e-5
+            )
             distiller = Distiller(fake_repo, config)
 
-            with patch("memvcs.core.privacy_budget.add_noise", side_effect=lambda v, s, e, d: v + 0.5):
+            with patch(
+                "memvcs.core.privacy_budget.add_noise", side_effect=lambda v, s, e, d: v + 0.5
+            ):
                 result = distiller.run()
             assert result.success
             assert result.facts_extracted >= 0