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(

  ASSERT_EQ(stream.str(), "None");
}

TEST(OStreamTest, TestTensorSpec) {
  std::stringstream stream;
  TensorSpec tensor_spec;
  tensor_spec.shape = tensorflow::PartialTensorShape({2});
  tensor_spec.dtype = tensorflow::DT_FLOAT;
  stream << tensor_spec;
  ASSERT_EQ(stream.str(), "TensorSpec(shape = [2], dtype = 1)");
}

}  // namespace impl
}  // namespace libtf

namespace impl {

TEST(TensorSpecTest, TestSupportsAbslHash) {
  tensorflow::PartialTensorShape unknown_shape;
  TensorSpec ts1;
  ts1.shape = unknown_shape;
  ts1.dtype = tensorflow::DT_FLOAT;

  TensorSpec ts2;
  ts2.shape = tensorflow::PartialTensorShape({2});
  ts2.dtype = tensorflow::DT_FLOAT;

  TensorSpec ts3;
  ts3.shape = tensorflow::PartialTensorShape({1, 2});
  ts3.dtype = tensorflow::DT_FLOAT;

  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.

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

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

        "iostream.cc",
    ],
    deps = [
        ":none",
        ":string",
        ":tensor_spec",
    ],
)

tf_cc_test(
    name = "iostream_test",
    size = "small",
    srcs = ["iostream_test.cc"],
    deps = [
        ":iostream",
        ":none",
        ":scalars",
        ":string",
        ":tensor_spec",
        "//tensorflow/core:framework",
        "//tensorflow/core:protos_all_cc",

        "\n",
        "tf_module = tf.Module()\n",
        "tf_module.f = tf.function(\n",
        "    jax_callable,\n",
        "    autograph=False,\n",
        "    input_signature=[\n",
        "        tf.TensorSpec(input_shape, jnp.float32, 'lhs_operand')\n",
        "    ],\n",
        ")\n",
        "\n",
        "saved_model_dir = '/tmp/saved_model'\n",
        "tf.saved_model.save(tf_module, saved_model_dir)\n",

    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(

    model = TwoMatmulModel()
    input_shape = (1, 2)

    save.save(
        model,
        self._input_saved_model_path,
        signatures=model.matmul.get_concrete_function(
            tensor_spec.TensorSpec(
                shape=input_shape, dtype=dtypes.float32, name='input_tensor'
            )
        ),
    )

    def data_gen() -> repr_dataset.RepresentativeDataset:
      for _ in range(50):

#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"