code: def _interp_args(draw, mode=None, mode_list=None):
      mixed_fn_compos = draw(st.booleans())
      curr_backend = ivy.current_backend_str()
      torch_modes = [
          "linear",
          "bilinear",
          "trilinear",
          "nearest",
          "nearest-exact",
          "area",
          "bicubic",
      ]
      tf_modes = [
          "linear",
          "bilinear",
          "trilinear",
          "nearest-exact",
          "tf_area",
          "tf_bicubic",
          "lanczos3",
          "lanczos5",
          "mitchellcubic",
          "gaussian",
      ]
      jax_modes = [
          "linear",
          "bilinear",
          "trilinear",
          "nearest-exact",
          "tf_bicubic",
          "lanczos3",
          "lanczos5",
      ]
      if mode_list == "torch":
          mode_list = torch_modes
      if not mode and not mode_list:
          if curr_backend == "torch" and not mixed_fn_compos:
              mode = draw(st.sampled_from(torch_modes))
          elif curr_backend == "tensorflow" and not mixed_fn_compos:
              mode = draw(st.sampled_from(tf_modes))
          elif curr_backend == "jax" and not mixed_fn_compos:
              mode = draw(st.sampled_from(jax_modes))
          else:
              mode = draw(
                  st.sampled_from(
                      [
                          "linear",
                          "bilinear",
                          "trilinear",
                          "nearest",
                          "nearest-exact",
                          "area",
                          "tf_area",
                          "tf_bicubic",
                          "lanczos3",
                          "lanczos5",
                          "mitchellcubic",
                          "gaussian",
                      ]
                  )
              )
      elif mode_list:
          mode = draw(st.sampled_from(mode_list))
      if mode == "linear":
          num_dims = 3
      elif mode in [
          "bilinear",
          "tf_bicubic",
          "bicubic",
          "mitchellcubic",
          "gaussian",
      ]:
          num_dims = 4
      elif mode == "trilinear":
          num_dims = 5
      elif mode in [
          "nearest",
          "area",
          "tf_area",
          "lanczos3",
          "lanczos5",
          "nearest-exact",
      ]:
          num_dims = (
              draw(
                  helpers.ints(
                      min_value=1,
                      max_value=3,
                      mixed_fn_compos=mixed_fn_compos,
                  )
              )
              + 2
          )
      if curr_backend == "tensorflow" and not mixed_fn_compos:
          num_dims = 3
      dtype, x = draw(
          helpers.dtype_and_values(
              available_dtypes=helpers.get_dtypes(
                  "float", mixed_fn_compos=mixed_fn_compos
              ),
              min_num_dims=num_dims,
              max_num_dims=num_dims,
              min_dim_size=2,
              max_dim_size=5,
              max_value=1e04,
              min_value=-1e04,
              abs_smallest_val=1e-04,
          )
      )
      align_corners = draw(st.booleans())
      if draw(st.booleans()):
          if draw(st.booleans()):
              scale_factor = draw(
                  st.floats(
                      min_value=max([1 / d for d in x[0].shape[2:]]),
                      max_value=3,
                  )
              )
          else:
              scale_factor = []
              for s in x[0].shape[2:]:
                  scale_factor += [
                      draw(st.floats(min_value=1 / s, max_value=3))
                  ]
          recompute_scale_factor = draw(st.booleans())
          size = None
      else:
          size = draw(
              st.one_of(
                  st.lists(
                      st.integers(
                          min_value=1, max_value=3 * max(x[0].shape)
                      ),
                      min_size=num_dims - 2,
                      max_size=num_dims - 2,
                  ),
                  st.integers(
                      min_value=1, max_value=3 * max(x[0].shape)
                  ),
              )
          )
          recompute_scale_factor = None
          scale_factor = None
      return (
          dtype,
          x,
          mode,
          size,
          align_corners,
          scale_factor,
          recompute_scale_factor,
      )
  
imports: import numpy
  import torch
  from hypothesis import strategies, assume
  import ivy
  import ivy_tests.test_ivy.helpers
  from ivy_tests.test_ivy.helpers import handle_test, BackendHandler
label_desc: Use image node_id 2 for calling a global function with example usage: _interp_args(draw, mode, mode_list) and returns: dtype,  x,  mode,  size,  align_corners,  scale_factor,  recompute_scale_factor