class_docstr: ArrowIOTensor
code: def __init__(self, table, spec=None, internal=False):
      # Get or build a new ArrowIOResource
      if isinstance(table, ArrowIOResource):
          arrow_resource = table
      else:
          arrow_resource = ArrowIOResource.from_table(table)
  
      # Get the ArrowIOTensor init resource op
      resource = arrow_resource.resource_op
  
      if tf.executing_eagerly():
          # Create a BaseIOTensor for each column
          elements = []
          columns = table.column_names
          for column_index, column in enumerate(columns):
              shape, dtype = core_ops.io_arrow_readable_spec(
                  resource, column_index, column
              )
              shape = tf.TensorShape(shape.numpy())
              dtype = tf.as_dtype(dtype.numpy())
              spec = tf.TensorSpec(shape, dtype, column)
              function = _ArrowIOTensorComponentFunction(  # pylint: disable=protected-access
                  core_ops.io_arrow_readable_read,
                  resource,
                  column_index,
                  column,
                  shape,
                  dtype,
              )
              elements.append(
                  ArrowBaseIOTensor(
                      shape,
                      dtype,
                      spec,
                      function,
                      arrow_resource,
                      internal=internal,
                  )
              )
          spec = tuple(e.spec for e in elements)
      else:
          assert spec is not None
          columns, entries = zip(*spec.items())
          # Column could be specified by index or name
          columns = [
              (column, "") if isinstance(column, int) else (-1, column)
              for column in columns
          ]
          dtypes = [
              entry
              if isinstance(entry, tf.dtypes.DType)
              else entry.dtype
              for entry in entries
          ]
  
          shapes = []
          for column_index, column in columns:
              shape, _ = core_ops.io_arrow_readable_spec(
                  resource, column_index, column
              )
              shapes.append(shape)
  
          entries = [
              tf.TensorSpec(
                  None,
                  dtype,
                  str(column_index) if column_index >= 0 else column,
              )
              for (dtype, (column_index, column)) in zip(
                  dtypes, columns
              )
          ]
  
          elements = []
          for (column_index, column), entry, shape in zip(
              columns, entries, shapes
          ):
              function = _ArrowIOTensorComponentFunction(
                  core_ops.io_arrow_readable_read,
                  resource,
                  column_index,
                  column,
                  shape,
                  entry.dtype,
              )
              elements.append(
                  ArrowBaseIOTensor(
                      shape,
                      entry.dtype,
                      entry,
                      function,
                      arrow_resource,
                      internal=internal,
                  )
              )
          spec = tuple(entries)
          columns = [
              str(column_index) if column_index >= 0 else column
              for (column_index, column) in columns
          ]
  
      super().__init__(spec, columns, elements, internal=internal)
  
imports: import uuid
  import tensorflow
  from tensorflow_io.python.ops import io_tensor_ops
  from tensorflow_io.python.ops import core_ops
label_desc: Use image node_id 1 to create a new ArrowIOTensor object from inherited base classes: io_tensor_ops with example: obj = ArrowIOTensor(table, spec, internal)