code: def array_indices_put_along_axis(
      draw,
      *,
      array_dtypes,
      indices_dtypes=get_dtypes("valid"),
      disable_random_axis=False,
      axis_zero=False,
      allow_inf=False,
      min_num_dims=1,
      max_num_dims=5,
      min_dim_size=1,
      max_dim_size=10,
      first_dimension_only=False,
      indices_same_dims=False,
      valid_bounds=True,
      values=None,
      values_dtypes=get_dtypes("valid"),
  ):
      """Generate two arrays x & indices, the values in the indices array are
      indices of the array x. Draws an integers randomly from the minimum and
      maximum number of positional arguments a given function can take.
  
      Parameters
      ----------
      draw
          special function that draws data randomly (but is reproducible) from a given
          data-set (ex. list).
      array_dtypes
          list of data type to draw the array dtype from.
      indices_dtypes
          list of data type to draw the indices dtype from.
      disable_random_axis
          axis is randomly generated with hypothesis if False. If True, axis is set
          to 0 if axis_zero is True, -1 otherwise.
      axis_zero
          If True, axis is set to zero if disable_random_axis is True.
      allow_inf
          inf values are allowed to be generated in the values array when True.
      min_num_dims
          The minimum number of dimensions the arrays can have.
      max_num_dims
          The maximum number of dimensions the arrays can have.
      min_dim_size
          The minimum size of the dimensions of the arrays.
      max_dim_size
          The maximum size of the dimensions of the arrays.
      indices_same_dims
          Set x and indices dimensions to be the same
      valid_bounds
          If False, the strategy may produce out-of-bounds indices.
      values
          Custom values array to use instead of randomly generated values.
      values_dtypes : Union[None, List[str]]
          A list of dtypes for the values parameter. The function will use the dtypes
          returned by 'get_dtypes("valid")'.
  
      Returns
      -------
      ret
          A strategy that can be used in the @given hypothesis
          decorator which generates arrays of values and indices.
  
      Examples
      --------
      @given(
          array_indices_axis=array_indices_axis(
              array_dtypes=helpers.get_dtypes("valid"),
              indices_dtypes=helpers.get_dtypes("integer"),
              min_num_dims=1,
              max_num_dims=5,
              min_dim_size=1,
              max_dim_size=10
              )
      )
  
      >>> array_indices_axis(
      ...    array_dtypes=get_dtypes("valid"),
      ...     indices_dtypes=["int64"],
      ...     max_num_dims=1,
      ...     indices_same_dims=True,
      ...     disable_random_axis=True,
      ...     axis_zero=True,
      ... )
      (['int64', 'int64'], array([-65536]), array([0]))
      (['bool', 'int64'], array([False, False, False, True,
          False, False, False, False]), array([0, 0, 2, 4,
          0, 0, 0, 1]))
      (['int64', 'int64'], array([0]), array([0]))
  
      >>> array_indices_axis(
      ...     array_dtypes=get_dtypes("valid"),
      ...     indices_dtypes=get_dtypes("integer"),
      ...     disable_random_axis=True,
      ...     first_dimension_only=True,
      ... )
      (['float64', 'uint64'], array([-2.44758124e-308]),
          array([0], dtype=uint64))
      (['bool', 'uint64'], array([False]), array([0], dtype=uint64))
      (['bool', 'int8'], array([False]), array([[0, 0, 0, 0],
         [0, 0, 0, 0],
         [0, 0, 0, 0],
         [0, 0, 0, 0]], dtype=int8))
  
      >>> array_indices_axis(
      ...     array_dtypes=get_dtypes("valid"),
      ...     indices_dtypes=["int64"],
      ...     max_num_dims=1,
      ...     indices_same_dims=True,
      ... )
      (['float16', 'int64'], array([-256.], dtype=float16),
          array([0]), 0, 0)
      (['uint8', 'int64'], array([1], dtype=uint8),
          array([0]), -1, 0)
      (['uint64', 'int64'], array([0], dtype=uint64),
          array([0]), 0, 0)
      """
      x_dtype, x, x_shape = draw(
          dtype_and_values(
              available_dtypes=array_dtypes,
              allow_inf=allow_inf,
              ret_shape=True,
              min_num_dims=min_num_dims,
              max_num_dims=max_num_dims,
              min_dim_size=min_dim_size,
              max_dim_size=max_dim_size,
          )
      )
      x_dtype = x_dtype[0]
      x = x[0]
      if disable_random_axis:
          if axis_zero:
              axis = 0
          else:
              axis = -1
          batch_dims = 0
          batch_shape = x_shape[0:0]
      else:
          axis = draw(
              number_helpers.ints(
                  min_value=-1 * len(x_shape),
                  max_value=len(x_shape) - 1,
              )
          )
          batch_dims = draw(
              number_helpers.ints(
                  min_value=0,
                  max_value=max(0, axis),
              )
          )
          batch_shape = x_shape[0:batch_dims]
      if indices_same_dims:
          indices_shape = x_shape
      else:
          shape_var = draw(
              gh.get_shape(
                  allow_none=False,
                  min_num_dims=min_num_dims,
                  max_num_dims=max_num_dims - batch_dims,
                  min_dim_size=min_dim_size,
                  max_dim_size=max_dim_size,
              )
          )
          indices_shape = batch_shape + shape_var
      if first_dimension_only:
          max_axis = max(x_shape[0] - 1, 0)
      else:
          max_axis = max(x_shape[axis] - 1, 0)
      if not valid_bounds:
          max_axis = max_axis + 10
      indices_dtype, indices = draw(
          dtype_and_values(
              available_dtypes=indices_dtypes,
              allow_inf=False,
              min_value=0,
              max_value=max_axis,
              shape=indices_shape,
          )
      )
      indices_dtype = indices_dtype[0]
      indices = indices[0]
      if disable_random_axis:
          return [x_dtype, indices_dtype], x, indices
  
      values_shape = indices_shape
      values_dtype, values = draw(
          dtype_and_values(
              available_dtypes=values_dtypes,
              allow_inf=False,
              shape=values_shape,
          )
      )
      values_dtype = values_dtype[0]
      values = values[0]
      return (
          [x_dtype, indices_dtype, values_dtype],
          x,
          indices,
          axis,
          values,
          batch_dims,
      )
  
imports: import numpy
  import hypothesis.extra.numpy
  from hypothesis import strategies
  from hypothesis.internal.floats import float_of
  from functools import reduce
  from operator import mul
  import sys
  import string
  import ml_dtypes
  import ivy_tests.test_ivy.helpers.globals
  from ..pipeline_helper import WithBackendContext
  import ivy_tests.test_ivy.helpers
  from ivy_tests.test_ivy.helpers.hypothesis_helpers.dtype_helpers import get_dtypes
  from .None import general_helpers
  from .None import dtype_helpers, number_helpers
  from ..globals import mod_backend
label_desc: Use image node_id 7 for calling a global function with example usage: array_indices_put_along_axis(draw) and returns: list,  x,  indices,  axis,  values,  batch_dims, list,  x,  indices