code: def get_axis(
      draw,
      *,
      shape,
      allow_neg=True,
      allow_none=False,
      sort_values=True,
      unique=True,
      min_size=1,
      max_size=None,
      force_tuple=False,
      force_int=False,
  ):
      """Draws one or more axis for the given shape.
  
      Parameters
      ----------
      draw
          special function that draws data randomly (but is reproducible) from a given
          data-set (ex. list).
      shape
          shape of the array as a tuple, or a hypothesis strategy from which the shape
          will be drawn
      allow_neg
          boolean; if True, allow negative axes to be drawn
      allow_none
          boolean; if True, allow None to be drawn
      sort_values
          boolean; if True, and a tuple of axes is drawn, tuple is sorted in increasing
          fashion
      unique
          boolean; if True, and a tuple of axes is drawn, all axes drawn will be unique
      min_size
          int or hypothesis strategy; if a tuple of axes is drawn, the minimum number of
          axes drawn
      max_size
          int or hypothesis strategy; if a tuple of axes is drawn, the maximum number of
          axes drawn.
          If None and unique is True, then it is set to the number of axes in the shape
      force_tuple
          boolean, if true, all axis will be returned as a tuple. If force_tuple and
          force_int are true, then an AssertionError is raised
      force_int
          boolean, if true, all axis will be returned as an int. If force_tuple and
          force_int are true, then an AssertionError is raised
  
      Returns
      -------
          A strategy that draws an axis or axes.
      """
      assert not (
          force_int and force_tuple
      ), "Cannot return an int and a tuple. If both are valid then set both to False."
  
      # Draw values from any strategies given
      if isinstance(shape, st._internal.SearchStrategy):
          shape = draw(shape)
      if isinstance(min_size, st._internal.SearchStrategy):
          min_size = draw(min_size)
      if isinstance(max_size, st._internal.SearchStrategy):
          max_size = draw(max_size)
  
      axes = len(shape)
      lower_axes_bound = axes if allow_neg else 0
  
      if max_size is None and unique:
          max_size = max(axes, min_size)
  
      valid_strategies = []
  
      if allow_none:
          valid_strategies.append(st.none())
  
      if min_size > 1:
          force_tuple = True
  
      if not force_tuple:
          if axes == 0:
              valid_strategies.append(st.just(0))
          else:
              valid_strategies.append(
                  st.integers(-lower_axes_bound, axes - 1)
              )
      if not force_int:
          if axes == 0:
              valid_strategies.append(
                  st.lists(
                      st.just(0), min_size=min_size, max_size=max_size
                  )
              )
          else:
              valid_strategies.append(
                  st.lists(
                      st.integers(-lower_axes_bound, axes - 1),
                      min_size=min_size,
                      max_size=max_size,
                      unique=unique,
                  )
              )
  
      axis = draw(
          st.one_of(*valid_strategies).filter(
              lambda x: (
                  all(i != axes + j for i in x for j in x)
                  if (isinstance(x, list) and unique and allow_neg)
                  else True
              )
          )
      )
  
      if isinstance(axis, list):
          if sort_values:
  
              def sort_key(ele, max_len):
                  if ele < 0:
                      return ele + max_len
                  return ele
  
              axis.sort(key=(lambda ele: sort_key(ele, axes)))
          axis = tuple(axis)
      return axis
  
imports: from hypothesis import assume, strategies
  from typing import Tuple
  from functools import lru_cache
  import math
  import numpy
  import ivy
  from .None import array_helpers, number_helpers, dtype_helpers
  from ..pipeline_helper import WithBackendContext
  from ivy.functional.ivy.layers import _deconv_length
  from ..globals import mod_backend
label_desc: Use image node_id 12 for calling a global function with example usage: get_axis(draw) and returns: axis, ele, unknown