const PyCelEnvConfig& env_config, PyObject* py_descriptor_pool,

std::vector<CelExtensionHandle> extension_handles,

absl::flat_hash_map<std::string, py::object>& function_impls)

: env_config_(env_config),

py_descriptor_database_(py_descriptor_pool),

descriptor_pool_(

std::make_shared<google::protobuf::DescriptorPool>(&py_descriptor_database_)),

message_factory_(descriptor_pool_.get()),

py_message_factory_(

std::make_shared<PyMessageFactory>(py_descriptor_pool)),

extensions_(std::move(extension_handles)),

function_impls_(std::move(function_impls)) {

cel_env_.SetDescriptorPool(descriptor_pool_);

cel_env_.SetConfig(env_config_.GetConfig());

cel::RegisterStandardExtensions(cel_env_);

cel_env_runtime_.SetDescriptorPool(descriptor_pool_);

cel_env_runtime_.SetConfig(env_config_.GetConfig());

cel::RegisterStandardExtensions(cel_env_runtime_);

for (CelExtensionHandle& extension_handle : extensions_) {

// This should never fail because we have already called GetExtension() once

// before calling this constructor.

CelExtension* extension = ThrowIfError(extension_handle.GetExtension());

cel_env_.RegisterCompilerLibrary(

extension->name(), extension->name(), 0,

[extension]() { return extension->GetCompilerLibrary(); });

cel_env_runtime_.RegisterExtensionFunctions(

extension->name(), extension->name(), 0,

[extension](

cel::RuntimeBuilder& runtime_builder,

const cel::RuntimeOptions& runtime_options) -> absl::Status {

return extension->ConfigureRuntime(runtime_builder, runtime_options);

});

}

const PyCelEnvConfig& env_config, PyObject* py_descriptor_pool,

const std::unordered_map<std::string, PyCelType>& variable_types,

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

for (const auto& [name, type] : variable_types) {

CEL_PYTHON_RETURN_IF_ERROR(

config.AddVariableConfig(cel::Config::VariableConfig{

.name = name,

.type_info = PyCelType::ToTypeInfo(type),

}));

}

std::vector<CelExtensionHandle> extension_handles;

extension_handles.reserve(extensions.size());

for (PyObject* ext : extensions) {

CelExtensionHandle handle(ext);

CEL_PYTHON_ASSIGN_OR_RETURN(CelExtension * extension,

handle.GetExtension());

std::string name;

if (!extension->alias().empty() &&

extension->alias() != extension->name()) {

// If the configuration lists the extension by name, use the name;

// otherwise, use the alias. This allows us to detect conflicting

// extension registrations, whether they are included by the extension

// name or alias.

name = extension->alias();

for (const cel::Config::ExtensionConfig& extension_config :

config.GetExtensionConfigs()) {

if (extension_config.name == extension->name()) {

name = extension_config.name;

break;

}

}

} else {

name = extension->name();

}

CEL_PYTHON_RETURN_IF_ERROR(config.AddExtensionConfig(

name, extension->version() >= 0

? extension->version()

: cel::Config::ExtensionConfig::kLatest));

extension_handles.push_back(std::move(handle));

}

cel::Config::ContainerConfig container_config = config.GetContainerConfig();

if (!container.container().empty()) {

container_config.name = std::string(container.container());

}

for (const auto& abbr : container.ListAbbreviations()) {

bool found = false;

for (const auto& existing : container_config.abbreviations) {

if (existing == abbr) {

found = true;

break;

}

}

if (!found) {

container_config.abbreviations.push_back(abbr);

}

}

for (const auto& alias_listing : container.ListAliases()) {

if (alias_listing.IsAbbreviation()) {

continue;

}

bool found = false;

for (const auto& existing : container_config.aliases) {

if (existing.alias == alias_listing.alias) {

if (existing.qualified_name != alias_listing.name) {

return absl::InvalidArgumentError(absl::StrCat(

"Alias '", alias_listing.alias,

"' is already defined with a different qualified name: ",

existing.qualified_name));

}

found = true;

break;

}

}

if (!found) {

container_config.aliases.push_back(

{.alias = alias_listing.alias, .qualified_name = alias_listing.name});

}

}

config.SetContainerConfig(container_config);

absl::flat_hash_map<std::string, py::object> impls;

for (const std::shared_ptr<PyCelFunctionDecl>& function : functions) {

CEL_PYTHON_RETURN_IF_ERROR(

config.AddFunctionConfig(function->ToFunctionConfig()));

for (const PyCelOverload& overload : function->overloads()) {

if (overload.py_function().is_none()) {

continue;

}

if (!impls.insert({overload.overload_id(), overload.py_function()})

.second) {

return absl::AlreadyExistsError(

absl::StrCat("An implementation for function overload id '",

overload.overload_id(), "' already exists."));

}

}

}

for (const auto& [overload_id, py_function] : function_impls) {

if (!impls.insert({overload_id, py_function}).second) {

return absl::AlreadyExistsError(

absl::StrCat("An implementation for function overload id '",

overload_id, "' already exists."));

}

}

return std::shared_ptr<PyCelEnvInternal>(

new PyCelEnvInternal(PyCelEnvConfig(config), py_descriptor_pool,

std::move(extension_handles), impls));

const std::shared_ptr<PyCelEnvInternal>& env) {

ABSL_CHECK(PyGILState_Check());

if (env->compiler_) {

return env->compiler_.get();

}

const cel::Config& config = env->env_config_.GetConfig();

CEL_PYTHON_ASSIGN_OR_RETURN(

std::unique_ptr<cel::CompilerBuilder> compiler_builder,

env->cel_env_.NewCompilerBuilder());

cel::TypeCheckerBuilder& checker_builder =

compiler_builder->GetCheckerBuilder();

cel::ExpressionContainer container;

const auto& container_config = config.GetContainerConfig();

if (!container_config.IsEmpty()) {

CEL_PYTHON_RETURN_IF_ERROR(container.SetContainer(container_config.name));

for (const auto& abbr : container_config.abbreviations) {

CEL_PYTHON_RETURN_IF_ERROR(container.AddAbbreviation(abbr));

}

for (const auto& alias : container_config.aliases) {

CEL_PYTHON_RETURN_IF_ERROR(

container.AddAlias(alias.alias, alias.qualified_name));

}

}

checker_builder.SetExpressionContainer(std::move(container));

// Convert variable types from cel::TypeInfo to PyCelType.

google::protobuf::Arena* arena = checker_builder.arena();

for (const cel::Config::VariableConfig& variable_config :

config.GetVariableConfigs()) {

CEL_PYTHON_ASSIGN_OR_RETURN(

cel::Type cel_type,

cel::TypeInfoToType(variable_config.type_info,

env->descriptor_pool_.get(), arena));

PyCelType py_cel_type = PyCelType::FromCelType(cel_type);

env->variable_types_[variable_config.name] = py_cel_type;

}

CEL_PYTHON_ASSIGN_OR_RETURN(env->compiler_, compiler_builder->Build());

return env->compiler_.get();

const std::shared_ptr<PyCelEnvInternal>& env, RuntimeMode runtime_mode) {

if (auto it = env->runtimes_.find(runtime_mode); it != env->runtimes_.end()) {

return it->second.get();

}

cel::RuntimeOptions& opts = env->cel_env_runtime_.mutable_runtime_options();

opts.container = env->GetEnvConfig().GetConfig().GetContainerConfig().name;

opts.enable_empty_wrapper_null_unboxing = true;

opts.enable_qualified_type_identifiers = true;

opts.enable_timestamp_duration_overflow_errors = true;

switch (runtime_mode) {

case kStandard:

break;

case kStandardIgnoreWarnings:

opts.fail_on_warnings = false;

break;

}

CEL_PYTHON_ASSIGN_OR_RETURN(cel::RuntimeBuilder builder,

env->cel_env_runtime_.CreateRuntimeBuilder());

CEL_PYTHON_RETURN_IF_ERROR(cel::EnableReferenceResolver(

builder, cel::ReferenceResolverEnabled::kAlways));

for (const cel::Config::FunctionConfig& function_config :

env->GetEnvConfig().GetConfig().GetFunctionConfigs()) {

for (const cel::Config::FunctionOverloadConfig& overload_config :

function_config.overload_configs) {

auto it = env->function_impls_.find(overload_config.overload_id);

if (it == env->function_impls_.end()) {

continue;

}

py::object py_function = it->second;

std::vector<cel::Kind> param_kinds;

param_kinds.reserve(overload_config.parameters.size());

for (const cel::Config::TypeInfo& parameter :

overload_config.parameters) {

CEL_PYTHON_ASSIGN_OR_RETURN(

cel::Type type,

cel::TypeInfoToType(parameter, env->descriptor_pool_.get(),

&env->arena_));

param_kinds.push_back(static_cast<cel::Kind>(type.kind()));

}

cel::FunctionDescriptor descriptor(

function_config.name, overload_config.is_member_function, param_kinds,

kFunctionDescriptorOptions);

CEL_PYTHON_ASSIGN_OR_RETURN(

cel::Type return_type,

cel::TypeInfoToType(overload_config.return_type,

env->descriptor_pool_.get(), &env->arena_));

CEL_PYTHON_RETURN_IF_ERROR(builder.function_registry().Register(

descriptor, std::make_unique<PyCelFunctionAdapter>(

function_config.name,

PyCelType::FromCelType(return_type), py_function)));

}

}

CEL_PYTHON_ASSIGN_OR_RETURN(std::unique_ptr<cel::Runtime> runtime,

std::move(builder).Build());

const cel::Runtime* runtime_ptr = runtime.get();

env->runtimes_[runtime_mode] = std::move(runtime);

return runtime_ptr;

: py_extension_(extension), cel_extension_(nullptr) {

ABSL_CHECK(PyGILState_Check());

Py_INCREF(py_extension_);

: py_extension_(other.py_extension_), cel_extension_(other.cel_extension_) {

other.py_extension_ = nullptr;

other.cel_extension_ = nullptr;

if (cel_extension_) {

return cel_extension_;

}

if (Py_IsNone(py_extension_)) {

return absl::InvalidArgumentError("Provided extension is None");

}

// First, check if the object is a CelExtension (extension implemented in

// Python)

absl::Status status_py_cel_extension;

try {

pybind11::handle handle = pybind11::handle(py_extension_);

return handle.cast<PyCelPythonExtension*>();

} catch (const pybind11::cast_error& e) {

status_py_cel_extension = absl::InvalidArgumentError(e.what());

}

// If that fails, check if the object is a pybind11 wrapper for

// CelExtension.

absl::Status status_cc_cel_extension;

try {

pybind11::handle handle = pybind11::handle(py_extension_);

return handle.cast<CelExtension*>();

} catch (const pybind11::cast_error& e) {

status_cc_cel_extension = absl::InvalidArgumentError(e.what());

}

PyTypeObject* py_type = Py_TYPE(py_extension_);

return absl::InternalError(absl::StrCat(

"Failed to cast ", py_type ? py_type->tp_name : "unknown",

" either as a Python CelExtension instance (",

status_py_cel_extension.ToString(), ") or as a pybind11 wrapper (",

status_cc_cel_extension.ToString(), ")"));