Store CEL container within cel::Config

This change simplifies the internal representation and ensures the container is part of the exported environment configuration.

PiperOrigin-RevId: 893173014

Author: dmitriplotnikov

MODULE.bazel

@@ -14,7 +14,7 @@ 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/30/2026
+# 04/01/2026
 _CEL_CPP_COMMIT = "5a3463337cf2a9b90b53833af2bbc1f35da90d64"
 
 _CEL_CPP_SHA256 = "299be398d1495340eb92da31f9a0667e1351479752e8a567ac31c385e4aea73c"

README.md

@@ -234,36 +234,34 @@ expr = cel_env.compile("my_func(1)")
 
 To define a custom extension in C++, define a class extending
 `cel_python::CelExtension`. There are two methods you will need to implement:
-`ConfigureCompiler` and `ConfigureRuntime`. The implementations of these methods
-use the same API as extensions written for the C++ CEL runtime. In fact,
+`GetCompilerLibrary` and `ConfigureRuntime`. The implementations of these
+methods use the same API as extensions written for the C++ CEL runtime. In fact,
 extensions written for the C++ runtime can be used unchanged with
 cel-expr-python - you would just need to write a trivial wrapper class invoking
 the registration functions defined by the C++ extension.
 
-```cpp
-  absl::Status ConfigureCompiler(
-      cel::CompilerBuilder& compiler_builder,
-      const proto2::DescriptorPool& descriptor_pool);
-```
 This method adds extension function definitions to the provided
 `CompilerBuilder`, for example:
 
 ```cpp
-absl::Status ConfigureCompiler(
-      cel::CompilerBuilder& compiler_builder,
-      const proto2::DescriptorPool& descriptor_pool) {
-    CEL_PYTHON_ASSIGN_OR_RETURN(
-        auto func_translate,
-        cel::MakeFunctionDecl("translate",
-            cel::MakeMemberOverloadDecl("translate_inst",
-                                /*return_type=*/cel::StringType(),
-                                /*target=*/cel::StringType(),
-                                /*from_lang=*/cel::StringType(),
-                                /*to_lang=*/cel::StringType())));
-    CEL_PYTHON_RETURN_IF_ERROR(
-        compiler_builder.GetCheckerBuilder().AddFunction(func_translate));
-    return absl::OkStatus();
-}
+  cel::CompilerLibrary GetCompilerLibrary() {
+    return cel::CompilerLibrary(
+        "translate-ext",
+        [](cel::TypeCheckerBuilder& checker_builder) -> absl::Status {
+          CEL_PYTHON_ASSIGN_OR_RETURN(
+              auto func_translate,
+              cel::MakeFunctionDecl(
+                  "translate",
+                  cel::MakeMemberOverloadDecl("translate_inst",
+                                              /*return_type=*/cel::StringType(),
+                                              /*target=*/cel::StringType(),
+                                              /*from_lang=*/cel::StringType(),
+                                              /*to_lang=*/cel::StringType())));
+          CEL_PYTHON_RETURN_IF_ERROR(
+              checker_builder.AddFunction(func_translate));
+          return absl::OkStatus();
+        });
+  }
 ```
 
 The other method registers the actual implementation

cel_expr_python/BUILD

