default:
      break;
  }
  *quantization_options_.mutable_quantization_method()
       ->mutable_custom_quantization_method() = custom_method;
  return quantization_options_;
}

LogicalResult GetActivationBitWidth(QuantizationOptions quantization_options,
                                    int* bit_width) {
  CustomQuantizationMethod custom_method =
      quantization_options.quantization_method().custom_quantization_method();

QuantizationOptions FillPresetQuantizationOptions(
    QuantizationOptions quantization_options);

// Returns LogicalResult depending on the look up of activation bit width in the
// custom quantization method. If such information exists, returns success,
// otherwise, returns false.
LogicalResult GetActivationBitWidth(QuantizationOptions quantization_options,
                                    int* bit_width);

    const QuantizationComponentSpec expected_bias_component) {
  QuantizationOptions quantization_options;
  quantization_options.mutable_quantization_method()
      ->mutable_preset_quantization_method()
      ->set_preset_method(preset_quantization_options);
  QuantizationOptions filled_quantization_options =
      quant::stablehlo::FillPresetQuantizationOptions(quantization_options);
  for (QuantizationComponentSpec component :

        signature_keys=['serving_default'],
    )

    model = quantize_model.quantize(
        temp_path,
        quantization_options=quantization_options,
        representative_dataset=data_gen(),
    )
    return model

  @test_util.run_in_graph_and_eager_modes
  def test_multiple_conversion_jobs_with_calibration(self):
    # Ensure that multiple conversion jobs with calibration won't encounter any
    # concurrency issue.

#include "tensorflow/compiler/mlir/quantization/stablehlo/quantization_options.pb.h"

namespace stablehlo {
namespace quantization {
// Adds passes for quantization of individual quantizable components.
// (i.e. activation, weight, bias)
void AddQuantizationPasses(mlir::PassManager& pass_manager,
                           const QuantizationOptions& quantization_options);

}  // namespace quantization
}  // namespace stablehlo

// bf16 is quantizable.
bool IsValueWithQuantizablePrecision(Value val);

std::optional<tensorflow::quantization::QuantizationComponentSpec>
GetWeightComponentSpec(
    const tensorflow::quantization::QuantizationOptions& quantization_options);

// Returns the spec for the given operation that can be used for both of
// dynamic and static range quantization.
std::unique_ptr<OpQuantSpec> GetTFOpQuantSpec(Operation* op);

    return true;
  return false;
}

std::optional<tensorflow::quantization::QuantizationComponentSpec>
GetWeightComponentSpec(
    const tensorflow::quantization::QuantizationOptions& quantization_options) {
  for (auto& cur_spec : quantization_options.quantization_method()
                            .quantization_component_specs()) {
    if (cur_spec.quantization_component() ==

      const int kWeightsMinNumElementsDefault = 1024;

      quantization::QuantizationOptions quantization_options;

      quantization_options.mutable_quantization_method()->set_preset_method(
          quantization::QuantizationMethod::METHOD_DYNAMIC_RANGE_INT8);
      quantization_options.set_op_set(quantization::UNIFORM_QUANTIZED);
      quantization_options.set_min_num_elements_for_weights(
          kWeightsMinNumElementsDefault);

#include "tensorflow/compiler/mlir/quantization/tensorflow/quantization_options.pb.h"

namespace mlir::quant {
namespace {

using QuantizationOptions = tensorflow::quantization::QuantizationOptions;
using QuantizationComponentSpec =
    tensorflow::quantization::QuantizationComponentSpec;

TEST(TfOpQuantSpecTest, WeightComponentSpecExist) {
  QuantizationOptions quant_options;
  QuantizationComponentSpec quant_spec;

 public:
  explicit QuantizeConstWeights(
      MLIRContext* context,
      const tensorflow::quantization::QuantizationOptions& quantization_options)
      : OpRewritePattern<TF::ConstOp>(context),
        quant_options_(quantization_options) {}

  LogicalResult matchAndRewrite(TF::ConstOp op,
                                PatternRewriter& rewriter) const override {