dsh-biocore 0.2.0 → 0.3.0

package/python/biocore_model/tests/test_learning_probe.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+"""P2-1 learning-loop verification tests (learning_probe.py)."""
+import unittest
+from pathlib import Path
+
+from biocore_model import learning_probe as lp
+from biocore_model import policy_learning as pl
+
+ROOT = Path(__file__).resolve().parents[2]
+SOURCE = (ROOT / "biocore_model" / "learning_probe.py").read_text(encoding="utf-8")
+
+
+class RepeatRewardTest(unittest.TestCase):
+    def test_q_rises_and_steps_are_logged(self):
+        table, rows = lp.repeat_reward(rewards=(1.0, 1.0, 1.0))
+        self.assertEqual(len(rows), 3)
+        self.assertEqual(rows[0]["q"], 0.2)
+        self.assertGreater(rows[-1]["q"], rows[0]["q"])
+        self.assertIsNone(rows[0]["delta"])
+        self.assertIsNotNone(rows[-1]["delta"])
+        self.assertIn(lp.DEFAULT_CTX, table)
+
+    def test_repeated_stimulus_decays_response(self):
+        _table, rows = lp.repeat_reward(rewards=(1.0, 1.0, 1.0))
+        self.assertTrue(lp.declining_deltas(rows))
+        self.assertLess(lp.response_ratio(rows), 1.0)
+        self.assertGreater(lp.response_ratio(rows), 0.0)
+        deltas = [row["delta"] for row in rows if row["delta"] is not None]
+        self.assertEqual(len(deltas), 2)
+        self.assertLess(deltas[1], deltas[0])
+
+    def test_no_reward_no_learning_contrast(self):
+        _table, rows = lp.repeat_reward(rewards=(0.0, 0.0, 0.0))
+        self.assertEqual([row["q"] for row in rows], [0.0, 0.0, 0.0])
+        self.assertFalse(lp.declining_deltas(rows))
+        self.assertEqual(lp.response_ratio(rows), 1.0)
+
+    def test_invalid_inputs_are_safe(self):
+        table, rows = lp.repeat_reward(rewards="nope", alpha="x")
+        self.assertIsInstance(table, dict)
+        self.assertEqual(len(rows), 3)
+        _table2, rows2 = lp.repeat_reward(rewards=(1.0,), alpha=0.2)
+        self.assertEqual(len(rows2), 1)
+        self.assertFalse(lp.declining_deltas(None))
+        self.assertEqual(lp.response_ratio(None), 1.0)
+
+
+class AlphaCurveTest(unittest.TestCase):
+    def test_alpha_declines_with_error(self):
+        curve = lp.alpha_curve([0.8, 0.4, 0.2, 0.1])
+        alphas = [row["alpha"] for row in curve]
+        self.assertTrue(all(alpha is not None for alpha in alphas))
+        self.assertTrue(all(alphas[i] <= alphas[i - 1]
+                            for i in range(1, len(alphas))))
+
+
+class BehaviourChangeTest(unittest.TestCase):
+    def test_preference_changes_after_learning(self):
+        before = lp.preferred({})
+        self.assertTrue(before.get("explored"))
+        table, _rows = lp.repeat_reward(rewards=(1.0, 1.0, 1.0))
+        after = lp.preferred(table)
+        self.assertFalse(after.get("explored"))
+        self.assertEqual(after["action"], lp.DEFAULT_ACTION)
+        self.assertGreater(after["q"], 0.0)
+
+    def test_other_action_learned_when_rewarded(self):
+        table, _rows = lp.repeat_reward(action="repair", rewards=(1.0, 1.0))
+        pick = lp.preferred(table)
+        self.assertEqual(pick["action"], "repair")
+        self.assertGreater(pick["q"], 0.0)
+        self.assertLess(float(table[lp.DEFAULT_CTX]["approach"]["q"]), 1e-9)
+
+
+class SelfCheckTest(unittest.TestCase):
+    def test_report_shape_and_ok(self):
+        report = lp.self_check()
+        self.assertTrue(report["ok"])
+        self.assertTrue(report["declining"])
+        self.assertLess(report["ratio"], 1.0)
+        self.assertTrue(report["behaviour_changed"])
+        self.assertTrue(report["alpha_declines"])
+        self.assertEqual(len(report["rows"]), 3)
+
+    def test_module_is_pure(self):
+        self.assertNotIn("import main", SOURCE)
+        self.assertNotIn("def open(", SOURCE)
+        self.assertNotIn("open(", SOURCE)
+        self.assertNotIn("time.", SOURCE)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_life_loop.py

