code: def tile(cls, op):
      in_tensor = op.input
      if np.isnan(in_tensor.shape[op.axis]):
          yield
  
      kth = op.kth
      if isinstance(kth, TENSOR_TYPE):
          # if `kth` is a tensor, make sure no unknown shape
          if has_unknown_shape(kth):
              yield
          kth = yield from recursive_tile(kth.rechunk(kth.shape))
  
      return_value, return_indices = op.return_value, op.return_indices
      if in_tensor.chunk_shape[op.axis] == 1:
          out_chunks, out_indices_chunks = [], []
          for chunk in in_tensor.chunks:
              chunk_op = op.copy().reset_key()
              kws = []
              if return_value:
                  kws.append(
                      {
                          "shape": chunk.shape,
                          "index": chunk.index,
                          "order": chunk.order,
                          "dtype": chunk.dtype,
                          "type": "partitioned",
                      }
                  )
              if return_indices:
                  kws.append(
                      {
                          "shape": chunk.shape,
                          "index": chunk.index,
                          "order": TensorOrder.C_ORDER,
                          "dtype": np.dtype(np.int64),
                          "type": "argpartition",
                      }
                  )
              chunk_inputs = [chunk]
              if isinstance(kth, TENSOR_TYPE):
                  chunk_inputs.append(kth.chunks[0])
              chunks = chunk_op.new_chunks(chunk_inputs, kws=kws)
              if return_value:
                  out_chunks.append(chunks[0])
              if return_indices:
                  out_indices_chunks.append(chunks[-1])
  
          new_op = op.copy()
          kws = [out.params for out in op.outputs]
          if return_value:
              kws[0]["nsplits"] = in_tensor.nsplits
              kws[0]["chunks"] = out_chunks
          if return_indices:
              kws[-1]["nsplits"] = in_tensor.nsplits
              kws[-1]["chunks"] = out_indices_chunks
          return new_op.new_tensors([in_tensor], kws=kws)
      else:
          return (yield from cls._tile_psrs(op, kth))
  
imports: import itertools
  import numpy
  from ...None import opcodes
  from ...core import recursive_tile
  from ...serialization.serializables import FieldTypes, KeyField, Int32Field, StringField, ListField, BoolField, AnyField
  from ...utils import has_unknown_shape, flatten, stack_back
  from ...core import ENTITY_TYPE, ExecutableTuple
  from ..operands import TensorOperand, TensorShuffleProxy
  from ..core import TENSOR_TYPE, TENSOR_CHUNK_TYPE, TensorOrder
  from ..array_utils import as_same_device, device
  from ..datasource import tensor
  from ..utils import validate_axis, validate_order
  from .psrs import TensorPSRSOperandMixin
label_desc: Use image node_id 15 for calling the TensorPartition obj's underlying member method code with example usage: obj.tile(cls, op) and returns: new_op, unknown