code: def arrays_for_pooling(
      draw,
      min_dims,
      max_dims,
      min_side,
      max_side,
      explicit_or_str_padding=False,
      only_explicit_padding=False,
      return_dilation=False,
      mixed_fn_compos=True,
      data_format="channel_last",
      return_data_format=False,
  ):
      in_shape = draw(
          nph.array_shapes(
              min_dims=min_dims,
              max_dims=max_dims,
              min_side=min_side,
              max_side=max_side,
          )
      )
      dtype, x = draw(
          dtype_and_values(
              available_dtypes=get_dtypes(
                  "float", mixed_fn_compos=mixed_fn_compos
              ),
              shape=in_shape,
              num_arrays=1,
              max_value=100,
              min_value=-100,
          )
      )
  
      if not isinstance(data_format, str):
          data_format = draw(data_format)
      array_dim = x[0].ndim
      if array_dim == 5:
          kernel = draw(
              st.tuples(
                  st.integers(1, in_shape[1]),
                  st.integers(1, in_shape[2]),
                  st.integers(1, in_shape[3]),
              )
          )
      if array_dim == 4:
          kernel = draw(
              st.tuples(
                  st.integers(1, in_shape[1]),
                  st.integers(1, in_shape[2]),
              )
          )
      if array_dim == 3:
          kernel = draw(st.tuples(st.integers(1, in_shape[1])))
      if return_dilation:
          dilations = []
          for i in range(len(kernel)):
              if kernel[i] > 1:
                  max_dilation = (in_shape[i + 1] - kernel[i]) // (
                      kernel[i] - 1
                  ) + 1
                  dilations.append(draw(st.integers(1, max_dilation)))
              else:
                  dilations.append(1)
      if explicit_or_str_padding or only_explicit_padding:
          if draw(st.booleans()):
              max_pad = min(
                  kernel[i] // 2 for i in range(array_dim - 2)
              )
              padding = draw(st.integers(0, max_pad))
          else:
              padding = []
              for i in range(array_dim - 2):
                  max_pad = kernel[i] // 2
                  padding.append(
                      draw(
                          st.tuples(
                              st.integers(0, max_pad),
                              st.integers(0, max_pad),
                          )
                      )
                  )
          if explicit_or_str_padding:
              padding = draw(
                  st.one_of(
                      st.just(padding),
                      st.sampled_from(["VALID", "SAME"]),
                  )
              )
      else:
          padding = draw(st.sampled_from(["VALID", "SAME"]))
  
      # We do this to avoid this error in the tf backend
      # ValueError: `strides > 1` not supported in conjunction with `dilation_rate > 1`
      # TODO: Explore fully compositional implementation for pooling to bypass this in tf.
      if return_dilation:
          strides = (
              draw(st.tuples(st.integers(1, min(kernel))))
              if max(dilations) <= 1
              else (1,)
          )
      else:
          strides = draw(st.tuples(st.integers(1, min(kernel))))
  
      if data_format == "channel_first":
          dim = len(in_shape)
          x[0] = np.transpose(x[0], (0, dim - 1, *range(1, dim - 1)))
  
      out = [dtype, x, kernel, strides, padding]
      if return_dilation:
          out.append(dilations)
      if return_data_format:
          out.append(data_format)
  
      return tuple(out)
  
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 17 for calling a global function with example usage: arrays_for_pooling(draw, min_dims, max_dims, min_side, max_side, explicit_or_str_padding, only_explicit_padding, return_dilation, mixed_fn_compos, data_format, return_data_format) and returns: tuple