code: def _tile_fft(cls, op, axes):
      in_tensor = op.inputs[0]
      out_tensor = op.outputs[0]
  
      if any(in_tensor.chunk_shape[axis] != 1 for axis in axes):
          if has_unknown_shape(in_tensor):
              yield
          # fft requires only 1 chunk for the specified axis, so we do rechunk first
          chunks = {
              validate_axis(in_tensor.ndim, axis): in_tensor.shape[axis]
              for axis in axes
          }
          new_chunks = decide_chunk_sizes(
              in_tensor.shape, chunks, in_tensor.dtype.itemsize
          )
          in_tensor = yield from recursive_tile(
              in_tensor.rechunk(new_chunks)
          )
  
      out_chunks = []
      for c in in_tensor.chunks:
          chunk_op = op.copy().reset_key()
          chunk_shape = cls._get_shape(op, c.shape)
          out_chunk = chunk_op.new_chunk(
              [c],
              shape=chunk_shape,
              index=c.index,
              order=out_tensor.order,
          )
          out_chunks.append(out_chunk)
  
      nsplits = [
          tuple(
              c.shape[i]
              for c in out_chunks
              if all(
                  idx == 0 for j, idx in enumerate(c.index) if j != i
              )
          )
          for i in range(len(out_chunks[0].shape))
      ]
      new_op = op.copy()
      return new_op.new_tensors(
          op.inputs,
          out_tensor.shape,
          order=out_tensor.order,
          chunks=out_chunks,
          nsplits=nsplits,
      )
  
imports: from collections.abc import Iterable
  from ...core import recursive_tile
  from ...serialization.serializables import FieldTypes, KeyField, StringField, Int32Field, Int64Field, TupleField
  from ...utils import has_unknown_shape
  from ..utils import validate_axis, decide_chunk_sizes
  from ..operands import TensorHasInput, TensorOperandMixin
  from ..array_utils import get_array_module
label_desc: Use image node_id 2 for calling the TensorFFTBaseMixin obj's underlying member method code with example usage: obj._tile_fft(cls, op, axes) and returns: new_op