Integrate cel::Config::VariableConfig into Python CEL environment

This change allows the Python CEL environment to be configured using a `cel.Config` object, which can be loaded from YAML. Variables provided in the `cel.NewEnv` call are now used to augment the configuration. The underlying C++ implementation now uses `cel::Env` to configure the compiler and runtime builders.

PiperOrigin-RevId: 891920215

Author: dmitriplotnikov

MODULE.bazel

@@ -14,10 +14,10 @@ bazel_dep(name = "bazel_skylib", version = "1.8.2")
 # https://registry.bazel.build/modules/cel-cpp
 bazel_dep(name = "cel-cpp", version = "0.14.0", repo_name = "com_google_cel_cpp")
 
-# 03/25/2026
-_CEL_CPP_COMMIT = "f6cd0c895e42954475b3734c867e8902557d1b37"
+# 03/30/2026
+_CEL_CPP_COMMIT = "5a3463337cf2a9b90b53833af2bbc1f35da90d64"
 
-_CEL_CPP_SHA256 = "8af44a84983f190e30ba4e5064ed5f2a2bbd13988a50b5c75288096636f1548b"
+_CEL_CPP_SHA256 = "299be398d1495340eb92da31f9a0667e1351479752e8a567ac31c385e4aea73c"
 
 archive_override(
     module_name = "cel-cpp",

cel_expr_python/BUILD

@@ -76,8 +76,7 @@ pybind_extension(
         "@com_google_cel_cpp//common:value",
         "@com_google_cel_cpp//common:value_kind",
         "@com_google_cel_cpp//compiler",
-        "@com_google_cel_cpp//compiler:compiler_factory",
-        "@com_google_cel_cpp//compiler:standard_library",
+        "@com_google_cel_cpp//env",
         "@com_google_cel_cpp//env:config",
         "@com_google_cel_cpp//env:env_yaml",
         "@com_google_cel_cpp//extensions/protobuf:runtime_adapter",
@@ -136,6 +135,7 @@ py_test(
     srcs = ["cel_env_test.py"],
     deps = [
         ":cel",
+        "//testing:proto2_test_all_types_py_pb2",
         "@com_google_absl_py//absl/testing:absltest",
     ],
 )

cel_expr_python/cel_env_test.py

@@ -20,6 +20,7 @@
 
 from absl.testing import absltest
 from cel_expr_python import cel
+from cel.expr.conformance.proto2 import test_all_types_pb2 as test_all_types_pb
 
 
 class CelEnvTest(absltest.TestCase):
@@ -85,11 +86,156 @@ def test_invalid_yaml(self):
       cel.NewEnvConfigFromYaml(" invalid yaml")
     self.assertIn(
         "1:2: Invalid CEL environment config YAML\n"
-        "| invalid yaml\n"
-        "| ^",
+        + "| invalid yaml\n"
+        + "| ^",
         str(e.exception),
     )
 
+  def test_config_export_variables(self):
+    config = cel.NewEnv(
+        variables={
+            "var_bool": cel.Type.BOOL,
+            "var_int": cel.Type.INT,
+            "var_uint": cel.Type.UINT,
+            "var_double": cel.Type.DOUBLE,
+            "var_str": cel.Type.STRING,
+            "var_bytes": cel.Type.BYTES,
+            "var_msg": cel.Type("cel.expr.conformance.proto2.TestAllTypes"),
+            "var_string_list": cel.Type.List(cel.Type.STRING),
+            "var_timestamp": cel.Type.TIMESTAMP,
+            "var_duration": cel.Type.DURATION,
+            "var_dyn_list": cel.Type.LIST,
+            "var_int_map": cel.Type.Map(cel.Type.INT, cel.Type.STRING),
+            "var_string_map": cel.Type.Map(cel.Type.STRING, cel.Type.BOOL),
+            "var_dyn_map": cel.Type.MAP,
+            "var_dyn": cel.Type.DYN,
+        }
+    )
+    yaml = config.config().to_yaml()
+    self.assertEqual(
+        normalize_yaml(yaml),
+        normalize_yaml("""
+          variables:
+            - name: "var_bool"
+              type_name: "bool"
+            - name: "var_bytes"
+              type_name: "bytes"
+            - name: "var_double"
+              type_name: "double"
+            - name: "var_duration"
+              type_name: "duration"
+            - name: "var_dyn"
+              type_name: "dyn"
+            - name: "var_dyn_list"
+              type_name: "list"
+              params:
+                - type_name: "dyn"
+            - name: "var_dyn_map"
+              type_name: "map"
+              params:
+                - type_name: "dyn"
+                - type_name: "dyn"
+            - name: "var_int"
+              type_name: "int"
+            - name: "var_int_map"
+              type_name: "map"
+              params:
+                - type_name: "int"
+                - type_name: "string"
+            - name: "var_msg"
+              type_name: "cel.expr.conformance.proto2.TestAllTypes"
+            - name: "var_str"
+              type_name: "string"
+            - name: "var_string_list"
+              type_name: "list"
+              params:
+                - type_name: "string"
+            - name: "var_string_map"
+              type_name: "map"
+              params:
+                - type_name: "string"
+                - type_name: "bool"
+            - name: "var_timestamp"
+              type_name: "timestamp"
+            - name: "var_uint"
+              type_name: "uint"
+      """),
+    )
+
+  def test_config_augmented_variables(self):
+    config = cel.NewEnvConfigFromYaml("""
+      variables:
+        - name: "var_bool"
+          type_name: "bool"
+      """)
+    env = cel.NewEnv(
+        config=config,
+        variables={
+            "var_msg": cel.Type("cel.expr.conformance.proto2.TestAllTypes"),
+        },
+    )
+    yaml = env.config().to_yaml()
+    self.assertEqual(
+        normalize_yaml(yaml),
+        normalize_yaml("""
+          variables:
+            - name: "var_bool"
+              type_name: "bool"
+            - name: "var_msg"
+              type_name: "cel.expr.conformance.proto2.TestAllTypes"
+        """),
+    )
+
+  def test_config_variable_override(self):
+    config = cel.NewEnvConfigFromYaml("""
+      variables:
+        - name: "var_bool"
+          type_name: "bool"
+      """)
+
+    with self.assertRaises(Exception) as e:
+      cel.NewEnv(
+          config=config,
+          variables={
+              "var_bool": cel.Type.INT,
+          },
+      )
+    self.assertIn(
+        "Variable 'var_bool' is already included",
+        str(e.exception),
+    )
+
+  def test_config_variable_types(self):
+    config = cel.NewEnvConfigFromYaml("""
+      variables:
+        - name: "var_bool"
+          type_name: "bool"
+        - name: "var_int"
+          type_name: "int"
+          value: 42
+      """)
+    env = cel.NewEnv(
+        config=config,
+        variables={
+            "var_msg": cel.Type("cel.expr.conformance.proto2.TestAllTypes"),
+        },
+    )
+    data = {
+        "var_bool": True,
+        "var_msg": test_all_types_pb.TestAllTypes(single_string="hello"),
+    }
+    res = env.compile("var_bool").eval(data=data)
+    self.assertEqual(res.type(), cel.Type.BOOL)
+    self.assertTrue(res.value())
+
+    res = env.compile("var_msg.single_string").eval(data=data)
+    self.assertEqual(res.type(), cel.Type.STRING)
+    self.assertEqual(res.value(), "hello")
+
+    res = env.compile("var_int").eval(data=data)
+    self.assertEqual(res.type(), cel.Type.INT)
+    self.assertEqual(res.value(), 42)
+
 
 def normalize_yaml(yaml: str) -> str:
   lines = yaml.split("\n")

cel_expr_python/py_cel_env.cc

@@ -25,8 +25,10 @@
 #include <vector>
 
 #include "absl/log/absl_check.h"
+#include "env/config.h"
 #include "cel_expr_python/py_cel_activation.h"
 #include "cel_expr_python/py_cel_arena.h"
+#include "cel_expr_python/py_cel_env_config.h"
 #include "cel_expr_python/py_cel_env_internal.h"
 #include "cel_expr_python/py_cel_expression.h"
 #include "cel_expr_python/py_cel_type.h"
@@ -42,7 +44,7 @@ void PyCelEnv::DefinePythonBindings(pybind11::module& m) {
   py::class_<PyCelEnv, std::shared_ptr<PyCelEnv>> cel_class(m, "Env");
   m.def(
       "NewEnv",
-      [](py::object descriptor_pool,
+      [](py::object descriptor_pool, std::optional<PyCelEnvConfig> config,
          std::optional<std::unordered_map<std::string, PyCelType>> variables,
          std::optional<std::vector<py::object>> extensions,
          const std::optional<std::string>& container) {
@@ -70,15 +72,17 @@ void PyCelEnv::DefinePythonBindings(pybind11::module& m) {
           }
         }
 
-        return PyCelEnv(pool_ptr,
+        return PyCelEnv(config.value_or(PyCelEnvConfig()), pool_ptr,
                         std::move(variables).value_or(
                             std::unordered_map<std::string, PyCelType>{}),
                         ext_ptrs, container.value_or(""));
       },
-      py::arg("descriptor_pool") = py::none(),
+      py::arg("descriptor_pool") = py::none(), py::arg("config") = py::none(),
       py::arg("variables") = py::none(), py::arg("extensions") = py::none(),
       py::arg("container") = py::none());
   cel_class
+      .def("config",
+           [](PyCelEnv& self) { return self.GetEnv()->GetEnvConfig(); })
       .def("compile", &PyCelEnv::Compile, py::arg("expression"),
            py::arg("disable_check") = false)
       .def("deserialize", &PyCelEnv::Deserialize, py::arg("serialized"))
@@ -108,13 +112,13 @@ void PyCelEnv::DefinePythonBindings(pybind11::module& m) {
           py::arg("arena") = nullptr);
 }
 
-PyCelEnv::PyCelEnv(PyObject* descriptor_pool,
+PyCelEnv::PyCelEnv(const PyCelEnvConfig& config, PyObject* descriptor_pool,
                    std::unordered_map<std::string, PyCelType> variable_types,
                    const std::vector<PyObject*>& extensions,
-                   std::string container)
-    : env_(std::make_unique<PyCelEnvInternal>(
-          descriptor_pool, std::move(variable_types), extensions,
-          std::move(container))) {
+                   std::string container) {
+  env_ = ThrowIfError(PyCelEnvInternal::NewCelEnvInternal(
+      config, descriptor_pool, std::move(variable_types), extensions,
+      std::move(container)));
   ABSL_CHECK(PyGILState_Check());
 }
 

cel_expr_python/py_cel_env.h

@@ -25,6 +25,7 @@
 
 #include "cel_expr_python/py_cel_activation.h"
 #include "cel_expr_python/py_cel_arena.h"
+#include "cel_expr_python/py_cel_env_config.h"
 #include "cel_expr_python/py_cel_expression.h"
 #include "cel_expr_python/py_cel_function.h"
 #include "cel_expr_python/py_cel_type.h"
@@ -65,9 +66,10 @@ class PyCelEnv {
 
  private:
   // Private constructor. Use `py_cel.NewEnv()` in python to obtain an instance.
-  PyCelEnv(PyObject* descriptor_pool,
+  PyCelEnv(const PyCelEnvConfig& config, PyObject* descriptor_pool,
            std::unordered_map<std::string, PyCelType> variable_types,
            const std::vector<PyObject*>& extensions, std::string container);
+
   std::shared_ptr<PyCelEnvInternal> env_;
 };
 

cel_expr_python/py_cel_env_config.h

@@ -27,9 +27,14 @@ class PyCelEnvConfig {
  public:
   static void DefinePythonBindings(pybind11::module& m);
 
+  PyCelEnvConfig() = default;
+  explicit PyCelEnvConfig(const cel::Config& config) : config_(config) {}
+
   static PyCelEnvConfig FromYaml(std::string yaml);
   std::string ToYaml() const;
 
+  const cel::Config& GetConfig() const { return config_; }
+
  private:
   cel::Config config_;
 };