@@ -63,6 +63,7 @@ pybind_extension(
         "@com_google_absl//absl/types:optional",
         "@com_google_absl//absl/types:span",
         "@com_google_cel_cpp//checker:type_checker_builder",
+        "@com_google_cel_cpp//checker:type_checker_builder_factory",
         "@com_google_cel_cpp//checker:validation_result",
         "@com_google_cel_cpp//common:ast",
         "@com_google_cel_cpp//common:ast_proto",
@@ -78,8 +79,13 @@ pybind_extension(
         "@com_google_cel_cpp//compiler",
         "@com_google_cel_cpp//env",
         "@com_google_cel_cpp//env:config",
+        "@com_google_cel_cpp//env:env_runtime",
+        "@com_google_cel_cpp//env:env_std_extensions",
         "@com_google_cel_cpp//env:env_yaml",
+        "@com_google_cel_cpp//env:runtime_std_extensions",
         "@com_google_cel_cpp//extensions/protobuf:runtime_adapter",
+        "@com_google_cel_cpp//parser",
+        "@com_google_cel_cpp//parser:options",
         "@com_google_cel_cpp//parser:parser_interface",
         "@com_google_cel_cpp//runtime",
         "@com_google_cel_cpp//runtime:activation",
@@ -88,7 +94,6 @@ pybind_extension(
         "@com_google_cel_cpp//runtime:reference_resolver",
         "@com_google_cel_cpp//runtime:runtime_builder",
         "@com_google_cel_cpp//runtime:runtime_options",
-        "@com_google_cel_cpp//runtime:standard_runtime_builder_factory",
         "@com_google_cel_spec//proto/cel/expr:checked_cc_proto",
         "@com_google_cel_spec//proto/cel/expr:syntax_cc_proto",
         "@com_google_protobuf//:protobuf",
@@ -135,6 +140,7 @@ py_test(
     srcs = ["cel_env_test.py"],
     deps = [
         ":cel",
+        "//cel_expr_python/ext:ext_math",
         "//testing:proto2_test_all_types_py_pb2",
         "@com_google_absl_py//absl/testing:absltest",
     ],

cel_expr_python/cel_env_test.py

@@ -18,8 +18,11 @@
 ability to be created from and serialized to YAML format.
 """
 
+import textwrap
+
 from absl.testing import absltest
 from cel_expr_python import cel
+from cel_expr_python.ext import ext_math
 from cel.expr.conformance.proto2 import test_all_types_pb2 as test_all_types_pb
 
 
@@ -91,6 +94,18 @@ def test_invalid_yaml(self):
         str(e.exception),
     )
 
+  def test_config_export_container(self):
+    env = cel.NewEnv(
+        container="test.container"
+    )
+    yaml = env.config().to_yaml()
+    self.assertEqual(
+        normalize_yaml(yaml),
+        normalize_yaml("""
+          container: "test.container"
+        """),
+    )
+
   def test_config_export_variables(self):
     config = cel.NewEnv(
         variables={
@@ -236,27 +251,78 @@ def test_config_variable_types(self):
     self.assertEqual(res.type(), cel.Type.INT)
     self.assertEqual(res.value(), 42)
 
+  def test_config_extensions(self):
+    config = cel.NewEnvConfigFromYaml("""
+      extensions:
+        - name: math
+        - name: strings
+      """)
+    env = cel.NewEnv(
+        config=config,
+        extensions=[TestCelExtension()],
+    )
+    yaml = env.config().to_yaml()
+    self.assertEqual(
+        normalize_yaml(yaml),
+        normalize_yaml("""
+          extensions:
+            - name: "math"
+            - name: "strings"
+            - name: "test_cel_extension"
+        """),
+    )
+    res = env.compile("'%.4f'.format([math.sqrt(2)])").eval()
+    self.assertEqual(res.value(), "1.4142")
+    res = env.compile("hello('World')").eval()
+    self.assertEqual(res.value(), "Hello, World!")
+
+  def test_config_extensions_override(self):
+    # TODO(b/498655870): add assertion based on extension aliases once
+    # supported.
+    config = cel.NewEnvConfigFromYaml("""
+      extensions:
+        - name: cel.lib.ext.math
+          version: 0
+        - name: cel.lib.ext.strings
+      """)
+    with self.assertRaises(Exception) as e:
+      cel.NewEnv(
+          config=config,
+          extensions=[ext_math.ExtMath()],
+      )
+    self.assertIn(
+        "Extension 'cel.lib.ext.math' version 0 is already included. Cannot"
+        " also include version 'latest'",
+        str(e.exception),
+    )
+
+
+class TestCelExtension(cel.CelExtension):
+  """An example CEL extension for testing."""
+
+  def __init__(self):
+    super().__init__(
+        "test_cel_extension",
+        functions=[
+            cel.FunctionDecl(
+                "hello",
+                [
+                    cel.Overload(
+                        "hello(string)",
+                        return_type=cel.Type.STRING,
+                        parameters=[
+                            cel.Type.STRING,
+                        ],
+                        impl=lambda arg: f"Hello, {arg}!",
+                    )
+                ],
+            ),
+        ],
+    )
+
 
 def normalize_yaml(yaml: str) -> str:
-  lines = yaml.split("\n")
-  indent = -1
-  unindented_lines = []
-  for line in lines:
-    pos = -1
-    for i, char in enumerate(line):
-      if char != " " and char != "\t":
-        pos = i
-        break
-    if pos == -1:
-      # Skip blank lines.
-      continue
-    if indent == -1:
-      indent = pos
-    if pos >= indent:
-      unindented_lines.append(line[indent:])
-    else:
-      unindented_lines.append(line)
-  return "\n".join(unindented_lines)
+  return textwrap.dedent(yaml).strip()
 
 
 if __name__ == "__main__":

cel_expr_python/cel_extension.h

@@ -24,7 +24,6 @@
 #include "compiler/compiler.h"
 #include "runtime/runtime_builder.h"
 #include "runtime/runtime_options.h"
-#include "google/protobuf/descriptor.h"
 
 #if defined(__cpp_exceptions) || defined(__EXCEPTIONS)
 // This include causes many issues if included in C++ environments that don't
@@ -42,10 +41,8 @@ class CelExtension {
   explicit CelExtension(std::string name) : name_(std::move(name)) {};
   virtual ~CelExtension() = default;
 
-  virtual absl::Status ConfigureCompiler(
-      cel::CompilerBuilder& compiler_builder,
-      const google::protobuf::DescriptorPool& descriptor_pool) {
-    return absl::OkStatus();
+  virtual cel::CompilerLibrary GetCompilerLibrary() {
+    return cel::CompilerLibrary(name_, nullptr, nullptr);
   }
 
   virtual absl::Status ConfigureRuntime(cel::RuntimeBuilder& runtime_builder,
@@ -76,11 +73,11 @@ class CelExtension {
 //
 //   CEL_EXTENSION_MODULE(sample_cel_ext, SampleCelExtension);
 //
-#define CEL_EXTENSION_MODULE(module_name, class_name)                        \
-  PYBIND11_MODULE(module_name, m) {                                          \
-    pybind11::module_::import(CEL_MODULE_NAME);                           \
+#define CEL_EXTENSION_MODULE(module_name, class_name)                      \
+  PYBIND11_MODULE(module_name, m) {                                        \
+    pybind11::module_::import(CEL_MODULE_NAME);                            \
     pybind11::class_<class_name, cel_python::CelExtension>(m, #class_name) \
-        .def(pybind11::init<>());                                            \
+        .def(pybind11::init<>());                                          \
   }
 
 }  // namespace cel_python

cel_expr_python/ext/ext_bindings.cc

@@ -12,23 +12,18 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "absl/status/status.h"
 #include "compiler/compiler.h"
 #include "extensions/bindings_ext.h"
 #include "cel_expr_python/cel_extension.h"
-#include "google/protobuf/descriptor.h"
 
 namespace cel_python {
 
 class ExtBindings : public CelExtension {
  public:
   explicit ExtBindings() : CelExtension("cel.lib.ext.cel.bindings") {}
 
-  absl::Status ConfigureCompiler(
-      cel::CompilerBuilder& compiler_builder,
-      const google::protobuf::DescriptorPool& descriptor_pool) override {
-    return compiler_builder.AddLibrary(
-        cel::extensions::BindingsCompilerLibrary());
+  cel::CompilerLibrary GetCompilerLibrary() override {
+    return cel::extensions::BindingsCompilerLibrary();
   }
 };
 

cel_expr_python/ext/ext_encoders.cc

@@ -13,25 +13,20 @@
 // limitations under the License.
 
 #include "absl/status/status.h"
-#include "checker/type_checker_builder.h"
 #include "compiler/compiler.h"
 #include "extensions/encoders.h"
 #include "runtime/runtime_builder.h"
 #include "runtime/runtime_options.h"
 #include "cel_expr_python/cel_extension.h"
-#include "google/protobuf/descriptor.h"
 
 namespace cel_python {
 
 class ExtEncoders : public CelExtension {
  public:
   explicit ExtEncoders() : CelExtension("cel.lib.ext.encoders") {}
 
-  absl::Status ConfigureCompiler(
-      cel::CompilerBuilder& compiler_builder,
-      const google::protobuf::DescriptorPool& descriptor_pool) override {
-    return compiler_builder.GetCheckerBuilder().AddLibrary(
-        cel::extensions::EncodersCheckerLibrary());
+  cel::CompilerLibrary GetCompilerLibrary() override {
+    return cel::extensions::EncodersCompilerLibrary();
   }
 
   absl::Status ConfigureRuntime(cel::RuntimeBuilder& runtime_builder,

cel_expr_python/ext/ext_math.cc

@@ -19,26 +19,21 @@
 #include "runtime/runtime_builder.h"
 #include "runtime/runtime_options.h"
 #include "cel_expr_python/cel_extension.h"
-#include "cel_expr_python/status_macros.h"
-#include "google/protobuf/descriptor.h"
 
 namespace cel_python {
 
 class ExtMath : public CelExtension {
  public:
   explicit ExtMath() : CelExtension("cel.lib.ext.math") {}
 
-  absl::Status ConfigureCompiler(
-      cel::CompilerBuilder& compiler_builder,
-      const google::protobuf::DescriptorPool& descriptor_pool) override {
-    return compiler_builder.AddLibrary(cel::extensions::MathCompilerLibrary());
+  cel::CompilerLibrary GetCompilerLibrary() override {
+    return cel::extensions::MathCompilerLibrary();
   }
 
   absl::Status ConfigureRuntime(cel::RuntimeBuilder& runtime_builder,
                                 const cel::RuntimeOptions& opts) override {
-    CEL_PYTHON_RETURN_IF_ERROR(cel::extensions::RegisterMathExtensionFunctions(
-        runtime_builder.function_registry(), opts));
-    return absl::OkStatus();
+    return cel::extensions::RegisterMathExtensionFunctions(
+        runtime_builder.function_registry(), opts);
   }
 };
 

cel_expr_python/ext/ext_optional.cc

@@ -19,18 +19,15 @@
 #include "runtime/runtime_builder.h"
 #include "runtime/runtime_options.h"
 #include "cel_expr_python/cel_extension.h"
-#include "google/protobuf/descriptor.h"
 
 namespace cel_python {
 
 class ExtOptional : public CelExtension {
  public:
-  explicit ExtOptional() : CelExtension("cel.lib.optional") {}
+  explicit ExtOptional() : CelExtension("optional") {}
 
-  absl::Status ConfigureCompiler(
-      cel::CompilerBuilder& compiler_builder,
-      const google::protobuf::DescriptorPool& descriptor_pool) override {
-    return compiler_builder.AddLibrary(cel::OptionalCompilerLibrary());
+  cel::CompilerLibrary GetCompilerLibrary() override {
+    return cel::OptionalCompilerLibrary();
   }
 
   absl::Status ConfigureRuntime(cel::RuntimeBuilder& runtime_builder,