dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_memory_inject.py

@@ -0,0 +1,211 @@
+# -*- coding: utf-8 -*-
+"""task-221 (batch 2): query recall injection + embedding stats persistence."""
+import json
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+from biocore_memory.recall import embedding
+from biocore_runtime import pipeline
+
+
+def entry(i, text, ts, importance=0.5):
+    return {"id": i, "text": text, "role": "user", "ts": ts,
+            "importance": importance, "hits": 1, "scope": "default",
+            "memory_confidence": 0.7, "memory_source": "direct"}
+
+
+class InjectCase(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.root = Path(self.tmp.name)
+        self.store = self.root / "data" / "memory"
+        self.entries = [
+            entry("new", "今天买了咖啡", 1700000300.0),
+            entry("old", "上次说的苹果很甜", 1700000100.0),
+            entry("mid", "明天要去公园", 1700000200.0),
+        ]
+        (self.store / "sessions" / "s1").mkdir(parents=True)
+        (self.store / "sessions" / "s1" / "memory.json").write_text(
+            json.dumps({"entries": self.entries}), encoding="utf-8")
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def inject(self, **kwargs):
+        return pipeline.inject_block("s1", str(self.store), **kwargs)
+
+
+class QueryModeTest(InjectCase):
+    def test_query_recall_orders_by_query(self):
+        out = self.inject(query="苹果", mode="query", top_k=3)
+        self.assertEqual(out["ids"][0], "old")
+
+    def test_recent_mode_keeps_newest_first(self):
+        out = self.inject(query="苹果", mode="recent", top_k=3)
+        self.assertEqual(out["ids"][0], "new")
+
+    def test_default_mode_is_query(self):
+        out = self.inject(query="苹果", top_k=2)
+        self.assertEqual(out["ids"][0], "old")
+        self.assertEqual(len(out["ids"]), 2)
+
+    def test_empty_query_falls_back_recent(self):
+        out = self.inject(query="", mode="query", top_k=3)
+        self.assertEqual(out["ids"][0], "new")
+
+    def test_engine_failure_falls_back_recent(self):
+        saved = pipeline._inject_engine
+        pipeline._inject_engine = lambda store, entries: (_ for _ in ()).throw(RuntimeError("boom"))
+        try:
+            out = self.inject(query="苹果", mode="query", top_k=2)
+        finally:
+            pipeline._inject_engine = saved
+        self.assertEqual(out["ids"][0], "new")
+        self.assertEqual(len(out["ids"]), 2)
+
+    def test_output_format_and_budget(self):
+        out = self.inject(query="苹果", mode="query", top_k=3, max_chars=60)
+        self.assertTrue(out["text"].startswith("你记得这些事："))
+        self.assertTrue(all(line.startswith("- ") for line in out["text"].split("\n")[1:]))
+        self.assertLessEqual(out["chars"], 60)
+        self.assertEqual(out["chars"], len(out["text"]))
+        self.assertTrue(set(out["ids"]).issubset({"new", "old", "mid"}))
+
+
+class RerankTest(InjectCase):
+    def test_rerank_reorders_when_enabled(self):
+        class FakeRerank:
+            def __init__(self):
+                self.calls = 0
+
+            def rerank_documents(self, query, documents, config):
+                self.calls += 1
+                return [{"index": 2}, {"index": 0}, {"index": 1}]
+
+        fake = FakeRerank()
+        saved = pipeline._rerank_mod
+        pipeline._rerank_mod = fake
+        try:
+            out = self.inject(query="苹果", mode="query", top_k=8,
+                              rerank_config={"rerank_enabled": True})
+        finally:
+            pipeline._rerank_mod = saved
+        self.assertEqual(fake.calls, 1)
+        # engine put 苹果 (old) first; rerank's order must win instead
+        self.assertEqual(out["ids"], ["mid", "old", "new"])
+
+    def test_rerank_off_does_not_call(self):
+        class Exploding:
+            def rerank_documents(self, *args, **kwargs):
+                raise AssertionError("rerank must not run")
+
+        saved = pipeline._rerank_mod
+        pipeline._rerank_mod = Exploding()
+        try:
+            out = self.inject(query="苹果", mode="query", top_k=8,
+                              rerank_config={"rerank_enabled": False})
+        finally:
+            pipeline._rerank_mod = saved
+        self.assertEqual(out["ids"][0], "old")
+
+
+class EmbeddingFallbackTest(InjectCase):
+    def test_embedding_provider_failure_degrades_to_lexical(self):
+        class BadProvider:
+            def embed_text(self, text):
+                raise RuntimeError("no network")
+
+        from biocore_memory.engine import MemoryEngine
+        from biocore_memory.store.json_store import MemoryStore
+
+        def engine_with_bad_embedder(store, entries):
+            memory = MemoryStore(doc={"entries": [dict(item) for item in entries]})
+            return MemoryEngine(store=memory, embedder=BadProvider(),
+                                config={"flags": {}})
+
+        saved = pipeline._inject_engine
+        pipeline._inject_engine = engine_with_bad_embedder
+        try:
+            out = self.inject(query="苹果", mode="query", top_k=3)
+        finally:
+            pipeline._inject_engine = saved
+        self.assertEqual(out["ids"][0], "old")
+
+    def test_learning_flags_default_on(self):
+        captured = {}
+
+        class CaptureEngine:
+            def __init__(self, **kwargs):
+                captured.update(kwargs)
+
+            def recall(self, query, budget=5):
+                return []
+
+        saved = pipeline._inject_engine
+        saved_engine = None
+        try:
+            from biocore_memory.engine import MemoryEngine
+            saved_engine = MemoryEngine
+            import biocore_memory.engine as engine_module
+            engine_module.MemoryEngine = CaptureEngine
+            try:
+                pipeline.inject_block("s1", str(self.store), query="苹果")
+            finally:
+                engine_module.MemoryEngine = saved_engine
+        finally:
+            pipeline._inject_engine = saved
+        flags = (captured.get("config") or {}).get("flags") or {}
+        for key in ("mood_recall", "affect_encoding",
+                    "memory_feedback", "preference_drift"):
+            self.assertIs(flags.get(key), True)
+
+
+class EmbedStatsTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.dir = Path(self.tmp.name)
+        self.stats_file = self.dir / "embed_stats.json"
+        self.cache_dir = self.dir / "cache"
+        self._env = {k: os.environ.get(k) for k in
+                     ("BIOCORE_EMBED_STATS_FILE", "BIOCORE_EMBEDDING_CACHE_FILE")}
+        os.environ["BIOCORE_EMBED_STATS_FILE"] = str(self.stats_file)
+        os.environ["BIOCORE_EMBEDDING_CACHE_FILE"] = str(self.cache_dir)
+        embedding.embed_stats(reset=True)
+
+    def tearDown(self):
+        for key, value in self._env.items():
+            if value is None:
+                os.environ.pop(key, None)
+            else:
+                os.environ[key] = value
+        self.tmp.cleanup()
+
+    def test_miss_remote_then_disk_hit(self):
+        class Provider:
+            def embed_text(self, text):
+                return [0.1] * 8
+
+        self.assertIsNotNone(embedding.embed("hello world", Provider()))
+        first = json.loads(self.stats_file.read_text(encoding="utf-8"))
+        self.assertEqual(first["miss"], 1)
+        self.assertEqual(first["remote"], 1)
+        self.assertEqual(first["disk_hit"], 0)
+        embedding.embed("hello world", Provider())
+        second = json.loads(self.stats_file.read_text(encoding="utf-8"))
+        self.assertEqual(second["disk_hit"], 1)
+
+    def test_stats_action_reads_persisted_file(self):
+        self.stats_file.write_text(json.dumps(
+            {"hit": 2, "disk_hit": 3, "miss": 4, "remote": 5,
+             "local": 6, "fail": 7}), encoding="utf-8")
+        store = self.dir / "memory"
+        out = pipeline.dispatch("stats", {"store": str(store)})
+        self.assertEqual(out["embed"]["disk_hit"], 3)
+        self.assertEqual(out["embed"]["miss"], 4)
+        self.assertEqual(out["embed"]["remote"], 5)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_memory_mood_recall.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+import json, os, tempfile, unittest
+from pathlib import Path
+from biocore_memory.engine import MemoryEngine
+from biocore_memory.core import config as engine_config
+
+def entry(i, text, affect=None, importance=0.5, ts=1700000000.0):
+    value = {"id": i, "text": text, "role": "user", "ts": ts, "importance": importance,
+             "vector": [], "hits": 1, "self_relevance": 0.0, "pin": False,
+             "memory_source": "direct", "memory_confidence": 0.7,
+             "previous_versions": [], "module": "biocore_memory", "scope": "default"}
+    if affect is not None:
+        value["affect"] = affect
+    return value
+
+class MoodRecallTest(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.dir = Path(self.tmp.name)
+        self._saved = {k: os.environ.get(k) for k in ("BIOCORE_MOOD_RECALL", "BIOCORE_MOOD_LAMBDA")}
+        os.environ.pop("BIOCORE_MOOD_RECALL", None)
+        os.environ.pop("BIOCORE_MOOD_LAMBDA", None)
+
+    def tearDown(self):
+        self.tmp.cleanup()
+        for k, v in self._saved.items():
+            if v is None: os.environ.pop(k, None)
+            else: os.environ[k] = v
+
+    def write(self, entries):
+        (self.dir / "memory.json").write_text(json.dumps({"entries": entries, "tombstones": [], "schema_version": 1}), encoding="utf-8")
+
+    def engine(self, affect=None):
+        return MemoryEngine(data_dir=str(self.dir), affect=affect)
+
+    def test_flag_defaults_off(self):
+        self.assertIs(engine_config.FLAGS.get("mood_recall"), False)
+
+    def test_write_stores_affect(self):
+        e = self.engine(affect={"v": 0.7, "a": 0.8})
+        result = e.remember({"text": "affect write probe"})
+        self.assertIsNotNone(result)
+        self.assertIn("affect", result)
+        self.assertAlmostEqual(result["affect"]["valence"], 0.7, places=3)
+        self.assertAlmostEqual(result["affect"]["arousal"], 0.8, places=3)
+
+    def test_off_is_baseline(self):
+        self.write([entry("h", "beach happy", {"valence": 0.9, "arousal": 0.8}),
+                    entry("s", "beach sad", {"valence": -0.9, "arousal": 0.2})])
+        rows = self.engine(affect={"v": 0.9, "a": 0.8}).recall("beach", budget=3)
+        self.assertEqual(len(rows), 2)
+        happy = next(r for r in rows if r["entry"]["id"] == "h")
+        sad = next(r for r in rows if r["entry"]["id"] == "s")
+        self.assertAlmostEqual(float(happy["score"]), float(sad["score"]), places=4)
+
+    def test_mood_on_ranks_matching_affect_higher(self):
+        os.environ["BIOCORE_MOOD_RECALL"] = "1"
+        self.write([entry("h", "beach happy", {"valence": 0.9, "arousal": 0.8}),
+                    entry("s", "beach sad", {"valence": -0.9, "arousal": 0.2})])
+        rows = self.engine(affect={"v": 0.9, "a": 0.8}).recall("beach", budget=3)
+        self.assertEqual(rows[0]["entry"]["id"], "h")
+        happy = next(r for r in rows if r["entry"]["id"] == "h")
+        sad = next(r for r in rows if r["entry"]["id"] == "s")
+        self.assertGreater(float(happy["score"]), float(sad["score"]))
+        self.assertGreater(happy.get("mood_cos", 0), sad.get("mood_cos", 0))
+
+    def test_mood_lambda_zero_neutralizes_affect_term(self):
+        os.environ["BIOCORE_MOOD_RECALL"] = "1"
+        os.environ["BIOCORE_MOOD_LAMBDA"] = "0"
+        self.write([entry("h", "beach happy", {"valence": 0.9, "arousal": 0.8}),
+                    entry("s", "beach sad", {"valence": -0.9, "arousal": 0.2})])
+        rows = self.engine(affect={"v": 0.9, "a": 0.8}).recall("beach", budget=3)
+        happy = next(r for r in rows if r["entry"]["id"] == "h")
+        sad = next(r for r in rows if r["entry"]["id"] == "s")
+        self.assertAlmostEqual(float(happy["score"]), float(sad["score"]), places=4)
+
+    def test_missing_affect_falls_back_neutral(self):
+        os.environ["BIOCORE_MOOD_RECALL"] = "1"
+        self.write([entry("n", "beach plain"), entry("h", "beach happy", {"valence": 0.9, "arousal": 0.8})])
+        rows = self.engine(affect={"v": 0.9, "a": 0.8}).recall("beach", budget=3)
+        neutral = next(r for r in rows if r["entry"]["id"] == "n")
+        self.assertIn("mood_cos", neutral)
+        self.assertTrue(float(neutral["score"]) >= 0.0)
+        self.assertLess(float(neutral["score"]), next(r for r in rows if r["entry"]["id"] == "h")["score"] + 1e-6)
+
+    def test_scores_finite_and_ordered(self):
+        os.environ["BIOCORE_MOOD_RECALL"] = "1"
+        self.write([entry("h", "beach happy", {"valence": 0.5, "arousal": 0.5}),
+                    entry("s", "beach sad", {"valence": -0.5, "arousal": 0.5})])
+        rows = self.engine(affect={"v": 0.5, "a": 0.5}).recall("beach", budget=3)
+        scores = [float(r["score"]) for r in rows]
+        self.assertTrue(all(x == x and x >= 0 for x in scores))
+        self.assertEqual(scores, sorted(scores, reverse=True))
+
+    def test_stability_repeated_recall(self):
+        os.environ["BIOCORE_MOOD_RECALL"] = "1"
+        self.write([entry("h", "beach happy", {"valence": 0.9, "arousal": 0.8}),
+                    entry("s", "beach sad", {"valence": -0.9, "arousal": 0.2})])
+        e = self.engine(affect={"v": 0.9, "a": 0.8})
+        first = [r["entry"]["id"] for r in e.recall("beach", budget=3)]
+        second = [r["entry"]["id"] for r in e.recall("beach", budget=3)]
+        self.assertEqual(first, second)
+
+    def test_mood_mismatch_lower(self):
+        os.environ["BIOCORE_MOOD_RECALL"] = "1"
+        self.write([entry("m", "beach mixed", {"valence": 0.0, "arousal": 0.5}),
+                    entry("h", "beach happy", {"valence": 0.9, "arousal": 0.8})])
+        rows = self.engine(affect={"v": 0.9, "a": 0.8}).recall("beach", budget=3)
+        mixed = next(r for r in rows if r["entry"]["id"] == "m")
+        happy = next(r for r in rows if r["entry"]["id"] == "h")
+        self.assertGreater(float(happy["score"]), float(mixed["score"]))
+
+    def test_no_affect_field_no_crash(self):
+        os.environ["BIOCORE_MOOD_RECALL"] = "1"
+        self.write([{"id": "bare", "text": "beach bare", "ts": 1700000000.0, "importance": 0.5, "hits": 1}])
+        rows = self.engine(affect=None).recall("beach", budget=3)
+        self.assertEqual(len(rows), 1)
+        self.assertIn("score", rows[0])