Support passing cel.ExpressionContainer to cel.NewEnv to allow specifying aliases and abbreviations for namespace resolution.

dmitriplotnikov · copybara-github · commit 0b56b4714a21 · 2026-05-13T10:53:22.000-07:00
PiperOrigin-RevId: 912692728
diff --git a/cel_expr_python/BUILD b/cel_expr_python/BUILD
@@ -66,10 +66,10 @@ 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",
+        "@com_google_cel_cpp//common:container",
         "@com_google_cel_cpp//common:decl",
         "@com_google_cel_cpp//common:function_descriptor",
         "@com_google_cel_cpp//common:kind",
@@ -87,8 +87,6 @@ pybind_extension(
         "@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",
diff --git a/cel_expr_python/cel.pyi b/cel_expr_python/cel.pyi
@@ -15,6 +15,10 @@ class CelExtensionBase:
 class EnvConfig:
   def to_yaml(self) -> str: ...
 
+class ExpressionContainer:
+  def __init__(self, name: str = ..., abbreviations: Sequence[str] | None = ..., aliases: Mapping[str, str] | None = ...) -> None: ...
+  def container(self) -> str: ...
+
 class Env:
   def Activation(self, data: Mapping[str, Any] | None = ..., functions: Sequence[Function] | None = ..., arena: _InternalArena = ...) -> Activation: ...
   def compile(self, expression: str, disable_check: bool = ...) -> Expression: ...
@@ -80,6 +84,6 @@ class _InternalArena:
 
 def Arena() -> _InternalArena: ...
 
-def NewEnv(descriptor_pool: proto_descriptor_pool.DescriptorPool | Any | None = ..., config: EnvConfig | None = ..., variables: Mapping[str, Type] | None = ..., extensions: Sequence[CelExtensionBase] | None = ..., container: str | None = ..., functions: Sequence[FunctionDecl] | None = ..., function_impls: Mapping[str, Callable[..., Any]] | None = ...) -> Env: ...
+def NewEnv(descriptor_pool: proto_descriptor_pool.DescriptorPool | Any | None = ..., config: EnvConfig | None = ..., variables: Mapping[str, Type] | None = ..., extensions: Sequence[CelExtensionBase] | None = ..., container: str | ExpressionContainer | None = ..., functions: Sequence[FunctionDecl] | None = ..., function_impls: Mapping[str, Callable[..., Any]] | None = ...) -> Env: ...
 
 def NewEnvConfigFromYaml(yaml: str) -> EnvConfig: ...
diff --git a/cel_expr_python/cel_env_test.py b/cel_expr_python/cel_env_test.py
@@ -108,6 +108,45 @@ def test_config_export_container(self):
         """),
     )
 
+  def test_expression_container_abbreviation(self):
+    expr_container = cel.ExpressionContainer(
+        "test.container", abbreviations=["x.y.foo"]
+    )
+
+    env: cel.Env = cel.NewEnv(
+        container=expr_container,
+        variables={
+            "x.y.foo": cel.Type.INT,
+        },
+    )
+
+    res = env.compile("foo").eval(data={"x.y.foo": 42})
+    self.assertEqual(res.value(), 42)
+    yaml: str = env.config().to_yaml()
+    self.assertEqual(
+        normalize_yaml(yaml),
+        normalize_yaml("""
+          container:
+            abbreviations:
+              - "x.y.foo"
+        """),
+    )
+
+  def test_expression_container_alias(self):
+    expr_container = cel.ExpressionContainer(
+        "test.container", aliases={"abc": "x.y.bar"}
+    )
+
+    env: cel.Env = cel.NewEnv(
+        container=expr_container,
+        variables={
+            "x.y.bar": cel.Type.INT,
+        },
+    )
+
+    res = env.compile("abc").eval(data={"x.y.bar": 42})
+    self.assertEqual(res.value(), 42)
+
   def test_config_export_variables(self):
     config: cel.Env = cel.NewEnv(
         variables={
diff --git a/cel_expr_python/py_cel_env.cc b/cel_expr_python/py_cel_env.cc
@@ -25,6 +25,7 @@
 #include <vector>
 
 #include "absl/log/absl_check.h"
+#include "common/container.h"
 #include "env/config.h"
 #include "cel_expr_python/py_cel_activation.h"
 #include "cel_expr_python/py_cel_arena.h"
@@ -42,13 +43,48 @@ namespace cel_python {
 namespace py = ::pybind11;
 
 void PyCelEnv::DefinePythonBindings(pybind11::module& m) {
+  py::class_<cel::ExpressionContainer>(m, "ExpressionContainer")
+      .def(py::init(
+               [](const std::string& name,
+                  const std::optional<std::vector<std::string>>& abbreviations,
+                  const std::optional<
+                      std::unordered_map<std::string, std::string>>& aliases) {
+                 auto container =
+                     ThrowIfError(cel::MakeExpressionContainer(name));
+
+                 if (abbreviations) {
+                   for (const auto& abrev : *abbreviations) {
+                     auto status = container.AddAbbreviation(abrev);
+                     if (!status.ok()) {
+                       throw StatusToException(status);
+                     }
+                   }
+                 }
+
+                 if (aliases) {
+                   for (const auto& [alias, full_name] : *aliases) {
+                     auto status = container.AddAlias(alias, full_name);
+                     if (!status.ok()) {
+                       throw StatusToException(status);
+                     }
+                   }
+                 }
+
+                 return container;
+               }),
+           py::arg("name") = "", py::arg("abbreviations") = py::none(),
+           py::arg("aliases") = py::none())
+      .def("container", [](const cel::ExpressionContainer& self) {
+        return std::string(self.container());
+      });
+
   py::class_<PyCelEnv, std::shared_ptr<PyCelEnv>> cel_class(m, "Env");
   m.def(
       "NewEnv",
       [](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,
+         py::object container,
          std::optional<std::vector<std::shared_ptr<PyCelFunctionDecl>>>&
              functions,
          std::optional<std::unordered_map<std::string, py::object>>&
@@ -77,10 +113,23 @@ void PyCelEnv::DefinePythonBindings(pybind11::module& m) {
           }
         }
 
+        cel::ExpressionContainer expr_container;
+        if (!container.is_none()) {
+          if (py::isinstance<py::str>(container)) {
+            expr_container = ThrowIfError(
+                cel::MakeExpressionContainer(container.cast<std::string>()));
+          } else if (py::isinstance<cel::ExpressionContainer>(container)) {
+            expr_container = container.cast<cel::ExpressionContainer>();
+          } else {
+            throw py::type_error(
+                "container must be a string or ExpressionContainer");
+          }
+        }
+
         return PyCelEnv(config.value_or(PyCelEnvConfig()), pool_ptr,
                         std::move(variables).value_or(
                             std::unordered_map<std::string, PyCelType>{}),
-                        ext_ptrs, container.value_or(""),
+                        ext_ptrs, std::move(expr_container),
                         functions.value_or(
                             std::vector<std::shared_ptr<PyCelFunctionDecl>>{}),
                         function_impls.value_or(
@@ -125,7 +174,8 @@ void PyCelEnv::DefinePythonBindings(pybind11::module& m) {
 PyCelEnv::PyCelEnv(
     const PyCelEnvConfig& config, PyObject* descriptor_pool,
     const std::unordered_map<std::string, PyCelType>& variable_types,
-    const std::vector<PyObject*>& extensions, const std::string& container,
+    const std::vector<PyObject*>& extensions,
+    cel::ExpressionContainer container,
     const std::vector<std::shared_ptr<PyCelFunctionDecl>>& functions,
     const std::unordered_map<std::string, py::object>& function_impls) {
   env_ = ThrowIfError(PyCelEnvInternal::NewCelEnvInternal(
diff --git a/cel_expr_python/py_cel_env.h b/cel_expr_python/py_cel_env.h
@@ -23,6 +23,7 @@
 #include <unordered_map>
 #include <vector>
 
+#include "common/container.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"
@@ -70,7 +71,7 @@ class PyCelEnv {
   PyCelEnv(const PyCelEnvConfig& config, PyObject* descriptor_pool,
            const std::unordered_map<std::string, PyCelType>& variable_types,
            const std::vector<PyObject*>& extensions,
-           const std::string& container,
+           cel::ExpressionContainer container,
            const std::vector<std::shared_ptr<PyCelFunctionDecl>>& functions,
            const std::unordered_map<std::string, py::object>& function_impls);
 
diff --git a/cel_expr_python/py_cel_env_internal.cc b/cel_expr_python/py_cel_env_internal.cc
@@ -26,6 +26,7 @@
 #include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "checker/type_checker_builder.h"
+#include "common/container.h"
 #include "common/function_descriptor.h"
 #include "common/kind.h"
 #include "common/type.h"
@@ -67,8 +68,10 @@ static const cel::FunctionDescriptorOptions kFunctionDescriptorOptions = {
 PyCelEnvInternal::PyCelEnvInternal(
     const PyCelEnvConfig& env_config, PyObject* py_descriptor_pool,
     std::vector<CelExtensionHandle> extension_handles,
-    absl::flat_hash_map<std::string, py::object>& function_impls)
+    absl::flat_hash_map<std::string, py::object>& function_impls,
+    cel::ExpressionContainer container)
     : env_config_(env_config),
+      container_(std::move(container)),
       py_descriptor_database_(py_descriptor_pool),
       descriptor_pool_(
           std::make_shared<google::protobuf::DescriptorPool>(&py_descriptor_database_)),
@@ -106,7 +109,8 @@ absl::StatusOr<std::shared_ptr<PyCelEnvInternal>>
 PyCelEnvInternal::NewCelEnvInternal(
     const PyCelEnvConfig& env_config, PyObject* py_descriptor_pool,
     const std::unordered_map<std::string, PyCelType>& variable_types,
-    const std::vector<PyObject*>& extensions, const std::string& container,
+    const std::vector<PyObject*>& extensions,
+    cel::ExpressionContainer container,
     const std::vector<std::shared_ptr<PyCelFunctionDecl>>& functions,
     const std::unordered_map<std::string, py::object>& function_impls) {
   cel::Config config = env_config.GetConfig();
@@ -151,7 +155,8 @@ PyCelEnvInternal::NewCelEnvInternal(
     extension_handles.push_back(std::move(handle));
   }
 
-  config.SetContainerConfig(cel::Config::ContainerConfig{.name = container});
+  config.SetContainerConfig(
+      cel::Config::ContainerConfig{.name = std::string(container.container())});
 
   absl::flat_hash_map<std::string, py::object> impls;
   for (const std::shared_ptr<PyCelFunctionDecl>& function : functions) {
@@ -178,9 +183,9 @@ PyCelEnvInternal::NewCelEnvInternal(
                        overload_id, "' already exists."));
     }
   }
-  return std::shared_ptr<PyCelEnvInternal>(
-      new PyCelEnvInternal(PyCelEnvConfig(config), py_descriptor_pool,
-                           std::move(extension_handles), impls));
+  return std::shared_ptr<PyCelEnvInternal>(new PyCelEnvInternal(
+      PyCelEnvConfig(config), py_descriptor_pool, std::move(extension_handles),
+      impls, std::move(container)));
 }
 
 absl::StatusOr<const cel::Compiler*> PyCelEnvInternal::GetCompiler(
@@ -200,7 +205,7 @@ absl::StatusOr<const cel::Compiler*> PyCelEnvInternal::GetCompiler(
   cel::TypeCheckerBuilder& checker_builder =
       compiler_builder->GetCheckerBuilder();
 
-  checker_builder.set_container(config.GetContainerConfig().name);
+  checker_builder.SetExpressionContainer(env->container_);
 
   // Convert variable types from cel::TypeInfo to PyCelType.
   google::protobuf::Arena* arena = checker_builder.arena();
diff --git a/cel_expr_python/py_cel_env_internal.h b/cel_expr_python/py_cel_env_internal.h
@@ -26,6 +26,7 @@
 #include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "common/container.h"
 #include "common/function_descriptor.h"
 #include "compiler/compiler.h"
 #include "env/env.h"
@@ -76,7 +77,8 @@ class PyCelEnvInternal {
   static absl::StatusOr<std::shared_ptr<PyCelEnvInternal>> NewCelEnvInternal(
       const PyCelEnvConfig& env_config, PyObject* py_descriptor_pool,
       const std::unordered_map<std::string, PyCelType>& variable_types,
-      const std::vector<PyObject*>& extensions, const std::string& container,
+      const std::vector<PyObject*>& extensions,
+      cel::ExpressionContainer container,
       const std::vector<std::shared_ptr<PyCelFunctionDecl>>& functions,
       const std::unordered_map<std::string, py::object>& function_impls);
 
@@ -112,10 +114,11 @@ class PyCelEnvInternal {
 
  private:
   // Use NewCelEnvInternal() to create an instance.
-  PyCelEnvInternal(
-      const PyCelEnvConfig& env_config, PyObject* py_descriptor_pool,
-      std::vector<CelExtensionHandle> extensions,
-      absl::flat_hash_map<std::string, py::object>& function_impls);
+  PyCelEnvInternal(const PyCelEnvConfig& env_config,
+                   PyObject* py_descriptor_pool,
+                   std::vector<CelExtensionHandle> extensions,
+                   absl::flat_hash_map<std::string, py::object>& function_impls,
+                   cel::ExpressionContainer container);
 
   absl::Status ConfigureStandardExtension(
       cel::CompilerBuilder& compiler_builder, const std::string& extension);
@@ -128,6 +131,7 @@ class PyCelEnvInternal {
   cel::Env cel_env_;
   cel::EnvRuntime cel_env_runtime_;
   PyCelEnvConfig env_config_;
+  cel::ExpressionContainer container_;
   PyDescriptorDatabase py_descriptor_database_;
   std::shared_ptr<google::protobuf::DescriptorPool> descriptor_pool_;
   google::protobuf::DynamicMessageFactory message_factory_;
