new_field.key_field = create_cloned_field(  # type: ignore[attr-defined]
            field.key_field,  # type: ignore[attr-defined]
            cloned_types=cloned_types,
        )
    new_field.validators = field.validators  # type: ignore[attr-defined]
    new_field.pre_validators = field.pre_validators  # type: ignore[attr-defined]
    new_field.post_validators = field.post_validators  # type: ignore[attr-defined]

  input: "Placeholder_1"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "adj_x"
    value {
      b: false
    }
  }
  attr {
    key: "adj_y"
    value {
      b: false
    }
  }
}
versions {
  producer: 175
}

                  .Input(inputs)
                  .Attr("ids", ids)
                  .Attr("calibration_methods", calibration_methods)
                  .Finalize(node_def()));
  ASSERT_THAT(InitOp(),
              StatusIs(tsl::error::INVALID_ARGUMENT,
                       HasSubstr("NodeDef missing attr 'output_file_path'")));
}

TEST_F(CalibrationStatisticsSaverTest, WrongNumInputs) {

    return false;
  }

  return DenseI64AttrToI32Vector(attr, out_vec);
}

std::optional<bool> GetBoolFromCompositeAttr(
    const DictionaryAttr& composite_attrs, llvm::StringRef attr_name) {
  auto attr = composite_attrs.get(attr_name);
  if (!attr) return std::nullopt;
  if (auto bool_attr = mlir::dyn_cast_or_null<BoolAttr>(attr)) {
    return bool_attr.getValue();
  }
  return std::nullopt;

)

func startProcess(name string, argv []string, attr *ProcAttr) (p *Process, err error) {
	// If there is no SysProcAttr (ie. no Chroot or changed
	// UID/GID), double-check existence of the directory we want
	// to chdir into. We can make the error clearer this way.
	if attr != nil && attr.Sys == nil && attr.Dir != "" {
		if _, err := Stat(attr.Dir); err != nil {
			pe := err.(*PathError)
			pe.Op = "chdir"

  bool IsValueInitValue(const DenseElementsAttr& attr) const override {
    auto element_type = attr.getType().getElementType();
    if (attr.getNumElements() != 1 || !element_type.isIntOrFloat())
      return false;
    if (mlir::isa<FloatType>(element_type)) {
      auto value = *attr.value_begin<APFloat>();
      return value.isNegative() && value.isInfinity();

// and writes X, Y as 32-bit integer attribute to `x`, `y`.
bool TFIntListIs1XY1(Operation *op, StringRef name, IntegerAttr *x,
                     IntegerAttr *y) {
  auto attr = op->getAttrOfType<ArrayAttr>(name);
  if (!attr) return false;

  auto elements = attr.getValue();
  if (elements.size() != 4 ||
      std::any_of(elements.begin(), elements.end(),
                  [](Attribute e) { return !mlir::isa<IntegerAttr>(e); }))

  }
}

// Shuffle elements in the `attr` according to the permutation. Optional
// `inner_size` allows to shuffle array attributes created from rank 2 tensors
// on outer dimension only.
ArrayAttr ShuffleArrayAttr(ArrayAttr attr, ArrayRef<int64_t> permutation,
                           int inner_size) {
  if (attr.empty()) return attr;

  assert(attr.size() % inner_size == 0);
  assert(attr.size() / inner_size == permutation.size());

		{name: "429s retry", attr: aliceAttr, allow: false, statusCode: 429, expectedErr: true, expectedAuthorized: false, expectedCalls: 5},
		// regular errors return errors but do not retry
		{name: "404 doesnt retry", attr: aliceAttr, allow: false, statusCode: 404, expectedErr: true, expectedAuthorized: false, expectedCalls: 1},

  let description = [{
    The CreateOp creates the tensorflow::OpKernel in the fallback context.
  }];

  let arguments = (ins
    StrAttr:$node_def,
    I32Attr:$op_key
  );

  let assemblyFormat = "attr-dict";
}

def ConstOp: TensorflowMlrt_Op<"constop", []> {
  let summary = "The tf_mlrt ConstOp";

  let description = [{
    The ConstOp creates a constant tensorflow::Tensor from serialized proto.
  }];