dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_runtime_proactive.py

@@ -0,0 +1,231 @@
+# -*- coding: utf-8 -*-
+"""task-205 follow-up: proactive_tick policy lives in the python pipeline.
+
+Covers disabled switches, gap/hourly-cap/cooldown, trust threshold, pending
+commitments, text composition and cooldown booking. No Node required.
+"""
+import json
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+from biocore_runtime import pipeline as pl
+
+NOW_MS = 1_800_000_000_000
+HOUR_MS = 3600 * 1000
+LAST_HUMAN_MS = NOW_MS - 4 * HOUR_MS
+
+
+def switches(**overrides):
+    base = {
+        "proactiveEnabled": True,
+        "proactiveSend": True,
+        "proactiveMinGapMinutes": 180,
+        "proactivePerHour": 2,
+        "proactiveMinTrust": 0.6,
+        "proactiveMaxChars": 60,
+        "proactiveRequireOpenLoop": True,
+        "proactiveIntervalMinutes": 30,
+    }
+    base.update(overrides)
+    return base
+
+
+def make_store(tmp, session_id="s1", trust=0.8, texts=None, now_ms=NOW_MS):
+    root = Path(tmp) / "memory"
+    sessions = root / "sessions" / pl.sanitize_session_id(session_id)
+    sessions.mkdir(parents=True, exist_ok=True)
+    rows = []
+    texts = texts if texts is not None else ("明天要去体检，记得问我结果",)
+    for index, text in enumerate(texts):
+        rows.append({"id": "e%d" % index, "text": text, "role": "user",
+                     "ts": now_ms / 1000.0 - index * 60, "deleted": False})
+    (sessions / "memory.json").write_text(
+        json.dumps({"entries": rows}), encoding="utf-8")
+    states = root.parent / "sessions"
+    states.mkdir(parents=True, exist_ok=True)
+    (states / (pl.sanitize_session_id(session_id) + ".json")).write_text(
+        json.dumps({"relationship": {"trust": trust, "closeness": trust}}),
+        encoding="utf-8")
+    return root
+
+
+class ShapeTest(unittest.TestCase):
+    def test_output_contract(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = make_store(tmp)
+            out = pl.proactive_tick("s1", LAST_HUMAN_MS, switches(), str(store), now=NOW_MS)
+            for key in ("ok", "should_send", "text", "reason", "gap_minutes"):
+                self.assertIn(key, out)
+            self.assertTrue(out["ok"])
+            self.assertTrue(out["should_send"])
+            self.assertEqual(out["reason"], "ok")
+            self.assertAlmostEqual(out["gap_minutes"], 240.0, places=1)
+            self.assertIn("体检", out["text"])
+
+    def test_dispatch_route(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = make_store(tmp)
+            out = pl.dispatch("proactive_tick", {
+                "session_id": "s1", "last_human_ts": LAST_HUMAN_MS,
+                "switches": switches(), "store": str(store), "now": NOW_MS})
+            self.assertTrue(out["should_send"])
+
+
+class SwitchTest(unittest.TestCase):
+    def test_disabled(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            out = pl.proactive_tick("s1", LAST_HUMAN_MS,
+                                    switches(proactiveEnabled=False),
+                                    str(make_store(tmp)), now=NOW_MS)
+            self.assertFalse(out["should_send"])
+            self.assertEqual(out["reason"], "disabled")
+
+    def test_send_off(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            out = pl.proactive_tick("s1", LAST_HUMAN_MS,
+                                    switches(proactiveSend=False),
+                                    str(make_store(tmp)), now=NOW_MS)
+            self.assertFalse(out["should_send"])
+            self.assertEqual(out["reason"], "send_off")
+
+    def test_no_session(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            out = pl.proactive_tick("", LAST_HUMAN_MS, switches(),
+                                    str(make_store(tmp)), now=NOW_MS)
+            self.assertFalse(out["should_send"])
+            self.assertEqual(out["reason"], "no_session")
+
+
+class TimingTest(unittest.TestCase):
+    def test_too_soon(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            out = pl.proactive_tick("s1", NOW_MS - 10 * 60 * 1000, switches(),
+                                    str(make_store(tmp)), now=NOW_MS)
+            self.assertEqual(out["reason"], "too_soon")
+            self.assertAlmostEqual(out["gap_minutes"], 10.0, places=1)
+
+    def test_hourly_cap(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = make_store(tmp)
+            (store / "proactive.json").write_text(json.dumps({
+                "lastSentAt": NOW_MS - 200 * 60 * 1000,
+                "sent": [NOW_MS - 30 * 60 * 1000, NOW_MS - 40 * 60 * 1000],
+            }), encoding="utf-8")
+            out = pl.proactive_tick("s1", LAST_HUMAN_MS, switches(), str(store),
+                                    now=NOW_MS)
+            self.assertEqual(out["reason"], "hourly_cap")
+
+    def test_cooldown(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = make_store(tmp)
+            (store / "proactive.json").write_text(json.dumps({
+                "lastSentAt": NOW_MS - 30 * 60 * 1000, "sent": [],
+            }), encoding="utf-8")
+            out = pl.proactive_tick("s1", LAST_HUMAN_MS, switches(), str(store),
+                                    now=NOW_MS)
+            self.assertEqual(out["reason"], "cooldown")
+
+    def test_seconds_timestamp_accepted(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            out = pl.proactive_tick("s1", LAST_HUMAN_MS / 1000.0, switches(),
+                                    str(make_store(tmp)), now=NOW_MS)
+            self.assertTrue(out["should_send"])
+            self.assertAlmostEqual(out["gap_minutes"], 240.0, places=1)
+
+
+class RelationshipTest(unittest.TestCase):
+    def test_not_close(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            out = pl.proactive_tick("s1", LAST_HUMAN_MS, switches(),
+                                    str(make_store(tmp, trust=0.2)),
+                                    now=NOW_MS)
+            self.assertEqual(out["reason"], "not_close")
+            self.assertAlmostEqual(out["trust"], 0.2, places=3)
+
+    def test_explicit_state_file(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = make_store(tmp, trust=0.1)
+            alt = Path(tmp) / "alt.json"
+            alt.write_text(json.dumps({"relationship": {"trust": 0.9}}),
+                           encoding="utf-8")
+            out = pl.proactive_tick("s1", LAST_HUMAN_MS, switches(), str(store),
+                                    now=NOW_MS, state_file=str(alt))
+            self.assertTrue(out["should_send"])
+
+    def test_missing_state_uses_default_trust(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = Path(tmp) / "memory"
+            (store / "sessions" / "s1").mkdir(parents=True, exist_ok=True)
+            (store / "sessions" / "s1" / "memory.json").write_text(
+                json.dumps({"entries": [{"text": "明天要体检",
+                                         "ts": time.time()}]}), encoding="utf-8")
+            out = pl.proactive_tick("s1", LAST_HUMAN_MS, switches(), str(store),
+                                    now=NOW_MS)
+            self.assertEqual(out["reason"], "not_close")
+
+
+class CommitmentTest(unittest.TestCase):
+    def test_no_commitment(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            out = pl.proactive_tick(
+                "s1", LAST_HUMAN_MS, switches(),
+                str(make_store(tmp, texts=("今天天气不错", "晚饭吃了面"))),
+                now=NOW_MS)
+            self.assertEqual(out["reason"], "no_commitment")
+
+    def test_optional_commitment_falls_back(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            out = pl.proactive_tick(
+                "s1", LAST_HUMAN_MS,
+                switches(proactiveRequireOpenLoop=False),
+                str(make_store(tmp, texts=("今天天气不错",))), now=NOW_MS)
+            self.assertTrue(out["should_send"])
+            self.assertIn("在忙吗", out["text"])
+
+    def test_due_hint_preferred(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            texts = ("记得给朋友回消息", "明天要去体检")
+            out = pl.proactive_tick("s1", LAST_HUMAN_MS, switches(),
+                                    str(make_store(tmp, texts=texts)),
+                                    now=NOW_MS)
+            self.assertTrue(out["should_send"])
+            self.assertIn("明天要去体检", out["text"])
+
+    def test_max_chars_cap(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            long_text = "明天要做的事情" * 10
+            out = pl.proactive_tick("s1", LAST_HUMAN_MS,
+                                    switches(proactiveMaxChars=24),
+                                    str(make_store(tmp, texts=(long_text,))),
+                                    now=NOW_MS)
+            self.assertTrue(out["should_send"])
+            self.assertLessEqual(len(out["text"]), 24)
+
+
+class BookingTest(unittest.TestCase):
+    def test_booking_written_and_second_tick_cooldowns(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = make_store(tmp)
+            first = pl.proactive_tick("s1", LAST_HUMAN_MS, switches(),
+                                      str(store), now=NOW_MS)
+            self.assertTrue(first["should_send"])
+            state = json.loads((store / "proactive.json").read_text(encoding="utf-8"))
+            self.assertEqual(state["lastSentAt"], float(NOW_MS))
+            self.assertTrue(state["lastText"])
+            second = pl.proactive_tick("s1", LAST_HUMAN_MS, switches(),
+                                       str(store), now=NOW_MS + 60 * 1000)
+            self.assertFalse(second["should_send"])
+            self.assertEqual(second["reason"], "cooldown")
+
+    def test_no_booking_when_skipped(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            store = make_store(tmp)
+            pl.proactive_tick("s1", NOW_MS - 60 * 1000, switches(), str(store),
+                              now=NOW_MS)
+            self.assertFalse((store / "proactive.json").exists())
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_scheduler.py

@@ -0,0 +1,79 @@
+# -*- coding: utf-8 -*-
+"""HUMAN-1 scheduler tests: dimensions, lazy decay, ranking."""
+import unittest
+
+from biocore_model import scheduler as sc
+
+
+def items():
+    return [
+        {"id": "a", "due_ts": 1000.0, "entity": "u1", "channel": "chat", "weight": 1.0, "last_ts": 0.0},
+        {"id": "b", "due_ts": 1000.0, "entity": "u2", "channel": "chat", "weight": 1.0, "last_ts": 0.0},
+        {"id": "c", "due_ts": 100.0, "entity": "u1", "channel": "note", "weight": 1.0, "last_ts": 0.0},
+    ]
+
+
+class TimeTest(unittest.TestCase):
+    def test_time_score_peaks_at_due(self):
+        row = {"due_ts": 1000.0}
+        self.assertAlmostEqual(sc.time_score(row, 1000.0), 1.0)
+        self.assertLess(sc.time_score(row, 1000.0 + 3600.0), 1.0)
+
+    def test_time_score_symmetric_distance(self):
+        row = {"due_ts": 1000.0}
+        self.assertAlmostEqual(sc.time_score(row, 1000.0 - 7200.0),
+                               sc.time_score(row, 1000.0 + 7200.0))
+
+
+class DimensionTest(unittest.TestCase):
+    def test_entity_match_beats_miss(self):
+        self.assertGreater(sc.entity_score({"entity": "u1"}, "u1"),
+                           sc.entity_score({"entity": "u1"}, "u2"))
+
+    def test_channel_match_beats_miss(self):
+        self.assertGreater(sc.channel_score({"channel": "chat"}, "chat"),
+                           sc.channel_score({"channel": "chat"}, "note"))
+
+    def test_no_filter_is_neutral(self):
+        self.assertEqual(sc.entity_score({"entity": "u1"}), 1.0)
+        self.assertEqual(sc.channel_score({"channel": "chat"}), 1.0)
+
+    def test_custom_weights_change_order(self):
+        now = 1000.0
+        default = sc.score(items()[1], now, entity="u1", channel="chat")
+        entity_heavy = sc.score(items()[1], now, entity="u1", channel="chat",
+                                weights={"time": 0.1, "entity": 0.8, "channel": 0.1})
+        self.assertNotAlmostEqual(default, entity_heavy)
+
+
+class DecayRankTest(unittest.TestCase):
+    def test_lazy_decay_halves_in_one_half_life(self):
+        row = sc.lazy_decay({"weight": 1.0, "last_ts": 0.0}, 12 * 3600.0)
+        self.assertAlmostEqual(row["weight"], 0.5, places=4)
+
+    def test_lazy_decay_does_not_mutate(self):
+        source = {"weight": 1.0, "last_ts": 0.0, "id": "x"}
+        sc.lazy_decay(source, 999999.0)
+        self.assertEqual(source, {"weight": 1.0, "last_ts": 0.0, "id": "x"})
+
+    def test_rank_is_descending_and_deterministic(self):
+        rows = sc.rank(items(), 1000.0, entity="u1", channel="chat")
+        scores = [row["score"] for row in rows]
+        self.assertEqual(scores, sorted(scores, reverse=True))
+        self.assertEqual(rows, sc.rank(items(), 1000.0, entity="u1", channel="chat"))
+
+    def test_pick_and_limit(self):
+        self.assertEqual(sc.pick(items(), 1000.0, entity="u1", channel="chat")["item"]["id"], "a")
+        self.assertEqual(len(sc.rank(items(), 1000.0, limit=2)), 2)
+        self.assertEqual(sc.rank([], 1000.0), [])
+
+    def test_due_window_filters(self):
+        rows = sc.due(items(), 1000.0, window_seconds=600.0)
+        ids = [row["id"] for row in rows]
+        self.assertIn("a", ids)
+        self.assertIn("b", ids)
+        self.assertNotIn("c", ids)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_secrecy.py

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+import unittest
+
+from biocore_model import secrecy as sc
+
+NOW = 1_700_000_000
+
+
+class SecrecyDecisionTest(unittest.TestCase):
+    def test_low_sensitivity_deep_relation_safe_setting_tells(self):
+        out = sc.decide(0.10, 0.85, 0.90)
+        self.assertEqual(out["action"], "tell")
+
+    def test_high_sensitivity_shallow_relation_unsafe_setting_withholds(self):
+        out = sc.decide(0.90, 0.15, 0.15)
+        self.assertEqual(out["action"], "withhold")
+
+    def test_high_sensitivity_close_relation_reframes(self):
+        out = sc.decide(0.80, 0.85, 0.50)
+        self.assertEqual(out["action"], "reframe")
+
+    def test_action_always_known(self):
+        for sentence in (None, -5, 5, "x"):
+            out = sc.decide(sentence, sentence, sentence)
+            self.assertIn(out["action"], sc.ACTIONS)
+
+    def test_decision_is_deterministic(self):
+        first = sc.decide(0.8, 0.85, 0.5)
+        second = sc.decide(0.8, 0.85, 0.5)
+        self.assertEqual(first, second)
+
+    def test_safer_setting_raises_tell_score(self):
+        unsafe = sc.tell_score(0.5, 0.5, 0.2)
+        safe = sc.tell_score(0.5, 0.5, 0.9)
+        self.assertGreater(safe, unsafe)
+
+    def test_confidence_is_bounded(self):
+        out = sc.decide(0.9, 0.1, 0.1)
+        self.assertGreaterEqual(out["confidence"], 0.0)
+        self.assertLessEqual(out["confidence"], 1.0)
+
+
+class SecrecyCostTest(unittest.TestCase):
+    def test_telling_has_no_hidden_cost(self):
+        self.assertEqual(sc.hidden_cost("tell", 0.9, 0.9), 0.0)
+        self.assertEqual(sc.decide(0.1, 0.9, 0.9)["pressure_add"], 0.0)
+
+    def test_withholding_has_a_cost(self):
+        self.assertGreater(sc.hidden_cost("withhold", 0.8, 0.5), 0.0)
+
+    def test_reframe_costs_less_than_withholding(self):
+        withheld = sc.hidden_cost("withhold", 0.8, 0.5)
+        softened = sc.hidden_cost("reframe", 0.8, 0.5)
+        self.assertGreater(withheld, softened)
+        self.assertGreater(softened, 0.0)
+
+
+class SecrecyPressureTest(unittest.TestCase):
+    def test_pressure_accumulates_across_hidden_turns(self):
+        first = sc.update(sc.initial(NOW - 3600), 0.9, 0.15, 0.15, now=NOW)
+        second = sc.update(first, 0.9, 0.15, 0.15, now=NOW + 3600)
+        self.assertGreater(first["pressure"], 0.0)
+        self.assertGreater(second["pressure"], first["pressure"])
+        self.assertEqual(second["withholds"], 2)
+
+    def test_same_turn_is_idempotent(self):
+        once = sc.update(sc.initial(NOW - 10), 0.9, 0.15, 0.15, now=NOW)
+        twice = sc.update(once, 0.9, 0.15, 0.15, now=NOW)
+        self.assertEqual(twice["pressure"], once["pressure"])
+        self.assertEqual(twice["withholds"], once["withholds"])
+
+    def test_telling_does_not_raise_withhold_count(self):
+        state = sc.update(sc.initial(NOW - 10), 0.1, 0.9, 0.9, now=NOW)
+        self.assertEqual(state["withholds"], 0)
+        self.assertEqual(state["pressure"], 0.0)
+
+    def test_pressure_is_capped_at_one(self):
+        state = dict(sc.initial(NOW - 10), pressure=0.99)
+        loaded = sc.update(state, 0.9, 0.15, 0.15, now=NOW)
+        self.assertLessEqual(loaded["pressure"], 1.0)
+
+    def test_pressure_decays_over_time(self):
+        state = dict(sc.initial(NOW), pressure=0.50)
+        rested = sc.update(state, 0.1, 0.9, 0.9, now=NOW + 10 * 3600)
+        self.assertAlmostEqual(rested["pressure"], 0.30)
+
+    def test_contained_flag(self):
+        self.assertTrue(sc.contained(dict(sc.initial(NOW), pressure=0.30)))
+        self.assertFalse(sc.contained(dict(sc.initial(NOW), pressure=0.70)))
+
+    def test_view_fields(self):
+        state = sc.update(sc.initial(NOW - 10), 0.9, 0.15, 0.15, now=NOW)
+        panel = sc.view(state)
+        for key in ("pressure", "contained", "withholds", "last_action",
+                    "last_pressure_add"):
+            self.assertIn(key, panel)
+
+    def test_bad_inputs_do_not_crash(self):
+        state = sc.update(None, None, None, None)
+        self.assertIn(state["last_action"], sc.ACTIONS)
+        self.assertEqual(sc.hidden_cost(None, None, None), 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_self_esteem.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import self_esteem as se
+
+NOW = 1_700_000_000
+
+class SelfEsteemTest(unittest.TestCase):
+    def test_initial_baseline(self):
+        state = se.initial(NOW)
+        self.assertAlmostEqual(state['value'], se.BASELINE)
+    def test_praised_raises(self):
+        self.assertAlmostEqual(se.update(se.initial(NOW), 'praised', NOW)['value'], 0.61)
+    def test_replied_raises(self):
+        self.assertAlmostEqual(se.update(se.initial(NOW), 'replied', NOW)['value'], 0.61)
+    def test_ignored_lowers(self):
+        self.assertAlmostEqual(se.update(se.initial(NOW), 'ignored', NOW)['value'], 0.5)
+    def test_insulted_lowers(self):
+        self.assertAlmostEqual(se.update(se.initial(NOW), 'insulted', NOW)['value'], 0.5)
+    def test_decay_toward_baseline(self):
+        state = {'value': 0.2, 'baseline': se.BASELINE, 'last_decay_ts': NOW - 1}
+        self.assertGreater(se.decay(state, NOW)['value'], 0.2)
+    def test_decay_same_now_idempotent(self):
+        state = {'value': 0.3, 'baseline': se.BASELINE, 'last_decay_ts': NOW}
+        self.assertEqual(se.decay(state, NOW)['value'], 0.3)
+    def test_update_same_now_does_not_double(self):
+        state = se.update(se.initial(NOW), 'praised', NOW)
+        again = se.update(se.initial(NOW), 'praised', NOW)
+        self.assertAlmostEqual(again['value'], state['value'])
+    def test_clamp_upper(self):
+        state = {'value': 0.99, 'baseline': se.BASELINE}
+        self.assertLessEqual(se.update(state, 'praised', NOW)['value'], 1.0)
+    def test_clamp_lower(self):
+        state = {'value': 0.01, 'baseline': se.BASELINE}
+        self.assertGreaterEqual(se.update(state, 'insulted', NOW)['value'], 0.0)
+    def test_unknown_event_no_change(self):
+        self.assertAlmostEqual(se.update(se.initial(NOW), 'bogus', NOW)['value'], se.BASELINE)
+    def test_confidence_low_esteem(self):
+        self.assertLess(se.confidence_delta(0.2), 0)  # lower esteem -> lower confidence
+    def test_view_fields(self):
+        view = se.view(se.update(se.initial(NOW), 'praised', NOW))
+        for key in ('value', 'baseline', 'last_event', 'confidence_delta'):
+            self.assertIn(key, view)
+
+if __name__ == '__main__':
+    unittest.main()