Skip to content

Commit 4a12980

Browse files
dmitriplotnikovcopybara-github
authored andcommitted
[Python] Support direct equality comparison on cel.Value.
Define `__eq__` on `PyCelValue` (`cel.Value`, inherited by `_CelListItemAccessor` and `_CelMapItemAccessor`) by delegating to `PyObject_RichCompare` on the lazily resolved Python value, unwrapping the right-hand side when comparing two `cel.Value` instances while keeping `ERROR` values distinct from plain `str` / `STRING` `cel.Value`s and `BOOL` values distinct from numeric types. Also mark `PyCelType`'s `__eq__` binding with `py::is_operator()` so comparing `cel.Type` against non-`Type` objects returns `NotImplemented` instead of raising `TypeError`. This allows `expr.eval()` and `expr.eval().value()` (including lists, maps, and indexed elements) to be compared directly against plain Python values (e.g. `assertEqual(expr.eval(), [0, 1, 2])`) without requiring `plain_value()`. PiperOrigin-RevId: 1015986905
1 parent 1876da3 commit 4a12980

9 files changed

Lines changed: 325 additions & 6 deletions

File tree

‎README.md‎

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -108,6 +108,23 @@ Result type: BOOL
108108
Result value: True
109109
```
110110

111+
#### Comparing values
112+
113+
* `==`: Compares `.value()` using Python equality (except `ERROR` values only
114+
match equal `ERROR` values).
115+
* `equals(other)`: Compares two `cel.Value` instances using CEL equality
116+
(`bool != int`, cross-numeric comparisons, CEL proto equality including
117+
`Any` unpacking, and `ERROR` returning `False`).
118+
119+
```python
120+
cel_bool = cel_env.compile("true").eval()
121+
cel_int = cel_env.compile("1").eval()
122+
123+
cel_bool == 1 # True (Python semantics)
124+
cel_bool == cel_int # True (Python semantics)
125+
cel_bool.equals(cel_int) # False (CEL semantics)
126+
```
127+
111128
### Using an Activation
112129

113130
The `eval()` function can also be invoked with an `Activation` object that

‎cel_expr_python/cel.pyi‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -74,16 +74,18 @@ class Type:
7474
def is_assignable_from(self, arg0: Type) -> bool: ...
7575
def is_message(self) -> bool: ...
7676
def name(self) -> str: ...
77-
def __eq__(self, arg0: Type) -> bool: ...
77+
def __eq__(self, arg0: object) -> bool: ...
7878

7979
BaseValue: TypeAlias = Union[None, bool, int, float, str, bytes, proto_message.Message, datetime.datetime, datetime.timedelta, Type]
8080
PlainValue: TypeAlias = Union[BaseValue, list[PlainValue], dict[PlainValue, PlainValue]]
8181
CelValue: TypeAlias = Union[BaseValue, list[Value], dict[PlainValue, Value]]
8282

8383
class Value:
84+
def equals(self, other: Value) -> bool: ...
8485
def plain_value(self) -> PlainValue: ...
8586
def type(self) -> Type: ...
8687
def value(self) -> Any: ...
88+
def __eq__(self, arg0: object) -> bool: ...
8789

8890
class _InternalArena:
8991
@staticmethod

‎cel_expr_python/cel_env_test.py‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -501,8 +501,13 @@ def test_standard_extensions_via_config(self):
501501
""")
502502
env: cel.Env = cel.NewEnv(config=config)
503503

504-
# Test lists extension (e.g., reverse)
504+
# Test lists extension (e.g., range and reverse)
505+
expr = env.compile("lists.range(3)")
506+
self.assertEqual(expr.eval(), [0, 1, 2])
507+
self.assertEqual(expr.eval().value(), [0, 1, 2])
505508
res = env.compile("[1, 2].reverse()").eval()
509+
self.assertEqual(res, [2, 1])
510+
self.assertEqual(res.value(), [2, 1])
506511
self.assertEqual(res.plain_value(), [2, 1])
507512

508513
# Test sets extension (e.g., intersects)

‎cel_expr_python/cel_parallel_test.py‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -224,23 +224,29 @@ def run_concurrent_value_test(n: int):
224224
def read_values(_):
225225
# Concurrently access plain_value, value, type, and repr
226226
# on shared instances
227+
self.assertEqual(val_scalar, n * 2)
227228
self.assertEqual(val_scalar.plain_value(), n * 2)
228229
self.assertEqual(val_scalar.value(), n * 2)
229230
self.assertEqual(val_scalar.type(), cel.Type.INT)
230231
self.assertNotEmpty(str(val_scalar))
231232

233+
self.assertEqual(val_list, [n, n + 1, n + 2])
232234
plain_list = val_list.plain_value()
233235
self.assertEqual(plain_list, [n, n + 1, n + 2])
234236
list_accessors = val_list.value()
237+
self.assertEqual(list_accessors, [n, n + 1, n + 2])
235238
for idx, item in enumerate(list_accessors):
239+
self.assertEqual(item, n + idx)
236240
self.assertEqual(item.plain_value(), n + idx)
237241
self.assertEqual(item.value(), n + idx)
238242
self.assertEqual(item.type(), cel.Type.INT)
239243
self.assertNotEmpty(str(item))
240244

245+
self.assertEqual(val_map, {"key": f"k_{n}", "value": n})
241246
plain_map = val_map.plain_value()
242247
self.assertEqual(plain_map, {"key": f"k_{n}", "value": n})
243248
map_accessors = val_map.value()
249+
self.assertEqual(map_accessors, {"key": f"k_{n}", "value": n})
244250
self.assertEqual(map_accessors["key"].plain_value(), f"k_{n}")
245251
self.assertEqual(map_accessors["key"].value(), f"k_{n}")
246252
self.assertEqual(map_accessors["value"].plain_value(), n)

‎cel_expr_python/cel_test.py‎

Lines changed: 180 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -108,10 +108,19 @@ def testUnsetVar(self):
108108
self.assertIn(
109109
'No value with name "var_bool" found in Activation', res.value()
110110
)
111+
self.assertEqual(res, self._eval("var_bool", {}))
112+
self.assertNotEqual(res, res.value())
113+
self.assertNotEqual(res.value(), res)
114+
self.assertNotEqual(res, self._eval("var_str", {"var_str": res.value()}))
115+
self.assertFalse(res.equals(res))
116+
self.assertFalse(res.equals(self._eval("var_bool", {})))
117+
self.assertFalse(res.equals(self._eval("true")))
111118

112119
def testEvalNull(self):
113120
res: cel.Value = self._eval("null", expected_return_type=cel.Type.NULL)
114121
self.assertEqual(res.type(), cel.Type.NULL)
122+
self.assertEqual(res, None) # pylint: disable=g-generic-assert
123+
self.assertEqual(None, res) # pylint: disable=g-generic-assert
115124
self.assertIsNone(res.value())
116125
self.assertIsNone(res.plain_value())
117126

@@ -129,9 +138,23 @@ def testEvalNull(self):
129138
def testEvalBool(self):
130139
res: cel.Value = self._eval("true", expected_return_type=cel.Type.BOOL)
131140
self.assertEqual(res.type(), cel.Type.BOOL)
141+
self.assertEqual(res, True) # pylint: disable=g-generic-assert
142+
self.assertEqual(True, res) # pylint: disable=g-generic-assert
143+
self.assertEqual(res, 1)
144+
self.assertEqual(1, res)
145+
self.assertEqual(res, self._eval("1"))
146+
self.assertTrue(res.equals(self._eval("true")))
147+
self.assertFalse(res.equals(self._eval("1")))
148+
with self.assertRaises(TypeError):
149+
non_cel_val: Any = True
150+
res.equals(non_cel_val)
132151
self.assertEqual(res.value(), True)
133152
self.assertEqual(res.plain_value(), True)
134153
res = self._eval("false")
154+
self.assertEqual(res, False) # pylint: disable=g-generic-assert
155+
self.assertEqual(res, 0)
156+
self.assertEqual(self._eval("[false]"), [0])
157+
self.assertFalse(self._eval("[false]").equals(self._eval("[0]")))
135158
self.assertEqual(res.value(), False)
136159
res = self._eval("1 + 1 == 2")
137160
self.assertEqual(res.value(), True)
@@ -147,6 +170,10 @@ def testEvalBool(self):
147170
def testEvalInt64(self):
148171
res: cel.Value = self._eval("42", expected_return_type=cel.Type.INT)
149172
self.assertEqual(res.type(), cel.Type.INT)
173+
self.assertEqual(res, 42)
174+
self.assertEqual(42, res)
175+
self.assertNotEqual(res, 43)
176+
self.assertEqual(res, self._eval("40 + 2"))
150177
self.assertEqual(res.value(), 42)
151178
self.assertEqual(res.plain_value(), 42)
152179
res = self._eval("1000 + 200 + 30 + 4")
@@ -369,12 +396,45 @@ def testEvalList(self):
369396
"[1, 'CEL', true]", expected_return_type=cel.Type.LIST
370397
)
371398
self.assertEqual(res.type(), cel.Type.LIST)
399+
self.assertEqual(res, [1, "CEL", True])
400+
self.assertEqual([1, "CEL", True], res)
401+
self.assertNotEqual(res, [1, "CEL", False])
402+
self.assertEqual(res.value(), [1, "CEL", True])
403+
self.assertEqual([1, "CEL", True], res.value())
404+
self.assertNotEqual(res.value(), [1, "CEL", False])
372405
self.assertEqual([item.value() for item in res.value()], [1, "CEL", True])
373406
self.assertEqual(res.plain_value(), [1, "CEL", True])
374407

408+
self.assertEqual(
409+
self._eval("[[1, 2], [3]]"),
410+
[[1, 2], [3]],
411+
)
412+
self.assertEqual(
413+
self._eval("[[1, 2], [3]]").value(),
414+
[[1, 2], [3]],
415+
)
416+
self.assertEqual(
417+
self._eval("[1, 2]"),
418+
self._eval("[1, 2]"),
419+
)
420+
self.assertEqual(
421+
self._eval("[1, 2]").value(),
422+
self._eval("[1, 2]").value(),
423+
)
424+
self.assertNotEqual(
425+
self._eval("[1, 2]"),
426+
self._eval("[1, 3]"),
427+
)
428+
self.assertNotEqual(
429+
self._eval("[1, 2]").value(),
430+
self._eval("[1, 3]").value(),
431+
)
432+
375433
res = self._eval("[1]", expected_return_type=cel.Type.List(cel.Type.INT))
376434
self.assertEqual(res.type(), cel.Type.LIST)
377-
self.assertEqual(res.value()[0].value(), 1)
435+
self.assertEqual(res, [1])
436+
self.assertEqual(res.value(), [1])
437+
self.assertEqual(res.value()[0], 1)
378438

379439
res = self._eval(
380440
"["
@@ -406,6 +466,31 @@ def testEvalList(self):
406466
self.assertEqual(res_list[1].type(), cel.Type.DOUBLE)
407467
self.assertAlmostEqual(res_list[1].value(), 3.14, places=3)
408468

469+
# An Any with an unknown type_url succeeds at field selection (producing a
470+
# valid LIST of _CelListItemAccessors) and only fails when the element is
471+
# lazily unpacked, exercising PyCelListItemAccessor::IsError() so error
472+
# elements match identical errors but not plain str or STRING values.
473+
bad_msg = test_all_types_pb.TestAllTypes()
474+
bad_msg.repeated_any.add().type_url = (
475+
"type.googleapis.com/nonexistent.Message"
476+
)
477+
bad_list_item = self._eval(
478+
"var_msg.repeated_any", {"var_msg": bad_msg}
479+
).value()[0]
480+
self.assertEqual(bad_list_item.type(), cel.Type.ERROR)
481+
self.assertEqual(
482+
bad_list_item,
483+
self._eval("var_msg.repeated_any", {"var_msg": bad_msg}).value()[0],
484+
)
485+
self.assertNotEqual(bad_list_item, bad_list_item.value())
486+
self.assertNotEqual(bad_list_item.value(), bad_list_item)
487+
self.assertNotEqual(
488+
bad_list_item,
489+
self._eval("var_str", {"var_str": bad_list_item.value()}),
490+
)
491+
self.assertFalse(bad_list_item.equals(bad_list_item))
492+
self.assertTrue(self._eval("[1, 2]").value()[0].equals(self._eval("1u")))
493+
409494
def testEvalList_unexpectedType(self):
410495
res = self._eval("var_string_list", {"var_string_list": ["pi", 3.14]})
411496
self.assertEqual(res.type(), cel.Type.ERROR)
@@ -421,11 +506,25 @@ def testEvalMap(self):
421506
expected_return_type=cel.Type.Map(cel.Type.INT, cel.Type.STRING),
422507
)
423508
self.assertEqual(res.type(), cel.Type.MAP)
509+
self.assertEqual(res, {777: "CEL", 42: "Python"})
510+
self.assertEqual({777: "CEL", 42: "Python"}, res)
511+
self.assertNotEqual(res, {777: "CEL", 42: "C++"})
424512
res_map = res.value()
425513
self.assertLen(res_map, 2)
426-
self.assertEqual(res_map[777].value(), "CEL")
427-
self.assertEqual(res_map[42].value(), "Python")
514+
self.assertEqual(res_map, {777: "CEL", 42: "Python"})
515+
self.assertEqual({777: "CEL", 42: "Python"}, res_map)
516+
self.assertNotEqual(res_map, {777: "CEL", 42: "C++"})
517+
self.assertEqual(res_map[777], "CEL")
518+
self.assertEqual(res_map[42], "Python")
428519
self.assertEqual(res.plain_value(), {777: "CEL", 42: "Python"})
520+
self.assertEqual(
521+
self._eval("{'a': [1, 2]}"),
522+
{"a": [1, 2]},
523+
)
524+
self.assertEqual(
525+
self._eval("{'a': [1, 2]}").value(),
526+
{"a": [1, 2]},
527+
)
429528

430529
res = self._eval(
431530
"var_int_map",
@@ -439,6 +538,33 @@ def testEvalMap(self):
439538
self.assertEqual(res_map[42].value(), "Python")
440539
self.assertEqual(res.plain_value(), {777: "CEL", 42: "Python"})
441540

541+
# An Any with an unknown type_url succeeds at field selection (producing a
542+
# valid MAP whose entries are _CelMapItemAccessors) and only fails when the
543+
# entry is lazily unpacked, exercising PyCelMapItemAccessor::IsError() so
544+
# error entries match identical errors but not plain str or STRING values.
545+
bad_msg = test_all_types_pb.TestAllTypes()
546+
bad_msg.map_int64_any[1].type_url = (
547+
"type.googleapis.com/nonexistent.Message"
548+
)
549+
bad_map_item = self._eval(
550+
"var_msg.map_int64_any", {"var_msg": bad_msg}
551+
).value()[1]
552+
self.assertEqual(bad_map_item.type(), cel.Type.ERROR)
553+
self.assertEqual(
554+
bad_map_item,
555+
self._eval("var_msg.map_int64_any", {"var_msg": bad_msg}).value()[1],
556+
)
557+
self.assertNotEqual(bad_map_item, bad_map_item.value())
558+
self.assertNotEqual(bad_map_item.value(), bad_map_item)
559+
self.assertNotEqual(
560+
bad_map_item,
561+
self._eval("var_str", {"var_str": bad_map_item.value()}),
562+
)
563+
self.assertFalse(bad_map_item.equals(bad_map_item))
564+
self.assertTrue(
565+
self._eval("{'a': 1}").value()["a"].equals(self._eval("1.0"))
566+
)
567+
442568
res = self._eval(
443569
"var_string_map", {"var_string_map": {"CEL": True, "Python": 42}}
444570
)
@@ -660,6 +786,9 @@ def testTypeType(self):
660786
"type(1)", expected_return_type=cel.Type.Type(cel.Type.INT)
661787
)
662788
self.assertEqual(res.type(), cel.Type.TYPE)
789+
self.assertEqual(res, cel.Type.INT)
790+
self.assertEqual(cel.Type.INT, res)
791+
self.assertNotEqual(res, 1)
663792
self.assertEqual(res.value(), cel.Type.INT)
664793

665794
res = self._eval(
@@ -703,6 +832,54 @@ def testTypeType(self):
703832
)
704833
self.assertEqual(res.value(), cel.Type.INT)
705834

835+
def testCelEquals(self):
836+
# Cross-numeric comparisons work in both == and equals().
837+
val_int = self._eval("1")
838+
val_uint = self._eval("1u")
839+
val_double = self._eval("1.0")
840+
self.assertEqual(val_int, val_uint)
841+
self.assertEqual(val_int, val_double)
842+
self.assertEqual(val_uint, val_double)
843+
self.assertTrue(val_int.equals(val_uint))
844+
self.assertTrue(val_int.equals(val_double))
845+
self.assertTrue(val_uint.equals(val_double))
846+
self.assertFalse(self._eval("-1").equals(val_uint))
847+
848+
# Python == compares int vs float exactly, whereas CEL equals() casts
849+
# int64/uint64 to double (matching CEL's in-language ==).
850+
exact_int = self._eval("9007199254740993") # (1 << 53) + 1
851+
approx_double = self._eval("9007199254740992.0") # float(1 << 53)
852+
self.assertNotEqual(exact_int, approx_double)
853+
self.assertTrue(exact_int.equals(approx_double))
854+
855+
# NaN is unequal to itself in both Python and CEL.
856+
nan_val = self._eval("0.0 / 0.0")
857+
self.assertNotEqual(nan_val, nan_val)
858+
self.assertFalse(nan_val.equals(nan_val))
859+
860+
# Containers apply CEL equality recursively to elements/values.
861+
self.assertTrue(self._eval("[1, 2]").equals(self._eval("[1u, 2.0]")))
862+
self.assertTrue(self._eval("{'a': 1}").equals(self._eval("{'a': 1.0}")))
863+
self.assertFalse(self._eval("[1, 2]").equals(self._eval("[1, 3]")))
864+
865+
# Proto comparisons: == delegates to Python protobuf Message.__eq__ (raw
866+
# Any bytes), whereas equals() uses CEL MessageEquals (unpacks Any).
867+
msg1 = test_all_types_pb.TestAllTypes()
868+
msg1.single_any.Pack(
869+
test_all_types_pb.TestAllTypes(single_int32=1, single_string="a")
870+
)
871+
msg2 = test_all_types_pb.TestAllTypes()
872+
msg2.single_any.type_url = msg1.single_any.type_url
873+
msg2.single_any.value = (
874+
test_all_types_pb.TestAllTypes(single_string="a").SerializeToString()
875+
+ test_all_types_pb.TestAllTypes(single_int32=1).SerializeToString()
876+
)
877+
cel_msg1 = self._eval("var_msg", {"var_msg": msg1})
878+
cel_msg2 = self._eval("var_msg", {"var_msg": msg2})
879+
self.assertEqual(cel_msg1, msg1)
880+
self.assertNotEqual(cel_msg1, cel_msg2)
881+
self.assertTrue(cel_msg1.equals(cel_msg2))
882+
706883
def testTypeInitSignature(self):
707884
self.assertEqual(cel.Type("int"), cel.Type.INT)
708885
self.assertEqual(cel.Type("list<int>"), cel.Type.List(cel.Type.INT))

‎cel_expr_python/py_cel_type.cc‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -65,7 +65,7 @@ void PyCelType::DefinePythonBindings(py::module& m) {
6565
.def("is_message", &PyCelType::IsMessage)
6666
.def("is_assignable_from", &PyCelType::IsAssignableFrom)
6767
.def("__repr__", &PyCelType::ToString)
68-
.def("__eq__", &PyCelType::operator==);
68+
.def("__eq__", &PyCelType::operator==, py::is_operator());
6969

7070
type.def_static("List", &PyCelType::ListType, py::arg("element_type"))
7171
.def_static("Map", &PyCelType::MapType, py::arg("key_type"),

0 commit comments

Comments
 (0)