dsh-biocore 0.2.0 → 0.3.1

package/python/biocore_model/tests/test_arch_convergence.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+import re, unittest
+from pathlib import Path
+from biocore_model import appraisal_action as aa, needs_esteem as ne, needs_sleep as ns
+from biocore_model import attachment_regulation as ar, attachment_state as ast
+from biocore_model import connection_bids as cb, sleep_circadian as sc, memory_forgetting as mf
+
+class ConvergenceTest(unittest.TestCase):
+    def test_appraisal_delegates(self):
+        self.assertEqual(aa.appraisal(0.5, 0.6, 0.7, 0.8, 0.9), aa._bio_appraisal.appraisal(0.5, 0.6, 0.7, 0.8, 0.9))
+    def test_appraise_delegates(self):
+        self.assertEqual(aa.appraise(-0.5, 0.8, 0.2, 0.6), aa._bio_appraisal.appraise(-0.5, 0.8, 0.2, 0.6))
+    def test_needs_esteem_delegates_to_needs_sleep(self):
+        old = ne.apply_silence(ne.defaults(), 10)
+        new = ns.need_step(ns.defaults(0), {'silence_hours': 10}, dt=0, now=1)
+        self.assertAlmostEqual(old['belonging'], new['belonging'], places=3)
+    def test_attachment_wrapper_delegates(self):
+        wrapped = ar.activation('anxious', threat=0.4, current=0.3, hours=1)
+        raised = ast.threat(0.3, 0.4); expected = ast.decay(raised, False, 1)
+        self.assertAlmostEqual(wrapped['activation'], expected, places=3)
+    def test_trust_derived_from_relationship(self):
+        derived = cb.trust_from_relationship({'state': {'trust': 0.7}})
+        self.assertAlmostEqual(derived['overall'], 0.7)
+    def test_circadian_reads_snapshot(self):
+        self.assertAlmostEqual(sc.circadian_from_snapshot({'circadian_alertness': 0.42}), 0.42)
+    def test_rumination_single_module_no_core_write(self):
+        source = Path(__file__).resolve().parent.parent.joinpath('memory_forgetting.py').read_text(encoding='utf-8')
+        self.assertIsNone(re.search(r'core\.[A-Za-z_]+\s*=', source))
+    def test_no_core_assignment_in_appraisal(self):
+        for name in ('appraisal_action.py', 'bio_appraisal.py'):
+            source = Path(__file__).resolve().parent.parent.joinpath(name).read_text(encoding='utf-8')
+            self.assertIsNone(re.search(r'core\.[A-Za-z_]+\s*=', source), name)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_attachment_behavior.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+"""Attachment styles as behaviour parameters."""
+import unittest
+
+from biocore_model import attachment_behavior as ab
+
+
+class StyleTest(unittest.TestCase):
+    def test_three_styles_distinct(self):
+        secure = ab.evaluate("secure")
+        anxious = ab.evaluate("anxious")
+        avoidant = ab.evaluate("avoidant")
+        self.assertGreater(anxious["seeking"], secure["seeking"])
+        self.assertGreater(anxious["seeking"], avoidant["seeking"])
+        self.assertGreater(avoidant["withdrawal"], secure["withdrawal"])
+        self.assertGreater(secure["initiative"], avoidant["initiative"])
+
+    def test_unknown_style_falls_back_secure(self):
+        out = ab.evaluate("weird")
+        self.assertEqual(out["style"], "secure")
+
+    def test_labels(self):
+        self.assertEqual(ab.evaluate("anxious")["label"], "焦虑型")
+
+
+class BoundsTest(unittest.TestCase):
+    def test_all_params_bounded(self):
+        for style in ab.STYLES:
+            out = ab.evaluate(style, {"closeness": 1.0, "stress": 1.0})
+            for key in ("initiative", "seeking", "withdrawal"):
+                self.assertGreaterEqual(out[key], 0.0)
+                self.assertLessEqual(out[key], 1.0)
+
+
+class ModifierTest(unittest.TestCase):
+    def test_stress_lowers_initiative_raises_withdrawal(self):
+        calm = ab.evaluate("secure", {"stress": 0.0})
+        tense = ab.evaluate("secure", {"stress": 1.0})
+        self.assertGreater(calm["initiative"], tense["initiative"])
+        self.assertLess(calm["withdrawal"], tense["withdrawal"])
+
+    def test_closeness_lifts_initiative(self):
+        far = ab.evaluate("secure", {"closeness": 0.1})
+        near = ab.evaluate("secure", {"closeness": 0.9})
+        self.assertGreater(near["initiative"], far["initiative"])
+
+
+class IgnoredTest(unittest.TestCase):
+    def test_anxious_seeks_more_when_ignored(self):
+        normal = ab.evaluate("anxious")
+        ignored = ab.evaluate("anxious", {"ignored": True})
+        self.assertGreater(ignored["seeking"], normal["seeking"])
+
+    def test_avoidant_withdraws_more_when_ignored(self):
+        normal = ab.evaluate("avoidant")
+        ignored = ab.evaluate("avoidant", {"ignored": True})
+        self.assertGreater(ignored["withdrawal"], normal["withdrawal"])
+
+    def test_on_ignored_text_per_style(self):
+        self.assertIn("再发", ab.evaluate("anxious")["on_ignored"])
+        self.assertIn("退回去", ab.evaluate("avoidant")["on_ignored"])
+
+
+class MixedTest(unittest.TestCase):
+    def test_blend_sits_between(self):
+        blend = ab.evaluate({"secure": 0.5, "anxious": 0.5})
+        self.assertTrue(0.4 <= blend["seeking"] <= 0.8)
+
+    def test_empty_mix_defaults_secure(self):
+        self.assertEqual(ab.evaluate({})["style"], "secure")
+
+
+class FallbackTest(unittest.TestCase):
+    def test_disabled(self):
+        out = ab.evaluate("anxious", flags={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["style"], "secure")
+
+    def test_malformed_context(self):
+        out = ab.evaluate("secure", "nope")
+        self.assertIn(out["style"], ab.STYLES)
+
+
+class DirectiveTest(unittest.TestCase):
+    def test_withdrawal_shortens(self):
+        out = ab.directives(ab.evaluate("avoidant", {"stress": 0.9}))
+        self.assertLessEqual(out["length_scale"], 1.0)
+
+    def test_disabled_directive(self):
+        out = ab.directives({"enabled": False})
+        self.assertEqual(out["tone"], "")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_attachment_regulation.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import attachment_regulation as ar
+
+class AttachmentTest(unittest.TestCase):
+    def test_anxious_drive(self):
+        self.assertAlmostEqual(ar.activation('anxious', threat=1.0)['drive_mult'], 1.2)
+    def test_avoidant_drive(self):
+        self.assertAlmostEqual(ar.activation('avoidant', threat=1.0)['drive_mult'], 0.7)
+    def test_secure_mode(self):
+        self.assertEqual(ar.activation('secure', threat=1.0)['mode'], 'comfort')
+    def test_activation_rises(self):
+        self.assertGreater(ar.activation('secure', threat=1.0)['activation'], 0)
+    def test_response_drop(self):
+        state = ar.activation('secure', threat=0.0, current=0.8, responded=True)
+        self.assertAlmostEqual(state['activation'], 0.4)
+    def test_decay_per_hour(self):
+        state = ar.activation('secure', threat=0.0, current=1.0, hours=5)
+        self.assertAlmostEqual(state['activation'], 0.5)
+
+class RegulationTest(unittest.TestCase):
+    def test_avoidant_suppresses(self):
+        self.assertEqual(ar.choose_strategy('avoidant'), 'suppress')
+    def test_low_energy_suppresses(self):
+        self.assertEqual(ar.choose_strategy('secure', energy=0.2), 'suppress')
+    def test_reappraise_mult(self):
+        self.assertAlmostEqual(ar.regulate('reappraise')['negative_mult'], 0.6)
+    def test_suppress_mult_and_stress(self):
+        out = ar.regulate('suppress')
+        self.assertAlmostEqual(out['negative_mult'], 0.5); self.assertGreater(out['stress_delta'], 0)
+    def test_effort_accumulates(self):
+        first = ar.regulate('suppress')['effort']; second = ar.regulate('suppress', effort=first)['effort']
+        self.assertGreater(second, first)
+    def test_regulation_risk(self):
+        self.assertFalse(ar.regulation_risk(0.5)); self.assertTrue(ar.regulation_risk(1.6))
+
+class MoodTest(unittest.TestCase):
+    def test_mood_toward_emotion(self):
+        mood = ar.mood_update({'valence': 0.0, 'arousal': 0.0}, valence=1.0)
+        self.assertGreater(mood['valence'], 0); self.assertLess(mood['valence'], 1)
+    def test_mood_converges_slowly(self):
+        mood = {'valence': 0.0, 'arousal': 0.0}
+        for _ in range(10): mood = ar.mood_update(mood, valence=1.0)
+        self.assertLess(mood['valence'], 0.5)  # 10 ticks ≈ 50 min, still far from target
+    def test_mood_half_life_ticks(self):
+        ticks = ar.mood_ticks_to_zero(-0.5)
+        self.assertGreaterEqual(ticks, 40); self.assertLessEqual(ticks, 80)
+    def test_view_fields(self):
+        v = ar.view('anxious', 0.5, 'hyperactivating', 'suppress', 0.3, True, {'valence': -0.2, 'arousal': 0.4})
+        for key in ('attachment', 'regulation', 'mood'): self.assertIn(key, v)
+
+    def test_unknown_style_falls_back(self):
+        self.assertEqual(ar.activation('bogus')['style'], 'secure')
+
+    def test_invalid_strategy_falls_back(self):
+        self.assertEqual(ar.regulate('bogus')['strategy'], 'reappraise')
+
+    def test_activation_clamped(self):
+        self.assertLessEqual(ar.activation('anxious', threat=5.0)['activation'], 1.0)
+
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_attachment_state.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import attachment_state as ast
+
+class AttachmentStateTest(unittest.TestCase):
+    def test_threat_raises(self):
+        self.assertGreater(ast.threat(0.0, 1.0), 0.0)
+    def test_modes(self):
+        self.assertEqual(ast.mode('anxious', 0.5), 'hyperactivating')
+        self.assertEqual(ast.mode('secure', 0.5), 'comfort')
+        self.assertEqual(ast.mode('avoidant', 0.5), 'deactivating')
+    def test_replied_halves(self):
+        self.assertAlmostEqual(ast.decay(0.8, True), 0.4)
+    def test_no_reply_decays_hourly(self):
+        self.assertAlmostEqual(ast.decay(1.0, False, dt=3), 0.7)
+    def test_drive_multipliers(self):
+        self.assertEqual(ast.drive_multiplier('anxious'), 1.2)
+        self.assertEqual(ast.drive_multiplier('avoidant'), 0.7)
+    def test_view_fields(self):
+        view = ast.view({'activation': 0.4}, 'secure')
+        for key in ('style', 'activation', 'mode', 'drive_mult'): self.assertIn(key, view)
+    def test_clamp(self):
+        self.assertLessEqual(ast.threat(0.95, 1.0), 1.0)
+        self.assertGreaterEqual(ast.decay(0.1, False, dt=100), 0.0)
+    def test_unknown_style(self):
+        self.assertEqual(ast.mode('bogus', 0.5), 'comfort')
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_attribution.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import attribution as at
+
+NOW = 1_700_000_000
+
+class InferTest(unittest.TestCase):
+    def test_shame_quadrant(self):
+        a = at.infer({'text': '我总是做不好，没办法改'})
+        self.assertEqual(a['locus'], 'internal'); self.assertEqual(a['stability'], 'stable'); self.assertEqual(a['controllability'], 'uncontrollable'); self.assertEqual(a['emotion_hint'], 'shame')
+    def test_anger_quadrant(self):
+        a = at.infer({'text': '他总是这样，我可以解决'})
+        self.assertEqual(a['locus'], 'external'); self.assertEqual(a['emotion_hint'], 'anger')
+    def test_sadness_quadrant(self):
+        a = at.infer({'text': '老板这次没办法改'})
+        self.assertEqual(a['emotion_hint'], 'sadness')
+    def test_guilt_quadrant(self):
+        a = at.infer({'text': '这次是我的错，可以改'})
+        self.assertEqual(a['emotion_hint'], 'guilt')
+    def test_neutral_when_ambiguous(self):
+        a = at.infer({'text': '今天天气如何'})
+        self.assertEqual(a['emotion_hint'], 'neutral'); self.assertEqual(a['locus'], 'neutral')
+    def test_conversation_hint_used(self):
+        a = at.infer({}, conversation_hint='他总是这样')
+        self.assertEqual(a['locus'], 'external')
+
+class ApplyTest(unittest.TestCase):
+    def test_apply_returns_deltas(self):
+        deltas = at.apply({}, {'emotion_hint': 'anger'}, NOW)
+        self.assertGreater(deltas['anger'], 0); self.assertGreater(deltas['stress'], 0)
+    def test_apply_shame(self):
+        deltas = at.apply({}, {'emotion_hint': 'shame'}, NOW)
+        self.assertGreater(deltas['self_blame'], 0); self.assertLess(deltas['valence'], 0)
+    def test_apply_guilt_repair(self):
+        deltas = at.apply({}, {'emotion_hint': 'guilt'}, NOW)
+        self.assertGreater(deltas['repair'], 0)
+    def test_apply_idempotent_same_now(self):
+        first = at.apply({}, {'emotion_hint': 'anger'}, NOW)
+        self.assertTrue(at.apply(first, {'emotion_hint': 'anger'}, NOW) == {})
+    def test_apply_neutral_empty(self):
+        self.assertEqual(at.apply({}, {'emotion_hint': 'neutral'}, NOW), {})
+    def test_apply_does_not_touch_appraisal(self):
+        deltas = at.apply({}, {'emotion_hint': 'anger'}, NOW)
+        self.assertNotIn('goal_congruence', deltas); self.assertNotIn('ego_involvement', deltas)
+
+class ViewTest(unittest.TestCase):
+    def test_view_fields(self):
+        view = at.view({}, at.infer({'text': '老板这次没办法改'}))
+        for key in ('locus', 'stability', 'controllability', 'emotion_hint'):
+            self.assertIn(key, view)
+    def test_view_quadrant_recompute(self):
+        view = at.view({}, {'locus': 'external', 'stability': 'stable', 'controllability': 'uncontrollable'})
+        self.assertEqual(view['emotion_hint'], 'sadness')
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_attributor.py

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+"""Attribution: four reaction types, bounds, fallbacks."""
+import unittest
+
+from biocore_model import attributor as ab
+
+class LocusTest(unittest.TestCase):
+    def test_blame_points_at_you(self):
+        out = ab.attribute({"blame": 0.9, "goal": -0.5, "hit": 0.6,
+                           "involve": 0.8}, {"who": "you"})
+        self.assertEqual(out["locus"], "you")
+        self.assertEqual(out["emotion"], "anger")
+
+    def test_self_blame_points_at_me(self):
+        out = ab.attribute({"blame": 0.5, "goal": -0.6, "hit": 0.8,
+                           "involve": 0.9}, {"who": "me"})
+        self.assertEqual(out["locus"], "me")
+        self.assertEqual(out["emotion"], "guilt")
+
+    def test_low_involvement_points_at_situation(self):
+        out = ab.attribute({"blame": 0.05, "goal": -0.2, "hit": 0.2,
+                           "involve": 0.05}, {"who": "situation"})
+        self.assertEqual(out["locus"], "situation")
+
+class EmotionTest(unittest.TestCase):
+    def test_sympathy_when_other_is_hurt(self):
+        out = ab.attribute({"blame": 0.05, "goal": -0.7, "hit": 0.9,
+                           "involve": 0.2}, {"who": "situation"},
+                          {"closeness": 0.8})
+        self.assertIn(out["emotion"], ("sympathy", "helplessness"))
+
+    def test_uncontrollable_self_is_helplessness(self):
+        out = ab.attribute({"blame": 0.0, "goal": -0.5, "hit": 0.3,
+                           "involve": 0.1}, {"who": "me"})
+        self.assertIn(out["emotion"], ("helplessness", "guilt"))
+
+class BoundsTest(unittest.TestCase):
+    def test_scores_in_range(self):
+        out = ab.attribute({"blame": 5, "goal": -9, "hit": 3,
+                           "involve": -2})
+        for value in out["scores"].values():
+            self.assertGreaterEqual(value, 0.0)
+            self.assertLessEqual(value, 1.0)
+        self.assertIn(out["locus"], ab.LOCI)
+        self.assertIn(out["emotion"], ab.EMOTIONS)
+        self.assertGreaterEqual(out["stability"], 0.0)
+        self.assertLessEqual(out["stability"], 1.0)
+
+    def test_confidence_not_negative(self):
+        out = ab.attribute({})
+        self.assertGreaterEqual(out["confidence"], 0.0)
+
+class StabilityTest(unittest.TestCase):
+    def test_conflict_raises_stability(self):
+        low = ab.attribute({"blame": 0.4}, {}, {"conflict": 0.0})
+        high = ab.attribute({"blame": 0.4}, {}, {"conflict": 0.9})
+        self.assertGreater(high["stability"], low["stability"])
+
+class ControllabilityTest(unittest.TestCase):
+    def test_situation_is_less_controllable(self):
+        a = ab.attribute({"blame": 0.6, "involve": 0.6}, {"who": "situation"})
+        b = ab.attribute({"blame": 0.6, "involve": 0.6}, {"who": "you"})
+        self.assertLess(a["controllability"], b["controllability"])
+
+class FallbackTest(unittest.TestCase):
+    def test_disabled_is_neutral(self):
+        out = ab.attribute({"blame": 0.9}, {"who": "you"},
+                           flags={"enabled": False})
+        self.assertFalse(out["enabled"])
+        self.assertEqual(out["emotion"], "neutral")
+        self.assertEqual(out["locus"], "situation")
+
+    def test_missing_fields_safe(self):
+        out = ab.attribute(None, None, None)
+        self.assertTrue(out["attribution_reason"])
+        self.assertTrue(out["reaction"])
+
+    def test_malformed_dims(self):
+        out = ab.attribute({"blame": "x", "goal": float("nan")})
+        self.assertIn(out["locus"], ab.LOCI)
+
+class DirectiveTest(unittest.TestCase):
+    def test_each_emotion_maps(self):
+        cases = {"anger": "angry", "guilt": "guilty",
+                 "helplessness": "helpless", "sympathy": "kind"}
+        for emotion in cases:
+            out = ab.directives({"enabled": True, "emotion": emotion,
+                                 "confidence": 0.5})
+            self.assertEqual(out["emotion"], emotion)
+            self.assertGreaterEqual(out["length_scale"], 0.5)
+
+    def test_disabled_directive(self):
+        out = ab.directives({"enabled": False})
+        self.assertEqual(out["tone"], "")
+
+class ThreeReactionsTest(unittest.TestCase):
+    def test_same_event_three_loci(self):
+        event = {"text": "他失约了"}
+        a = ab.attribute({"blame": 0.9, "goal": -0.6, "hit": 0.5,
+                         "involve": 0.8}, dict(event, who="you"))
+        b = ab.attribute({"blame": 0.5, "goal": -0.6, "hit": 0.8,
+                         "involve": 0.9}, dict(event, who="me"))
+        c = ab.attribute({"blame": 0.1, "goal": -0.6, "hit": 0.5,
+                         "involve": 0.1}, dict(event, who="situation"))
+        self.assertEqual(len({a["emotion"], b["emotion"], c["emotion"]}), 3)
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_autonomic.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+"""HUMAN-3 autonomic oscillation tests: band, period, threshold modulation."""
+import unittest
+
+from biocore_model import autonomic as au
+
+
+class FrequencyTest(unittest.TestCase):
+    def test_default_and_none(self):
+        self.assertEqual(au.frequency(None), au.DEFAULT_FREQ)
+        self.assertEqual(au.frequency(), au.DEFAULT_FREQ)
+
+    def test_clamped_to_band(self):
+        self.assertEqual(au.frequency(0.01), au.FREQ_MIN)
+        self.assertEqual(au.frequency(5.0), au.FREQ_MAX)
+
+    def test_period(self):
+        self.assertAlmostEqual(au.period(0.2), 5.0, places=4)
+        self.assertAlmostEqual(au.period(0.1), 10.0, places=4)
+
+    def test_in_band(self):
+        self.assertTrue(au.in_band(0.2))
+        self.assertFalse(au.in_band(0.05))
+        self.assertFalse(au.in_band("x"))
+
+
+class WaveTest(unittest.TestCase):
+    def test_amplitude_bound_and_zero(self):
+        self.assertAlmostEqual(au.wave(0.0), 0.0, places=4)
+        for now in range(0, 20):
+            self.assertLessEqual(abs(au.wave(now * 0.37, amplitude=0.4)), 0.4)
+
+    def test_periodic(self):
+        self.assertAlmostEqual(au.wave(1.0, freq=0.2),
+                               au.wave(1.0 + au.period(0.2), freq=0.2), places=3)
+
+    def test_phase_shift_equals_time_shift(self):
+        self.assertAlmostEqual(au.wave(0.0, phase0=1.0),
+                               au.wave(1.0 / (2 * 3.141592653589793 * 0.2)), places=3)
+
+
+class ThresholdTest(unittest.TestCase):
+    def test_threshold_bounds(self):
+        for now in range(0, 30):
+            value = au.threshold(now=now * 0.4)
+            self.assertGreaterEqual(value, au.THRESHOLD_MIN)
+            self.assertLessEqual(value, au.THRESHOLD_MAX)
+
+    def test_threshold_oscillates_around_base(self):
+        values = [au.threshold(now=index * 0.5) for index in range(20)]
+        self.assertLess(min(values), au.BASE_THRESHOLD)
+        self.assertGreater(max(values), au.BASE_THRESHOLD)
+
+    def test_zero_amplitude_constant(self):
+        self.assertEqual(au.threshold(now=3.0, amplitude=0.0), au.BASE_THRESHOLD)
+
+    def test_modulate_triggered(self):
+        low = au.modulate(0.0, now=1.0)
+        high = au.modulate(0.99, now=1.0)
+        self.assertFalse(low["triggered"])
+        self.assertTrue(high["triggered"])
+        self.assertGreater(high["ratio"], 1.0)
+
+    def test_sample_length(self):
+        self.assertEqual(len(au.sample(0.0, seconds=5.0, step=0.5)), 10)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_accumulator.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+import math, random, unittest
+from biocore_model import autonomy_model as am
+
+class AccumulatorTest(unittest.TestCase):
+    def test_v_accumulates_until_theta(self):
+        V = 0.0; fired = 0
+        for _ in range(30):
+            out = am.step(V, 0.1, leak=0.15, sigma=0.0, theta=0.55)
+            V = out['V']
+            if out['fire']: fired += 1; self.assertEqual(V, 0.0)
+        self.assertGreaterEqual(fired, 1)
+
+    def test_leak_half_life_about_4_3_ticks(self):
+        V = 1.0
+        for _ in range(5):
+            V = am.step(V, 0.0, leak=0.15, sigma=0.0, theta=99)['V']
+        self.assertAlmostEqual(V, 0.85 ** 5, places=6)
+        half = math.log(0.5) / math.log(1 - 0.15)
+        self.assertAlmostEqual(half, 4.27, delta=0.05)
+
+    def test_sigma_zero_deterministic(self):
+        a = [am.step(0.0, 0.1, sigma=0.0)['V'] for _ in range(3)]
+        b = [am.step(0.0, 0.1, sigma=0.0)['V'] for _ in range(3)]
+        self.assertEqual(a, b)
+
+    def test_sigma_creates_jitter(self):
+        rng = random.Random(42)
+        times = []
+        for _ in range(20):
+            V = 0.0
+            for tick in range(1, 200):
+                out = am.step(V, 0.1, sigma=0.06, theta=0.55, rng=rng)
+                V = out['V']
+                if out['fire']: times.append(tick); break
+        self.assertGreater(len(set(times)), 1)
+
+    def test_fire_resets_v(self):
+        out = am.step(0.6, 0.1, sigma=0.0, theta=0.55)
+        self.assertTrue(out['fire']); self.assertEqual(out['V'], 0.0)
+
+    def test_user_reply_satiety(self):
+        self.assertAlmostEqual(am.on_user_reply(1.0), 0.3)
+
+    def test_drift_weights_sum(self):
+        self.assertAlmostEqual(sum(am.DRIFT_WEIGHTS.values()), 1.0, places=6)
+
+    def test_drift_value_clamped(self):
+        self.assertLessEqual(am.drift_value({k: 1.0 for k in am.DRIFT_WEIGHTS}), 1.0)
+
+    def test_memory_due_today(self):
+        now = 1_700_000_000
+        out = am.memory_due([{'id': 'e1', 'due_ts': now + 3600}], now)
+        self.assertAlmostEqual(out['memory_due'], 1.0)
+
+    def test_memory_due_commitment_bonus(self):
+        now = 1_700_000_000
+        out = am.memory_due([{'id': 'e1', 'due_ts': now + 86400 * 1.2, 'title': '记得答应她'}], now)
+        self.assertGreater(out['memory_due'], 0.7)
+
+    def test_memory_due_only_once(self):
+        now = 1_700_000_000
+        first = am.memory_due([{'id': 'e1', 'due_ts': now + 3600}], now)
+        second = am.memory_due([{'id': 'e1', 'due_ts': now + 3600}], now, triggered={'e1': now})
+        self.assertEqual(first['memory_due'], 1.0); self.assertEqual(second['memory_due'], 0.0)
+
+    def test_memory_due_far_events_ignored(self):
+        now = 1_700_000_000
+        self.assertEqual(am.memory_due([{'id': 'x', 'due_ts': now + 86400 * 10}], now)['memory_due'], 0.0)
+
+    def test_snapshot_fields(self):
+        snap = am.accumulator_snapshot({'V': 0.3, 'ticks_since_fire': 4}, theta=0.55)
+        for key in ('V', 'theta', 'drift', 'leak', 'sigma', 'ticks_since_fire', 'to_threshold'):
+            self.assertIn(key, snap)
+
+    def test_to_threshold(self):
+        snap = am.accumulator_snapshot({'V': 0.25}, theta=0.55)
+        self.assertAlmostEqual(snap['to_threshold'], 0.3)
+
+    def test_theta_configurable(self):
+        self.assertFalse(am.step(0.4, 0.05, theta=0.9, sigma=0.0)['fire'])
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_affect.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_affect as aa
+
+class FakeCore:
+    v = 0.0; a = 0.5; stress = 0.2; social = 0.5; confidence = 1.0
+
+NOW = 1_700_000_000
+
+class AffectTest(unittest.TestCase):
+    def test_silence_deltas(self):
+        delta = aa.compute_deltas(24, 1.0, 0.0)
+        self.assertAlmostEqual(delta['valence'], -0.015); self.assertAlmostEqual(delta['lonely'], 0.02)
+    def test_blame_valence(self):
+        delta = aa.compute_deltas(0, 0.0, 0.5)
+        self.assertAlmostEqual(delta['valence'], -0.05); self.assertAlmostEqual(delta['confidence'], 0.75)
+    def test_dt_cap(self):
+        capped = aa.compute_deltas(100, 1.0, 0.0)
+        full = aa.compute_deltas(6, 1.0, 0.0)
+        self.assertAlmostEqual(capped['valence'], full['valence'])
+    def test_apply_applies_once(self):
+        core = FakeCore()
+        _, acc = aa.apply(core, {}, NOW, 24, 1.0, 0.0)
+        v1 = core.v
+        _, acc = aa.apply(core, acc, NOW, 24, 1.0, 0.0)
+        self.assertAlmostEqual(core.v, v1)
+    def test_apply_clamps(self):
+        core = FakeCore(); core.v = -0.55
+        aa.apply(core, {}, NOW, 100, 4.0, 0.5)
+        self.assertGreaterEqual(core.v, -0.6)
+    def test_confidence_written(self):
+        core = FakeCore()
+        aa.apply(core, {}, NOW, 0, 0.0, 0.6)
+        self.assertAlmostEqual(core.confidence, 0.7)
+    def test_affect_field_on_core(self):
+        core = FakeCore()
+        aa.apply(core, {}, NOW, 12, 0.5, 0.2)
+        self.assertIn('autonomy_affect', core.__dict__)
+    def test_affect_in_acc(self):
+        _, acc = aa.apply(FakeCore(), {}, NOW, 12, 0.5, 0.0)
+        for key in ('valence', 'arousal', 'stress', 'lonely'):
+            self.assertIn(key, acc['affect'])
+    def test_no_duplicate_stress(self):
+        delta = aa.compute_deltas(24, 1.0, 0.0)
+        self.assertEqual(delta['stress'], 0.0); self.assertEqual(delta['arousal'], 0.0)
+    def test_first_tick_dt_zero(self):
+        core = FakeCore()
+        delta, _ = aa.apply(core, {}, NOW, 24, 1.0, 0.0)
+        self.assertEqual(delta['valence'], 0.0)
+    def test_lonely_only_from_silence(self):
+        delta = aa.compute_deltas(0, 0.0, 1.0)
+        self.assertEqual(delta['lonely'], 0.0)
+    def test_second_call_same_now_zero(self):
+        core = FakeCore()
+        _, acc = aa.apply(core, {}, NOW - 3600, 12, 1.0, 0.0)
+        _, acc = aa.apply(core, acc, NOW, 12, 1.0, 0.0)
+        v = core.v
+        _, acc = aa.apply(core, acc, NOW, 12, 1.0, 0.0)
+        self.assertAlmostEqual(core.v, v)
+
+if __name__ == '__main__':
+    unittest.main()

package/python/biocore_model/tests/test_autonomy_blame.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+import unittest
+from biocore_model import autonomy_model as am, proactive_context as pc
+
+class BlameTest(unittest.TestCase):
+    def test_6h_low(self):
+        self.assertLess(am.self_blame_value(6, 0.4, 'secure'), 0.12)
+    def test_24h(self):
+        self.assertAlmostEqual(am.self_blame_value(24, 0.4, 'secure'), 0.4)
+    def test_48h_capped(self):
+        self.assertAlmostEqual(am.self_blame_value(48, 0.4, 'secure'), 0.7)
+    def test_rs_scales(self):
+        self.assertAlmostEqual(am.self_blame_value(24, 0.8, 'secure'), 0.7)
+    def test_anxious(self):
+        self.assertAlmostEqual(am.self_blame_value(24, 0.4, 'anxious'), 0.52)
+    def test_avoidant(self):
+        self.assertAlmostEqual(am.self_blame_value(24, 0.4, 'avoidant'), 0.2)
+    def test_decay(self):
+        self.assertAlmostEqual(am.self_blame_decay(0.4, 2), 0.2)
+        self.assertEqual(am.self_blame_decay(0.4, 5), 0.0)
+    def test_blame_mult(self):
+        self.assertAlmostEqual(am.blame_mult('anxious', 0.5), 1.075)
+        self.assertAlmostEqual(am.blame_mult('avoidant', 0.5), 0.85)
+        self.assertAlmostEqual(am.blame_mult('secure', 0.5), 1.0)
+    def test_blame_effects(self):
+        eff = am.blame_effects(0.4)
+        self.assertAlmostEqual(eff['valence'], -0.04); self.assertAlmostEqual(eff['confidence'], 0.8)
+        self.assertNotIn('stress', eff); self.assertNotIn('arousal', eff)
+    def test_motive_fields(self):
+        view = am.motive_view(24, 2, attachment_style='anxious', self_blame=0.5)
+        for key in ('silence_mult', 'frust_mult', 'blame_mult', 'total_mult', 'confidence'):
+            self.assertIn(key, view)
+    def test_clamp_range(self):
+        self.assertLessEqual(am.compose_mult(2.0, 10, 1.5), 1.8)
+        self.assertGreaterEqual(am.compose_mult(0.2, 0, 0.5), 0.2)
+    def test_confidence(self):
+        self.assertAlmostEqual(am.motive_view(0, 0, self_blame=0.4)['confidence'], 0.8)
+    def test_tone_lines(self):
+        self.assertEqual(len(pc.tone_lines(0.2)), 0)
+        self.assertEqual(len(pc.tone_lines(0.4)), 1)
+        self.assertEqual(len(pc.tone_lines(0.6)), 2)
+
+if __name__ == '__main__':
+    unittest.main()