orca-runtime-python 0.1.21__tar.gz → 0.1.25__tar.gz

{orca_runtime_python-0.1.21 → orca_runtime_python-0.1.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orca-runtime-python
-Version: 0.1.21
+Version: 0.1.25
 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.21 → orca_runtime_python-0.1.25}/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.25"
 
 __all__ = [
     # Types

{orca_runtime_python-0.1.21 → orca_runtime_python-0.1.25}/orca_runtime_python/machine.py

@@ -717,10 +717,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.21 → orca_runtime_python-0.1.25}/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.21 → orca_runtime_python-0.1.25}/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.21 → orca_runtime_python-0.1.25}/orca_runtime_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orca-runtime-python
-Version: 0.1.21
+Version: 0.1.25
 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.21 → orca_runtime_python-0.1.25}/pyproject.toml

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

{orca_runtime_python-0.1.21 → orca_runtime_python-0.1.25}/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