chartflow 0.1__py3-none-any.whl

chartflow/fsm/test/test_stage.py

@@ -0,0 +1,314 @@
+"""Tests for Stage class"""
+
+import pytest
+from chartflow.fsm.stage import Stage, _NamedNode
+from chartflow.fsm.meta import clear_prototypes, StageMachineMeta
+from chartflow.fsm.decorators import recursive, behavior, sequence, selector, parallel
+
+
+@pytest.fixture(autouse=True)
+def reset_state():
+    """Reset state before each test"""
+    clear_prototypes()
+    StageMachineMeta.__ID_PROTOS__ = {}
+    yield
+
+
+class TestNamedNode:
+    """Test _NamedNode base class"""
+    
+    def test_parent_child_relationship(self):
+        """Test parent-child relationships"""
+        parent = _NamedNode()
+        parent._name = "parent"
+        child = _NamedNode()
+        child._name = "child"
+        
+        parent._add_child(child)
+
+        assert child.parent is parent
+        assert child in parent._children
+
+    def test_remove_child(self):
+        """Test removing a child"""
+        parent = _NamedNode()
+        parent._name = "parent"
+        child = _NamedNode()
+        child._name = "child"
+
+        parent._add_child(child)
+        parent._remove_child(child)
+        
+        assert child.parent is None
+        assert child not in parent._children
+
+
+class TestStageInit:
+    """Test Stage initialization"""
+    
+    def test_stage_requires_name(self):
+        """Test that Stage requires NAME"""
+        
+        class BadStage(Stage):
+            NAME = ""
+        
+        with pytest.raises(ValueError):
+            BadStage()
+    
+    def test_stage_rejects_digit_suffix_name(self):
+        """Test that Stage rejects NAME ending with digit"""
+
+        with pytest.raises(ValueError):
+            class BadStage(Stage):
+                NAME = "BadStage1"
+    
+    def test_stage_generates_unique_ids(self):
+        """Test that Stage generates unique IDs"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+        
+        stage1 = TestStage()
+        stage2 = TestStage()
+        
+        assert stage1.uid != stage2.uid
+        assert stage1.uid == 0
+        assert stage2.uid == 1
+    
+    def test_stage_full_name(self):
+        """Test that Stage generates full name with uid"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+        
+        stage = TestStage()
+        
+        assert stage.name == "TestStage0"
+        assert stage._name == "TestStage0"
+
+
+class TestStageStates:
+    """Test state execution"""
+    
+    def test_stage_executes_initial_state(self):
+        """Test that stage executes initial state"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            def initial(self, inst):
+                return None
+        
+        stage = TestStage()
+        stage._current = "initial"
+        
+        result = stage.handleStage(log=False)
+        
+        assert stage.current == "initial"
+    
+    def test_stage_transitions_state(self):
+        """Test that stage transitions on state return"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            def state_a(self, inst):
+                return "state_b"
+            
+            def state_b(self, inst):
+                return None
+        
+        stage = TestStage()
+        stage._current = "state_a"
+        
+        stage.handleStage(log=False)
+        
+        assert stage.current == "state_b"
+    
+    def test_stage_recursive_execution(self):
+        """Test recursive state execution"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            @recursive
+            def counter(self, inst):
+                if not hasattr(self, 'count'):
+                    self.count = 0
+                self.count += 1
+                if self.count >= 3:
+                    return "done"
+                return "counter"
+            
+            def done(self, inst):
+                return None
+        
+        stage = TestStage()
+        stage._current = "counter"
+        
+        stage.handleStage(log=False)
+        
+        assert stage.count == 3
+        assert stage.current == "done"
+
+
+class TestStageBehaviorTree:
+    """Test behavior tree composites"""
+    
+    def test_behavior_transition(self):
+        """Test @behavior decorator"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            @behavior("second")
+            def first(self, inst):
+                return True  # Success triggers behavior
+            
+            def second(self, inst):
+                return None
+        
+        stage = TestStage()
+        stage._current = "first"
+        
+        stage.handleStage(log=False)
+        
+        assert stage.current == "second"
+    
+    def test_sequence_execution(self):
+        """Test @sequence decorator"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            @sequence("b", "c")
+            def a(self, inst):
+                return True
+
+            def b(self, inst):
+                return True
+            
+            def c(self, inst):
+                return None
+        
+        stage = TestStage()
+        stage._current = "a"
+        
+        # First call enters sequence
+        stage.handleStage(log=False)
+        # Should be at "b" now
+        assert stage.current == "b"
+    
+    def test_selector_execution(self):
+        """Test @selector decorator"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            @selector("b", "c")
+            def a(self, inst):
+                return False  # Failure triggers selector
+
+            def b(self, inst):
+                return True  # Success stops selector
+            
+            def c(self, inst):
+                return None
+        
+        stage = TestStage()
+        stage._current = "a"
+        
+        stage.handleStage(log=False)
+        
+        # After a fails, should try b
+        assert stage.current == "b"
+
+
+class TestStageHooks:
+    """Test lifecycle hooks"""
+    
+    def test_onchanged_hook(self):
+        """Test onChanged hook is called"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            def __init__(self):
+                super().__init__()
+                self.changes = []
+            
+            def state_a(self, inst):
+                return "state_b"
+            
+            def state_b(self, inst):
+                return None
+            
+            def onChanged(self, src, dst, inst):
+                self.changes.append((src, dst))
+        
+        stage = TestStage()
+        stage._current = "state_a"
+        
+        stage.handleStage(log=False)
+        
+        assert ("state_a", "state_b") in stage.changes
+    
+    def test_onloading_hook(self):
+        """Test onLoading hook is called"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            def __init__(self):
+                self.loaded = False
+                super().__init__()
+            
+            def onLoading(self, it):
+                self.loaded = True
+        
+        stage = TestStage()
+        
+        assert stage.loaded
+
+
+class TestStageProperties:
+    """Test Stage properties"""
+    
+    def test_inst_property(self):
+        """Test inst property"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+        
+        mock_inst = object()
+        stage = TestStage(mock_inst)
+        
+        assert stage.inst is mock_inst
+    
+    def test_current_property(self):
+        """Test current property"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            def my_state(self, inst):
+                return None
+        
+        stage = TestStage()
+        stage._current = "my_state"
+        
+        assert stage.current == "my_state"
+    
+    def test_current_setter_validates(self):
+        """Test current setter validates state"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            def valid_state(self, inst):
+                return None
+        
+        stage = TestStage()
+        
+        with pytest.raises(ValueError):
+            stage.current = "invalid_state"

chartflow/fsm/test_behavior_events.py

@@ -0,0 +1,263 @@
+"""Test behavior tree events - verify CHANGED events are triggered for child nodes"""
+
+import random
+import sys
+import time
+sys.path.insert(0, 'F:\\Python\\Python314\\Lib\\site-packages')
+
+from chartflow.fsm import Stage
+from chartflow.fsm.decorators import parallel, sequence, selector
+
+
+class TestStage(Stage):
+    """Test stage with behavior tree - captures events synchronously"""
+    NAME = "TestStage"
+    LOG = True  # Enable to see state transitions in console
+
+    def __init__(self):
+        super().__init__()
+        self.events = []
+
+    def onChanged(self, src, dst, inst):
+        """Synchronously capture state changes"""
+        super().onChanged(src, dst, inst)
+        self.events.append(("CHANGED", f"{src} -> {dst}"))
+
+    def entry(self, inst):
+        return "root"
+
+    @parallel("a", "b")
+    def root(self, inst):
+        return True
+
+    def a(self, inst):
+        return True
+
+    @sequence("c", "d")
+    def b(self, inst):
+        return True
+
+    def c(self, inst):
+        return True
+
+    def d(self, inst):
+        return True
+
+
+def test_parallel_behavior():
+    """Test parallel behavior tree triggers CHANGED for children"""
+    print("="*60)
+    print("TEST: Parallel behavior - CHANGED events for children")
+    print("="*60)
+
+    stage = TestStage()
+    stage.events.clear()  # Clear init events
+
+    print("\n--- Tick 1: entry -> root ---")
+    stage.handleStage(log=True)
+    print(f"Current state: {stage.current}")
+    print(f"Events: {stage.events}")
+
+    print("\n--- Tick 2: root parallel execution ---")
+    stage.events.clear()
+    stage.handleStage(log=True)
+    print(f"Current state: {stage.current}")
+    print(f"Events: {stage.events}")
+
+    # Check for child transitions
+    changed_events = [e for e in stage.events if e[0] == "CHANGED"]
+    child_transitions = [e for e in changed_events if "->" in e[1]]
+
+    print(f"\nChild transitions captured: {len(child_transitions)}")
+    for t in child_transitions:
+        print(f"  {t[1]}")
+
+    # We expect to see transitions like:
+    # - root -> a
+    # - a -> b (or similar, depending on execution order)
+    success = len(child_transitions) > 0
+
+    # Check specific transitions
+    has_root_to_child = any("root ->" in e[1] for e in child_transitions)
+
+    if has_root_to_child:
+        print("PASS: Found CHANGED event from root to child")
+    else:
+        print("FAIL: No CHANGED event from root to child")
+
+    return success and has_root_to_child
+
+
+def test_sequence_behavior():
+    """Test sequence behavior tree"""
+    print("\n" + "="*60)
+    print("TEST: Sequence behavior - step by step execution")
+    print("="*60)
+
+    class SeqStage(Stage):
+        NAME = "SeqStage"
+        LOG = True
+
+        def __init__(self):
+            super().__init__()
+            self.events = []
+
+        def onChanged(self, src, dst, inst):
+            self.events.append(("CHANGED", f"{src} -> {dst}"))
+
+        def entry(self, inst):
+            return "seq"
+
+        @sequence("s1", "s2", "s3")
+        def seq(self, inst):
+            return True
+
+        def s1(self, inst):
+            return True
+
+        def s2(self, inst):
+            return True
+
+        def s3(self, inst):
+            return True
+
+    stage = SeqStage()
+    stage.events.clear()
+
+    print("\n--- Tick 1: entry -> seq ---")
+    stage.handleStage(log=True)
+    print(f"Events: {stage.events}")
+
+    all_events = []
+    all_events.extend(stage.events)
+
+    print("\n--- Tick 2: seq starts ---")
+    stage.events.clear()
+    stage.handleStage(log=True)
+    print(f"Events: {stage.events}")
+    all_events.extend(stage.events)
+
+    # Sequence pauses after each child, so run more ticks
+    for i in range(5):
+        print(f"\n--- Tick {i+3} ---")
+        stage.events.clear()
+        stage.handleStage(log=True)
+        if stage.events:
+            print(f"Events: {stage.events}")
+        all_events.extend(stage.events)
+        if not stage.events:
+            break
+
+    print(f"\n=== All CHANGED events ===")
+    changed = [e for e in all_events if e[0] == "CHANGED"]
+    for c in changed:
+        print(f"  {c[1]}")
+
+    # Check for child transitions in sequence
+    child_changes = [e for e in changed if "seq" in e[1] or "s1" in e[1] or "s2" in e[1] or "s3" in e[1]]
+
+    # We expect at least: entry -> seq, and some transitions involving s1, s2, s3
+    success = len(child_changes) >= 2
+
+    if success:
+        print(f"PASS: Found {len(child_changes)} relevant CHANGED events")
+    else:
+        print(f"FAIL: Only found {len(child_changes)} relevant CHANGED events")
+
+    return success
+
+
+def test_selector_behavior():
+    """Test selector behavior tree"""
+    print("\n" + "="*60)
+    print("TEST: Selector behavior - first success stops")
+    print("="*60)
+
+    class SelStage(Stage):
+        NAME = "SelStage"
+        LOG = True
+
+        def __init__(self):
+            super().__init__()
+            self.events = []
+
+        def onChanged(self, src, dst, inst):
+            self.events.append(("CHANGED", f"{src} -> {dst}"))
+
+        def entry(self, inst):
+            return "sel"
+
+        @selector("f1", "f2", "f3")
+        def sel(self, inst):
+            return True
+
+        def f1(self, inst):
+            return False  # Fail, try next
+
+        def f2(self, inst):
+            return True  # Success, stop
+
+        def f3(self, inst):
+            return True  # Won't execute
+
+    stage = SelStage()
+    stage.events.clear()
+
+    print("\n--- Tick 1: entry -> sel ---")
+    stage.handleStage(log=True)
+
+    all_events = list(stage.events)
+
+    print("\n--- Tick 2: selector execution ---")
+    stage.events.clear()
+    stage.handleStage(log=True)
+    all_events.extend(stage.events)
+
+    # Run more ticks
+    for i in range(3):
+        print(f"\n--- Tick {i+3} ---")
+        stage.events.clear()
+        stage.handleStage(log=True)
+        if stage.events:
+            print(f"Events: {stage.events}")
+        all_events.extend(stage.events)
+
+    print(f"\n=== All CHANGED events ===")
+    changed = [e for e in all_events if e[0] == "CHANGED"]
+    for c in changed:
+        print(f"  {c[1]}")
+
+    # Selector should have transitioned to f1, then to f2 (when f1 fails)
+    has_child_transition = any("sel" in e[1] or "f1" in e[1] or "f2" in e[1] for e in changed)
+
+    if has_child_transition:
+        print("PASS: Selector has child transitions")
+        return True
+    else:
+        print("FAIL: No child transitions in selector")
+        return False
+
+
+if __name__ == "__main__":
+    results = []
+
+    results.append(("Parallel", test_parallel_behavior()))
+    results.append(("Sequence", test_sequence_behavior()))
+    results.append(("Selector", test_selector_behavior()))
+
+    print("\n" + "="*60)
+    print("FINAL RESULTS")
+    print("="*60)
+    all_pass = True
+    for name, passed in results:
+        status = "PASS" if passed else "FAIL"
+        print(f"  {name}: {status}")
+        if not passed:
+            all_pass = False
+
+    if all_pass:
+        print("\nALL TESTS PASSED!")
+        sys.exit(0)
+    else:
+        print("\nSOME TESTS FAILED")
+        sys.exit(1)

chartflow/fsm/test_nested_parallel.py

@@ -0,0 +1,80 @@
+"""Test nested behavior tree in parallel"""
+from chartflow.fsm import Stage
+from chartflow.fsm.decorators import sequence, parallel
+
+# Use lowercase method names as states (Stage auto-discovers them)
+
+
+class DemoLogic(Stage):
+    NAME = "DemoLogic"
+    LOG = True
+
+    def __init__(self):
+        super().__init__()
+        self.call_order = []
+
+    def entry(self, inst):
+        self.call_order.append("entry")
+        return "root"
+
+    @parallel("a", "b")
+    def root(self, inst):
+        self.call_order.append("root")
+        return True
+
+    def a(self, inst):
+        self.call_order.append("a")
+        return False  # FAIL
+
+    @sequence("c", "d")
+    def b(self, inst):
+        self.call_order.append("b")
+        return True
+
+    def c(self, inst):
+        self.call_order.append("c")
+        return True
+
+    def d(self, inst):
+        self.call_order.append("d")
+        return True
+
+    def c(self, inst):
+        self.call_order.append("c")
+        return True
+
+    def d(self, inst):
+        self.call_order.append("d")
+        return True
+
+
+def test_nested_parallel():
+    print("\n" + "="*60)
+    print("TEST: Nested sequence in parallel")
+    print("="*60)
+
+    stage = DemoLogic()
+
+    # Tick 1: entry -> root
+    print("\n--- Tick 1 ---")
+    stage.handleStage(log=True)
+
+    # Tick 2: parallel execution
+    print("\n--- Tick 2 ---")
+    stage.handleStage(log=True)
+
+    # Tick 3: continue parallel
+    print("\n--- Tick 3 ---")
+    stage.handleStage(log=True)
+
+    print(f"\nCall order: {stage.call_order}")
+    print(f"Current state: {stage.current_state}")
+
+    # Verify c and d were both called
+    assert "c" in stage.call_order, "c should be called"
+    assert "d" in stage.call_order, "d should be called"
+    print("PASS: Both c and d were called")
+
+
+if __name__ == "__main__":
+    test_nested_parallel()