class_docstr: Represents data from mars tensor
code: def _tile_input_1d_tileables(cls, op: "DataFrameFromTensor"):
      # make sure all tensor have known chunk shapes
      if has_unknown_shape(*op.inputs):
          yield
  
      out_df = op.outputs[0]
      in_tensors = op.inputs
      in_tensors = yield from unify_chunks(*in_tensors)
      nsplit = in_tensors[0].nsplits[0]
  
      cum_sizes = [0] + np.cumsum(nsplit).tolist()
      out_chunks = []
      for i in range(in_tensors[0].chunk_shape[0]):
          chunk_op = op.copy().reset_key()
          new_input = OrderedDict()
          for k, v in op.input.items():
              if not isinstance(v, ENTITY_TYPE):
                  try:
                      new_input[k] = v[cum_sizes[i] : cum_sizes[i + 1]]
                  except TypeError:
                      # scalar
                      new_input[k] = v
              else:
                  # do not need to do slice,
                  # will be done in set_inputs
                  new_input[k] = v
          chunk_op.input = new_input
          columns_value = out_df.columns_value
          dtypes = out_df.dtypes
          chunk_index = (i, 0)
          if isinstance(op.index, INDEX_TYPE):
              index_value = in_tensors[-1].chunks[i].index_value
          elif isinstance(op.index, pd.Index):
              chunk_op.index = pd_index = op.index[
                  cum_sizes[i] : cum_sizes[i + 1]
              ]
              index_value = parse_index(pd_index, store_data=True)
          else:
              assert op.index is not None
              index_chunk = in_tensors[-1].cix[i,]
              index_value = parse_index(
                  pd.Index([], dtype=index_chunk.dtype),
                  index_chunk,
                  type(chunk_op).__name__,
              )
          shape = (nsplit[i], len(out_df.dtypes))
          out_chunk = chunk_op.new_chunk(
              [t.cix[(i,)] for t in in_tensors],
              shape=shape,
              index=chunk_index,
              dtypes=dtypes,
              index_value=index_value,
              columns_value=columns_value,
          )
          out_chunks.append(out_chunk)
  
      nsplits = (nsplit, (len(out_df.dtypes),))
      new_op = op.copy()
      return new_op.new_dataframes(
          out_df.inputs,
          out_df.shape,
          dtypes=out_df.dtypes,
          index_value=out_df.index_value,
          columns_value=out_df.columns_value,
          chunks=out_chunks,
          nsplits=nsplits,
      )
  
imports: from collections import OrderedDict
  from typing import Any, Dict, List, Union
  import numpy
  import pandas
  from ...None import opcodes
  from ...core import ENTITY_TYPE, OutputType, recursive_tile
  from ...core.context import Context
  from ...serialization.serializables import KeyField, AnyField
  from ...tensor.core import Tensor
  from ...tensor.datasource import tensor
  from ...tensor.utils import unify_chunks
  from ...typing import EntityType, TileableType
  from ...utils import has_unknown_shape
  from ..core import INDEX_TYPE, SERIES_TYPE
  from ..operands import DataFrameOperand, DataFrameOperandMixin
  from ..utils import parse_index
label_desc: Use image node_id 9 for calling the DataFrameFromTensor obj's underlying member method code with example usage: obj._tile_input_1d_tileables(cls, op) and returns: new_op