code: def arrays(
      dtype,  # type: Any
      shape,  # type: Union[int, Shape, st.SearchStrategy[Shape]]
      elements=None,  # type: st.SearchStrategy[Any]
      fill=None,  # type: st.SearchStrategy[Any]
      unique=False,  # type: bool
  ):
      # type: (...) -> st.SearchStrategy[np.ndarray]
      r"""Returns a strategy for generating :class:`numpy:numpy.ndarray`\ s.
  
      * ``dtype`` may be any valid input to :class:`~numpy:numpy.dtype`
        (this includes :class:`~numpy:numpy.dtype` objects), or a strategy that
        generates such values.
      * ``shape`` may be an integer >= 0, a tuple of such integers, or a
        strategy that generates such values.
      * ``elements`` is a strategy for generating values to put in the array.
        If it is None a suitable value will be inferred based on the dtype,
        which may give any legal value (including eg ``NaN`` for floats).
        If you have more specific requirements, you should supply your own
        elements strategy.
      * ``fill`` is a strategy that may be used to generate a single background
        value for the array. If None, a suitable default will be inferred
        based on the other arguments. If set to
        :func:`~hypothesis.strategies.nothing` then filling
        behaviour will be disabled entirely and every element will be generated
        independently.
      * ``unique`` specifies if the elements of the array should all be
        distinct from one another. Note that in this case multiple NaN values
        may still be allowed. If fill is also set, the only valid values for
        it to return are NaN values (anything for which :obj:`numpy:numpy.isnan`
        returns True. So e.g. for complex numbers (nan+1j) is also a valid fill).
        Note that if unique is set to True the generated values must be hashable.
  
      Arrays of specified ``dtype`` and ``shape`` are generated for example
      like this:
  
      .. code-block:: pycon
  
        >>> import numpy as np
        >>> arrays(np.int8, (2, 3)).example()
        array([[-8,  6,  3],
               [-6,  4,  6]], dtype=int8)
  
      - See :doc:`What you can generate and how <data>`.
  
      .. code-block:: pycon
  
        >>> import numpy as np
        >>> from hypothesis.strategies import floats
        >>> arrays(np.float, 3, elements=floats(0, 1)).example()
        array([ 0.88974794,  0.77387938,  0.1977879 ])
  
      Array values are generated in two parts:
  
      1. Some subset of the coordinates of the array are populated with a value
         drawn from the elements strategy (or its inferred form).
      2. If any coordinates were not assigned in the previous step, a single
         value is drawn from the fill strategy and is assigned to all remaining
         places.
  
      You can set fill to :func:`~hypothesis.strategies.nothing` if you want to
      disable this behaviour and draw a value for every element.
  
      If fill is set to None then it will attempt to infer the correct behaviour
      automatically: If unique is True, no filling will occur by default.
      Otherwise, if it looks safe to reuse the values of elements across
      multiple coordinates (this will be the case for any inferred strategy, and
      for most of the builtins, but is not the case for mutable values or
      strategies built with flatmap, map, composite, etc) then it will use the
      elements strategy as the fill, else it will default to having no fill.
  
      Having a fill helps Hypothesis craft high quality examples, but its
      main importance is when the array generated is large: Hypothesis is
      primarily designed around testing small examples. If you have arrays with
      hundreds or more elements, having a fill value is essential if you want
      your tests to run in reasonable time.
      """
      # We support passing strategies as arguments for convenience, or at least
      # for legacy reasons, but don't want to pay the perf cost of a composite
      # strategy (i.e. repeated argument handling and validation) when it's not
      # needed.  So we get the best of both worlds by recursing with flatmap,
      # but only when it's actually needed.
      if isinstance(dtype, SearchStrategy):
          return dtype.flatmap(
              lambda d: arrays(
                  d, shape, elements=elements, fill=fill, unique=unique
              )
          )
      if isinstance(shape, SearchStrategy):
          return shape.flatmap(
              lambda s: arrays(
                  dtype, s, elements=elements, fill=fill, unique=unique
              )
          )
      # From here on, we're only dealing with values and it's relatively simple.
      dtype = np.dtype(dtype)
      if elements is None:
          elements = from_dtype(dtype)
      if isinstance(shape, integer_types):
          shape = (shape,)
      shape = tuple(shape)
      check_argument(
          all(isinstance(s, integer_types) for s in shape),
          "Array shape must be integer in each dimension, provided shape was {}",
          shape,
      )
      fill = fill_for(elements=elements, unique=unique, fill=fill)
      return ArrayStrategy(elements, shape, dtype, fill, unique)
  
imports: from __future__ import absolute_import, division, print_function
  import math
  import re
  from collections import namedtuple
  import numpy
  import hypothesis.internal.conjecture.utils
  import hypothesis.strategies._internal.core
  from hypothesis import Verbosity, assume
  from hypothesis._settings import note_deprecation
  from hypothesis.errors import InvalidArgument
  from hypothesis.internal.compat import PY2, hrange, integer_types, quiet_raise, string_types
  from hypothesis.internal.coverage import check_function
  from hypothesis.internal.reflection import proxies, reserved_means_kwonly_star
  from hypothesis.internal.validation import check_type, check_valid_interval
  from hypothesis.reporting import current_verbosity
  from hypothesis.strategies._internal import SearchStrategy
  from hypothesis.utils.conventions import UniqueIdentifier, not_set
label_desc: Use image node_id 5 for calling a global function with example usage: arrays(dtype, shape, elements, fill, unique) and returns: ArrayStrategy, dtype, shape