docstr: ivy.Container instance method variant of ivy.reshape. This method
  simply wraps the function, and so the docstring for ivy.reshape also
  applies to this method with minimal changes.
  
  Parameters
  ----------
  self
      input container.
  shape
      The new shape should be compatible with the original shape.
      One shape dimension can be -1. In this case, the value is
      inferred from the length of the array and remaining dimensions.
  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``.
  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``.
  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``.
  order
      Read the elements of the input container using this index order,
      and place the elements into the reshaped array using this index order.
      ‘C’ means to read / write the elements using C-like index order,
      with the last axis index changing fastest, back to the first axis index
      changing slowest.
      ‘F’ means to read / write the elements using Fortran-like index order, with
      the first index changing fastest, and the last index changing slowest.
      Note that the ‘C’ and ‘F’ options take no account of the memory layout
      of the underlying array, and only refer to the order of indexing.
      Default order is 'C'
  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 as ``self``
      and elements as ``self``.
  
  Examples
  --------
  >>> x = ivy.Container(a=ivy.array([0, 1, 2, 3, 4, 5]),
  ...                   b=ivy.array([0, 1, 2, 3, 4, 5]))
  >>> y = x.reshape((2,3))
  >>> print(y)
  {
      a: ivy.array([[0, 1, 2],
                    [3, 4, 5]]),
      b: ivy.array([[0, 1, 2],
                    [3, 4, 5]])
  }
  
  >>> x = ivy.Container(a=ivy.array([0, 1, 2, 3, 4, 5]),
  ...                   b=ivy.array([0, 1, 2, 3, 4, 5]))
  >>> y = x.reshape((2,3), order='F')
  >>> print(y)
  {
      a: ivy.array([[0, 2, 4],
                    [1, 3, 5]]),
      b: ivy.array([[0, 2, 4],
                    [1, 3, 5]])
  }
code: def reshape(
      self: ivy.Container,
      /,
      shape: Union[
          ivy.Shape, ivy.NativeShape, Sequence[int], ivy.Container
      ],
      *,
      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,
      copy: Optional[Union[bool, ivy.Container]] = None,
      order: Union[str, ivy.Container] = "C",
      allowzero: Union[bool, ivy.Container] = True,
      out: Optional[ivy.Container] = None,
  ) -> ivy.Container:
      """ivy.Container instance method variant of ivy.reshape. This method
      simply wraps the function, and so the docstring for ivy.reshape also
      applies to this method with minimal changes.
  
      Parameters
      ----------
      self
          input container.
      shape
          The new shape should be compatible with the original shape.
          One shape dimension can be -1. In this case, the value is
          inferred from the length of the array and remaining dimensions.
      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``.
      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``.
      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``.
      order
          Read the elements of the input container using this index order,
          and place the elements into the reshaped array using this index order.
          ‘C’ means to read / write the elements using C-like index order,
          with the last axis index changing fastest, back to the first axis index
          changing slowest.
          ‘F’ means to read / write the elements using Fortran-like index order, with
          the first index changing fastest, and the last index changing slowest.
          Note that the ‘C’ and ‘F’ options take no account of the memory layout
          of the underlying array, and only refer to the order of indexing.
          Default order is 'C'
      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 as ``self``
          and elements as ``self``.
  
      Examples
      --------
      >>> x = ivy.Container(a=ivy.array([0, 1, 2, 3, 4, 5]),
      ...                   b=ivy.array([0, 1, 2, 3, 4, 5]))
      >>> y = x.reshape((2,3))
      >>> print(y)
      {
          a: ivy.array([[0, 1, 2],
                        [3, 4, 5]]),
          b: ivy.array([[0, 1, 2],
                        [3, 4, 5]])
      }
  
      >>> x = ivy.Container(a=ivy.array([0, 1, 2, 3, 4, 5]),
      ...                   b=ivy.array([0, 1, 2, 3, 4, 5]))
      >>> y = x.reshape((2,3), order='F')
      >>> print(y)
      {
          a: ivy.array([[0, 2, 4],
                        [1, 3, 5]]),
          b: ivy.array([[0, 2, 4],
                        [1, 3, 5]])
      }
      """
      return self._static_reshape(
          self,
          shape,
          key_chains=key_chains,
          to_apply=to_apply,
          prune_unapplied=prune_unapplied,
          map_sequences=map_sequences,
          copy=copy,
          allowzero=allowzero,
          out=out,
          order=order,
      )
  
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 12 for calling the _ContainerWithManipulation obj's underlying member method code with example usage: obj.reshape(shape) and returns: self