flatmachines 1.0.0__py3-none-any.whl

flatmachines/expressions/cel.py

@@ -0,0 +1,101 @@
+"""
+CEL expression engine for flatmachines.
+
+Wraps cel-python to provide full CEL support including:
+- List macros (all, exists, filter, map)
+- String methods (startsWith, contains, endsWith)
+- Timestamps and durations
+- Type coercion
+
+Requires: pip install flatmachines[cel]
+"""
+
+from typing import Any, Dict
+
+try:
+    import celpy
+    from celpy import celtypes
+    CEL_AVAILABLE = True
+except ImportError:
+    CEL_AVAILABLE = False
+
+
+class CELExpressionEngine:
+    """
+    CEL expression engine using cel-python.
+    
+    Provides full CEL support for advanced expressions.
+    """
+
+    def __init__(self):
+        if not CEL_AVAILABLE:
+            raise ImportError(
+                "CEL expression engine requires cel-python. "
+                "Install with: pip install flatmachines[cel]"
+            )
+        self._env = celpy.Environment()
+
+    def evaluate(self, expression: str, variables: Dict[str, Any]) -> Any:
+        """
+        Evaluate a CEL expression with the given variables.
+
+        Args:
+            expression: The CEL expression string to evaluate
+            variables: Dictionary of variable names to values
+
+        Returns:
+            The result of evaluating the expression
+
+        Raises:
+            ValueError: If expression syntax is invalid
+        """
+        if not expression or not expression.strip():
+            return True  # Empty expression is always true
+
+        try:
+            # Parse the expression
+            ast = self._env.compile(expression)
+            
+            # Create the program
+            prog = self._env.program(ast)
+            
+            # Convert Python values to CEL types
+            cel_vars = self._to_cel_types(variables)
+            
+            # Evaluate
+            result = prog.evaluate(cel_vars)
+            
+            # Convert result back to Python
+            return self._from_cel_type(result)
+            
+        except Exception as e:
+            raise ValueError(f"CEL expression error: {expression} - {e}") from e
+
+    def _to_cel_types(self, obj: Any) -> Any:
+        """Convert Python types to CEL types."""
+        if isinstance(obj, dict):
+            return {k: self._to_cel_types(v) for k, v in obj.items()}
+        if isinstance(obj, list):
+            return [self._to_cel_types(v) for v in obj]
+        # Primitives pass through
+        return obj
+
+    def _from_cel_type(self, obj: Any) -> Any:
+        """Convert CEL types back to Python types."""
+        if CEL_AVAILABLE:
+            if isinstance(obj, celtypes.BoolType):
+                return bool(obj)
+            if isinstance(obj, celtypes.IntType):
+                return int(obj)
+            if isinstance(obj, celtypes.DoubleType):
+                return float(obj)
+            if isinstance(obj, celtypes.StringType):
+                return str(obj)
+            if isinstance(obj, celtypes.ListType):
+                return [self._from_cel_type(v) for v in obj]
+            if isinstance(obj, celtypes.MapType):
+                return {k: self._from_cel_type(v) for k, v in obj.items()}
+        return obj
+
+
+__all__ = ["CELExpressionEngine", "CEL_AVAILABLE"]

flatmachines/expressions/simple.py

