Rewrote the Windows presubmit script from .ps1 to .bat to fix execution issues on Kokoro Windows executors where .ps1 files could not be executed directly. Updated the build config to point to the new batch file.

PiperOrigin-RevId: 915470198

Author: dmitriplotnikov

MODULE.bazel

@@ -13,13 +13,14 @@ bazel_dep(name = "bazel_skylib", version = "1.8.2")
 
 # https://registry.bazel.build/modules/cel-cpp
 bazel_dep(name = "cel-cpp", version = "0.15.0", repo_name = "com_google_cel_cpp")
-single_version_override(
+git_override(
     module_name = "cel-cpp",
+    commit = "2e6e9ff4493bfbe0baf883107f3fb7ce6f675d88",
     patch_cmds = [
         # ABSL_CONST_INIT is incompatible with MSVC-CL with the /std:c++20 option
         "sed -i 's/ABSL_CONST_INIT //g' common/values/optional_value.cc",
     ],
-    version = "0.15.0",
+    remote = "https://github.com/google/cel-cpp",
 )
 
 # https://registry.bazel.build/modules/cel-spec

README.md

@@ -26,9 +26,27 @@ The `cel.NewEnv` constructor also accepts the following optional parameters:
 *   `pool` (`descriptor_pool.DescriptorPool`): The descriptor pool used for
     resolving protobuf message types within CEL expressions. If not provided,
     a default pool (`descriptor_pool.Default()`) is used.
-*   `container` (str): The container name used for name resolution. For example,
+*   `container` (`str` or `cel.ExpressionContainer`): The container name used
+    for name resolution. For example,
     if `container` is `"foo.bar"`, then `Baz` will resolve to
     `foo.bar.Baz`.
+
+    You can also pass a `cel.ExpressionContainer` to configure abbreviations
+    and aliases:
+
+    ```python
+    container = cel.ExpressionContainer(
+        name="foo.bar",
+        abbreviations=["foo.bar.baz"],
+        aliases={"my_alias": "full.name.of.something"}
+    )
+    cel_env = cel.NewEnv(container=container)
+    ```
+
+    *   `abbreviations`: A list of fully qualified names that can be referred
+        to by their last component.
+    *   `aliases`: A dictionary mapping an alias name to a fully qualified
+        name.
 *   `extensions` (list): A list of extension objects to load. This can include
     standard extensions (like `math` or `string` libraries) or custom extensions
     defined in Python or C++.

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",

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: ...

cel_expr_python/cel_env_test.py

@@ -108,6 +108,147 @@ def test_config_export_container(self):
         """),
     )
 
+  def test_expression_container_abbreviations_and_aliases(self):
+    expr_container = cel.ExpressionContainer(
+        "test.container", abbreviations=["x.y.foo"], aliases={"abc": "x.y.bar"}
+    )
+
+    env: cel.Env = cel.NewEnv(
+        container=expr_container,
+        variables={
+            "x.y.foo": cel.Type.INT,
+            "x.y.bar": cel.Type.STRING,
+        },
+    )
+
+    res = env.compile("foo").eval(data={"x.y.foo": 42})
+    self.assertEqual(res.value(), 42)
+    res = env.compile("abc").eval(data={"x.y.bar": "chocolate"})
+    self.assertEqual(res.value(), "chocolate")
+
+    yaml: str = env.config().to_yaml()
+    self.assertEqual(
+        normalize_yaml(yaml),
+        normalize_yaml("""
+          container:
+            name: "test.container"
+            abbreviations:
+              - "x.y.foo"
+            aliases:
+              - alias: "abc"
+                qualified_name: "x.y.bar"
+          variables:
+            - name: "x.y.bar"
+              type_name: "string"
+            - name: "x.y.foo"
+              type_name: "int"
+        """),
+    )
+
+  def test_abbreviations_and_aliases_from_yaml(self):
+    env: cel.Env = cel.NewEnv(config=cel.NewEnvConfigFromYaml("""
+        container:
+          name: "test.container"
+          abbreviations:
+            - "x.y.foo"
+          aliases:
+            - alias: "abc"
+              qualified_name: "x.y.bar"
+        variables:
+          - name: "x.y.bar"
+            type_name: "string"
+          - name: "x.y.foo"
+            type_name: "int"
+      """))
+
+    res = env.compile("foo").eval(data={"x.y.foo": 42})
+    self.assertEqual(res.value(), 42)
+    res = env.compile("abc").eval(data={"x.y.bar": "chocolate"})
+    self.assertEqual(res.value(), "chocolate")
+
+  def test_abbreviations_and_aliases_combined(self):
+    env: cel.Env = cel.NewEnv(
+        config=cel.NewEnvConfigFromYaml("""
+          container:
+            name: "test.container"
+            abbreviations:
+              - "x.y.foo"
+            aliases:
+              - alias: "abc"
+                qualified_name: "x.y.bar"
+          variables:
+            - name: "x.y.bar"
+              type_name: "string"
+            - name: "x.y.foo"
+              type_name: "int"
+            - name: "a.b.qux"
+              type_name: "string"
+            - name: "a.b.baz"
+              type_name: "int"
+        """),
+        container=cel.ExpressionContainer(
+            "test.container",
+            abbreviations=["a.b.baz"],
+            aliases={"def": "a.b.qux"},
+        ),
+    )
+
+    res = env.compile("foo").eval(data={"x.y.foo": 42})
+    self.assertEqual(res.value(), 42)
+    res = env.compile("baz").eval(data={"a.b.baz": 24})
+    self.assertEqual(res.value(), 24)
+
+    res = env.compile("abc").eval(data={"x.y.bar": "chocolate"})
+    self.assertEqual(res.value(), "chocolate")
+    res = env.compile("def").eval(data={"a.b.qux": "vanilla"})
+    self.assertEqual(res.value(), "vanilla")
+
+    yaml: str = env.config().to_yaml()
+    self.assertEqual(
+        normalize_yaml(yaml),
+        normalize_yaml("""
+          container:
+            name: "test.container"
+            abbreviations:
+              - "a.b.baz"
+              - "x.y.foo"
+            aliases:
+              - alias: "abc"
+                qualified_name: "x.y.bar"
+              - alias: "def"
+                qualified_name: "a.b.qux"
+          variables:
+            - name: "a.b.baz"
+              type_name: "int"
+            - name: "a.b.qux"
+              type_name: "string"
+            - name: "x.y.bar"
+              type_name: "string"
+            - name: "x.y.foo"
+              type_name: "int"
+        """),
+    )
+
+  def test_alias_redefinition_error(self):
+    with self.assertRaises(Exception) as e:
+      cel.NewEnv(
+          container=cel.ExpressionContainer(
+              "test.container", aliases={"abc": "x.y.bar"}
+          ),
+          config=cel.NewEnvConfigFromYaml("""
+            container:
+              name: "test.container"
+              aliases:
+                - alias: "abc"
+                  qualified_name: "x.y.baz"
+          """),
+      )
+    self.assertIn(
+        "Alias 'abc' is already defined with a different qualified name:"
+        " x.y.baz",
+        str(e.exception),
+    )
+
   def test_config_export_variables(self):
     config: cel.Env = cel.NewEnv(
         variables={

cel_expr_python/py_cel_env.cc

@@ -25,7 +25,7 @@
 #include <vector>
 
 #include "absl/log/absl_check.h"
-#include "env/config.h"
+#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"
@@ -42,13 +42,42 @@ 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) {
+                     ThrowIfError(container.AddAbbreviation(abrev));
+                   }
+                 }
+
+                 if (aliases) {
+                   for (const auto& [alias, full_name] : *aliases) {
+                     ThrowIfError(container.AddAlias(alias, full_name));
+                   }
+                 }
+
+                 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 +106,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 +167,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(

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);