LATEST_KYAML=$(echo "${PUBLISHED_RELEASES}" | jq -r '[ .[] | select(.tag_name | startswith("kyaml/v")) ] | sort_by(.published_at) | last | .tag_name | scan("\/(v[\\d.]+)") | .[0]')

      return absl::AbortedError("Failed to parse input MLIR model.");
    }

    return quant::stablehlo::ImportedMlirModuleOp(std::move(module), nullptr);
  }

  std::unordered_set<std::string> tag_set(tag_names.begin(), tag_names.end());
  return quant::stablehlo::SavedModelToMlirModuleOp(
      input_path, tag_set, exported_model_signatures, *context);
}

// Convert an TF module to a StableHLO module

             {"serving_default"},
         const std::vector<std::string>& tag_names = {"serve"},
         absl::string_view input_arg_shapes_str = "") -> py::bytes {
        auto module_bytecode =
            PywrapSavedModelToStablehlo(input_path, exported_model_signatures,
                                        tag_names, input_arg_shapes_str);
        if (!module_bytecode.ok()) {
          PyErr_SetString(PyExc_ValueError,

        javaCrash = false
    }
})

private fun determineFlakyTestStrategy(stage: Stage): String {
    val stageName = StageName.values().first { it.stageName == stage.stageName.stageName }
    // See gradlebuild.basics.FlakyTestStrategy
    return if (stageName < StageName.READY_FOR_RELEASE) "exclude" else "include"
}

fun getTestTaskName(testCoverage: TestCoverage, subprojects: List<String>): String {

    val testsWithOs = model.stages.filter {
        it.stageName in listOf(
            StageName.QUICK_FEEDBACK_LINUX_ONLY,
            StageName.QUICK_FEEDBACK,
            StageName.PULL_REQUEST_FEEDBACK,
            StageName.READY_FOR_NIGHTLY,
        )
    }.flatMap { it.functionalTests }.filter { it.os == os }

    if (os == Os.LINUX) {
        steps {

//  context: The MLIR context to use for parsing or creating the MLIR module.
//  exported_model_signatures: List of exported model signatures (strings) to
//    convert.
//  tag_names: List of tag names (strings) used for loading SavedModel.
//    Ignored for MLIR input.
//  input_arg_shapes_str:  A string representation of input argument shapes for

# LINT.IfChange(savedmodel_to_stablehlo)
def savedmodel_to_stablehlo(
    input_path: str,
    exported_model_signatures: list[str] = ["serving_default"],
    tag_names: list[str] = ["serve"],
    input_arg_shapes_str: str = "",
) -> bytes: ...
# LINT.ThenChange()

# LINT.IfChange(tensorflow_module_to_stablehlo)
def tensorflow_module_to_stablehlo(
    module: str,

        private final String taskName;

        public TaskPathSpec(ProjectInternal targetProject, String taskName) {
            this.targetProject = targetProject;
            this.taskName = taskName;
        }

        @Override
        public boolean isSatisfiedBy(Task element) {
            if (!element.getName().equals(taskName)) {
                return true;
            }

import model.CIBuildModel
import model.JsonBasedGradleSubprojectProvider
import model.PerformanceTestCoverage
import model.PerformanceTestType
import model.Stage
import model.StageName
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Test
import java.io.File

class PerformanceTestBuildTypeTest {
    init {
        DslContext.initForTest()
    }

    const std::vector<std::string>& tag_names,
    absl::string_view input_arg_shapes_str) {
  mlir::DialectRegistry registry;
  RegisterAllTensorFlowDialects(registry);
  mlir::MLIRContext context(registry);
  context.loadAllAvailableDialects();

  auto module =
      TfToStablehlo(input_path, &context, exported_model_signatures, tag_names,
                    input_arg_shapes_str, /*is_input_mlir_module=*/false);