docstr: ivy.Container static method variant of ivy.split. This method simply
  wraps the function, and so the docstring for ivy.split also applies to
  this method with minimal changes.
  
  Parameters
  ----------
  x
      array to be divided into sub-arrays.
  num_or_size_splits
      Number of equal arrays to divide the array into along the given axis if an
      integer. The size of each split element if a sequence of integers
      or 1-D array. Default is to divide into as many 1-dimensional arrays
      as the axis dimension.
  copy
      boolean indicating whether or not to copy the input array.
      If True, the function must always copy.
      If False, the function must never copy and must
      raise a ValueError in case a copy would be necessary.
      If None, the function must reuse existing memory buffer if possible
      and copy otherwise. Default: ``None``.
  axis
      The axis along which to split, default is ``0``.
  with_remainder
      If the tensor does not split evenly, then store the last remainder entry.
      Default is ``False``.
  key_chains
      The key-chains to apply or not apply the method to. Default is ``None``.
  to_apply
      If True, the method will be applied to key_chains, otherwise key_chains will
      be skipped. Default is ``True``.
  prune_unapplied
      Whether to prune key_chains for which the function was not applied. Default
      is False.
  map_sequences
      Whether to also map method to sequences (lists, tuples).
      Default is ``False``.
  
  Returns
  -------
      list of containers of sub-arrays.
  
  Examples
  --------
  >>> x = ivy.Container(a=ivy.array([2, 1, 5, 9]), b=ivy.array([3, 7, 2, 11]))
  >>> y = ivy.Container.static_split(x, num_or_size_splits=2)
  >>> print(y)
  [{
      a: ivy.array([2, 1]),
      b: ivy.array([3, 7])
  }, {
      a: ivy.array([5, 9]),
      b: ivy.array([2, 11])
  }]
code: def _static_split(
      x: Union[ivy.Container, ivy.Array, ivy.NativeArray],
      /,
      *,
      copy: Optional[Union[bool, ivy.Container]] = None,
      num_or_size_splits: Optional[
          Union[
              int,
              Sequence[int],
              ivy.Array,
              ivy.NativeArray,
              ivy.Container,
          ]
      ] = None,
      axis: Union[int, ivy.Container] = 0,
      with_remainder: Union[bool, ivy.Container] = False,
      key_chains: Optional[
          Union[List[str], Dict[str, str], ivy.Container]
      ] = None,
      to_apply: Union[bool, ivy.Container] = True,
      prune_unapplied: Union[bool, ivy.Container] = False,
      map_sequences: Union[bool, ivy.Container] = False,
  ) -> List[ivy.Container]:
      """ivy.Container static method variant of ivy.split. This method simply
      wraps the function, and so the docstring for ivy.split also applies to
      this method with minimal changes.
  
      Parameters
      ----------
      x
          array to be divided into sub-arrays.
      num_or_size_splits
          Number of equal arrays to divide the array into along the given axis if an
          integer. The size of each split element if a sequence of integers
          or 1-D array. Default is to divide into as many 1-dimensional arrays
          as the axis dimension.
      copy
          boolean indicating whether or not to copy the input array.
          If True, the function must always copy.
          If False, the function must never copy and must
          raise a ValueError in case a copy would be necessary.
          If None, the function must reuse existing memory buffer if possible
          and copy otherwise. Default: ``None``.
      axis
          The axis along which to split, default is ``0``.
      with_remainder
          If the tensor does not split evenly, then store the last remainder entry.
          Default is ``False``.
      key_chains
          The key-chains to apply or not apply the method to. Default is ``None``.
      to_apply
          If True, the method will be applied to key_chains, otherwise key_chains will
          be skipped. Default is ``True``.
      prune_unapplied
          Whether to prune key_chains for which the function was not applied. Default
          is False.
      map_sequences
          Whether to also map method to sequences (lists, tuples).
          Default is ``False``.
  
      Returns
      -------
          list of containers of sub-arrays.
  
      Examples
      --------
      >>> x = ivy.Container(a=ivy.array([2, 1, 5, 9]), b=ivy.array([3, 7, 2, 11]))
      >>> y = ivy.Container.static_split(x, num_or_size_splits=2)
      >>> print(y)
      [{
          a: ivy.array([2, 1]),
          b: ivy.array([3, 7])
      }, {
          a: ivy.array([5, 9]),
          b: ivy.array([2, 11])
      }]
      """
      return ContainerBase.cont_multi_map_in_function(
          "split",
          x,
          copy=copy,
          num_or_size_splits=num_or_size_splits,
          axis=axis,
          with_remainder=with_remainder,
          key_chains=key_chains,
          to_apply=to_apply,
          prune_unapplied=prune_unapplied,
          map_sequences=map_sequences,
      )
  
imports: from typing import Optional, Union, List, Tuple, Dict, Iterable, Sequence
  from numbers import Number
  import ivy
  from ivy.data_classes.container.base import ContainerBase
label_desc: Use image node_id 5 for calling the _ContainerWithManipulation obj's underlying member method code with example usage: obj._static_split() and returns: ContainerBase