docstr: ivy.Container static method variant of ivy.flip. This method simply
  wraps the function, and so the docstring for ivy.flip also applies to
  this method with minimal changes.
  
  Parameters
  ----------
  x
      input container.
  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
      axis (or axes) along which to flip. If axis is None,
      all input array axes are flipped. If axis is negative,
      axis is counted from the last dimension. If provided more
      than one axis, only the specified axes. Default: None.
  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.
  out
      optional output container, for writing the result to.
      It must have a shape that the inputs broadcast to.
  
  Returns
  -------
  ret
      an output container having the same data type and
      shape as ``x`` and whose elements, relative to ``x``, are reordered.
  
  Examples
  --------
  With one :class:`ivy.Container` input:
  
  >>> x = ivy.Container(a=ivy.array([-1, 0, 1]),
  ...                   b=ivy.array([2, 3, 4]))
  >>> y = ivy.Container.static_flip(x)
  >>> print(y)
  {
      a: ivy.array([1, 0, -1]),
      b: ivy.array([4, 3, 2])
  }
  
  >>> x = ivy.Container(a=ivy.array([-1, 0, 1]),
  ...                   b=ivy.array([2, 3, 4]))
  >>> y = ivy.Container.static_flip(x, axis=0)
  >>> print(y)
  {
      a: ivy.array([1, 0, -1]),
      b: ivy.array([4, 3, 2])
  }
code: def _static_flip(
      x: ivy.Container,
      /,
      *,
      copy: Optional[Union[bool, ivy.Container]] = None,
      axis: Optional[Union[int, Sequence[int], ivy.Container]] = None,
      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,
      out: Optional[ivy.Container] = None,
  ) -> ivy.Container:
      """ivy.Container static method variant of ivy.flip. This method simply
      wraps the function, and so the docstring for ivy.flip also applies to
      this method with minimal changes.
  
      Parameters
      ----------
      x
          input container.
      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
          axis (or axes) along which to flip. If axis is None,
          all input array axes are flipped. If axis is negative,
          axis is counted from the last dimension. If provided more
          than one axis, only the specified axes. Default: None.
      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.
      out
          optional output container, for writing the result to.
          It must have a shape that the inputs broadcast to.
  
      Returns
      -------
      ret
          an output container having the same data type and
          shape as ``x`` and whose elements, relative to ``x``, are reordered.
  
      Examples
      --------
      With one :class:`ivy.Container` input:
  
      >>> x = ivy.Container(a=ivy.array([-1, 0, 1]),
      ...                   b=ivy.array([2, 3, 4]))
      >>> y = ivy.Container.static_flip(x)
      >>> print(y)
      {
          a: ivy.array([1, 0, -1]),
          b: ivy.array([4, 3, 2])
      }
  
      >>> x = ivy.Container(a=ivy.array([-1, 0, 1]),
      ...                   b=ivy.array([2, 3, 4]))
      >>> y = ivy.Container.static_flip(x, axis=0)
      >>> print(y)
      {
          a: ivy.array([1, 0, -1]),
          b: ivy.array([4, 3, 2])
      }
      """
      return ContainerBase.cont_multi_map_in_function(
          "flip",
          x,
          copy=copy,
          axis=axis,
          key_chains=key_chains,
          to_apply=to_apply,
          prune_unapplied=prune_unapplied,
          map_sequences=map_sequences,
          out=out,
      )
  
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 9 for calling the _ContainerWithManipulation obj's underlying member method code with example usage: obj._static_flip() and returns: ContainerBase