// `signature`. `signature` must outlive flattened_specs. `signature` must also
// be the input or output signature of a SavedConcreteFunction (i.e. "nested
// structures of tensorspecs").
Status FlattenSignature(const StructuredValue& signature,
                        std::vector<const TensorSpecProto*>* flattened_specs);

// Find the node id in `object_graph` at location `path`. `path` must be

          PartialTensorShape shape = arg.tensor_spec_value().shape();
          DataType dtype = arg.tensor_spec_value().dtype();
          TaggedValue tensor_spec(shape, dtype);
          input_signature.tuple().emplace_back(tensor_spec);
        }

        // Setup output signature.
        TensorSpecProto output_tensor_spec_proto =
            saved_concrete_function.output_signature().tensor_spec_value();

  // (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",

#include "tensorflow/c/experimental/saved_model/core/tensor_spec.h"

#include <initializer_list>

#include "tensorflow/core/framework/tensor_shape.h"
#include "tensorflow/core/framework/types.pb.h"

namespace tensorflow {

TensorSpec::TensorSpec()
    : shape_(std::initializer_list<int64_t>()), dtype_(DT_FLOAT) {}

TensorSpec::TensorSpec(PartialTensorShape shape, DataType dtype)

#ifdef __cplusplus
extern "C" {
#endif  // __cplusplus

// An opaque type corresponding to TensorSpec
typedef struct TF_TensorSpec TF_TensorSpec;

// Returns the dtype associated with the TensorSpec.
TF_CAPI_EXPORT extern TF_DataType TF_TensorSpecDataType(
    const TF_TensorSpec* spec);

// Returns the shape associated with the TensorSpec. The returned Shape is not
// owned by the caller. Caller must not call TF_DeleteShape on the returned

namespace libtf {
namespace impl {
/// @brief The TensorSpec struct.
///
/// The TensorSpec describes the shape and dtype of a Tensor.

struct TensorSpec {
  tensorflow::PartialTensorShape shape;
  tensorflow::DataType dtype;

  bool operator==(const TensorSpec& o) const {
    return dtype == o.dtype && shape.IsIdenticalTo(o.shape);
  }

  /// Overload AbslHashValue to make TensorSpec hashable.
  template <typename H>

// attribute here, we can always add it back in; but let's see how far we can
// get without it."
class TensorSpec {
 public:
  // Constructs a scalar, DT_FLOAT TensorSpec
  TensorSpec();

  TensorSpec(PartialTensorShape shape, DataType dtype);

  explicit TensorSpec(const TensorSpecProto& proto);

  const PartialTensorShape& shape() const;
  DataType dtype() const;

 private:

limitations under the License.
==============================================================================*/

#include "tensorflow/c/experimental/saved_model/public/tensor_spec.h"

#include "tensorflow/c/experimental/saved_model/core/tensor_spec.h"
#include "tensorflow/c/experimental/saved_model/internal/tensor_spec_type.h"
#include "tensorflow/c/tf_shape_internal.h"

extern "C" {

          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(

  """A simple model used for exercising the C++ API."""

  @def_function.function(input_signature=[
      tensor_spec.TensorSpec(shape=(), dtype=dtypes.float32),
  ])
  def test_float(self, x):
    return constant_op.constant(3.0) * x

  @def_function.function(input_signature=[
      tensor_spec.TensorSpec(shape=(), dtype=dtypes.int32),
  ])
  def test_int(self, x):
    return constant_op.constant(3) * x