code: def combinations(
      *comb: Union[Any, Tuple[Any, ...]],
      argnames: Optional[str] = None,
      id_: Optional[str] = None,
      **kw: str,
  ) -> Callable[[_FN], _FN]:
      r"""Deliver multiple versions of a test based on positional combinations.
  
      This is a facade over pytest.mark.parametrize.
  
  
      :param \*comb: argument combinations.  These are tuples that will be passed
       positionally to the decorated function.
  
      :param argnames: optional list of argument names.   These are the names
       of the arguments in the test function that correspond to the entries
       in each argument tuple.   pytest.mark.parametrize requires this, however
       the combinations function will derive it automatically if not present
       by using ``inspect.getfullargspec(fn).args[1:]``.  Note this assumes the
       first argument is "self" which is discarded.
  
      :param id\_: optional id template.  This is a string template that
       describes how the "id" for each parameter set should be defined, if any.
       The number of characters in the template should match the number of
       entries in each argument tuple.   Each character describes how the
       corresponding entry in the argument tuple should be handled, as far as
       whether or not it is included in the arguments passed to the function, as
       well as if it is included in the tokens used to create the id of the
       parameter set.
  
       If omitted, the argument combinations are passed to parametrize as is.  If
       passed, each argument combination is turned into a pytest.param() object,
       mapping the elements of the argument tuple to produce an id based on a
       character value in the same position within the string template using the
       following scheme::
  
          i - the given argument is a string that is part of the id only, don't
              pass it as an argument
  
          n - the given argument should be passed and it should be added to the
              id by calling the .__name__ attribute
  
          r - the given argument should be passed and it should be added to the
              id by calling repr()
  
          s - the given argument should be passed and it should be added to the
              id by calling str()
  
          a - (argument) the given argument should be passed and it should not
              be used to generated the id
  
       e.g.::
  
          @testing.combinations(
              (operator.eq, "eq"),
              (operator.ne, "ne"),
              (operator.gt, "gt"),
              (operator.lt, "lt"),
              id_="na"
          )
          def test_operator(self, opfunc, name):
              pass
  
      The above combination will call ``.__name__`` on the first member of
      each tuple and use that as the "id" to pytest.param().
  
  
      """
      return _fixture_functions.combinations(
          *comb, id_=id_, argnames=argnames, **kw
      )
  
imports: from __future__ import annotations
  from argparse import Namespace
  import collections
  import inspect
  import typing
  from typing import Any
  from typing import Callable
  from typing import Iterable
  from typing import NoReturn
  from typing import Optional
  from typing import Tuple
  from typing import TypeVar
  from typing import Union
  from .None import mock
  from .None import requirements
  from .util import fail
label_desc: Use image node_id 1 for calling a global function with example usage: combinations() and returns: _fixture_functions