dsh-biocore 0.3.3 → 0.5.0

package/python/biocore_model/tests/test_governance.py

@@ -1,181 +1,181 @@
-# -*- coding: utf-8 -*-
-"""task-223: memory governance (decay/index/consolidate/concepts) + relationship."""
-import json
-import tempfile
-import time
-import unittest
-from pathlib import Path
-
-from biocore_runtime import governance
-from biocore_runtime import pipeline
-from biocore_runtime import relationship_state
-
-
-def write_json(path, data):
-    path = Path(path)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
-
-
-def memory(entry_id, text, ts, importance=0.5, concepts=None):
-    row = {"id": entry_id, "text": text, "role": "user", "ts": ts,
-           "importance": importance, "hits": 1}
-    if concepts is not None:
-        row["concepts"] = list(concepts)
-    return row
-
-
-class StoreCase(unittest.TestCase):
-    NOW = 1700000000.0
-
-    def setUp(self):
-        self.tmp = tempfile.TemporaryDirectory()
-        self.data_dir = Path(self.tmp.name) / "data"
-        self.store = self.data_dir / "memory"
-        self.persona = Path(self.tmp.name) / "missing_persona.json"
-        self.write_session("s1", [
-            memory("fresh", "今天买了咖啡", self.NOW - 60, 0.9),
-            memory("old", "很久以前的事", self.NOW - 400 * 86400, 0.2),
-            memory("mid", "苹果很甜", self.NOW - 86400, 0.5),
-        ])
-
-    def tearDown(self):
-        self.tmp.cleanup()
-
-    def write_session(self, session_id, entries):
-        write_json(self.store / "sessions" / session_id / "memory.json",
-                   {"session_id": session_id, "entries": entries})
-
-    def payload(self, session_id="s1", **extra):
-        data = {"store": str(self.store), "session_id": session_id,
-                "persona_profile": str(self.persona)}
-        data.update(extra)
-        return data
-
-    def turn_end(self, session_id="s1", user_text="", **extra):
-        return pipeline.dispatch("turn_end", self.payload(
-            session_id, user_text=user_text, assistant_text="嗯。",
-            capture=False, **extra))
-
-
-class DecayTest(StoreCase):
-    def test_decay_marks_but_never_deletes(self):
-        before = len(governance._entries(self.store))
-        out = governance.run(self.store, now=self.NOW, force=True)
-        after = len(governance._entries(self.store))
-        self.assertEqual(before, after)
-        self.assertGreaterEqual(out["decay"]["cold"], 1)
-        self.assertEqual(out["decay"]["deleted"], 0)
-        self.assertLess(governance.weight_of(self.store, "old"), 1.0)
-
-    def test_fresh_entry_keeps_full_weight(self):
-        governance.run(self.store, now=self.NOW, force=True)
-        self.assertEqual(governance.weight_of(self.store, "fresh"), 1.0)
-
-    def test_evict_delete_flag_does_not_delete(self):
-        write_json(self.data_dir / "flags.json", {"evict_delete": True})
-        before = len(governance._entries(self.store))
-        governance.run(self.store, now=self.NOW, force=True)
-        self.assertEqual(len(governance._entries(self.store)), before)
-
-    def test_governance_off_skips(self):
-        write_json(self.data_dir / "flags.json", {"governance": False})
-        out = governance.run(self.store, now=self.NOW, force=True)
-        self.assertTrue(out.get("skipped"))
-        self.assertFalse((self.store / "governance.json").exists())
-
-
-class IndexAndConceptTest(StoreCase):
-    def test_index_lookup_hits_entry(self):
-        governance.run(self.store, now=self.NOW, force=True)
-        self.assertIn("mid", governance.lookup(self.store, "苹果"))
-        doc = json.loads((self.store / "index.json").read_text(encoding="utf-8"))
-        self.assertTrue(doc["terms"])
-
-    def test_inject_uses_index_and_counts_hit(self):
-        governance.run(self.store, now=self.NOW, force=True)
-        out = pipeline.inject_block("s1", str(self.store), query="苹果",
-                                    mode="query", top_k=3)
-        self.assertEqual(out["ids"][0], "mid")
-        gov = json.loads((self.store / "governance.json").read_text(encoding="utf-8"))
-        self.assertGreaterEqual(gov.get("index_hits", 0), 1)
-
-    def test_remember_stores_concepts(self):
-        pipeline.tool_call("remember", {"text": "苹果和咖啡都很好"},
-                           {"root": str(self.store)}, session_id="s2")
-        doc = json.loads((self.store / "sessions" / "s2" / "memory.json")
-                         .read_text(encoding="utf-8"))
-        self.assertTrue(doc["entries"][0].get("concepts"))
-
-    def test_concept_filter_narrows_candidates(self):
-        entries = [{"id": "a", "concepts": ["苹果", "甜"]},
-                   {"id": "b", "concepts": ["香蕉", "黄"]}]
-        kept = pipeline._concept_filter(entries, "苹果")
-        self.assertEqual([row["id"] for row in kept], ["a"])
-
-
-class ConsolidateTest(StoreCase):
-    def test_consolidate_is_idempotent(self):
-        self.write_session("s2", [
-            memory("c1", "注意安全", self.NOW - 3),
-            memory("c2", "出门注意安全", self.NOW - 2),
-            memory("c3", "记得注意安全", self.NOW - 1),
-        ])
-        first = governance.run(self.store, now=self.NOW, force=True)
-        second = governance.run(self.store, now=self.NOW + 1, force=True)
-        self.assertEqual(first["consolidate"]["candidates"],
-                         second["consolidate"]["candidates"])
-        self.assertTrue(second["consolidate"]["candidates"] >= 1)
-        self.assertFalse(second["consolidate"]["changed"])
-        doc = json.loads((self.store / "consolidate.json").read_text(encoding="utf-8"))
-        self.assertGreaterEqual(doc["runs"], 2)
-
-    def test_graph_and_aggregate(self):
-        self.write_session("s2", [memory("g1", "苹果 苹果 甜", self.NOW - 5),
-                                  memory("g2", "苹果 很甜", self.NOW - 4)])
-        out = governance.run(self.store, now=self.NOW, force=True)
-        self.assertGreaterEqual(out["graph"]["nodes"], 1)
-        self.assertGreaterEqual(out["aggregate"]["sessions"], 2)
-
-
-class RelationshipTest(StoreCase):
-    def test_warm_text_raises_closeness(self):
-        self.turn_end(user_text="谢谢你陪我，今天很开心")
-        rel = json.loads((self.store / "relationship.json").read_text(encoding="utf-8"))
-        self.assertGreater(rel["relationship"]["closeness"], 0.5)
-        self.assertGreater(rel["relationship"]["trust"], 0.5)
-
-    def test_conflict_text_raises_conflict(self):
-        self.turn_end(user_text="我很生气，别说了")
-        rel = json.loads((self.store / "relationship.json").read_text(encoding="utf-8"))
-        self.assertGreater(rel["relationship"]["conflict"], 0.0)
-        self.assertLess(rel["relationship"]["trust"], 0.5)
-
-    def test_repair_lowers_conflict(self):
-        self.turn_end(user_text="我很生气")
-        self.turn_end(user_text="对不起，是我不好")
-        rel = json.loads((self.store / "relationship.json").read_text(encoding="utf-8"))
-        summary = relationship_state.summary(self.store, rel["relationship"])
-        self.assertGreaterEqual(summary["repairs"], 1)
-        self.assertLess(rel["relationship"]["conflict"], 0.02)
-
-    def test_relationship_off_keeps_values(self):
-        write_json(self.data_dir / "flags.json", {"relationship_governance": False})
-        self.turn_end(user_text="谢谢你陪我")
-        rel = json.loads((self.store / "relationship.json").read_text(encoding="utf-8"))
-        self.assertAlmostEqual(rel["relationship"]["closeness"], 0.5, places=4)
-        self.assertAlmostEqual(rel["relationship"]["trust"], 0.5, places=4)
-        self.assertFalse((self.store / "relationship_memory.json").exists())
-
-    def test_state_exposes_numbers(self):
-        self.turn_end(user_text="谢谢你陪我")
-        out = pipeline.dispatch("state", self.payload())
-        body = out["state"]
-        self.assertIn("governance", body)
-        self.assertIn("decay", body["governance"])
-        self.assertIn("relationship_summary", body)
-        self.assertGreaterEqual(body["relationship_summary"]["events"], 1)
-
-
-if __name__ == "__main__":
-    unittest.main()
+# -*- coding: utf-8 -*-
+"""task-223: memory governance (decay/index/consolidate/concepts) + relationship."""
+import json
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+from biocore_runtime import governance
+from biocore_runtime import pipeline
+from biocore_runtime import relationship_state
+
+
+def write_json(path, data):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def memory(entry_id, text, ts, importance=0.5, concepts=None):
+    row = {"id": entry_id, "text": text, "role": "user", "ts": ts,
+           "importance": importance, "hits": 1}
+    if concepts is not None:
+        row["concepts"] = list(concepts)
+    return row
+
+
+class StoreCase(unittest.TestCase):
+    NOW = 1700000000.0
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.data_dir = Path(self.tmp.name) / "data"
+        self.store = self.data_dir / "memory"
+        self.persona = Path(self.tmp.name) / "missing_persona.json"
+        self.write_session("s1", [
+            memory("fresh", "今天买了咖啡", self.NOW - 60, 0.9),
+            memory("old", "很久以前的事", self.NOW - 400 * 86400, 0.2),
+            memory("mid", "苹果很甜", self.NOW - 86400, 0.5),
+        ])
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def write_session(self, session_id, entries):
+        write_json(self.store / "sessions" / session_id / "memory.json",
+                   {"session_id": session_id, "entries": entries})
+
+    def payload(self, session_id="s1", **extra):
+        data = {"store": str(self.store), "session_id": session_id,
+                "persona_profile": str(self.persona)}
+        data.update(extra)
+        return data
+
+    def turn_end(self, session_id="s1", user_text="", **extra):
+        return pipeline.dispatch("turn_end", self.payload(
+            session_id, user_text=user_text, assistant_text="嗯。",
+            capture=False, **extra))
+
+
+class DecayTest(StoreCase):
+    def test_decay_marks_but_never_deletes(self):
+        before = len(governance._entries(self.store))
+        out = governance.run(self.store, now=self.NOW, force=True)
+        after = len(governance._entries(self.store))
+        self.assertEqual(before, after)
+        self.assertGreaterEqual(out["decay"]["cold"], 1)
+        self.assertEqual(out["decay"]["deleted"], 0)
+        self.assertLess(governance.weight_of(self.store, "old"), 1.0)
+
+    def test_fresh_entry_keeps_full_weight(self):
+        governance.run(self.store, now=self.NOW, force=True)
+        self.assertEqual(governance.weight_of(self.store, "fresh"), 1.0)
+
+    def test_evict_delete_flag_does_not_delete(self):
+        write_json(self.data_dir / "flags.json", {"evict_delete": True})
+        before = len(governance._entries(self.store))
+        governance.run(self.store, now=self.NOW, force=True)
+        self.assertEqual(len(governance._entries(self.store)), before)
+
+    def test_governance_off_skips(self):
+        write_json(self.data_dir / "flags.json", {"governance": False})
+        out = governance.run(self.store, now=self.NOW, force=True)
+        self.assertTrue(out.get("skipped"))
+        self.assertFalse((self.store / "governance.json").exists())
+
+
+class IndexAndConceptTest(StoreCase):
+    def test_index_lookup_hits_entry(self):
+        governance.run(self.store, now=self.NOW, force=True)
+        self.assertIn("mid", governance.lookup(self.store, "苹果"))
+        doc = json.loads((self.store / "index.json").read_text(encoding="utf-8"))
+        self.assertTrue(doc["terms"])
+
+    def test_inject_uses_index_and_counts_hit(self):
+        governance.run(self.store, now=self.NOW, force=True)
+        out = pipeline.inject_block("s1", str(self.store), query="苹果",
+                                    mode="query", top_k=3)
+        self.assertEqual(out["ids"][0], "mid")
+        gov = json.loads((self.store / "governance.json").read_text(encoding="utf-8"))
+        self.assertGreaterEqual(gov.get("index_hits", 0), 1)
+
+    def test_remember_stores_concepts(self):
+        pipeline.tool_call("remember", {"text": "苹果和咖啡都很好"},
+                           {"root": str(self.store)}, session_id="s2")
+        doc = json.loads((self.store / "sessions" / "s2" / "memory.json")
+                         .read_text(encoding="utf-8"))
+        self.assertTrue(doc["entries"][0].get("concepts"))
+
+    def test_concept_filter_narrows_candidates(self):
+        entries = [{"id": "a", "concepts": ["苹果", "甜"]},
+                   {"id": "b", "concepts": ["香蕉", "黄"]}]
+        kept = pipeline._concept_filter(entries, "苹果")
+        self.assertEqual([row["id"] for row in kept], ["a"])
+
+
+class ConsolidateTest(StoreCase):
+    def test_consolidate_is_idempotent(self):
+        self.write_session("s2", [
+            memory("c1", "注意安全", self.NOW - 3),
+            memory("c2", "出门注意安全", self.NOW - 2),
+            memory("c3", "记得注意安全", self.NOW - 1),
+        ])
+        first = governance.run(self.store, now=self.NOW, force=True)
+        second = governance.run(self.store, now=self.NOW + 1, force=True)
+        self.assertEqual(first["consolidate"]["candidates"],
+                         second["consolidate"]["candidates"])
+        self.assertTrue(second["consolidate"]["candidates"] >= 1)
+        self.assertFalse(second["consolidate"]["changed"])
+        doc = json.loads((self.store / "consolidate.json").read_text(encoding="utf-8"))
+        self.assertGreaterEqual(doc["runs"], 2)
+
+    def test_graph_and_aggregate(self):
+        self.write_session("s2", [memory("g1", "苹果 苹果 甜", self.NOW - 5),
+                                  memory("g2", "苹果 很甜", self.NOW - 4)])
+        out = governance.run(self.store, now=self.NOW, force=True)
+        self.assertGreaterEqual(out["graph"]["nodes"], 1)
+        self.assertGreaterEqual(out["aggregate"]["sessions"], 2)
+
+
+class RelationshipTest(StoreCase):
+    def test_warm_text_raises_closeness(self):
+        self.turn_end(user_text="谢谢你陪我，今天很开心")
+        rel = json.loads((self.store / "relationship.json").read_text(encoding="utf-8"))
+        self.assertGreater(rel["relationship"]["closeness"], 0.5)
+        self.assertGreater(rel["relationship"]["trust"], 0.5)
+
+    def test_conflict_text_raises_conflict(self):
+        self.turn_end(user_text="我很生气，别说了")
+        rel = json.loads((self.store / "relationship.json").read_text(encoding="utf-8"))
+        self.assertGreater(rel["relationship"]["conflict"], 0.0)
+        self.assertLess(rel["relationship"]["trust"], 0.5)
+
+    def test_repair_lowers_conflict(self):
+        self.turn_end(user_text="我很生气")
+        self.turn_end(user_text="对不起，是我不好")
+        rel = json.loads((self.store / "relationship.json").read_text(encoding="utf-8"))
+        summary = relationship_state.summary(self.store, rel["relationship"])
+        self.assertGreaterEqual(summary["repairs"], 1)
+        self.assertLess(rel["relationship"]["conflict"], 0.02)
+
+    def test_relationship_off_keeps_values(self):
+        write_json(self.data_dir / "flags.json", {"relationship_governance": False})
+        self.turn_end(user_text="谢谢你陪我")
+        rel = json.loads((self.store / "relationship.json").read_text(encoding="utf-8"))
+        self.assertAlmostEqual(rel["relationship"]["closeness"], 0.5, places=4)
+        self.assertAlmostEqual(rel["relationship"]["trust"], 0.5, places=4)
+        self.assertFalse((self.store / "relationship_memory.json").exists())
+
+    def test_state_exposes_numbers(self):
+        self.turn_end(user_text="谢谢你陪我")
+        out = pipeline.dispatch("state", self.payload())
+        body = out["state"]
+        self.assertIn("governance", body)
+        self.assertIn("decay", body["governance"])
+        self.assertIn("relationship_summary", body)
+        self.assertGreaterEqual(body["relationship_summary"]["events"], 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_lifecycle.py

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+"""task-36 + task-78: tier hysteresis, reconsolidation, minimal repair loop."""
+import json
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+from biocore_memory.store import tiering
+from biocore_runtime import lifecycle, pipeline
+
+
+def write_json(path, data):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
+
+
+def entry(i, text="记得这件事", ts=None, hits=1, importance=0.5):
+    return {"id": i, "text": text, "role": "user",
+            "ts": ts or (time.time() - 3600), "importance": importance,
+            "hits": hits}
+
+
+class Case(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.data_dir = Path(self.tmp.name) / "data"
+        self.store = self.data_dir / "memory"
+        (self.store / "sessions" / "s1").mkdir(parents=True)
+        self.persona = Path(self.tmp.name) / "missing.json"
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def write_entries(self, entries):
+        write_json(self.store / "sessions" / "s1" / "memory.json",
+                   {"entries": entries})
+        return entries
+
+    def read_entries(self):
+        return json.loads((self.store / "sessions" / "s1" / "memory.json")
+                          .read_text(encoding="utf-8"))["entries"]
+
+    def payload(self, **extra):
+        data = {"store": str(self.store), "session_id": "s1",
+                "persona_profile": str(self.persona)}
+        data.update(extra)
+        return data
+
+
+class TierTest(Case):
+    def test_enter_hot_at_five_hits(self):
+        self.assertEqual(tiering.tier_of(entry("a", hits=5), now=time.time()),
+                         "hot")
+
+    def test_stays_hot_between_three_and_five(self):
+        now = time.time()
+        self.assertEqual(tiering.tier_of(entry("a", hits=4), now=now,
+                                         previous="hot"), "hot")
+
+    def test_exits_hot_below_three(self):
+        now = time.time()
+        self.assertNotEqual(tiering.tier_of(entry("a", hits=2), now=now,
+                                            previous="hot"), "hot")
+
+    def test_tick_counts_entered_exited(self):
+        now = time.time()
+        old_ts = time.time() - 3 * 86400
+        rows = [entry("a", hits=5), entry("b", hits=2, ts=old_ts)]
+        first = lifecycle.tier_tick(self.store, rows, now=now)
+        self.assertEqual(first["counts"]["hot"], 1)
+        rows[0]["hits"] = 1
+        second = lifecycle.tier_tick(self.store, rows, now=now + 1)
+        self.assertGreaterEqual(second["exited"], 1)
+        summary = lifecycle.tier_summary(self.store)
+        self.assertIn("hot", summary)
+        self.assertIn("exited", summary)
+
+
+class ReconsolidationTest(Case):
+    def test_updates_recalled_entry(self):
+        now = time.time()
+        self.write_entries([entry("a", "苹果很甜", hits=1)])
+        lifecycle.record_recall(self.store, "s1", ["a"], now=now)
+        result = lifecycle.reconsolidate(self.store, now=now + 60)
+        self.assertEqual(result["updated"], 1)
+        row = self.read_entries()[0]
+        self.assertGreater(row.get("regenerated_at", 0), 0)
+        self.assertEqual(row.get("reconsolidation_count"), 1)
+        self.assertGreater(row.get("importance", 0), 0.5)
+        self.assertEqual(len(self.read_entries()), 1)
+
+    def test_idempotent_second_call(self):
+        now = time.time()
+        self.write_entries([entry("a", hits=1)])
+        lifecycle.record_recall(self.store, "s1", ["a"], now=now)
+        lifecycle.reconsolidate(self.store, now=now + 60)
+        again = lifecycle.reconsolidate(self.store, now=now + 61)
+        self.assertEqual(again["updated"], 0)
+        self.assertGreaterEqual(again["skipped"], 1)
+
+    def test_window_expires(self):
+        now = time.time()
+        self.write_entries([entry("a", hits=1)])
+        lifecycle.record_recall(self.store, "s1", ["a"], now=now - 7 * 3600)
+        result = lifecycle.reconsolidate(self.store, now=now)
+        self.assertEqual(result["updated"], 0)
+        self.assertEqual(result["reason"], "window")
+
+    def test_no_recall_ids(self):
+        self.write_entries([entry("a")])
+        result = lifecycle.reconsolidate(self.store, now=time.time())
+        self.assertEqual(result["updated"], 0)
+
+
+class RepairTest(Case):
+    def test_arm_and_consume_once(self):
+        now = time.time()
+        self.assertTrue(lifecycle.arm_repair(self.store, "boundary", now=now))
+        lines = lifecycle.repair_lines(self.store, now=now + 1)
+        self.assertTrue(lines)
+        self.assertTrue(any("修复" in line for line in lines))
+        self.assertEqual(lifecycle.repair_lines(self.store, now=now + 2), [])
+
+    def test_cooldown_blocks_rearm(self):
+        now = time.time()
+        lifecycle.arm_repair(self.store, "boundary", now=now)
+        lifecycle.repair_lines(self.store, now=now + 1)
+        self.assertFalse(lifecycle.arm_repair(self.store, "boundary",
+                                             now=now + 2))
+
+    def test_expired_repair_returns_empty(self):
+        now = time.time()
+        lifecycle.arm_repair(self.store, "boundary", now=now)
+        self.assertEqual(lifecycle.repair_lines(self.store,
+                                                now=now + 31 * 60), [])
+
+    def test_state_exposes_lifecycle(self):
+        now = time.time()
+        self.write_entries([entry("a", hits=5)])
+        lifecycle.record_recall(self.store, "s1", ["a"], now=now)
+        lifecycle.tier_tick(self.store, [entry("a", hits=5)], now=now)
+        pipeline.dispatch("turn_end", self.payload(
+            user_text="好", assistant_text="嗯。", capture=False))
+        body = pipeline.dispatch("state", self.payload())["state"]
+        self.assertIn("tiers", body)
+        self.assertIn("reconsolidation", body)
+        self.assertIn("repair", body)
+
+
+if __name__ == "__main__":
+    unittest.main()