@@ -0,0 +1,166 @@
+"""
+Simple expression engine for flatmachines.
+
+Supports:
+- Comparisons: ==, !=, <, <=, >, >=
+- Boolean operators: and, or, not
+- Field access: context.field, input.field, output.field
+- Literals: strings, numbers, booleans, null
+
+Examples:
+    context.score >= 8
+    context.current == context.target
+    context.score >= 8 and context.round < 4
+    not context.failed
+"""
+
+import ast
+import operator
+import re
+from typing import Any, Dict, List, Optional, Tuple
+
+
+class SimpleExpressionEngine:
+    """
+    Simple expression parser and evaluator.
+    
+    Uses Python's ast module for safe parsing, then evaluates
+    with a restricted set of operations.
+    """
+
+    # Supported comparison operators
+    COMPARISON_OPS = {
+        ast.Eq: operator.eq,
+        ast.NotEq: operator.ne,
+        ast.Lt: operator.lt,
+        ast.LtE: operator.le,
+        ast.Gt: operator.gt,
+        ast.GtE: operator.ge,
+    }
+
+    # Supported boolean operators
+    BOOL_OPS = {
+        ast.And: lambda values: all(values),
+        ast.Or: lambda values: any(values),
+    }
+
+    def __init__(self):
+        pass
+
+    def evaluate(self, expression: str, variables: Dict[str, Any]) -> Any:
+        """
+        Evaluate an expression with the given variables.
+
+        Args:
+            expression: The expression string to evaluate
+            variables: Dictionary of variable names to values
+
+        Returns:
+            The result of evaluating the expression
+
+        Raises:
+            ValueError: If expression syntax is invalid
+            KeyError: If referenced variable doesn't exist
+        """
+        if not expression or not expression.strip():
+            return True  # Empty expression is always true (default transition)
+
+        try:
+            tree = ast.parse(expression, mode='eval')
+        except SyntaxError as e:
+            raise ValueError(f"Invalid expression syntax: {expression}") from e
+
+        return self._eval_node(tree.body, variables)
+
+    def _eval_node(self, node: ast.AST, variables: Dict[str, Any]) -> Any:
+        """Recursively evaluate an AST node."""
+
+        # Literals
+        if isinstance(node, ast.Constant):
+            return node.value
+
+        # Name (variable reference like 'context', 'input', 'output')
+        if isinstance(node, ast.Name):
+            name = node.id
+            # Handle boolean literals
+            if name == 'true' or name == 'True':
+                return True
+            if name == 'false' or name == 'False':
+                return False
+            if name == 'null' or name == 'None':
+                return None
+            if name not in variables:
+                raise KeyError(f"Unknown variable: {name}")
+            return variables[name]
+
+        # Attribute access (e.g., context.score, context.nested.field)
+        if isinstance(node, ast.Attribute):
+            value = self._eval_node(node.value, variables)
+            attr = node.attr
+            if isinstance(value, dict):
+                if attr not in value:
+                    return None  # Missing fields return None
+                return value[attr]
+            return getattr(value, attr, None)
+
+        # Comparison (e.g., context.score >= 8)
+        if isinstance(node, ast.Compare):
+            left = self._eval_node(node.left, variables)
+            for op, comparator in zip(node.ops, node.comparators):
+                right = self._eval_node(comparator, variables)
+                op_func = self.COMPARISON_OPS.get(type(op))
+                if op_func is None:
+                    raise ValueError(f"Unsupported comparison operator: {type(op).__name__}")
+                if not op_func(left, right):
+                    return False
+                left = right
+            return True
+
+        # Boolean operators (and, or)
+        if isinstance(node, ast.BoolOp):
+            op_func = self.BOOL_OPS.get(type(node.op))
+            if op_func is None:
+                raise ValueError(f"Unsupported boolean operator: {type(node.op).__name__}")
+            # Short-circuit evaluation
+            if isinstance(node.op, ast.And):
+                for value_node in node.values:
+                    if not self._eval_node(value_node, variables):
+                        return False
+                return True
+            else:  # Or
+                for value_node in node.values:
+                    if self._eval_node(value_node, variables):
+                        return True
+                return False
+
+        # Unary operators (not)
+        if isinstance(node, ast.UnaryOp):
+            operand = self._eval_node(node.operand, variables)
+            if isinstance(node.op, ast.Not):
+                return not operand
+            raise ValueError(f"Unsupported unary operator: {type(node.op).__name__}")
+
+        # Binary operators (for arithmetic in expressions like context.round + 1)
+        if isinstance(node, ast.BinOp):
+            left = self._eval_node(node.left, variables)
+            right = self._eval_node(node.right, variables)
+            if isinstance(node.op, ast.Add):
+                return left + right
+            if isinstance(node.op, ast.Sub):
+                return left - right
+            if isinstance(node.op, ast.Mult):
+                return left * right
+            if isinstance(node.op, ast.Div):
+                return left / right
+            raise ValueError(f"Unsupported binary operator: {type(node.op).__name__}")
+
+        # Subscript (e.g., context["key"])
+        if isinstance(node, ast.Subscript):
+            value = self._eval_node(node.value, variables)
+            index = self._eval_node(node.slice, variables)
+            return value[index]
+
+        raise ValueError(f"Unsupported expression type: {type(node).__name__}")
+
+
+__all__ = ["SimpleExpressionEngine"]