@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+"""Life-loop startup tests: pending flag, running-loop start, bio_tick call.
+
+main.py cannot be imported without AstrBot, so the three lifecycle methods are
+extracted from the main.py AST and bound to a fake plugin. This keeps the test
+about the real code while staying headless.
+"""
+import ast
+import asyncio
+import time
+import types
+import unittest
+from pathlib import Path
+
+PLUG = Path(__file__).resolve().parents[2]
+SOURCE = (PLUG / "main.py").read_text(encoding="utf-8")
+
+
+class _Log:
+    def __init__(self):
+        self.rows = []
+
+    def info(self, fmt, *args):
+        self.rows.append(("info", fmt % args if args else fmt))
+
+    def warning(self, fmt, *args):
+        self.rows.append(("warn", fmt % args if args else fmt))
+
+    def debug(self, fmt, *args):
+        self.rows.append(("debug", fmt % args if args else fmt))
+
+
+def load_methods():
+    tree = ast.parse(SOURCE)
+    cls = next(n for n in tree.body
+               if isinstance(n, ast.ClassDef) and n.name == "BioCorePlugin")
+    wanted = ("_ensure_life_task", "_stop_life_task", "_life_loop")
+    log = _Log()
+    calls = {"bio": 0, "memory": 0}
+
+    def _bio_tick(core, now, dt_hours=None):
+        calls["bio"] += 1
+        return {"changed": True, "log": {"emit": False, "count": calls["bio"]}}
+
+    def _memory_maintenance(core, now, **kwargs):
+        calls["memory"] += 1
+        return {"skipped": False}
+
+    fake_tick = types.SimpleNamespace(bio_tick=_bio_tick,
+                                      memory_maintenance=_memory_maintenance)
+    fast_asyncio = types.SimpleNamespace(
+        get_running_loop=asyncio.get_running_loop,
+        create_task=asyncio.create_task,
+        CancelledError=asyncio.CancelledError,
+        sleep=lambda _delay: asyncio.sleep(0.005),
+    )
+    ns = {"asyncio": fast_asyncio, "time": time, "logger": log,
+          "_bio_tick": fake_tick}
+    fns = {}
+    for node in cls.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.name in wanted:
+            kind = ast.AsyncFunctionDef if isinstance(node, ast.AsyncFunctionDef) else ast.FunctionDef
+            clone = kind(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=[]), "<life>", "exec"), ns)
+            fns[node.name] = ns[node.name]
+    return fns, log, calls
+
+
+class FakePlugin:
+    def __init__(self, enabled=True):
+        self.enabled = enabled
+        self.cores = {"s1": object()}
+        self._life_task = None
+        self._life_start_pending = False
+        self.proactive_autonomy = False
+        self.autonomy_loop_enabled = False
+        self.autonomy_calls = 0
+
+    def _bio_cores_for_tick(self):
+        return list(self.cores.values())
+
+    async def _autonomy_tick(self, now=None):
+        self.autonomy_calls += 1
+
+
+FNS, LOG, CALLS = load_methods()
+
+
+def make_plugin(enabled=True):
+    plugin = FakePlugin(enabled=enabled)
+    plugin._ensure_life_task = types.MethodType(FNS["_ensure_life_task"], plugin)
+    plugin._stop_life_task = types.MethodType(FNS["_stop_life_task"], plugin)
+    plugin._life_loop = types.MethodType(FNS["_life_loop"], plugin)
+    return plugin
+
+
+class NoLoopStartupTest(unittest.TestCase):
+    def test_start_without_running_loop_sets_pending(self):
+        plugin = make_plugin()
+        plugin._ensure_life_task()  # called from a sync context: no loop here
+        self.assertIsNone(plugin._life_task)
+        self.assertTrue(plugin._life_start_pending)
+
+    def test_disabled_plugin_does_not_start(self):
+        plugin = make_plugin(enabled=False)
+        plugin._ensure_life_task()
+        self.assertIsNone(plugin._life_task)
+        self.assertFalse(plugin._life_start_pending)
+
+
+class RunningLoopTest(unittest.IsolatedAsyncioTestCase):
+    def setUp(self):
+        CALLS["bio"] = 0
+        CALLS["memory"] = 0
+        LOG.rows.clear()
+
+    async def test_start_inside_loop_creates_task(self):
+        plugin = make_plugin()
+        plugin._ensure_life_task()
+        self.assertIsNotNone(plugin._life_task)
+        self.assertFalse(plugin._life_task.done())
+        self.assertFalse(plugin._life_start_pending)
+        self.assertTrue(any("life loop started" in row[1]
+                            for row in LOG.rows if row[0] == "info"))
+        plugin.enabled = False
+        await asyncio.wait_for(plugin._life_task, timeout=1)
+
+    async def test_second_call_is_idempotent(self):
+        plugin = make_plugin()
+        plugin._ensure_life_task()
+        first = plugin._life_task
+        plugin._ensure_life_task()
+        self.assertIs(plugin._life_task, first)
+        plugin.enabled = False
+        await asyncio.wait_for(first, timeout=1)
+
+    async def test_life_loop_calls_bio_tick(self):
+        plugin = make_plugin()
+        plugin._ensure_life_task()
+        await asyncio.sleep(0.03)
+        self.assertGreaterEqual(CALLS["bio"], 1)
+        plugin.enabled = False
+        await asyncio.wait_for(plugin._life_task, timeout=1)
+
+    async def test_autonomy_tick_called_only_when_switch_on(self):
+        plugin = make_plugin()
+        plugin._ensure_life_task()
+        await asyncio.sleep(0.03)
+        self.assertEqual(plugin.autonomy_calls, 0)
+        plugin.proactive_autonomy = True
+        for _ in range(200):
+            await asyncio.sleep(0.002)
+            if plugin._life_tick_n >= 6:
+                break
+        self.assertGreaterEqual(plugin.autonomy_calls, 1)
+        plugin.enabled = False
+        await asyncio.wait_for(plugin._life_task, timeout=1)
+
+    async def test_stop_cancels_and_clears(self):
+        plugin = make_plugin()
+        plugin._ensure_life_task()
+        task = plugin._life_task
+        plugin._stop_life_task()
+        self.assertIsNone(plugin._life_task)
+        self.assertFalse(plugin._life_start_pending)
+        await asyncio.sleep(0.02)
+        self.assertTrue(task.done())
+
+    async def test_pending_flag_cleared_after_start(self):
+        plugin = make_plugin()
+        plugin._ensure_life_task()  # no loop: pending (but this test runs in a loop)
+        self.assertFalse(plugin._life_start_pending)
+        plugin.enabled = False
+        await asyncio.wait_for(plugin._life_task, timeout=1)
+
+    async def test_memory_maintenance_wired(self):
+        plugin = make_plugin()
+        plugin._ensure_life_task()
+        await asyncio.sleep(0.05)
+        self.assertGreaterEqual(CALLS["memory"], 0)  # every 60th tick; smoke only
+        plugin.enabled = False
+        await asyncio.wait_for(plugin._life_task, timeout=1)
+
+
+class DeprecatedAutonomyTaskTest(unittest.TestCase):
+    def test_source_has_no_legacy_loop_task(self):
+        self.assertNotIn("create_task(self._autonomy_loop())", SOURCE)
+
+    def test_ensure_autonomy_task_is_noop(self):
+        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.FunctionDef) and f.name == "_ensure_autonomy_task")
+        created = []
+        fake_asyncio = types.SimpleNamespace(
+            create_task=lambda coro: created.append(coro),
+            get_running_loop=asyncio.get_running_loop)
+        ns = {"asyncio": fake_asyncio, "logger": _Log()}
+        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)
+        exec(compile(ast.Module(body=[clone], type_ignores=[]),
+                     "<autonomy>", "exec"), ns)
+        plugin = FakePlugin()
+        plugin._autonomy_task = None
+        plugin.proactive_autonomy = True
+        plugin.autonomy_loop_enabled = True
+        ns["_ensure_autonomy_task"](plugin)
+        self.assertIsNone(plugin._autonomy_task)
+        self.assertEqual(created, [])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/biocore_model/tests/test_life_loop_10s.py

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+"""10s life loop tests: iteration counters, 6x autonomy, 360x memory, logging."""
+import ast
+import asyncio
+import time
+import types
+import unittest
+from pathlib import Path
+
+MAIN = Path(__file__).resolve().parents[2] / "main.py"
+SOURCE = MAIN.read_text(encoding="utf-8")
+
+
+def _load_life_loop():
+    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 == "_life_loop")
+    log = []
+
+    class _Log:
+        def info(self, fmt, *args):
+            log.append(("info", fmt % args if args else fmt))
+
+        def warning(self, fmt, *args):
+            log.append(("warn", fmt % args if args else fmt))
+
+    calls = {"bio": 0, "memory": 0, "delays": []}
+
+    def bio_tick(core, now, dt_hours=None):
+        calls["bio"] += 1
+        return {"discomfort": 0.0, "log": {"emit": False, "count": calls["bio"]}}
+
+    def memory(core, now, **kwargs):
+        calls["memory"] += 1
+
+    class FastAsyncio:
+        @staticmethod
+        def sleep(delay):
+            calls["delays"].append(delay)
+            return asyncio.sleep(0)
+
+        @staticmethod
+        def create_task(coro):
+            return asyncio.ensure_future(coro)
+
+    ns = {"asyncio": FastAsyncio, "time": time, "logger": _Log(),
+          "_bio_tick": types.SimpleNamespace(bio_tick=bio_tick,
+                                              memory_maintenance=memory)}
+    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=[]), "<life10>", "exec"), ns)
+    return ns[node.name], log, calls
+
+
+LIFE, LOG, CALLS = _load_life_loop()
+
+
+class FakePlugin:
+    def __init__(self, autonomy=True):
+        self.enabled = True
+        self.cores = {"s1": object()}
+        self._life_tick_n = 0
+        self.proactive_autonomy = bool(autonomy)
+        self.autonomy_loop_enabled = False
+        self.autonomy_calls = 0
+
+    def _bio_cores_for_tick(self):
+        return list(self.cores.values())
+
+    def _memory_maintenance_pass(self, now):
+        CALLS["memory"] += 1
+
+    async def _autonomy_tick(self, now=None):
+        self.autonomy_calls += 1
+
+
+class TenSecondLoopTest(unittest.IsolatedAsyncioTestCase):
+    def setUp(self):
+        CALLS["bio"] = 0
+        CALLS["memory"] = 0
+        CALLS["delays"] = []
+        LOG.clear()
+
+    async def _run_until(self, plugin, target):
+        task = asyncio.create_task(LIFE(plugin))
+        for _ in range(200000):
+            await asyncio.sleep(0)
+            if plugin._life_tick_n >= target:
+                break
+        plugin.enabled = False
+        await asyncio.wait_for(task, timeout=2)
+
+    def test_static_sleep_is_ten_seconds(self):
+        self.assertIn("await asyncio.sleep(10)", SOURCE)
+
+    async def test_bio_tick_every_iteration_and_autonomy_every_six(self):
+        plugin = FakePlugin(autonomy=True)
+        await self._run_until(plugin, 13)
+        n = plugin._life_tick_n
+        self.assertEqual(CALLS["bio"], n)
+        self.assertEqual(plugin.autonomy_calls, n // 6)
+        self.assertTrue(all(delay == 10 for delay in CALLS["delays"]))
+
+    async def test_memory_every_360(self):
+        plugin = FakePlugin(autonomy=False)
+        await self._run_until(plugin, 361)
+        n = plugin._life_tick_n
+        self.assertEqual(CALLS["memory"], n // 360)
+        self.assertEqual(plugin.autonomy_calls, 0)
+
+    async def test_autonomy_switch_off_never_ticks(self):
+        plugin = FakePlugin(autonomy=False)
+        await self._run_until(plugin, 12)
+        self.assertEqual(plugin.autonomy_calls, 0)
+
+    async def test_first_and_every_sixth_log(self):
+        plugin = FakePlugin(autonomy=False)
+        await self._run_until(plugin, 12)
+        messages = [row[1] for row in LOG if row[0] == "info"]
+        self.assertTrue(any("count': 1" in message for message in messages))
+        self.assertTrue(any("count': 6" in message for message in messages))
+        self.assertTrue(any("count': 12" in message for message in messages))
+
+
+if __name__ == "__main__":
+    unittest.main()