bool enable_per_channel_quantization) {
    op_set_ = op_set;
    quantization_method_ = quantization_method;
    enable_per_channel_quantization_ = enable_per_channel_quantization;
  }

  PreprocessOpPass(const PreprocessOpPass& other) {
    op_set_ = other.op_set_;
    quantization_method_ = other.quantization_method_;
    enable_per_channel_quantization_ = other.enable_per_channel_quantization_;
  }

                                   OpSet op_set,
                                   bool enable_per_channel_quantization)
      : OpRewritePattern<arith::ConstantOp>(context),
        quant_specs_(quant_specs),
        op_set_(op_set),
        enable_per_channel_quantization_(enable_per_channel_quantization) {}

  LogicalResult matchAndRewrite(arith::ConstantOp op,

                               QuantMethod quantization_method)
      : quant_specs_(quant_specs) {
    quant_specs_.inference_type = tensorflow::DT_QINT8;
    enable_per_channel_quantization_ = !quant_specs_.disable_per_channel;
    enable_post_training_quantize_ =
        (quantization_method == tensorflow::quantization::QuantizationMethod::
                                    METHOD_STATIC_RANGE_INT8);

LogicalResult FillAttributesForUniformQuantizedDotOp(
    PatternRewriter& rewriter, Operation* op,
    llvm::StringMap<Attribute>& identifier_to_attr,
    QuantMethod quantization_method, bool enable_per_channel_quantization) {
  NamedAttrList attrs;

  if (quantization_method ==
      tensorflow::quantization::QuantizationMethod::METHOD_DYNAMIC_RANGE_INT8) {
    // Fill quantization related attributes for Hybrid op.

      tensorflow::quantization::QuantizationMethod::METHOD_STATIC_RANGE_INT8;
  auto res = FillAttributesForUniformQuantizedAddOp(
      test_peer.rewriter_, op, identifier_to_attr, quantization_method,
      /*enable_per_channel_quantization=*/false);
  ASSERT_TRUE(succeeded(res));
  ASSERT_EQ(2147483647, op.getLhsQuantizationMaxValAttr().getInt());
  ASSERT_EQ(-2147483648, op.getLhsQuantizationMinValAttr().getInt());

  // applicable
  pm.addPass(mlir::quant::CreateQuantizeCompositeFunctionsPass(
      quantization_options.quantization_method().preset_method(),
      quantization_options.op_set(),
      quantization_options.enable_per_channel_quantization(),
      quantization_options.min_num_elements_for_weights(),
      quantization_options.enable_legacy_weight_only(), mlir_dump_file_prefix));
  pm.addPass(mlir::createSymbolDCEPass());

std::unique_ptr<OperationPass<ModuleOp>> CreateQuantizeCompositeFunctionsPass(
    tensorflow::quantization::QuantizationMethod::PresetMethod
        quantization_method,
    tensorflow::quantization::OpSet target_opset,
    bool enable_per_channel_quantization, int min_num_elements_for_weights,
    bool enable_legacy_weight_only = false,
    std::optional<const absl::string_view> mlir_dump_file_prefix =
        std::nullopt);

        ),
        _DYNAMIC_RANGE_DEFAULT_MIN_NUM_ELEMENTS_FOR_WEIGHTS,
    )

  if not quantization_options.HasField('enable_per_channel_quantization'):
    quantization_options.enable_per_channel_quantization = False

  if quantization_options.enable_per_channel_quantization and not (
      (
          quantization_options.op_set == quant_opts_pb2.OpSet.UNIFORM_QUANTIZED

  // TODO: b/331302857 - Remove `enable_per_channel_quantized_weight` usage.
  quantization_config.mutable_static_range_ptq_preset()
      ->set_enable_per_channel_quantized_weight(
          quantization_options.enable_per_channel_quantization());
  // When targeting server TPUs quantized types should be unpacked into
  // integer ops.
  quantization_config.mutable_pipeline_config()->set_unpack_quantized_types(
      true);