builder.insert(metadata_op.clone());
  for (Operation& op : func.getOps()) {
    if (!IsTPUOp(&op)) continue;
    op.setAttr(TF::kReplicationInfoAttr, new_group);
  }
  TF::TPUCompilationResultOp new_result = compilation_op.clone();
  new_result->setAttr(kTpuCompilationStatus, new_group);
  builder.insert(new_result);
}

template <typename OpType>
LogicalResult FindAndExcludeOp(func::FuncOp func,

      /*config_proto=*/builder.getStringAttr(""),
      /*executor_type=*/builder.getStringAttr(""));
  caller.setFAttr(symbol);

  // Set an attribute that our inliner will look for when choosing which
  // TF::StatefulPartitionedCallOps to inline.
  if (flag_for_inlining)
    caller->setAttr(kEmbeddingPipeliningInlineAttr, builder.getBoolAttr(true));
  return caller;
}

  if (failed(::mlir::TF::UpdateDataFormat(data_format, this))) return failure();

  // Update convolution attributes.
  (*this)->setAttr("dilations", ShuffleArrayAttr(getDilations(), perm));
  (*this)->setAttr("strides", ShuffleArrayAttr(getStrides(), perm));
  (*this)->setAttr("explicit_paddings",
                   ShuffleArrayAttr(getExplicitPaddings(), perm, 2));

  return success();
}

                                           mlir::CallInterfaceCallable callee) {
  // Direct call.
  if (SymbolRefAttr fAttr = op.getFAttr()) {
    SymbolRefAttr calleeAttr = callee.get<SymbolRefAttr>();
    return op.setFAttr(cast<FlatSymbolRefAttr>(calleeAttr));
  }
  // Indirect call, callee Value is the first operand.
  return op.setOperand(0, callee.get<Value>());
}

void PartitionedCallOp::setCalleeFromCallable(

_initializers = _KerasLazyLoader(
    globals(), submodule="initializers", name="initializers", mode="v2")
setattr(_current_module, "losses", _losses)
setattr(_current_module, "metrics", _metrics)
setattr(_current_module, "optimizers", _optimizers)

  auto cluster = builder.create<mlir::tf_device::ClusterOp>(
      mlir::UnknownLoc::get(&context), result_types);
  cluster->setAttr(kNumCoresPerReplicaAttr,
                   builder.getIntegerAttr(builder.getIntegerType(64), 1));
  cluster->setAttr(kTopologyAttr, builder.getStringAttr(""));
  cluster->setAttr(kDeviceAssignmentAttr, builder.getArrayAttr({}));

  EXPECT_FALSE(HasModelParallelism(cluster));
}

        if (device_attr.getValue().empty()) {
          op->setAttr(kDeviceAttr, builder.getStringAttr(default_device_));
        }
      } else if (op->getDialect() == tf) {
        // Assign default device to all ops in Tensorflow dialect that do not
        // have device attribute.
        op->setAttr(kDeviceAttr, builder.getStringAttr(default_device_));
      }
    });
  }
};

    // Convert `_tpu_replicate`.
    if (op->hasAttr(TF::kTpuReplicateAttr)) {
      op->setAttr(tensorflow::kReplicationInfoAttr,
                  op->getAttr(TF::kTpuReplicateAttr));
      op->removeAttr(tensorflow::kTpuReplicateAttr);
      op->setAttr(tensorflow::kCompileDeviceTypeAttr,
                  builder.getStringAttr(tensorflow::kTpuDevice));
    }

    // Convert `_XlaMustCompile`.

_initializers = _KerasLazyLoader(
    globals(), submodule="initializers", name="initializers")
setattr(_current_module, "losses", _losses)
setattr(_current_module, "metrics", _metrics)
setattr(_current_module, "optimizers", _optimizers)
setattr(_current_module, "initializers", _initializers)


# Do an eager load for Keras' code so that any function/method that needs to

  // function name can be changed by those passes.
  call_op->setAttr(TF::kStablehloEntryFunctionAttrName,
                   FlatSymbolRefAttr::get(builder.getStringAttr(func_name)));
  // Store the custom attribute to restore the function name when loading it
  // back in the post calibration stage. As mentioned above, the above entry
  // function attribute is not reliable.
  call_op->setAttr(kOriginalStablehloEntryFunctionAttrName,