Add EvaluationMode for CEL expression evaluation and update evaluate function

Author: hardbyte

python/cel/__init__.py

@@ -1,13 +1,33 @@
 # Import the Rust extension
 # Import CLI functionality
+from enum import Enum
+
 from . import cli
 from .cel import *
 
+
+class EvaluationMode(str, Enum):
+    """
+    Defines the evaluation dialect for a CEL expression.
+    """
+
+    PYTHON = "python"
+    """
+    Enables Python-friendly type promotions (e.g., int -> float). (Default)
+    """
+    STRICT = "strict"
+    """
+    Enforces strict cel-rust type rules with no automatic coercion to match Wasm behavior.
+    """
+
+
 __doc__ = cel.__doc__
 if hasattr(cel, "__all__"):
-    __all__ = cel.__all__
+    # Ensure EvaluationMode is always exported even if Rust module defines __all__
+    __all__ = list(cel.__all__) + ["EvaluationMode"]
 else:
     __all__ = [
         "evaluate",
         "Context",
+        "EvaluationMode",
     ]

python/cel/cel.pyi

@@ -2,7 +2,10 @@
 Type stubs for the CEL Rust extension module.
 """
 
-from typing import Any, Dict, Union, Optional, Callable, overload
+from typing import TYPE_CHECKING, Any, Callable, Dict, Literal, Optional, Union, overload
+
+if TYPE_CHECKING:
+    from . import EvaluationMode
 
 class Context:
     """CEL evaluation context for variables and functions."""
@@ -30,13 +33,20 @@ class Context:
         """Update context with variables from a dictionary."""
         ...
 
-def evaluate(expression: str, context: Optional[Union[Dict[str, Any], Context]] = None) -> Any:
+def evaluate(
+    expression: str,
+    context: Optional[Union[Dict[str, Any], Context]] = None,
+    *,
+    mode: Union[Literal["python", "strict"], "EvaluationMode", str] = "python",
+) -> Any:
     """
     Evaluate a CEL expression.
 
     Args:
         expression: The CEL expression to evaluate
         context: Optional context with variables and functions
+        mode: Evaluation mode - either "python" (default) for mixed arithmetic
+              or "strict" for strict type matching
 
     Returns:
         The result of evaluating the expression

python/cel/cli.py

@@ -38,11 +38,12 @@
 from typing_extensions import Annotated
 
 try:
-    from . import cel
+    from . import EvaluationMode, cel
 except ImportError:
     # Fallback for running as standalone script
     try:
         import cel
