orca-runtime-python 0.1.24__tar.gz → 0.1.26__tar.gz

{orca_runtime_python-0.1.24 → orca_runtime_python-0.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orca-runtime-python
-Version: 0.1.24
+Version: 0.1.26
 Summary: Python async runtime for Orca state machines
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/orca-lang/orca-lang

{orca_runtime_python-0.1.24 → orca_runtime_python-0.1.26}/orca_runtime_python/__init__.py

@@ -33,7 +33,7 @@ from .persistence import PersistenceAdapter, AsyncPersistenceAdapter, FilePersis
 
 from .logging import LogSink, FileSink, ConsoleSink, MultiSink
 
-__version__ = "0.1.0"
+__version__ = "0.1.26"
 
 __all__ = [
     # Types

{orca_runtime_python-0.1.24 → orca_runtime_python-0.1.26}/orca_runtime_python/machine.py

@@ -390,10 +390,10 @@ class OrcaMachine:
                 from_state=str(self._state),
             )
 
-        # Find matching transition
-        transition = self._find_transition(evt)
+        # Find matching transitions (may be multiple with different guards)
+        candidates = self._find_transitions(evt)
 
-        if not transition:
+        if not candidates:
             # No transition found - event unhandled
             return TransitionResult(
                 taken=False,
@@ -401,16 +401,28 @@ class OrcaMachine:
                 error=f"No transition for event {event_key} from {self._state.leaf()}"
             )
 
-        # Evaluate guard if present
-        if transition.guard:
-            guard_passed = await self._evaluate_guard(transition.guard)
-            if not guard_passed:
-                return TransitionResult(
-                    taken=False,
-                    from_state=str(self._state),
-                    guard_failed=True,
-                    error=f"Guard '{transition.guard}' failed"
-                )
+        # Try each candidate in order; first whose guard passes wins
+        transition = None
+        last_guard_name = None
+        for candidate in candidates:
+            if candidate.guard:
+                guard_passed = await self._evaluate_guard(candidate.guard)
+                if guard_passed:
+                    transition = candidate
+                    break
+                last_guard_name = candidate.guard
+            else:
+                # No guard — unconditional match
+                transition = candidate
+                break
+
+        if transition is None:
+            return TransitionResult(
+                taken=False,
+                from_state=str(self._state),
+                guard_failed=True,
+                error=f"Guard '{last_guard_name}' failed"
+            )
 
         # Execute the transition
         old_state = StateValue(self._state.value)
@@ -532,16 +544,20 @@ class OrcaMachine:
         # Default fallback
         return EventType.STATE_CHANGED
 
-    def _find_transition(self, event: Event) -> Transition | None:
-        """Find a transition matching the current state and event."""
+    def _find_transitions(self, event: Event) -> list[Transition]:
+        """Find all transitions matching the current state and event."""
         event_key = event.event_name or event.type.value
+        result: list[Transition] = []
 
         # Check all active leaf states (important for parallel states)
         for current in self._state.leaves():
             # Try direct match on current leaf state
             for t in self.definition.transitions:
                 if t.source == current and t.event == event_key:
-                    return t
+                    result.append(t)
+
+            if result:
+                return result
 
             # For compound states, also check parent's transitions
             # Transitions on parent fire from any child
@@ -549,10 +565,12 @@ class OrcaMachine:
             while parent:
                 for t in self.definition.transitions:
                     if t.source == parent and t.event == event_key:
-                        return t
+                        result.append(t)
+                if result:
+                    return result
                 parent = self._get_parent_state(parent)
 
-        return None
+        return result
 
     def _get_parent_state(self, state_name: str) -> str | None:
         """Get parent state name if state is nested (searches parallel regions too)."""
@@ -717,10 +735,10 @@ class OrcaMachine:
         """Resolve a ValueRef to its Python value."""
         return ref.value
 
-    def _eval_compare(self, op: str, left: VariableRef, right: ValueRef) -> bool:
+    def _eval_compare(self, op: str, left: VariableRef, right: "ValueRef | VariableRef") -> bool:
         """Evaluate a comparison guard."""
         lhs = self._resolve_variable(left)
-        rhs = self._resolve_value(right)
+        rhs = self._resolve_variable(right) if isinstance(right, VariableRef) else self._resolve_value(right)
 
         # Try numeric comparison
         try:

{orca_runtime_python-0.1.24 → orca_runtime_python-0.1.26}/orca_runtime_python/parser.py

@@ -556,6 +556,14 @@ def _parse_guard_expression(input_str: str) -> GuardExpression:
             return GuardNot(expr=parse_primary())
         return parse_primary()
 
+    def _lookahead_is_var_path() -> bool:
+        """Check if current position starts a variable path (ident.ident...)."""
+        return (
+            pos[0] + 1 < len(tokens)
+            and tokens[pos[0]].type == "ident"
+            and tokens[pos[0] + 1].type == "dot"
+        )
+
     def parse_primary() -> GuardExpression:
         tok = peek()
 
@@ -593,6 +601,10 @@ def _parse_guard_expression(input_str: str) -> GuardExpression:
         # Comparison operator
         if peek().type == "op":
             op = advance().value
+            # RHS: variable path (ctx.foo) or literal value
+            if peek().type == "ident" and _lookahead_is_var_path():
+                right_ref = parse_var_path()
+                return GuardCompare(op=_map_op(op), left=var_path, right=right_ref)
             right = parse_value()
             # Special case: != null and == null
             if right.type == "null":

{orca_runtime_python-0.1.24 → orca_runtime_python-0.1.26}/orca_runtime_python/types.py

@@ -124,7 +124,7 @@ class GuardCompare(GuardExpression):
     """Comparison guard: left op right"""
     op: str  # eq, ne, lt, gt, le, ge
     left: VariableRef
-    right: ValueRef
+    right: "ValueRef | VariableRef"
 
 
 @dataclass

{orca_runtime_python-0.1.24 → orca_runtime_python-0.1.26}/orca_runtime_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orca-runtime-python
-Version: 0.1.24
+Version: 0.1.26
 Summary: Python async runtime for Orca state machines
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/orca-lang/orca-lang

{orca_runtime_python-0.1.24 → orca_runtime_python-0.1.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "orca-runtime-python"
-version = "0.1.24"
+version = "0.1.26"
 description = "Python async runtime for Orca state machines"
 readme = "README.md"
 license = {text = "Apache-2.0"}

{orca_runtime_python-0.1.24 → orca_runtime_python-0.1.26}/tests/test_guards.py

@@ -12,6 +12,7 @@ from orca_runtime_python.types import (
     GuardOr,
     GuardNot,
     GuardNullcheck,
+    VariableRef,
 )
 
 
@@ -126,6 +127,30 @@ def test_parse_string_compare():
     assert guard.right.value == "pending", f"Expected value 'pending', got {guard.right.value}"
 
 
+def test_parse_var_to_var_compare():
+    defn = parse_orca_md(orca_md("ctx.score >= ctx.threshold", "score"))
+    guard = defn.guards["g"]
+    assert isinstance(guard, GuardCompare), f"Expected GuardCompare, got {type(guard)}"
+    assert guard.op == "ge", f"Expected op 'ge', got '{guard.op}'"
+    assert guard.left.path == ["ctx", "score"]
+    assert isinstance(guard.right, VariableRef), f"Expected VariableRef on RHS, got {type(guard.right)}"
+    assert guard.right.path == ["ctx", "threshold"]
+
+
+def test_parse_var_to_var_and():
+    defn = parse_orca_md(orca_md("ctx.a > ctx.b and ctx.c < ctx.d", "a"))
+    guard = defn.guards["g"]
+    assert isinstance(guard, GuardAnd), f"Expected GuardAnd, got {type(guard)}"
+    left = guard.left
+    right = guard.right
+    assert isinstance(left, GuardCompare)
+    assert isinstance(left.right, VariableRef)
+    assert left.right.path == ["ctx", "b"]
+    assert isinstance(right, GuardCompare)
+    assert isinstance(right.right, VariableRef)
+    assert right.right.path == ["ctx", "d"]
+
+
 # ---- Evaluator tests ----
 
 async def _test_eval_compare_pass():
@@ -252,6 +277,86 @@ async def _test_eval_false_literal():
     assert result.guard_failed is True, f"Expected guard_failed"
 
 
+def _orca_md_multi_ctx(guard_expr: str, fields: list[tuple[str, str, str]]) -> str:
+    """Helper with multiple context fields: [(name, type, default), ...]."""
+    rows = "\n".join(f"| {n} | {t} | {d} |" for n, t, d in fields)
+    return f"""# machine test
+
+## context
+
+| Field | Type | Default |
+|-------|------|---------|
+{rows}
+
+## events
+
+- GO
+
+## state idle [initial]
+> Idle state
+
+## state done [final]
+> Done state
+
+## guards
+
+| Name | Expression |
+|------|------------|
+| g | `{guard_expr}` |
+
+## transitions
+
+| Source | Event | Target | Guard |
+|--------|-------|--------|-------|
+| idle   | GO    | done   | g |
+"""
+
+
+async def _test_eval_var_to_var_ge_pass():
+    defn = parse_orca_md(_orca_md_multi_ctx(
+        "ctx.score >= ctx.threshold",
+        [("score", "number", "95"), ("threshold", "number", "80")],
+    ))
+    machine = OrcaMachine(defn, event_bus=EventBus())
+    await machine.start()
+    result = await machine.send("GO")
+    assert result.taken is True, f"Expected transition taken, got: {result.error}"
+
+
+async def _test_eval_var_to_var_ge_fail():
+    defn = parse_orca_md(_orca_md_multi_ctx(
+        "ctx.score >= ctx.threshold",
+        [("score", "number", "0"), ("threshold", "number", "0")],
+    ))
+    machine = OrcaMachine(defn, event_bus=EventBus(), context={"score": 50, "threshold": 80})
+    await machine.start()
+    result = await machine.send("GO")
+    assert result.taken is False, f"Expected transition NOT taken"
+    assert result.guard_failed is True, f"Expected guard_failed"
+
+
+async def _test_eval_var_to_var_lt_pass():
+    defn = parse_orca_md(_orca_md_multi_ctx(
+        "ctx.retry_count < ctx.max_retries",
+        [("retry_count", "number", "0"), ("max_retries", "number", "0")],
+    ))
+    machine = OrcaMachine(defn, event_bus=EventBus(), context={"retry_count": 1, "max_retries": 3})
+    await machine.start()
+    result = await machine.send("GO")
+    assert result.taken is True, f"Expected transition taken, got: {result.error}"
+
+
+async def _test_eval_var_to_var_eq():
+    defn = parse_orca_md(_orca_md_multi_ctx(
+        "ctx.actual == ctx.expected",
+        [("actual", "number", "0"), ("expected", "number", "0")],
+    ))
+    machine = OrcaMachine(defn, event_bus=EventBus(), context={"actual": 42, "expected": 42})
+    await machine.start()
+    result = await machine.send("GO")
+    assert result.taken is True, f"Expected transition taken, got: {result.error}"
+
+
 # ---- Sync test wrappers ----
 
 def test_eval_compare_pass():
@@ -299,6 +404,18 @@ def test_eval_true_literal():
 def test_eval_false_literal():
     asyncio.run(_test_eval_false_literal())
 
+def test_eval_var_to_var_ge_pass():
+    asyncio.run(_test_eval_var_to_var_ge_pass())
+
+def test_eval_var_to_var_ge_fail():
+    asyncio.run(_test_eval_var_to_var_ge_fail())
+
+def test_eval_var_to_var_lt_pass():
+    asyncio.run(_test_eval_var_to_var_lt_pass())
+
+def test_eval_var_to_var_eq():
+    asyncio.run(_test_eval_var_to_var_eq())
+
 
 if __name__ == "__main__":
     tests = [
@@ -329,6 +446,13 @@ if __name__ == "__main__":
         ("eval compare >= boundary", test_eval_compare_ge),
         ("eval true literal", test_eval_true_literal),
         ("eval false literal", test_eval_false_literal),
+        # Variable-to-variable comparison tests
+        ("parse var-to-var compare", test_parse_var_to_var_compare),
+        ("parse var-to-var and", test_parse_var_to_var_and),
+        ("eval var-to-var >= pass (95 >= 80)", test_eval_var_to_var_ge_pass),
+        ("eval var-to-var >= fail (50 >= 80)", test_eval_var_to_var_ge_fail),
+        ("eval var-to-var < pass (1 < 3)", test_eval_var_to_var_lt_pass),
+        ("eval var-to-var == pass (42 == 42)", test_eval_var_to_var_eq),
     ]
 
     passed = 0