code: def tile(cls, op: "TensorDelete"):
      inp = op.input
      index_obj = op.index_obj
      axis = op.axis
      if axis is None:
          inp = yield from recursive_tile(inp.flatten())
          axis = 0
      if has_unknown_shape(inp):
          yield
  
      if isinstance(index_obj, int):
          index_obj = [index_obj]
  
      if isinstance(index_obj, ENTITY_TYPE):
          index_obj = yield from recursive_tile(
              index_obj.rechunk(index_obj.shape)
          )
          offsets = np.cumsum([0] + list(inp.nsplits[axis]))
          out_chunks = []
          for c in inp.chunks:
              chunk_op = op.copy().reset_key()
              chunk_op._index_obj = index_obj.chunks[0]
              chunk_op._offset_on_axis = int(offsets[c.index[axis]])
              shape = tuple(
                  np.nan if j == axis else s
                  for j, s in enumerate(c.shape)
              )
              out_chunks.append(
                  chunk_op.new_chunk(
                      [c, index_obj.chunks[0]],
                      shape=shape,
                      index=c.index,
                  )
              )
          nsplits_on_axis = (np.nan,) * len(inp.nsplits[axis])
      else:
          nsplits_on_axis = [None for _ in inp.nsplits[axis]]
          out_chunks = []
          # index_obj is list, tuple, slice or array like
          if isinstance(index_obj, slice):
              slc_splits = slice_split(index_obj, inp.nsplits[axis])
              for c in inp.chunks:
                  if c.index[axis] in slc_splits:
                      chunk_op = op.copy().reset_key()
                      chunk_slc = slc_splits[c.index[axis]]
                      shape = tuple(
                          s - calc_object_length(chunk_slc, s)
                          if j == axis
                          else s
                          for j, s in enumerate(c.shape)
                      )
                      chunk_op._index_obj = chunk_slc
                      out_chunks.append(
                          chunk_op.new_chunk(
                              [c], shape=shape, index=c.index
                          )
                      )
                      nsplits_on_axis[c.index[axis]] = shape[axis]
                  else:
                      out_chunks.append(c)
                      nsplits_on_axis[c.index[axis]] = c.shape[axis]
          else:
              index_obj = np.array(index_obj)
              cum_splits = np.cumsum([0] + list(inp.nsplits[axis]))
              chunk_indexes = defaultdict(list)
              for int_idx in index_obj:
                  in_idx = (
                      cum_splits.searchsorted(int_idx, side="right") - 1
                  )
                  chunk_indexes[in_idx].append(
                      int_idx - cum_splits[in_idx]
                  )
  
              for c in inp.chunks:
                  idx_on_axis = c.index[axis]
                  if idx_on_axis in chunk_indexes:
                      chunk_op = op.copy().reset_key()
                      chunk_op._index_obj = chunk_indexes[idx_on_axis]
                      shape = tuple(
                          s - len(chunk_indexes[idx_on_axis])
                          if j == axis
                          else s
                          for j, s in enumerate(c.shape)
                      )
                      out_chunks.append(
                          chunk_op.new_chunk(
                              [c], shape=shape, index=c.index
                          )
                      )
                      nsplits_on_axis[c.index[axis]] = shape[axis]
                  else:
                      out_chunks.append(c)
                      nsplits_on_axis[c.index[axis]] = c.shape[axis]
  
      nsplits = tuple(
          s if i != axis else tuple(nsplits_on_axis)
          for i, s in enumerate(inp.nsplits)
      )
      out = op.outputs[0]
      new_op = op.copy()
      return new_op.new_tensors(
          op.inputs,
          shape=out.shape,
          order=out.order,
          chunks=out_chunks,
          nsplits=nsplits,
      )
  
imports: from collections import defaultdict
  import numpy
  from ...None import opcodes
  from ...core import ENTITY_TYPE, recursive_tile
  from ...serialization.serializables import Int32Field, Int64Field, AnyField, KeyField
  from ...utils import has_unknown_shape
  from ..datasource import tensor
  from ..operands import TensorHasInput, TensorOperandMixin
  from ..utils import filter_inputs, validate_axis, slice_split, calc_object_length
label_desc: Use image node_id 6 for calling the TensorDelete obj's underlying member method code with example usage: obj.tile(cls, op) and returns: new_op