class_docstr: Represents data from mars tensor
code: def _tile_input_tensor(cls, op: "DataFrameFromTensor"):
      out_df = op.outputs[0]
      in_tensor = op.input
      out_chunks = []
      if out_df.index_value.has_value() and has_unknown_shape(
          in_tensor
      ):
          yield
  
      nsplits = in_tensor.nsplits
  
      if op.index is not None and hasattr(op.index, "key"):
          # rechunk index if it's a tensor
          if has_unknown_shape(*op.inputs):
              yield
          index_tensor = yield from recursive_tile(
              op.index.rechunk([nsplits[0]])
          )
      else:
          index_tensor = None
  
      # nsplits
      if in_tensor.ndim == 1:
          out_nsplits = in_tensor.nsplits + ((1,),)
      else:
          out_nsplits = in_tensor.nsplits
  
      cum_nsplits = [[0] + np.cumsum(ns).tolist() for ns in out_nsplits]
      for in_chunk in in_tensor.chunks:
          out_op = op.copy().reset_key()
          chunk_inputs = [in_chunk]
          if in_chunk.ndim == 1:
              i = in_chunk.index[0]
              chunk_index = (i, 0)
              chunk_shape = (in_chunk.shape[0], 1)
          else:
              i, j = in_chunk.index
              chunk_index = in_chunk.index
              chunk_shape = in_chunk.shape
  
          if op.columns is not None:
              column_nsplit = cum_nsplits[1]
              j = chunk_index[1]
              out_op.columns = op.columns[
                  column_nsplit[j] : column_nsplit[j + 1]
              ]
  
          if isinstance(op.index, INDEX_TYPE):
              index_chunk = index_tensor.chunks[i]
              chunk_inputs.append(index_chunk)
          elif isinstance(op.index, pd.Index):
              index_nsplit = cum_nsplits[0]
              if op.index.size > 0:
                  out_op.index = op.index[
                      index_nsplit[i] : index_nsplit[i + 1]
                  ]
          elif index_tensor is not None:
              index_chunk = index_tensor.cix[i]
              chunk_inputs.append(index_chunk)
  
          out_chunk = out_op.new_chunk(
              chunk_inputs, shape=chunk_shape, index=chunk_index
          )
          out_chunk._set_tileable_meta(
              tileable_key=out_df.key,
              nsplits=out_nsplits,
              index_value=out_df.index_value,
              columns_value=out_df.columns_value,
              dtypes=out_df.dtypes,
          )
          out_chunks.append(out_chunk)
  
      new_op = op.copy()
      params = out_df.params.copy()
      params["chunks"] = out_chunks
      params["nsplits"] = out_nsplits
      return new_op.new_dataframes(out_df.inputs, kws=[params])
  
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 10 for calling the DataFrameFromTensor obj's underlying member method code with example usage: obj._tile_input_tensor(cls, op) and returns: new_op