dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_debug_values.py

@@ -0,0 +1,169 @@
+# -*- coding: utf-8 -*-
+"""Debug-page regression tests: discomfort, needs progress, autonomy drift."""
+import ast
+import json
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import autonomy_model as am
+from biocore_model import autonomy_tick as at
+from biocore_model import bio_tick as bt
+from biocore_model import intero_core as ic
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+
+
+class FakeCore:
+    def __init__(self, partial=False):
+        self.v = -0.2
+        self.a = 0.8
+        self.d = 0.4
+        self.social = 0.3
+        self.stress = 0.7
+        self.energy = 0.2
+        self.labels = {"emotion": "sadness", "intensity": 0.8}
+        self.allostatic_load = 0.5
+        self.boredom = 0.4
+        self.homeostasis = {"L_int": 0.3}
+        self.open_loops = [{"status": "open"}, {"status": "open"}]
+        self.open_loops_due = 2
+        self.needs = None
+        self.sleep_debt = 0.0
+        self.last_debt_ts = 0.0
+        self.last_bio_tick_ts = 0.0
+        self._bio_tick_count = 0
+        self.relationship_context = {"state": {"closeness": 0.3, "conflict": 0.6, "repair": 0.1}}
+        self.tension = 0.55
+        if partial:
+            self.intero = {"tension": 0.55}
+        else:
+            self.intero = {"tension": 0.55, "warmth": 0.6, "heaviness": 0.3, "clarity": 0.7}
+
+    def snapshot(self):
+        return {"v": self.v, "a": self.a, "d": self.d, "social": self.social,
+                "stress": self.stress, "energy": self.energy,
+                "allostatic_load": self.allostatic_load, "boredom": self.boredom,
+                "homeostasis": dict(self.homeostasis),
+                "open_loops": list(self.open_loops),
+                "open_loops_due": self.open_loops_due,
+                "labels": dict(self.labels)}
+
+
+class PartsDriftTest(unittest.TestCase):
+    def test_parts_from_state_nonzero_drift(self):
+        core = FakeCore()
+        rel = {"state": {"closeness": 0.3, "conflict": 0.6, "repair": 0.1}}
+        parts = am.parts_from_state(core, rel, now=10000.0,
+                                    acc={"last_user_msg_ts": 10000.0 - 7200.0})
+        self.assertGreater(parts["social_gap"], 0.0)
+        self.assertGreater(parts["stress_load"], 0.0)
+        drift = am.drift_value(parts)
+        self.assertGreater(drift, 0.02)
+        motive = at._compute_motive({}, parts)
+        self.assertGreater(motive["drift"], 0.0)
+
+    def test_v_accumulates_with_built_parts(self):
+        core = FakeCore()
+        parts = am.parts_from_state(core, core.relationship_context, now=10000.0,
+                                    acc={"last_user_msg_ts": 10000.0 - 7200.0})
+        drift = am.drift_value(parts)
+        value = 0.0
+        for _ in range(5):
+            out = am.step(value, drift, theta=5.0, xi=0.0)
+            value = out["V"]
+        self.assertGreater(value, 0.02)
+
+    def test_parts_missing_inputs_still_bounded(self):
+        parts = am.parts_from_state(object(), {}, now=1.0, acc={})
+        self.assertTrue(parts)
+        for value in parts.values():
+            self.assertGreaterEqual(value, 0.0)
+            self.assertLessEqual(value, 1.0)
+
+
+class NeedsProgressTest(unittest.TestCase):
+    def test_needs_move_over_ticks(self):
+        core = FakeCore()
+        first = bt.bio_tick(core, now=100000.0, dt_hours=1.0)
+        start = dict(first["log"]["needs"])
+        for index in range(5):
+            out = bt.bio_tick(core, now=100000.0 + (index + 1) * 3600.0, dt_hours=1.0)
+        end = dict(out["log"]["needs"])
+        self.assertLess(end["belonging"], start["belonging"])
+        self.assertNotEqual(end, start)
+
+
+class DiscomfortTest(unittest.TestCase):
+    def test_tension_055_is_positive(self):
+        out = ic.discomfort({"tension": 0.55, "warmth": ic.COMFORT["warmth"],
+                             "heaviness": ic.COMFORT["heaviness"],
+                             "clarity": ic.COMFORT["clarity"]})
+        self.assertGreater(out["total"], 0.0)
+
+    def test_partial_intero_is_null_not_zero(self):
+        self.assertIsNone(_page_debug_discomfort({"tension": 0.55}))
+        self.assertIsNone(_page_debug_discomfort(None))
+        self.assertGreater(_page_debug_discomfort(
+            {"tension": 0.55, "warmth": 0.6, "heaviness": 0.3, "clarity": 0.7}), 0.0)
+
+
+def _load_page_debug():
+    tree = ast.parse(SOURCE)
+    cls = next(n for n in tree.body
+               if isinstance(n, ast.ClassDef) and n.name == "BioCorePlugin")
+    node = next(f for f in cls.body
+                if isinstance(f, ast.AsyncFunctionDef) and f.name == "page_debug")
+    ns = {"_bc_blocks": types.SimpleNamespace(BLOCKS=[], _enabled_map=lambda plugin: {}),
+          "PROFILE_PATH": Path("/p.json"), "DATA_DIR": Path("/d")}
+    clone = ast.AsyncFunctionDef(name=node.name, args=node.args, body=node.body,
+                                 decorator_list=[], returns=node.returns,
+                                 type_comment=None, lineno=node.lineno,
+                                 col_offset=node.col_offset, end_lineno=node.end_lineno,
+                                 end_col_offset=node.end_col_offset)
+    exec(compile(ast.Module(body=[clone], type_ignores=[]), "<page_debug>", "exec"), ns)
+    return ns[node.name]
+
+
+PAGE_DEBUG = _load_page_debug()
+
+
+def _page_debug_discomfort(intero):
+    try:
+        if not isinstance(intero, dict):
+            return None
+        if any(dim not in intero for dim in ic.DIMS):
+            return None
+        return ic.discomfort(intero).get("total")
+    except Exception:
+        return None
+
+
+class PageDebugTest(unittest.IsolatedAsyncioTestCase):
+    async def test_page_debug_discomfort_uses_same_intero(self):
+        plugin = types.SimpleNamespace(
+            cores={"s": FakeCore()}, _life_tick_n=3,
+            _bc_blocks=types.SimpleNamespace(BLOCKS=[], _enabled_map=lambda p: {}),
+            _load_policy_q=lambda: {}, _policy_pending=None,
+            data_dir="/tmp")
+        out = await PAGE_DEBUG(plugin)
+        self.assertGreater(out["data"]["bio"]["discomfort"], 0.0)
+
+    async def test_partial_intero_returns_null(self):
+        plugin = types.SimpleNamespace(
+            cores={"s": FakeCore(partial=True)}, _life_tick_n=3,
+            _load_policy_q=lambda: {}, _policy_pending=None, data_dir="/tmp")
+        out = await PAGE_DEBUG(plugin)
+        self.assertIsNone(out["data"]["bio"]["discomfort"])
+
+
+class WiringStaticTest(unittest.TestCase):
+    def test_needs_log_and_parts_wiring(self):
+        self.assertIn("[biocore] needs tick %s", SOURCE)
+        self.assertIn("_am.parts_from_state(", SOURCE)
+        self.assertIn("if all(dim in intero for dim in _ic_debug.DIMS)", SOURCE)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_defense_mechanisms.py

