Test evaluation mode and slight refactor

Author: hardbyte

.github/workflows/ci.yml

@@ -93,10 +93,7 @@ jobs:
           test -f python/cel/cel.pyi || (echo "❌ Type stub file missing" && exit 1)
           test -f python/cel/py.typed || (echo "❌ PEP 561 marker missing" && exit 1)
           echo "✅ Type stub files present"
-      
-      - name: Run type checking tests
-        run: uv run pytest tests/test_type_stubs.py -v
-      
+
       - name: Test ty type checker integration
         run: |
           echo "from cel import evaluate, Context; evaluate('1+1')" > test_types.py

docs/reference/python-api.md

@@ -81,6 +81,7 @@ In STRICT mode, the library:
 3. Raises TypeError for incompatible type operations
 
 **Example with Context:**
+
 ```python
 from cel import evaluate, EvaluationMode
 

python/cel/__init__.py

@@ -1,21 +1,5 @@
 # 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.
-    """
+from .evaluation_modes import EvaluationMode

python/cel/cel.pyi

@@ -2,10 +2,9 @@
 Type stubs for the CEL Rust extension module.
 """
 
-from typing import TYPE_CHECKING, Any, Callable, Dict, Literal, Optional, Union, overload
+from typing import Any, Callable, Dict, Literal, Optional, Union, overload
 
-if TYPE_CHECKING:
-    from . import EvaluationMode
+from .evaluation_modes import EvaluationMode
 
 class Context:
     """CEL evaluation context for variables and functions."""

python/cel/cli.py

@@ -37,19 +37,9 @@
 from rich.table import Table
 from typing_extensions import Annotated
 
-try:
-    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(
-            "[red]Error: 'cel' package not found. Please install with: pip install common-expression-language[/red]"
-        )
-        sys.exit(1)
+# Import directly from relative modules to avoid circular imports
+from .cel import Context, evaluate
+from .evaluation_modes import EvaluationMode
 
 # Initialize Rich console
 console = Console()
@@ -202,15 +192,15 @@ def __init__(self, context: Optional[Dict[str, Any]] = None, mode: str = "strict
     def _update_cel_context(self):
         """Update the internal CEL context object."""
         if self.context:
-            self._cel_context = cel.Context(self.context)
+            self._cel_context = Context(self.context)
         else:
             self._cel_context = None
 
     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, mode=self.mode)
+        return evaluate(expression, self._cel_context, mode=self.mode)
 
     def update_context(self, new_context: Dict[str, Any]):
         """Update the evaluation context."""

python/cel/evaluation_modes.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+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.
+    """

tests/test_evaluation_mode.py

@@ -0,0 +1,154 @@
+"""Tests for EvaluationMode functionality."""
+
+import pytest
+from cel import Context, EvaluationMode, evaluate
+
+
+def test_evaluation_mode_enum_values():
+    """Test that EvaluationMode enum has expected values."""
+    assert EvaluationMode.PYTHON == "python"
+    assert EvaluationMode.STRICT == "strict"
+    # String representation shows enum name, but equality works with values
+    assert str(EvaluationMode.PYTHON) == "EvaluationMode.PYTHON"
+    assert str(EvaluationMode.STRICT) == "EvaluationMode.STRICT"
+
+
+def test_default_mode_is_python_compatible():
+    """Test that the default evaluation mode allows mixed arithmetic."""
+    # Without explicit mode, should use python by default
+    result = evaluate("1 + 2.5")
+    assert result == 3.5
+
+
+def test_python_mode_explicit():
+    """Test explicit python mode allows mixed arithmetic."""
+    # Using enum
+    result = evaluate("1 + 2.5", mode=EvaluationMode.PYTHON)
+    assert result == 3.5
+
+    # Using string
+    result = evaluate("1 + 2.5", mode="python")
+    assert result == 3.5
+
+
+def test_strict_mode_rejects_mixed_arithmetic():
+    """Test that strict mode rejects mixed int/float arithmetic."""
+    # Using enum
+    with pytest.raises(TypeError, match="Unsupported addition operation"):
+        evaluate("1 + 2.5", mode=EvaluationMode.STRICT)
+
+    # Using string
+    with pytest.raises(TypeError, match="Unsupported addition operation"):
+        evaluate("1 + 2.5", mode="strict")
+
+
+def test_same_type_arithmetic_works_in_both_modes():
+    """Test that same-type arithmetic works in both modes."""
+    # Integer arithmetic
+    assert evaluate("1 + 2", mode=EvaluationMode.PYTHON) == 3
+    assert evaluate("1 + 2", mode=EvaluationMode.STRICT) == 3
+
+    # Float arithmetic
+    assert evaluate("1.5 + 2.5", mode=EvaluationMode.PYTHON) == 4.0
+    assert evaluate("1.5 + 2.5", mode=EvaluationMode.STRICT) == 4.0
+
+
+def test_context_with_mixed_types():
+    """Test evaluation modes with context containing mixed types."""
+    context = {"x": 1, "y": 2.5}
+
+    # Python mode should promote and work
+    result = evaluate("x + y", context, mode=EvaluationMode.PYTHON)
+    assert result == 3.5
+
+    # Strict should fail
+    with pytest.raises(TypeError, match="Unsupported addition operation"):
+        evaluate("x + y", context, mode=EvaluationMode.STRICT)
+
+
+def test_context_object_with_mixed_types():
+    """Test evaluation modes with Context object containing mixed types."""
+    context = Context(variables={"a": 5, "b": 3.0})
+
+    # Python mode should work
+    result = evaluate("a + b", context, mode=EvaluationMode.PYTHON)
+    assert result == 8.0
+
+    # Strict should fail
+    with pytest.raises(TypeError, match="Unsupported addition operation"):
+        evaluate("a + b", context, mode=EvaluationMode.STRICT)
+
+
+def test_invalid_mode_string():
+    """Test that invalid mode strings raise appropriate errors."""
+    with pytest.raises(TypeError, match="Invalid EvaluationMode"):
+        evaluate("1 + 2", mode="InvalidMode")
+
+
+def test_context_type_promotion_in_python_mode():
+    """Test that python mode promotes context integers when floats are present."""
+    context = {"int_val": 10, "float_val": 2.5}
+
+    # This should work in python mode due to type promotion
+    result = evaluate("int_val * float_val", context, mode=EvaluationMode.PYTHON)
+    assert result == 25.0
+
+
+def test_expression_preprocessing_in_python_mode():
+    """Test that python mode preprocesses integer literals when mixed with floats."""
+    # This expression has mixed literals, should work in python mode
+    result = evaluate("10 + 2.5", mode=EvaluationMode.PYTHON)
+    assert result == 12.5
+
+    # Should fail in strict mode
+    with pytest.raises(TypeError):
+        evaluate("10 + 2.5", mode=EvaluationMode.STRICT)
+
+
+def test_non_arithmetic_expressions_work_in_both_modes():
+    """Test that non-arithmetic expressions work the same in both modes."""
+    # String operations
+    assert evaluate('"hello" + " world"', mode=EvaluationMode.PYTHON) == "hello world"
+    assert evaluate('"hello" + " world"', mode=EvaluationMode.STRICT) == "hello world"
+
+    # Boolean operations
+    assert evaluate("true && false", mode=EvaluationMode.PYTHON) is False
+    assert evaluate("true && false", mode=EvaluationMode.STRICT) is False
+
+    # List operations
+    assert evaluate("[1, 2, 3].size()", mode=EvaluationMode.PYTHON) == 3
+    assert evaluate("[1, 2, 3].size()", mode=EvaluationMode.STRICT) == 3
+
+
+def test_mode_with_custom_functions():
+    """Test that evaluation modes work with custom functions."""
+
+    def add_numbers(a, b):
+        return a + b
+
+    context = Context(variables={"x": 1, "y": 2.5}, functions={"add": add_numbers})
+
+    # The Python function itself will handle mixed arithmetic
+    result = evaluate("add(x, y)", context, mode=EvaluationMode.STRICT)
+    assert result == 3.5  # Python function can handle mixed types
+
+    # But CEL arithmetic still fails in strict mode
+    with pytest.raises(TypeError):
+        evaluate("x + y", context, mode=EvaluationMode.STRICT)
+
+
+def test_mode_parameter_positions():
+    """Test that mode parameter works in different positions."""
+    context = {"a": 1, "b": 2}
+
+    # Mode as third parameter
+    result1 = evaluate("a + b", context, EvaluationMode.PYTHON)
+    assert result1 == 3
+
+    # Mode as keyword argument
+    result2 = evaluate("a + b", context, mode=EvaluationMode.PYTHON)
+    assert result2 == 3
+
+    # Mode without context
+    result3 = evaluate("1 + 2", mode=EvaluationMode.PYTHON)
+    assert result3 == 3