+        from cel import EvaluationMode
     except ImportError:
         console = Console()
         console.print(
@@ -191,9 +192,10 @@ def _get_auto_renderable(result: Any) -> Any:
 class CELEvaluator:
     """Enhanced CEL expression evaluator."""
 
-    def __init__(self, context: Optional[Dict[str, Any]] = None):
-        """Initialize evaluator with optional context."""
+    def __init__(self, context: Optional[Dict[str, Any]] = None, mode: str = "python"):
+        """Initialize evaluator with optional context and mode."""
         self.context = context or {}
+        self.mode = mode
         self._cel_context = None
         self._update_cel_context()
 
@@ -208,7 +210,7 @@ def evaluate(self, expression: str) -> Any:
         """Evaluate a CEL expression."""
         if not expression.strip():
             raise ValueError("Empty expression")
-        return cel.evaluate(expression, self._cel_context)
+        return cel.evaluate(expression, self._cel_context, mode=self.mode)
 
     def update_context(self, new_context: Dict[str, Any]):
         """Update the evaluation context."""
@@ -554,6 +556,13 @@ def main(
         typer.Option("--file", help="Read expressions from file (one per line)"),
     ] = None,
     output: Annotated[str, typer.Option("-o", "--output", help="Output format")] = "auto",
+    mode: Annotated[
+        str,
+        typer.Option(
+            "--mode",
+            help="Evaluation mode: python (mixed arithmetic) or strict (type matching)",
+        ),
+    ] = "python",
     interactive: Annotated[
         bool, typer.Option("-i", "--interactive", help="Start interactive REPL mode")
     ] = False,
@@ -585,6 +594,10 @@ def main(
 
         # Evaluate expressions from file
         cel --file expressions.cel --output json
+
+        # Use strict evaluation mode
+        cel '1 + 2.0' --mode strict  # This will fail due to mixed types
+        cel '1.0 + 2.0' --mode strict  # This will work
     """
 
     # Load context
@@ -600,8 +613,13 @@ def main(
         file_context = load_context_from_file(context_file)
         eval_context.update(file_context)
 
+    # Validate mode parameter
+    if mode not in ("python", "strict"):
+        console.print(f"[red]Error: Invalid mode '{mode}'. Use 'python' or 'strict'[/red]")
+        raise typer.Exit(1)
+
     # Initialize evaluator
-    evaluator = CELEvaluator(eval_context)
+    evaluator = CELEvaluator(eval_context, mode=mode)
 
     # Interactive mode
     if interactive:

src/lib.rs

@@ -16,6 +16,25 @@ use std::error::Error;
 use std::fmt;
 use std::sync::Arc;
 
+#[derive(Clone, Debug, PartialEq)]
+pub enum EvaluationMode {
+    PythonCompatible,
+    Strict,
+}
+
+impl<'py> FromPyObject<'py> for EvaluationMode {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
+        let s: String = ob.extract()?;
+        match s.as_str() {
+            "python" => Ok(EvaluationMode::PythonCompatible),
+            "strict" => Ok(EvaluationMode::Strict),
+            _ => Err(PyTypeError::new_err(format!(
+                "Invalid EvaluationMode: expected 'python' or 'strict', got '{s}'"
+            ))),
+        }
+    }
+}
+
 #[derive(Debug)]
 struct RustyCelType(Value);
 
@@ -424,6 +443,12 @@ impl TryIntoValue for RustyPyType<'_> {
 ///         - A `cel.Context` object (recommended for reusable contexts)
 ///         - A standard Python dictionary containing variables and functions
 ///         - None (for expressions that don't require external variables)
+///     mode (Union[str, cel.EvaluationMode]): The evaluation mode to use.
+///         Defaults to "python". Can be:
+///         - "python" or EvaluationMode.PYTHON: Enables Python-friendly type
+///           promotions (e.g., int -> float) for better mixed arithmetic compatibility
+///         - "strict" or EvaluationMode.STRICT: Enforces strict CEL type rules
+///           with no automatic coercion to match WebAssembly behavior
 ///
 /// Returns:
 ///     Union[bool, int, float, str, list, dict, datetime.datetime, bytes, None]:
@@ -508,7 +533,7 @@ impl TryIntoValue for RustyPyType<'_> {
 ///
 ///     Using Context object for reusable evaluations:
 ///
-///     >>> from cel import Context
+///     >>> from cel import Context, EvaluationMode
 ///     >>> context = Context(
 ///     ...     variables={"base_url": "https://api.example.com"},
 ///     ...     functions={"len": len}
@@ -518,19 +543,32 @@ impl TryIntoValue for RustyPyType<'_> {
 ///     >>> evaluate("len('hello world')", context)
 ///     11
 ///
+///     Using different evaluation modes:
+///
+///     >>> # Python mode (default) - allows mixed arithmetic
+///     >>> evaluate("1 + 2.5")
+///     3.5
+///     >>> evaluate("1 + 2.5", mode=EvaluationMode.PYTHON)
+///     3.5
+///     >>> # Strict mode - enforces type matching
+///     >>> try:
+///     ...     evaluate("1 + 2.5", mode=EvaluationMode.STRICT)
+///     ... except TypeError as e:
+///     ...     print("Strict mode error:", e)
+///     Strict mode error: Unsupported addition operation: Int + Double...
+///
 /// See Also:
 ///     - cel.Context: For managing reusable evaluation contexts
 ///     - CEL Language Guide: For comprehensive language documentation
 ///     - Python API Reference: For detailed API documentation
-#[pyfunction(signature = (src, evaluation_context=None))]
-fn evaluate(src: String, evaluation_context: Option<&Bound<'_, PyAny>>) -> PyResult<RustyCelType> {
-    // Preprocess expression for better mixed int/float arithmetic compatibility
-    // First check if expression itself has mixed literals
-    let mut processed_src = if expression_has_mixed_numeric_literals(&src) {
-        preprocess_expression_for_mixed_arithmetic_always(&src)
-    } else {
-        src.clone()
-    };
+#[pyfunction(signature = (src, evaluation_context=None, mode=None))]
+fn evaluate(
+    src: String,
+    evaluation_context: Option<&Bound<'_, PyAny>>,
+    mode: Option<EvaluationMode>,
+) -> PyResult<RustyCelType> {
+    // Use PythonCompatible as default if mode is not provided
+    let mode = mode.unwrap_or(EvaluationMode::PythonCompatible);
 
     let mut environment = CelContext::default();
     let mut ctx = context::Context::new(None, None)?;
@@ -539,7 +577,7 @@ fn evaluate(src: String, evaluation_context: Option<&Bound<'_, PyAny>>) -> PyRes
     // Custom Rust functions can also be added to the environment...
     //environment.add_function("add", |a: i64, b: i64| a + b);
 
-    // Process the evaluation context if provided first to determine if we need preprocessing
+    // Process the evaluation context if provided
     if let Some(evaluation_context) = evaluation_context {
         // Attempt to extract directly as a Context object
         if let Ok(py_context_ref) = evaluation_context.extract::<PyRef<context::Context>>() {
@@ -555,21 +593,35 @@ fn evaluate(src: String, evaluation_context: Option<&Bound<'_, PyAny>>) -> PyRes
             ));
         };
 
-        // Smart numeric coercion for mixed int/float arithmetic compatibility
         variables_for_env = ctx.variables.clone();
+    }
 
-        // Check if we should promote integers to floats for better compatibility
-        let should_promote = should_promote_integers_to_floats(&variables_for_env)
-            || expression_has_mixed_numeric_literals(&src);
-
-        if should_promote {
-            promote_integers_in_context(&mut variables_for_env);
-
-            // Always preprocess the expression when we're promoting types
-            // This handles cases where context has floats but expression has integer literals
-            processed_src = preprocess_expression_for_mixed_arithmetic_always(&src);
+    // Apply type promotion logic based on evaluation mode (consolidated)
+    let processed_src = match mode {
+        EvaluationMode::PythonCompatible => {
+            // Check if we should promote integers to floats for better compatibility
+            let should_promote = should_promote_integers_to_floats(&variables_for_env)
+                || expression_has_mixed_numeric_literals(&src);
+
+            if should_promote {
+                // Promote integers in context if we have one
+                if !variables_for_env.is_empty() {
+                    promote_integers_in_context(&mut variables_for_env);
+                }
+                // Always preprocess the expression when promoting types
+                preprocess_expression_for_mixed_arithmetic_always(&src)
+            } else if expression_has_mixed_numeric_literals(&src) {
+                // Preprocess expression even without context if it has mixed literals
+                preprocess_expression_for_mixed_arithmetic_always(&src)
+            } else {
+                src.clone()
+            }
         }
-    }
+        EvaluationMode::Strict => {
+            // Do nothing - preserve strict type behavior with no promotions or rewriting
+            src.clone()
+        }
+    };
 
     // Use panic::catch_unwind to handle parser panics gracefully
     let program = panic::catch_unwind(|| Program::compile(&processed_src))