const int operand_number = use.getOperandNumber();
          next_values_to_visit.push_back(
              while_op.getCond().front().getArgument(operand_number));
          next_values_to_visit.push_back(
              while_op.getBody().front().getArgument(operand_number));
          continue;
        }

        if (llvm::isa<mlir::TF::IdentityOp, mlir::TF::CastOp,

## Documents OpenAPI et API

Si vous renvoyez directement des codes HTTP et des réponses supplémentaires, ils ne seront pas inclus dans le schéma OpenAPI (la documentation de l'API), car FastAPI n'a aucun moyen de savoir à l'avance ce que vous allez renvoyer.

  int num_control_inputs_added = 0;

  // We call `VerifyExportSuitable` in the beginning of the pass, so every
  // function has a single graph op.
  auto graph = cast<GraphOp>(func.front().front());
  for (Operation& op_ref : graph.GetBody()) {
    Operation* op = &op_ref;
    // We only represent control dependencies between island and fetch ops.
    if (!isa<IslandOp, FetchOp>(op)) continue;

    llvm::ArrayRef<TF::AssignVariableOp> tail_assign_variable_ops) {
  const auto num_replicas = replicate_op.getN();
  auto return_op = llvm::dyn_cast<tf_device::ReturnOp>(
      replicate_op.getRegion().front().getTerminator());

  // Get the new result types.
  // TODO(prakalps): Do not add a value to returned values if it is already
  // returned.
  auto new_result_types = llvm::to_vector<4>(replicate_op->getResultTypes());

TEST_F(TpuMetadataUtilsTest, SingleDevice) {
  TF_ASSERT_OK_AND_ASSIGN(auto cluster_func_ops,
                          GetClusterFuncOps("basic_cluster.mlir"));
  mlir::tf_device::ClusterFuncOp cluster_func_op = cluster_func_ops.front();

  tensorflow::tpu::TPUCompileMetadataProto compile_metadata;

  ASSERT_TRUE(mlir::succeeded(SetMetadataProtoFromClusterFuncOp(
      cluster_func_op,

bool TryPruneResultDefiningOp(TF::WhileRegionOp while_op, OpResult result) {
  // Don't prune if result is used.
  if (!result.use_empty()) return false;

  Block& body_block = while_op.getBody().front();
  Block& cond_block = while_op.getCond().front();
  Operation* body_yield_op = body_block.getTerminator();

  // The body yield operand, body block argument, condition block argument, and

    if (entry.second.size() > 1) {
      unformat_replicate_operands.emplace_back(entry.second,
                                               entry.second.front().getType());
    } else {
      unformat_packed_operands.emplace_back(entry.second.front());
    }
  }
  llvm::SmallVector<Value, 4> state_var_vals(state_vars.size());
  for (const auto& entry : llvm::enumerate(state_vars)) {

	oldRootMode := RootMode
	defer func() {
		allowMissingModuleImports = oldAllowMissingModuleImports
		RootMode = oldRootMode
	}()
	allowMissingModuleImports = true
	RootMode = NoRoot

	ctx := context.Background()
	rs := LoadModFile(ctx)

	for _, tt := range importTests {
		t.Run(strings.ReplaceAll(tt.path, "/", "_"), func(t *testing.T) {

    new_shape.push_back(shape.getNumElements());
    value = builder.create<TF::ReshapeOp>(
        loc, value, Create1DConstValue(builder, loc, new_shape));
  }
  return ConstantFoldOpIfPossible(value.getDefiningOp()).front();
}

// Matches convolution op with "NHWC" data format or matmul op with false adj_y.
// The list of supported ops in this function is:
// - Conv2DOp
// - Conv3DOp
// - DepthwiseConv2dNativeOp

    if (reduce_op.getDimensions().getNumElements() != 1) return failure();

    // Check that the operand init is the expected value.
    DenseElementsAttr operand_init;
    if (!matchPattern(reduce_op.getInitValues().front(),
                      m_Constant(&operand_init)))
      return failure();
    if (!IsValueInitValue(operand_init)) return failure();

    // Check that the iota init is zero.
    DenseElementsAttr iota_init;