code: def __call__(self, a, indices_or_sections, is_split=False):
      axis = self._axis
      size = a.shape[axis]
      if np.isnan(size):
          raise ValueError(
              "cannot split array with unknown shape, "
              "call `.execute()` on input tensor first"
          )
  
      if (
          isinstance(indices_or_sections, Tensor)
          and hasattr(indices_or_sections.op, "data")
          and indices_or_sections.op.data is not None
      ):
          indices_or_sections = indices_or_sections.op.data
  
      try:
          indices_or_sections = int(indices_or_sections)
          if is_split:
              if size % indices_or_sections:
                  raise ValueError(
                      "tensor split does not result in an equal division"
                  )
              nparts = indices_or_sections
              nsplit = (size // indices_or_sections,) * nparts
          else:
              nparts = indices_or_sections
              if size % indices_or_sections == 0:
                  nsplit = (size // indices_or_sections,) * nparts
              else:
                  nsplit = (size // indices_or_sections + 1,) * (
                      size % indices_or_sections
                  ) + (size // indices_or_sections,) * (
                      size - size % indices_or_sections
                  )
      except TypeError:
          if isinstance(indices_or_sections, Tensor):
              nparts = indices_or_sections.shape[0] + 1
              nsplit = (np.nan,) * nparts
          else:
              ind = indices_or_sections = get_array_module(
                  indices_or_sections
              ).asarray(indices_or_sections)
              if indices_or_sections.ndim != 1 or not np.issubdtype(
                  indices_or_sections.dtype, np.integer
              ):
                  raise TypeError(
                      "slice indices must be integers or None"
                  )
              nparts = indices_or_sections.shape[0] + 1
              get = lambda i: None if i < 0 or i >= len(ind) else ind[i]
              nsplit = [
                  calc_sliced_size(size, slice(get(j - 1), get(j)))
                  for j in range(nparts)
              ]
  
      inputs = [a]
      if isinstance(indices_or_sections, Tensor):
          inputs.append(indices_or_sections)
      else:
          self._indices_or_sections = indices_or_sections
  
      kws = [
          {
              "i": i,
              "shape": a.shape[:axis]
              + (nsplit[i],)
              + a.shape[axis + 1 :],
              "order": a.order,
          }
          for i in range(nparts)
      ]
      return ExecutableTuple(
          self.new_tensors(inputs, kws=kws, output_limit=nparts)
      )
  
imports: import numpy
  from ...None import opcodes
  from ...core import ExecutableTuple, recursive_tile
  from ...lib.sparse.core import get_array_module
  from ...serialization.serializables import KeyField, AnyField, Int32Field
  from ..core import Tensor
  from ..datasource import tensor
  from ..utils import calc_sliced_size
  from ..operands import TensorHasInput, TensorOperandMixin
label_desc: Use image node_id 6 for calling the TensorSplit obj's underlying member method code with example usage: obj.__call__(a, indices_or_sections, is_split) and returns: ExecutableTuple