// (args, kwargs), where args is an empty tuple, and kwargs is a dictionary of
  // string keys to TensorSpecs.
  if (!canonicalized_input_signature.has_tuple_value()) {
    return absl::FailedPreconditionError(absl::StrCat(
        "SignatureDefFunction's canonicalized_input_signature should be "
        "of form tuple(tuple(), dict()), but was instead: \n",

          input_signature=[
              tensor_spec.TensorSpec(
                  name='x', shape=x_signature, dtype=dtypes.float32
              )
          ]
      )
      def einsum_with_kernel(self, x: core.Tensor) -> Mapping[str, core.Tensor]:
        return self._einsum(x, self._kernel)

      @def_function.function(
          input_signature=[
              tensor_spec.TensorSpec(

  const TaggedValueTensor& tensor() const { return get<TaggedValueTensor>(); }

  /// Retrieves underlying value from a TaggedValue with type TENSOR_SPEC.
  const TensorSpec& tensor_spec() const { return get<TensorSpec>(); }

  /// Retrieves underlying value from a TaggedValue with type CAPSULE.
  void* capsule() const { return get<impl::Capsule>().get(); }

  /// Retrieves type of TaggedValue.

  Function tf_function;
  PartialTensorShape unknown_shape;
  TaggedValue tensor_spec(unknown_shape, DT_FLOAT);
  TaggedValue input_signature = TaggedValue::Tuple();
  input_signature.tuple().emplace_back(tensor_spec);
  input_signature.tuple().emplace_back(tensor_spec);
  Status s =
      tf_function.RegisterTrace(std::move(trace), input_signature, tensor_spec);
  ASSERT_TRUE(s.ok()) << s.message();

    deps = [
        "//tensorflow/c:conversion_macros",
        "//tensorflow/c/experimental/saved_model/core:signature_def_function_metadata",
    ],
)

cc_library(
    name = "tensor_spec",
    srcs = [
        "tensor_spec.cc",
    ],
    hdrs = [
        "//tensorflow/c/experimental/saved_model/public:tensor_spec.h",
    ],
    copts = tf_copts(),
    visibility = [

    const mlir::Type& type) {
  DataType dtype;
  TF_RETURN_IF_ERROR(ConvertToDataType(type, &dtype));
  TensorSpecProto tensor_spec;
  tensor_spec.set_dtype(dtype);
  *tensor_spec.mutable_shape() = ConvertTypeToTensorShape(type).AsProto();
  return tensor_spec;
}

// Converts the tensor shape proto into an MLIR shape attribute.
absl::StatusOr<mlir::Attribute> ConvertTensorShapeProto(

    TF_RETURN_IF_ERROR(LockVariables(absl::MakeSpan(variable_infos)));
  }

  absl::StatusOr<std::vector<XlaCompiler::Argument>> args;

  if (compiler_arg_source == CompilerArgSource::TENSOR_SPEC) {
    args = BuildXlaCompilerArgumentFromTensorSpec(fbody, constant_arg_indices,
                                                  inputs, variable_infos,

#include "tensorflow/c/experimental/saved_model/public/signature_def_param.h"
#include "tensorflow/c/experimental/saved_model/public/signature_def_param_list.h"
#include "tensorflow/c/experimental/saved_model/public/tensor_spec.h"
#include "tensorflow/c/tf_datatype.h"
#include "tensorflow/c/tf_shape.h"
#include "tensorflow/c/tf_status.h"
#include "tensorflow/c/tf_tensor.h"
#include "tensorflow/core/lib/io/path.h"