@@ -0,0 +1,177 @@
+# -*- coding: utf-8 -*-
+import unittest
+
+from biocore_model import defense_mechanisms as dm
+
+
+class DefenseMechanismSelectionTest(unittest.TestCase):
+    def test_denial_on_near_threat(self):
+        out = dm.assess(
+            {"kind": "failure", "valence": -0.9, "intensity": 0.9},
+            state={"v": -0.7, "a": 0.7, "d": 0.2, "stress": 0.85},
+            self_concept={"clarity": 0.15},
+        )
+        self.assertEqual(out["mechanism"], "denial")
+        self.assertEqual(out["label"], "否认")
+        self.assertGreaterEqual(out["strength"], 0.6)
+
+    def test_rationalization_on_self_caused_failure(self):
+        out = dm.assess(
+            {"kind": "failure", "valence": -0.6, "intensity": 0.7,
+             "self_caused": True},
+            state={"v": -0.4, "a": 0.4, "d": 0.6, "stress": 0.3},
+            self_concept={"clarity": 0.6, "competence": 0.85,
+                          "honesty": 0.8},
+        )
+        self.assertEqual(out["mechanism"], "rationalization")
+        self.assertGreater(out["strength"], 0.5)
+
+    def test_projection_when_own_anger_lands_on_other(self):
+        out = dm.assess(
+            {"kind": "conflict", "valence": -0.5, "intensity": 0.7,
+             "target": "peer"},
+            state={"anger": 0.85, "fear": 0.2, "trust": 0.15,
+                   "d": 0.5, "stress": 0.5},
+            self_concept={"clarity": 0.5},
+        )
+        self.assertEqual(out["mechanism"], "projection")
+        self.assertEqual(out["label"], "投射")
+
+    def test_displacement_when_source_is_untouchable(self):
+        out = dm.assess(
+            {"kind": "criticism", "valence": -0.6, "intensity": 0.8,
+             "target": "authority", "power_gap": 1.0},
+            state={"anger": 0.8, "d": 0.1, "trust": 0.5, "stress": 0.5},
+            self_concept={"clarity": 0.5},
+        )
+        self.assertEqual(out["mechanism"], "displacement")
+        self.assertEqual(out["label"], "转移")
+
+    def test_strongest_mechanism_wins(self):
+        scores = dm.mechanism_scores(
+            {"kind": "criticism", "valence": -0.6, "intensity": 0.8,
+             "target": "authority", "power_gap": 1.0},
+            state={"anger": 0.8, "d": 0.1, "trust": 0.5, "stress": 0.5},
+            self_concept={"clarity": 0.5},
+        )
+        self.assertGreater(scores["displacement"], scores["projection"])
+        out = dm.assess(
+            {"kind": "criticism", "valence": -0.6, "intensity": 0.8,
+             "target": "authority", "power_gap": 1.0},
+            state={"anger": 0.8, "d": 0.1, "trust": 0.5, "stress": 0.5},
+            self_concept={"clarity": 0.5},
+        )
+        self.assertEqual(out["mechanism"], "displacement")
+
+
+class DefenseMechanismOutputTest(unittest.TestCase):
+    CASES = (
+        ({"kind": "failure", "valence": -0.9, "intensity": 0.9},
+         {"v": -0.7, "a": 0.7, "d": 0.2, "stress": 0.85},
+         {"clarity": 0.15}),
+        ({"kind": "failure", "valence": -0.6, "intensity": 0.7,
+          "self_caused": True}, {"stress": 0.3},
+         {"clarity": 0.6, "competence": 0.85}),
+        ({"kind": "conflict", "valence": -0.5, "intensity": 0.7,
+          "target": "peer"},
+         {"anger": 0.85, "trust": 0.15}, {"clarity": 0.5}),
+        ({"kind": "criticism", "valence": -0.6, "intensity": 0.8,
+          "target": "authority", "power_gap": 1.0},
+         {"anger": 0.8, "d": 0.1}, {"clarity": 0.5}),
+    )
+
+    def test_strength_and_cost_are_bounded(self):
+        for event, state, concept in self.CASES:
+            out = dm.assess(event, state=state, self_concept=concept)
+            self.assertGreaterEqual(out["strength"], 0.0)
+            self.assertLessEqual(out["strength"], 1.0)
+            self.assertGreaterEqual(out["cost"], 0.0)
+            self.assertLessEqual(out["cost"], 1.0)
+
+    def test_cost_scales_with_strength(self):
+        for event, state, concept in self.CASES:
+            out = dm.assess(event, state=state, self_concept=concept)
+            base = dm.COST_BASE[out["mechanism"]]
+            self.assertEqual(out["cost"], round(base * out["strength"], 4))
+
+    def test_reason_and_self_talk_present_for_each(self):
+        for event, state, concept in self.CASES:
+            out = dm.assess(event, state=state, self_concept=concept)
+            self.assertTrue(out["mechanism"])
+            self.assertTrue(out["reason"])
+            self.assertTrue(out["self_talk"])
+
+    def test_mechanism_scores_cover_all_four(self):
+        scores = dm.mechanism_scores({}, None, None)
+        self.assertEqual(set(scores), set(dm.MECHANISMS))
+        for value in scores.values():
+            self.assertGreaterEqual(value, 0.0)
+            self.assertLessEqual(value, 1.0)
+
+    def test_deterministic(self):
+        first = dm.assess(
+            {"kind": "conflict", "valence": -0.5, "intensity": 0.7},
+            state={"anger": 0.85, "trust": 0.15}, self_concept={"clarity": 0.5})
+        second = dm.assess(
+            {"kind": "conflict", "valence": -0.5, "intensity": 0.7},
+            state={"anger": 0.85, "trust": 0.15}, self_concept={"clarity": 0.5})
+        self.assertEqual(first, second)
+
+
+class DefenseMechanismSwitchTest(unittest.TestCase):
+    DENIAL_EVENT = {"kind": "failure", "valence": -0.9, "intensity": 0.9}
+    DENIAL_STATE = {"v": -0.7, "a": 0.7, "d": 0.2, "stress": 0.85}
+    DENIAL_CONCEPT = {"clarity": 0.15}
+
+    def test_disabled_bool(self):
+        out = dm.assess(self.DENIAL_EVENT, state=self.DENIAL_STATE,
+                        self_concept=self.DENIAL_CONCEPT, config=False)
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["mechanism"], "")
+        self.assertEqual(out["strength"], 0.0)
+        self.assertEqual(out["cost"], 0.0)
+        self.assertEqual(out["self_talk"], "")
+        self.assertTrue(out["reason"])
+
+    def test_disabled_config_dict(self):
+        out = dm.assess(self.DENIAL_EVENT, state=self.DENIAL_STATE,
+                        self_concept=self.DENIAL_CONCEPT,
+                        config={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["mechanism"], "")
+
+    def test_no_defense_when_nothing_negative(self):
+        out = dm.assess({"kind": "praise", "valence": 0.8, "intensity": 0.9},
+                        state={"v": 0.6, "a": 0.5}, self_concept={"clarity": 0.6})
+        self.assertEqual(out["mechanism"], "")
+        self.assertEqual(out["strength"], 0.0)
+        self.assertEqual(out["self_talk"], "")
+        self.assertTrue(out["reason"])
+
+    def test_threshold_can_be_raised(self):
+        out = dm.assess(self.DENIAL_EVENT, state=self.DENIAL_STATE,
+                        self_concept=self.DENIAL_CONCEPT,
+                        config={"threshold": 0.95})
+        self.assertEqual(out["mechanism"], "")
+
+    def test_malformed_inputs_do_not_crash(self):
+        for event, state, concept in ((None, None, None),
+                                      ("bad", "bad", "bad"),
+                                      ({"valence": "x"}, {"stress": "x"}, [])):
+            out = dm.assess(event, state=state, self_concept=concept)
+            self.assertIn("mechanism", out)
+            self.assertIn("scores", out)
+            self.assertGreaterEqual(out["strength"], 0.0)
+            self.assertLessEqual(out["strength"], 1.0)
+
+    def test_view_fields(self):
+        out = dm.assess(self.DENIAL_EVENT, state=self.DENIAL_STATE,
+                        self_concept=self.DENIAL_CONCEPT)
+        panel = dm.view(out)
+        for key in ("enabled", "mechanism", "label", "strength", "cost",
+                    "reason", "self_talk"):
+            self.assertIn(key, panel)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_delta_budget.py

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+"""P0-2: per-message total |dims delta| budget (delta_budget + main wiring)."""
+import ast
+import json
+import types
+import unittest
+from pathlib import Path
+
+from biocore_model import appraisal
+from biocore_model import delta_budget as db
+
+ROOT = Path(__file__).resolve().parents[2]
+MAIN = ROOT / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+SCHEMA = json.loads((ROOT / "_conf_schema.json").read_text(encoding="utf-8"))
+
+
+def _load_budget_helper():
+    tree = ast.parse(SOURCE)
+    node = next(item for item in tree.body
+                if isinstance(item, ast.FunctionDef)
+                and item.name == "_budget_dims_deltas")
+    clone = ast.FunctionDef(name=node.name, args=node.args, body=node.body,
+                            decorator_list=[], returns=node.returns,
+                            type_comment=None, lineno=node.lineno,
+                            col_offset=node.col_offset,
+                            end_lineno=node.end_lineno,
+                            end_col_offset=node.end_col_offset)
+    ns = {"logger": types.SimpleNamespace(
+        info=lambda *a, **k: None, warning=lambda *a, **k: None,
+        debug=lambda *a, **k: None)}
+    exec(compile(ast.Module(body=[clone], type_ignores=[]),
+                 "<_budget_dims_deltas>", "exec"), ns)
+    return ns[node.name]
+
+
+BUDGET_METHOD = _load_budget_helper()
+
+
+class _FakePlugin:
+    def __init__(self, limit=0.2, enabled=True):
+        self.dims_delta_limit = limit
+        self.dims_delta_limit_enabled = enabled
+
+
+class BudgetTest(unittest.TestCase):
+    def test_within_limit_unchanged(self):
+        deltas = {"v": 0.10, "a": -0.05}
+        scaled, report = db.budget(deltas)
+        self.assertFalse(report["scaled"])
+        self.assertEqual(scaled, deltas)
+        self.assertAlmostEqual(report["raw_total"], 0.15)
+        self.assertAlmostEqual(report["factor"], 1.0)
+
+    def test_over_limit_scaled_proportionally(self):
+        deltas = {"v": 0.6, "a": -0.3, "stress": 0.1}
+        scaled, report = db.budget(deltas, limit=0.2)
+        self.assertTrue(report["scaled"])
+        self.assertAlmostEqual(report["raw_total"], 1.0)
+        self.assertLessEqual(report["scaled_total"], 0.2 + 1e-6)
+        self.assertAlmostEqual(report["factor"], 0.2)
+        # direction and channel ratios are preserved
+        self.assertGreater(scaled["v"], 0)
+        self.assertLess(scaled["a"], 0)
+        self.assertAlmostEqual(scaled["v"] / scaled["a"], deltas["v"] / deltas["a"])
+        self.assertAlmostEqual(scaled["v"], 0.12, places=4)
+
+    def test_zero_deltas_unchanged(self):
+        scaled, report = db.budget({"v": 0.0, "a": 0.0})
+        self.assertEqual(scaled, {"v": 0.0, "a": 0.0})
+        self.assertFalse(report["scaled"])
+        self.assertEqual(report["raw_total"], 0.0)
+
+    def test_multi_field_sum_crosses_limit(self):
+        deltas = {"v": 0.08, "a": 0.08, "d": 0.08, "social": 0.04}
+        scaled, report = db.budget(deltas, limit=0.2)
+        self.assertTrue(report["scaled"])
+        self.assertAlmostEqual(report["raw_total"], 0.28)
+        self.assertLessEqual(db.total(scaled), 0.2 + 1e-6)
+        self.assertEqual(len(scaled), 4)
+
+    def test_disabled_returns_unchanged(self):
+        deltas = {"v": 0.6, "stress": 0.3}
+        scaled, report = db.budget(deltas, limit=0.2, enabled=False)
+        self.assertEqual(scaled, deltas)
+        self.assertFalse(report["scaled"])
+        self.assertFalse(report["enabled"])
+
+    def test_custom_limit_respected(self):
+        scaled, report = db.budget({"v": 0.5, "a": 0.5}, limit=0.5)
+        self.assertTrue(report["scaled"])
+        self.assertAlmostEqual(sum(abs(x) for x in scaled.values()), 0.5)
+
+    def test_invalid_values_dropped(self):
+        scaled, report = db.budget({"v": "abc", "a": None, "d": float("nan"),
+                                    "stress": float("inf"), "trust": 0.05})
+        self.assertEqual(scaled, {"trust": 0.05})
+        self.assertFalse(report["scaled"])
+
+    def test_invalid_limit_falls_back_to_default(self):
+        self.assertAlmostEqual(db.clean_limit(0), db.DEFAULT_LIMIT)
+        self.assertAlmostEqual(db.clean_limit("x"), db.DEFAULT_LIMIT)
+        self.assertAlmostEqual(db.clean_limit(None), db.DEFAULT_LIMIT)
+        self.assertAlmostEqual(db.clean_limit(5.0), db.MAX_LIMIT)
+        self.assertAlmostEqual(db.clean_limit(0.0001), db.MIN_LIMIT)
+
+    def test_negative_deltas_use_absolute_sum(self):
+        scaled, report = db.budget({"v": -0.5, "a": -0.5}, limit=0.2)
+        self.assertTrue(report["scaled"])
+        self.assertAlmostEqual(report["raw_total"], 1.0)
+        self.assertAlmostEqual(scaled["v"], -0.1, places=4)
+
+    def test_real_appraise_output_is_bounded(self):
+        # full-blown dims from the appraisal layer can exceed one message budget
+        dims = {"goal": 1.0, "blame": 1.0, "hit": 1.0, "involve": 1.0,
+                "control": 1.0, "novelty": 1.0, "certainty": 1.0}
+        deltas = appraisal.appraise(dims, confidence=1.0)
+        self.assertGreater(db.total(deltas), 0.2)
+        scaled, report = db.budget(deltas)
+        self.assertTrue(report["scaled"])
+        self.assertLessEqual(db.total(scaled), 0.2 + 1e-6)
+
+
+class MainWiringTest(unittest.TestCase):
+    def test_config_attrs_and_call_sites(self):
+        self.assertIn("dims_delta_limit_enabled", SOURCE)
+        self.assertIn("dims_delta_limit", SOURCE)
+        self.assertIn("def _budget_dims_deltas(plugin, deltas", SOURCE)
+        self.assertEqual(SOURCE.count("_budget_dims_deltas(self, "), 2)
+        self.assertIn('"user"', SOURCE)
+        self.assertIn('"reply"', SOURCE)
+
+    def test_schema_entries(self):
+        for key in ("dims_delta_limit_enabled", "dims_delta_limit"):
+            self.assertIn(key, SCHEMA)
+        self.assertTrue(SCHEMA["dims_delta_limit_enabled"]["default"])
+        self.assertAlmostEqual(SCHEMA["dims_delta_limit"]["default"], 0.2)
+        self.assertEqual(SCHEMA["dims_delta_limit"]["type"], "float")
+
+    def test_method_scales_with_plugin_config(self):
+        scaled = BUDGET_METHOD(_FakePlugin(limit=0.2), {"v": 0.6, "a": 0.4},
+                               "user")
+        self.assertAlmostEqual(sum(abs(x) for x in scaled.values()), 0.2,
+                               places=4)
+
+    def test_method_honours_disabled_flag(self):
+        deltas = {"v": 0.6, "a": 0.4}
+        self.assertEqual(BUDGET_METHOD(_FakePlugin(enabled=False), deltas,
+                                       "reply"), deltas)
+
+    def test_method_without_config_uses_default(self):
+        scaled = BUDGET_METHOD(types.SimpleNamespace(), {"v": 0.9}, "reply")
+        self.assertAlmostEqual(scaled["v"], 0.2, places=4)
+
+
+if __name__ == "__main__":
+    unittest.main()