chartflow 0.1__py3-none-any.whl

chartflow/fsm/stdio.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+"""stdio compatibility module for qfsm.
+
+This module provides a compatibility layer for the std.info/std.error/std.warn
+functions used in the old version of qfsm.
+"""
+
+# Color codes for terminal output
+class Colors:
+    RESET = "\033[0m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+    BRIGHT = "\033[1m"
+
+
+def info(tag: str, message: str, extra: str = "") -> None:
+    """Print info message.
+
+    Args:
+        tag: Message tag/source (e.g., "LogicName.fbm")
+        message: Main message content
+        extra: Extra information to append
+    """
+    if extra:
+        print(f"[{tag}] {message} {extra}")
+    else:
+        print(f"[{tag}] {message}")
+
+
+def error(tag: str, message: str, *args) -> None:
+    """Print error message.
+
+    Args:
+        tag: Message tag/source
+        message: Error message
+        *args: Additional arguments to print
+    """
+    msg = f"[{tag}] {message}"
+    if args:
+        msg += " " + " ".join(str(a) for a in args)
+    print(msg)
+
+
+def warn(tag: str, message: str) -> None:
+    """Print warning message.
+
+    Args:
+        tag: Message tag/source
+        message: Warning message
+    """
+    print(f"[{tag}] {message}")
+
+
+def debug(tag: str, message: str) -> None:
+    """Print debug message.
+
+    Args:
+        tag: Message tag/source
+        message: Debug message
+    """
+    print(f"[{tag}] {message}")

chartflow/fsm/test/__init__.py

@@ -0,0 +1,7 @@
+"""
+qfsm test package
+
+Run tests with: python -m pytest qfsm/test/ -v
+"""
+
+__all__ = []

chartflow/fsm/test/test_decorators.py

@@ -0,0 +1,210 @@
+"""Tests for decorators"""
+
+import pytest
+from chartflow.fsm.decorators import (
+    recursive, listen, behavior,
+    sequence, selector, parallel
+)
+from chartflow.fsm.stage import Stage
+from chartflow.fsm.meta import clear_prototypes
+
+
+@pytest.fixture(autouse=True)
+def reset_state():
+    """Reset state before each test"""
+    clear_prototypes()
+    Stage._Stage__id__ = {}
+    yield
+
+
+class TestRecursiveDecorator:
+    """Test @recursive decorator"""
+    
+    def test_recursive_marked(self):
+        """Test that @recursive marks method"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            @recursive
+            def my_state(self, inst):
+                return None
+        
+        assert "my_state" in TestStage.__recursive__
+    
+    def test_recursive_inheritance(self):
+        """Test that @recursive is inherited"""
+        
+        class BaseStage(Stage):
+            NAME = "BaseStage"
+            
+            @recursive
+            def base_state(self, inst):
+                return None
+        
+        class DerivedStage(BaseStage):
+            NAME = "DerivedStage"
+            
+            def derived_state(self, inst):
+                return None
+        
+        assert "base_state" in DerivedStage.__recursive__
+
+
+class TestListenDecorator:
+    """Test @listen decorator"""
+    
+    def test_listen_marked(self):
+        """Test that @listen marks method"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            @listen("event1")
+            def handler1(self, data):
+                pass
+            
+            @listen("event2", "source1", "source2")
+            def handler2(self, data):
+                pass
+        
+        assert "event1" in TestStage.__listens__
+        assert "handler1" in [h[0] for h in TestStage.__listens__["event1"]]
+        
+        assert "event2" in TestStage.__listens__
+        handlers = TestStage.__listens__["event2"]
+        assert any(h[0] == "handler2" and list(h[1]) == ["source1", "source2"] for h in handlers)
+    
+    def test_listen_inheritance(self):
+        """Test that @listen is inherited"""
+        
+        class BaseStage(Stage):
+            NAME = "BaseStage"
+            
+            @listen("event1")
+            def handler1(self, data):
+                pass
+        
+        class DerivedStage(BaseStage):
+            NAME = "DerivedStage"
+            
+            @listen("event2")
+            def handler2(self, data):
+                pass
+        
+        assert "event1" in DerivedStage.__listens__
+        assert "event2" in DerivedStage.__listens__
+
+
+class TestBehaviorDecorator:
+    """Test @behavior decorator"""
+    
+    def test_behavior_marked(self):
+        """Test that @behavior marks state transition"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            @behavior("next_state")
+            def current_state(self, inst):
+                return True
+            
+            def next_state(self, inst):
+                return None
+        
+        assert "current_state" in TestStage.__behaviors__
+        assert TestStage.__behaviors__["current_state"]["children"] == "next_state"
+        assert TestStage.__behaviors__["current_state"]["composite"] is None
+
+
+class TestSequenceDecorator:
+    """Test @sequence decorator"""
+    
+    def test_sequence_marked(self):
+        """Test that @sequence marks composite"""
+        
+        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
+        
+        assert "a" in TestStage.__behaviors__
+        assert TestStage.__behaviors__["a"]["children"] == ["b", "c"]
+        assert TestStage.__behaviors__["a"]["composite"] == "sequence"
+
+
+class TestSelectorDecorator:
+    """Test @selector decorator"""
+    
+    def test_selector_marked(self):
+        """Test that @selector marks composite"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            @selector("b", "c")
+            def a(self, inst):
+                return False
+            
+            def b(self, inst):
+                return True
+            
+            def c(self, inst):
+                return None
+        
+        assert "a" in TestStage.__behaviors__
+        assert TestStage.__behaviors__["a"]["children"] == ["b", "c"]
+        assert TestStage.__behaviors__["a"]["composite"] == "selector"
+
+
+class TestParallelDecorator:
+    """Test @parallel decorator"""
+    
+    def test_parallel_marked(self):
+        """Test that @parallel marks composite"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            @parallel("b", "c")
+            def a(self, inst):
+                return True
+            
+            def b(self, inst):
+                return True
+            
+            def c(self, inst):
+                return None
+        
+        assert "a" in TestStage.__behaviors__
+        assert TestStage.__behaviors__["a"]["children"] == ["b", "c"]
+        assert TestStage.__behaviors__["a"]["composite"] == "parallel"
+
+
+class TestDecoratorCombinations:
+    """Test combining decorators"""
+    
+    def test_recursive_and_behavior(self):
+        """Test @recursive with @behavior"""
+        
+        class TestStage(Stage):
+            NAME = "TestStage"
+            
+            @recursive
+            @behavior("next")
+            def current(self, inst):
+                return True
+            
+            def next(self, inst):
+                return None
+        
+        assert "current" in TestStage.__recursive__
+        assert "current" in TestStage.__behaviors__

chartflow/fsm/test/test_events.py

@@ -0,0 +1,202 @@
+"""Tests for EventSystem"""
+
+import pytest
+from chartflow.fsm.utils import EventSystem
+
+
+class TestEventSystemBasic:
+    """Test basic EventSystem functionality"""
+    
+    def test_listen_for_event(self):
+        """Test listenFor registers callback"""
+        es = EventSystem()
+        
+        called = False
+        
+        def handler(data):
+            nonlocal called
+            called = True
+        
+        es.listenFor("test_event", handler)
+        es.pushEvent("test_event", {})
+        
+        assert called
+    
+    def test_multiple_handlers(self):
+        """Test multiple handlers for same event"""
+        es = EventSystem()
+        
+        calls = []
+        
+        def handler1(data):
+            calls.append(1)
+        
+        def handler2(data):
+            calls.append(2)
+        
+        es.listenFor("test_event", handler1)
+        es.listenFor("test_event", handler2)
+        es.pushEvent("test_event", {})
+        
+        assert 1 in calls
+        assert 2 in calls
+    
+    def test_cancel_listen(self):
+        """Test cancelListen removes callback"""
+        es = EventSystem()
+        
+        called = False
+        
+        def handler(data):
+            nonlocal called
+            called = True
+        
+        es.listenFor("test_event", handler)
+        es.cancelListen("test_event", handler)
+        es.pushEvent("test_event", {})
+        
+        assert not called
+    
+    def test_cancel_all_listeners(self):
+        """Test cancelListen without handler removes all"""
+        es = EventSystem()
+        
+        calls = []
+        
+        def handler1(data):
+            calls.append(1)
+        
+        def handler2(data):
+            calls.append(2)
+        
+        es.listenFor("test_event", handler1)
+        es.listenFor("test_event", handler2)
+        es.cancelListen("test_event")
+        es.pushEvent("test_event", {})
+        
+        assert len(calls) == 0
+
+
+class TestEventSystemSourceFiltering:
+    """Test source filtering"""
+    
+    def test_source_filter_matching(self):
+        """Test that events from matching sources are received"""
+        es = EventSystem()
+        
+        calls = []
+        
+        def handler(data):
+            calls.append(data)
+        
+        es.listenFor("test_event", handler, "source1", "source2")
+        es.pushEvent("test_event", {"msg": "hello"}, source="source1")
+        
+        assert len(calls) == 1
+        assert calls[0]["msg"] == "hello"
+    
+    def test_source_filter_non_matching(self):
+        """Test that events from non-matching sources are filtered"""
+        es = EventSystem()
+        
+        calls = []
+        
+        def handler(data):
+            calls.append(data)
+        
+        es.listenFor("test_event", handler, "source1")
+        es.pushEvent("test_event", {"msg": "hello"}, source="source2")
+        
+        assert len(calls) == 0
+    
+    def test_no_source_filter_receives_all(self):
+        """Test that listeners without source filter receive all"""
+        es = EventSystem()
+        
+        calls = []
+        
+        def handler(data):
+            calls.append(data)
+        
+        es.listenFor("test_event", handler)
+        es.pushEvent("test_event", {"msg": "hello"}, source="any_source")
+        
+        assert len(calls) == 1
+
+
+class TestEventSystemTargetFiltering:
+    """Test target filtering"""
+    
+    def test_target_filter_matching(self):
+        """Test that events with matching targets are received"""
+        es = EventSystem()
+
+        calls = []
+
+        def handler(data):
+            calls.append(data)
+
+        es.listenFor("test_event", handler)
+        # No targets specified means all listeners receive
+        es.pushEvent("test_event", {"msg": "hello"})
+
+        assert len(calls) == 1
+    
+    def test_data_passed_to_handler(self):
+        """Test that data is passed to handler"""
+        es = EventSystem()
+        
+        received_data = None
+        
+        def handler(data):
+            nonlocal received_data
+            received_data = data
+        
+        es.listenFor("test_event", handler)
+        es.pushEvent("test_event", {"key": "value", "num": 42})
+        
+        assert received_data["key"] == "value"
+        assert received_data["num"] == 42
+
+
+class TestEventSystemEdgeCases:
+    """Test edge cases"""
+    
+    def test_no_listeners(self):
+        """Test that pushEvent with no listeners doesn't error"""
+        es = EventSystem()
+        
+        es.pushEvent("test_event", {})  # Should not raise
+    
+    def test_unknown_event(self):
+        """Test that pushEvent for unknown event doesn't error"""
+        es = EventSystem()
+        
+        def handler(data):
+            pass
+        
+        es.listenFor("other_event", handler)
+        es.pushEvent("test_event", {})  # Should not raise
+    
+    def test_handler_exception(self):
+        """Test that handler exception doesn't break system"""
+        es = EventSystem()
+        
+        calls = []
+        
+        def bad_handler(data):
+            raise ValueError("Test error")
+        
+        def good_handler(data):
+            calls.append(data)
+        
+        es.listenFor("test_event", bad_handler)
+        es.listenFor("test_event", good_handler)
+        
+        try:
+            es.pushEvent("test_event", {})
+        except:
+            pass  # Exception might propagate
+        
+        # Good handler should still be called
+        assert len(calls) == 1