diff --git a/README.md b/README.md index 830c90b..a4cb662 100644 --- a/README.md +++ b/README.md @@ -252,7 +252,7 @@ This method adds extension function definitions to the provided absl::Status ConfigureCompiler( cel::CompilerBuilder& compiler_builder, const proto2::DescriptorPool& descriptor_pool) { - PY_CEL_ASSIGN_OR_RETURN( + CEL_PYTHON_ASSIGN_OR_RETURN( auto func_translate, cel::MakeFunctionDecl("translate", cel::MakeMemberOverloadDecl("translate_inst", @@ -260,7 +260,7 @@ absl::Status ConfigureCompiler( /*target=*/cel::StringType(), /*from_lang=*/cel::StringType(), /*to_lang=*/cel::StringType()))); - PY_CEL_RETURN_IF_ERROR( + CEL_PYTHON_RETURN_IF_ERROR( compiler_builder.GetCheckerBuilder().AddFunction(func_translate)); return absl::OkStatus(); } @@ -292,7 +292,7 @@ absl::Status ConfigureRuntime(cel::RuntimeBuilder& runtime_builder, const StringValue&>; auto status = TranslateFunctionAdapter::RegisterMemberOverload( "translate", &Translate, runtime_builder.function_registry()); - PY_CEL_RETURN_IF_ERROR(status); + CEL_PYTHON_RETURN_IF_ERROR(status); return absl::OkStatus(); } ``` @@ -368,7 +368,7 @@ If the extension is written in C++, use the `RegisterLazyFunction` function: using MyFunctionAdapter = cel::UnaryFunctionAdapter, const cel::IntValue&>; - PY_CEL_RETURN_IF_ERROR( + CEL_PYTHON_RETURN_IF_ERROR( runtime_builder.function_registry().RegisterLazyFunction( MyFunctionAdapter::CreateDescriptor( "my_func", diff --git a/custom_ext/sample_cel_ext.cc b/custom_ext/sample_cel_ext.cc index efc435b..cba0d2b 100644 --- a/custom_ext/sample_cel_ext.cc +++ b/custom_ext/sample_cel_ext.cc @@ -71,7 +71,7 @@ class SampleCelExtension : public cel_python::CelExtension { absl::Status ConfigureCompiler( cel::CompilerBuilder& compiler_builder, const google::protobuf::DescriptorPool& descriptor_pool) override { - PY_CEL_ASSIGN_OR_RETURN( + CEL_PYTHON_ASSIGN_OR_RETURN( auto func_translate, MakeFunctionDecl("translate", MakeMemberOverloadDecl("translate_inst", @@ -79,16 +79,16 @@ class SampleCelExtension : public cel_python::CelExtension { /*target=*/StringType(), /*from_lang=*/StringType(), /*to_lang=*/StringType()))); - PY_CEL_RETURN_IF_ERROR( + CEL_PYTHON_RETURN_IF_ERROR( compiler_builder.GetCheckerBuilder().AddFunction(func_translate)); - PY_CEL_ASSIGN_OR_RETURN( + CEL_PYTHON_ASSIGN_OR_RETURN( auto func_translate_late, MakeFunctionDecl("translate_late", MakeOverloadDecl("late_bound_translation", /*return_type=*/StringType(), /*text=*/StringType()))); - PY_CEL_RETURN_IF_ERROR( + CEL_PYTHON_RETURN_IF_ERROR( compiler_builder.GetCheckerBuilder().AddFunction(func_translate_late)); return absl::OkStatus(); } @@ -101,13 +101,13 @@ class SampleCelExtension : public cel_python::CelExtension { const StringValue&>; auto status = TranslateFunctionAdapter::RegisterMemberOverload( "translate", &Translate, runtime_builder.function_registry()); - PY_CEL_RETURN_IF_ERROR(status); + CEL_PYTHON_RETURN_IF_ERROR(status); // Register a lazy function that will be bound at evaluation time. using TranslateLateFunctionAdapter = ::cel::UnaryFunctionAdapter, const StringValue&>; - PY_CEL_RETURN_IF_ERROR( + CEL_PYTHON_RETURN_IF_ERROR( runtime_builder.function_registry().RegisterLazyFunction( TranslateLateFunctionAdapter::CreateDescriptor( "translate_late", diff --git a/py_cel/ext/ext_math.cc b/py_cel/ext/ext_math.cc index 6d61be2..224d2e1 100644 --- a/py_cel/ext/ext_math.cc +++ b/py_cel/ext/ext_math.cc @@ -36,7 +36,7 @@ class ExtMath : public CelExtension { absl::Status ConfigureRuntime(cel::RuntimeBuilder& runtime_builder, const cel::RuntimeOptions& opts) override { - PY_CEL_RETURN_IF_ERROR(cel::extensions::RegisterMathExtensionFunctions( + CEL_PYTHON_RETURN_IF_ERROR(cel::extensions::RegisterMathExtensionFunctions( runtime_builder.function_registry(), opts)); return absl::OkStatus(); } diff --git a/py_cel/py_cel_env_internal.cc b/py_cel/py_cel_env_internal.cc index 1c2580c..ce25cab 100644 --- a/py_cel/py_cel_env_internal.cc +++ b/py_cel/py_cel_env_internal.cc @@ -70,31 +70,31 @@ absl::StatusOr PyCelEnvInternal::GetCompiler( cel::CompilerOptions compiler_options; compiler_options.parser_options.enable_quoted_identifiers = true; - PY_CEL_ASSIGN_OR_RETURN( + CEL_PYTHON_ASSIGN_OR_RETURN( std::unique_ptr compiler_builder, cel::NewCompilerBuilder(&env->descriptor_pool_, compiler_options)); compiler_builder->GetCheckerBuilder().set_container(env->container_); - PY_CEL_RETURN_IF_ERROR( + CEL_PYTHON_RETURN_IF_ERROR( compiler_builder->AddLibrary(cel::StandardCompilerLibrary())); for (std::unique_ptr& extension_handle : env->extensions_) { - PY_CEL_ASSIGN_OR_RETURN(CelExtension * extension, - extension_handle->GetExtension(env)); - PY_CEL_RETURN_IF_ERROR( + CEL_PYTHON_ASSIGN_OR_RETURN(CelExtension * extension, + extension_handle->GetExtension(env)); + CEL_PYTHON_RETURN_IF_ERROR( extension->ConfigureCompiler(*compiler_builder, env->descriptor_pool_)); } google::protobuf::Arena* arena = compiler_builder->GetCheckerBuilder().arena(); for (const auto& [name, type] : env->variable_types_) { - PY_CEL_ASSIGN_OR_RETURN( + CEL_PYTHON_ASSIGN_OR_RETURN( cel::Type cel_type, PyCelType::ToCelType(type, arena, env->descriptor_pool_)); cel::VariableDecl var; var.set_name(name); var.set_type(cel_type); - PY_CEL_RETURN_IF_ERROR( + CEL_PYTHON_RETURN_IF_ERROR( compiler_builder->GetCheckerBuilder().AddVariable(var)); } - PY_CEL_ASSIGN_OR_RETURN(env->compiler_, compiler_builder->Build()); + CEL_PYTHON_ASSIGN_OR_RETURN(env->compiler_, compiler_builder->Build()); return env->compiler_.get(); } @@ -116,19 +116,19 @@ absl::StatusOr PyCelEnvInternal::GetRuntime( opts.fail_on_warnings = false; break; } - PY_CEL_ASSIGN_OR_RETURN( + CEL_PYTHON_ASSIGN_OR_RETURN( cel::RuntimeBuilder builder, cel::CreateStandardRuntimeBuilder(&env->descriptor_pool_, opts)); - PY_CEL_RETURN_IF_ERROR(cel::EnableReferenceResolver( + CEL_PYTHON_RETURN_IF_ERROR(cel::EnableReferenceResolver( builder, cel::ReferenceResolverEnabled::kAlways)); for (std::unique_ptr& extension_handle : env->extensions_) { - PY_CEL_ASSIGN_OR_RETURN(CelExtension * extension, - extension_handle->GetExtension(env)); - PY_CEL_RETURN_IF_ERROR(extension->ConfigureRuntime(builder, opts)); + CEL_PYTHON_ASSIGN_OR_RETURN(CelExtension * extension, + extension_handle->GetExtension(env)); + CEL_PYTHON_RETURN_IF_ERROR(extension->ConfigureRuntime(builder, opts)); } - PY_CEL_ASSIGN_OR_RETURN(std::unique_ptr runtime, - std::move(builder).Build()); + CEL_PYTHON_ASSIGN_OR_RETURN(std::unique_ptr runtime, + std::move(builder).Build()); const cel::Runtime* runtime_ptr = runtime.get(); env->runtimes_[runtime_mode] = std::move(runtime); return runtime_ptr; diff --git a/py_cel/py_cel_expression.cc b/py_cel/py_cel_expression.cc index 82ba99f..391cca1 100644 --- a/py_cel/py_cel_expression.cc +++ b/py_cel/py_cel_expression.cc @@ -107,25 +107,25 @@ absl::StatusOr PyCelExpression::Compile( bool disable_check) { ABSL_CHECK(PyGILState_Check()); - PY_CEL_ASSIGN_OR_RETURN(const cel::Compiler* compiler, - PyCelEnvInternal::GetCompiler(env)); + CEL_PYTHON_ASSIGN_OR_RETURN(const cel::Compiler* compiler, + PyCelEnvInternal::GetCompiler(env)); if (disable_check) { - PY_CEL_ASSIGN_OR_RETURN(auto s, cel::NewSource(cel_expr, "")); - CEL_PYTHON_ASSIGN_OR_RETURN(auto ast, compiler->GetParser().Parse(*s)); + CEL_PYTHON_ASSIGN_OR_RETURN(auto s, cel::NewSource(cel_expr, "")); + PY_CEL_PYTHON_ASSIGN_OR_RETURN(auto ast, compiler->GetParser().Parse(*s)); ParsedExpr parsed_expr; - PY_CEL_RETURN_IF_ERROR(cel::AstToParsedExpr(*ast, &parsed_expr)); + CEL_PYTHON_RETURN_IF_ERROR(cel::AstToParsedExpr(*ast, &parsed_expr)); return PyCelExpression(parsed_expr, env); } - CEL_PYTHON_ASSIGN_OR_RETURN(auto validation, compiler->Compile(cel_expr)); + PY_CEL_PYTHON_ASSIGN_OR_RETURN(auto validation, compiler->Compile(cel_expr)); if (!validation.IsValid() || validation.GetAst() == nullptr) { return absl::InvalidArgumentError(validation.FormatError()); } - PY_CEL_ASSIGN_OR_RETURN(std::unique_ptr ast, - validation.ReleaseAst()); + CEL_PYTHON_ASSIGN_OR_RETURN(std::unique_ptr ast, + validation.ReleaseAst()); CheckedExpr checked_expr; - PY_CEL_RETURN_IF_ERROR(cel::AstToCheckedExpr(*ast, &checked_expr)); + CEL_PYTHON_RETURN_IF_ERROR(cel::AstToCheckedExpr(*ast, &checked_expr)); return PyCelExpression(checked_expr, env); } @@ -151,18 +151,18 @@ absl::StatusOr PyCelExpression::Eval( ABSL_CHECK(PyGILState_Check()); if (cel_program_ == nullptr) { if (std::holds_alternative(expr_)) { - CEL_PYTHON_ASSIGN_OR_RETURN( + PY_CEL_PYTHON_ASSIGN_OR_RETURN( const cel::Runtime* runtime, PyCelEnvInternal::GetRuntime( env_, PyCelEnvInternal::kStandardIgnoreWarnings)); - CEL_PYTHON_ASSIGN_OR_RETURN( + PY_CEL_PYTHON_ASSIGN_OR_RETURN( cel_program_, cel::extensions::ProtobufRuntimeAdapter::CreateProgram( *runtime, std::get(expr_))); } else { - CEL_PYTHON_ASSIGN_OR_RETURN( + PY_CEL_PYTHON_ASSIGN_OR_RETURN( const cel::Runtime* runtime, PyCelEnvInternal::GetRuntime(env_, PyCelEnvInternal::kStandard)); - CEL_PYTHON_ASSIGN_OR_RETURN( + PY_CEL_PYTHON_ASSIGN_OR_RETURN( cel_program_, cel::extensions::ProtobufRuntimeAdapter::CreateProgram( *runtime, std::get(expr_))); } @@ -173,7 +173,7 @@ absl::StatusOr PyCelExpression::Eval( cel::EvaluateOptions options; options.message_factory = env->GetMessageFactory(); options.embedder_context = &embedder_context; - CEL_PYTHON_ASSIGN_OR_RETURN( + PY_CEL_PYTHON_ASSIGN_OR_RETURN( cel::Value result, cel_program_->Evaluate(arena->GetArena(), *activation.GetActivation(), std::move(options))); diff --git a/py_cel/py_cel_function.cc b/py_cel/py_cel_function.cc index f65ff40..a3179bc 100644 --- a/py_cel/py_cel_function.cc +++ b/py_cel/py_cel_function.cc @@ -86,8 +86,8 @@ absl::StatusOr PyCelFunctionAdapter::Invoke( ABSL_CHECK(PyGILState_Check()); std::shared_ptr env = GetEnvFromContext(context); - PY_CEL_ASSIGN_OR_RETURN(auto py_arena, - PyCelArena::FromProtoArena(context.arena())); + CEL_PYTHON_ASSIGN_OR_RETURN(auto py_arena, + PyCelArena::FromProtoArena(context.arena())); PyObject* py_args = PyTuple_New(args.size()); for (int i = 0; i < args.size(); ++i) { PyTuple_SetItem(py_args, i, diff --git a/py_cel/py_cel_python_extension.cc b/py_cel/py_cel_python_extension.cc index 01961a4..e9c0502 100644 --- a/py_cel/py_cel_python_extension.cc +++ b/py_cel/py_cel_python_extension.cc @@ -71,7 +71,7 @@ absl::Status PyCelPythonExtension::ConfigureCompiler( for (const PyCelOverload& overload : function.overloads()) { cel::OverloadDecl overload_decl; overload_decl.set_id(overload.overload_id()); - PY_CEL_ASSIGN_OR_RETURN( + CEL_PYTHON_ASSIGN_OR_RETURN( cel::Type cel_type, PyCelType::ToCelType(overload.return_type(), arena, descriptor_pool)); overload_decl.set_result(cel_type); @@ -79,15 +79,15 @@ absl::Status PyCelPythonExtension::ConfigureCompiler( auto& mutable_args = overload_decl.mutable_args(); mutable_args.reserve(overload.parameters().size()); for (const auto& arg : overload.parameters()) { - PY_CEL_ASSIGN_OR_RETURN( + CEL_PYTHON_ASSIGN_OR_RETURN( cel::Type cel_type, PyCelType::ToCelType(arg, arena, descriptor_pool)); mutable_args.push_back(cel_type); } - PY_CEL_RETURN_IF_ERROR( + CEL_PYTHON_RETURN_IF_ERROR( function_decl.AddOverload(std::move(overload_decl))); } - PY_CEL_RETURN_IF_ERROR( + CEL_PYTHON_RETURN_IF_ERROR( compiler_builder.GetCheckerBuilder().MergeFunction(function_decl)); } @@ -113,12 +113,12 @@ absl::Status PyCelPythonExtension::ConfigureRuntime( cel::FunctionDescriptor descriptor(function.name(), overload.is_member(), types, kFunctionDescriptorOptions); if (!overload.py_function().is_none()) { - PY_CEL_RETURN_IF_ERROR(runtime_builder.function_registry().Register( + CEL_PYTHON_RETURN_IF_ERROR(runtime_builder.function_registry().Register( descriptor, std::make_unique( function.name(), overload.return_type(), overload.py_function()))); } else { - PY_CEL_RETURN_IF_ERROR( + CEL_PYTHON_RETURN_IF_ERROR( runtime_builder.function_registry().RegisterLazyFunction( descriptor)); } diff --git a/py_cel/py_cel_value.cc b/py_cel/py_cel_value.cc index 2563280..b17040e 100644 --- a/py_cel/py_cel_value.cc +++ b/py_cel/py_cel_value.cc @@ -452,8 +452,8 @@ absl::StatusOr PyObjectToCelValue( switch (expected_type.GetKind()) { case cel::Kind::kDyn: { - PY_CEL_ASSIGN_OR_RETURN(const PyCelType& type, - PyCelType::ForPyObject(py_object, context)); + CEL_PYTHON_ASSIGN_OR_RETURN(const PyCelType& type, + PyCelType::ForPyObject(py_object, context)); return PyObjectToCelValue(py_object, type, context, env, arena, /*bypass_type_check=*/true); } @@ -649,8 +649,8 @@ absl::StatusOr PyObjectToCelValue( } } case cel::Kind::kMessage: { - PY_CEL_ASSIGN_OR_RETURN(const PyCelType& type, - PyCelType::ForPyObject(py_object, context)); + CEL_PYTHON_ASSIGN_OR_RETURN(const PyCelType& type, + PyCelType::ForPyObject(py_object, context)); if (!bypass_type_check && type.GetName() != expected_type.GetName()) { return InvalidTypeError(py_object, context, expected_type); } @@ -718,15 +718,15 @@ absl::StatusOr PyObjectToCelValue( PyObject* item = PyList_GetItem(py_object, i); // Note: PyList_GetItem returns a borrowed reference, so we shouldn't // DECREF it. - PY_CEL_ASSIGN_OR_RETURN(cel::Value converted_value, - PyObjectToCelValue( - item, element_type, - [context, i]() { - return absl::StrFormat("%s[%d]", - context(), i); - }, - env, arena)); - PY_CEL_RETURN_IF_ERROR(builder->Add(converted_value)); + CEL_PYTHON_ASSIGN_OR_RETURN(cel::Value converted_value, + PyObjectToCelValue( + item, element_type, + [context, i]() { + return absl::StrFormat( + "%s[%d]", context(), i); + }, + env, arena)); + CEL_PYTHON_RETURN_IF_ERROR(builder->Add(converted_value)); } return std::move(*builder).Build(); } @@ -742,7 +742,7 @@ absl::StatusOr PyObjectToCelValue( while (PyDict_Next(py_object, &pos, &key, &value)) { // Note: PyDict_Next returns borrowed references, so we shouldn't // DECREF them. - PY_CEL_ASSIGN_OR_RETURN( + CEL_PYTHON_ASSIGN_OR_RETURN( cel::Value converted_key, PyObjectToCelValue( key, key_type, @@ -753,7 +753,7 @@ absl::StatusOr PyObjectToCelValue( }, env, arena)); - PY_CEL_ASSIGN_OR_RETURN( + CEL_PYTHON_ASSIGN_OR_RETURN( cel::Value converted_value, PyObjectToCelValue( value, value_type, @@ -764,7 +764,8 @@ absl::StatusOr PyObjectToCelValue( PyUnicode_AsUTF8(PyObject_Repr(value))); }, env, arena)); - PY_CEL_RETURN_IF_ERROR(builder->Put(converted_key, converted_value)); + CEL_PYTHON_RETURN_IF_ERROR( + builder->Put(converted_key, converted_value)); } return std::move(*builder).Build(); } diff --git a/py_cel/py_error_status.h b/py_cel/py_error_status.h index 2ac8d83..24f4fbe 100644 --- a/py_cel/py_error_status.h +++ b/py_cel/py_error_status.h @@ -25,10 +25,10 @@ #include "py_cel/status_macros.h" #include -#define CEL_PYTHON_ASSIGN_OR_RETURN(...) \ - PY_CEL_RETURN_IF_ERROR(PyErr_toStatus()); \ - PY_CEL_ASSIGN_OR_RETURN(__VA_ARGS__); \ - PY_CEL_RETURN_IF_ERROR(PyErr_toStatus()); +#define PY_CEL_PYTHON_ASSIGN_OR_RETURN(...) \ + CEL_PYTHON_RETURN_IF_ERROR(PyErr_toStatus()); \ + CEL_PYTHON_ASSIGN_OR_RETURN(__VA_ARGS__); \ + CEL_PYTHON_RETURN_IF_ERROR(PyErr_toStatus()); namespace cel_python { diff --git a/py_cel/status_macros.h b/py_cel/status_macros.h index 6fe59f3..0e39cc8 100644 --- a/py_cel/status_macros.h +++ b/py_cel/status_macros.h @@ -20,27 +20,28 @@ #include "absl/base/optimization.h" #include "absl/status/status.h" -#define PY_CEL_RETURN_IF_ERROR(expr) \ - { \ - absl::Status __PY_CEL_STATUS__ = (expr); \ - if (!__PY_CEL_STATUS__.ok()) { \ - return __PY_CEL_STATUS__; \ - } \ +#define CEL_PYTHON_RETURN_IF_ERROR(expr) \ + { \ + absl::Status __CEL_STATUS__ = (expr); \ + if (!__CEL_STATUS__.ok()) { \ + return __CEL_STATUS__; \ + } \ } -#define PY_CEL_ASSIGN_OR_RETURN_(statusor, lhs, expr) \ - auto statusor = (expr); \ - if (ABSL_PREDICT_FALSE(!statusor.ok())) { \ - return statusor.status(); \ - } \ +#define CEL_PYTHON_ASSIGN_OR_RETURN_(statusor, lhs, expr) \ + auto statusor = (expr); \ + if (ABSL_PREDICT_FALSE(!statusor.ok())) { \ + return statusor.status(); \ + } \ lhs = std::move(statusor).value() -#define PY_CEL_ASSIGN_OR_RETURN_CONCAT_HELPER_(x, y) x##y -#define PY_CEL_ASSIGN_OR_RETURN_CONCAT_(x, y) \ - PY_CEL_ASSIGN_OR_RETURN_CONCAT_HELPER_(x, y) +#define CEL_PYTHON_ASSIGN_OR_RETURN_CONCAT_HELPER_(x, y) x##y +#define CEL_PYTHON_ASSIGN_OR_RETURN_CONCAT_(x, y) \ + CEL_PYTHON_ASSIGN_OR_RETURN_CONCAT_HELPER_(x, y) -#define PY_CEL_ASSIGN_OR_RETURN(lval, expr) \ - PY_CEL_ASSIGN_OR_RETURN_( \ - PY_CEL_ASSIGN_OR_RETURN_CONCAT_(status_or_value, __LINE__), lval, expr) +#define CEL_PYTHON_ASSIGN_OR_RETURN(lval, expr) \ + CEL_PYTHON_ASSIGN_OR_RETURN_( \ + CEL_PYTHON_ASSIGN_OR_RETURN_CONCAT_(status_or_value, __LINE__), lval, \ + expr) #endif // THIRD_PARTY_CEL_PYTHON_STATUS_MACROS_H_