code: def given(
      *_given_arguments,  # type: Union[SearchStrategy, InferType]
      **_given_kwargs,  # type: Union[SearchStrategy, InferType]
  ):
      # type: (...) -> Callable[[Callable[..., None]], Callable[..., None]]
      """A decorator for turning a test function that accepts arguments into a
      randomized test.
  
      This is the main entry point to Hypothesis.
      """
  
      def run_test_as_given(test):
          if inspect.isclass(test):
              # Provide a meaningful error to users, instead of exceptions from
              # internals that assume we're dealing with a function.
              raise InvalidArgument(
                  "@given cannot be applied to a class."
              )
          given_arguments = tuple(_given_arguments)
          given_kwargs = dict(_given_kwargs)
  
          original_argspec = getfullargspec(test)
  
          check_invalid = is_invalid_test(
              test.__name__,
              original_argspec,
              given_arguments,
              given_kwargs,
          )
  
          # If the argument check found problems, return a dummy test function
          # that will raise an error if it is actually called.
          if check_invalid is not None:
              return check_invalid
  
          # Because the argument check succeeded, we can convert @given's
          # positional arguments into keyword arguments for simplicity.
          if given_arguments:
              assert not given_kwargs
              for name, strategy in zip(
                  reversed(original_argspec.args),
                  reversed(given_arguments),
              ):
                  given_kwargs[name] = strategy
          # These have been converted, so delete them to prevent accidental use.
          del given_arguments
  
          argspec = new_given_argspec(original_argspec, given_kwargs)
  
          @impersonate(test)
          @define_function_signature(
              test.__name__, test.__doc__, argspec
          )
          def wrapped_test(*arguments, **kwargs):
              # Tell pytest to omit the body of this function from tracebacks
              __tracebackhide__ = True
  
              test = wrapped_test.hypothesis.inner_test
  
              if getattr(test, "is_hypothesis_test", False):
                  raise InvalidArgument(
                      (
                          "You have applied @given to the test %s more than once, which "
                          "wraps the test several times and is extremely slow. A "
                          "similar effect can be gained by combining the arguments "
                          "of the two calls to given. For example, instead of "
                          "@given(booleans()) @given(integers()), you could write "
                          "@given(booleans(), integers())"
                      )
                      % (test.__name__,)
                  )
  
              settings = wrapped_test._hypothesis_internal_use_settings
  
              random = get_random_for_wrapped_test(test, wrapped_test)
  
              # Use type information to convert "infer" arguments into appropriate
              # strategies.
              if infer in given_kwargs.values():
                  hints = get_type_hints(test)
              for name in [
                  name
                  for name, value in given_kwargs.items()
                  if value is infer
              ]:
                  if name not in hints:
                      raise InvalidArgument(
                          "passed %s=infer for %s, but %s has no type annotation"
                          % (name, test.__name__, name)
                      )
                  given_kwargs[name] = st.from_type(hints[name])
  
              processed_args = process_arguments_to_given(
                  wrapped_test,
                  arguments,
                  kwargs,
                  given_kwargs,
                  argspec,
                  test,
                  settings,
              )
              (
                  arguments,
                  kwargs,
                  test_runner,
                  search_strategy,
              ) = processed_args
  
              runner = getattr(search_strategy, "runner", None)
              if isinstance(runner, TestCase) and test.__name__ in dir(
                  TestCase
              ):
                  msg = (
                      "You have applied @given to the method %s, which is "
                      "used by the unittest runner but is not itself a test."
                      "  This is not useful in any way." % test.__name__
                  )
                  fail_health_check(
                      settings, msg, HealthCheck.not_a_test_method
                  )
              if bad_django_TestCase(runner):  # pragma: no cover
                  # Covered by the Django tests, but not the pytest coverage task
                  raise InvalidArgument(
                      "You have applied @given to a method on %s, but this "
                      "class does not inherit from the supported versions in "
                      "`hypothesis.extra.django`.  Use the Hypothesis variants "
                      "to ensure that each example is run in a separate "
                      "database transaction." % qualname(type(runner))
                  )
  
              state = StateForActualGivenExecution(
                  test_runner,
                  search_strategy,
                  test,
                  settings,
                  random,
                  wrapped_test,
              )
  
              reproduce_failure = (
                  wrapped_test._hypothesis_internal_use_reproduce_failure
              )
  
              # If there was a @reproduce_failure decorator, use it to reproduce
              # the error (or complain that we couldn't). Either way, this will
              # always raise some kind of error.
              if reproduce_failure is not None:
                  expected_version, failure = reproduce_failure
                  if expected_version != __version__:
                      raise InvalidArgument(
                          (
                              "Attempting to reproduce a failure from a different "
                              "version of Hypothesis. This failure is from %s, but "
                              "you are currently running %r. Please change your "
                              "Hypothesis version to a matching one."
                          )
                          % (expected_version, __version__)
                      )
                  try:
                      state.execute_once(
                          ConjectureData.for_buffer(
                              decode_failure(failure)
                          ),
                          print_example=True,
                          is_final=True,
                      )
                      raise DidNotReproduce(
                          "Expected the test to raise an error, but it "
                          "completed successfully."
                      )
                  except StopTest:
                      raise DidNotReproduce(
                          "The shape of the test data has changed in some way "
                          "from where this blob was defined. Are you sure "
                          "you're running the same test?"
                      )
                  except UnsatisfiedAssumption:
                      raise DidNotReproduce(
                          "The test data failed to satisfy an assumption in the "
                          "test. Have you added it since this blob was "
                          "generated?"
                      )
  
              # There was no @reproduce_failure, so start by running any explicit
              # examples from @example decorators.
  
              execute_explicit_examples(
                  state, wrapped_test, arguments, kwargs
              )
  
              # If there were any explicit examples, they all ran successfully.
              # The next step is to use the Conjecture engine to run the test on
              # many different inputs.
  
              if settings.max_examples <= 0:
                  return
  
              if not (
                  Phase.reuse in settings.phases
                  or Phase.generate in settings.phases
              ):
                  return
  
              try:
                  if isinstance(runner, TestCase) and hasattr(
                      runner, "subTest"
                  ):
                      subTest = runner.subTest
                      try:
                          runner.subTest = fake_subTest
                          state.run_engine()
                      finally:
                          runner.subTest = subTest
                  else:
                      state.run_engine()
              except BaseException as e:
                  # The exception caught here should either be an actual test
                  # failure (or MultipleFailures), or some kind of fatal error
                  # that caused the engine to stop.
  
                  generated_seed = (
                      wrapped_test._hypothesis_internal_use_generated_seed
                  )
                  with local_settings(settings):
                      if not (
                          state.failed_normally
                          or generated_seed is None
                      ):
                          if running_under_pytest:
                              report(
                                  "You can add @seed(%(seed)d) to this test or "
                                  "run pytest with --hypothesis-seed=%(seed)d "
                                  "to reproduce this failure."
                                  % {"seed": generated_seed}
                              )
                          else:
                              report(
                                  "You can add @seed(%d) to this test to "
                                  "reproduce this failure."
                                  % (generated_seed,)
                              )
                      # The dance here is to avoid showing users long tracebacks
                      # full of Hypothesis internals they don't care about.
                      # We have to do this inline, to avoid adding another
                      # internal stack frame just when we've removed the rest.
                      if PY2:
                          # Python 2 doesn't have Exception.with_traceback(...);
                          # instead it has a three-argument form of the `raise`
                          # statement.  Unfortunately this is a SyntaxError on
                          # Python 3, and before Python 2.7.9 it was *also* a
                          # SyntaxError to use it in a nested function so we
                          # can't `exec` or `eval` our way out (BPO-21591).
                          # So unless we break some versions of Python 2, none
                          # of them get traceback elision.
                          raise
                      # On Python 3, we swap out the real traceback for our
                      # trimmed version.  Using a variable ensures that the line
                      # which will actually appear in tracebacks is as clear as
                      # possible - "raise the_error_hypothesis_found".
                      the_error_hypothesis_found = e.with_traceback(
                          get_trimmed_traceback()
                      )
                      raise the_error_hypothesis_found
  
          # After having created the decorated test function, we need to copy
          # over some attributes to make the switch as seamless as possible.
  
          for attrib in dir(test):
              if not (
                  attrib.startswith("_")
                  or hasattr(wrapped_test, attrib)
              ):
                  setattr(wrapped_test, attrib, getattr(test, attrib))
          wrapped_test.is_hypothesis_test = True
          if hasattr(test, "_hypothesis_internal_settings_applied"):
              # Used to check if @settings is applied twice.
              wrapped_test._hypothesis_internal_settings_applied = True
          wrapped_test._hypothesis_internal_use_seed = getattr(
              test, "_hypothesis_internal_use_seed", None
          )
          wrapped_test._hypothesis_internal_use_settings = (
              getattr(test, "_hypothesis_internal_use_settings", None)
              or Settings.default
          )
          wrapped_test._hypothesis_internal_use_reproduce_failure = (
              getattr(
                  test,
                  "_hypothesis_internal_use_reproduce_failure",
                  None,
              )
          )
          wrapped_test.hypothesis = HypothesisHandle(test)
          return wrapped_test
  
      return run_test_as_given
  
imports: from __future__ import absolute_import, division, print_function
  import base64
  import contextlib
  import datetime
  import inspect
  import random
  import sys
  import traceback
  import warnings
  import zlib
  from random import Random
  from unittest import TestCase
  import attr
  import hypothesis.strategies
  from hypothesis._settings import HealthCheck, Phase, Verbosity, local_settings, settings
  from hypothesis.control import BuildContext
  from hypothesis.errors import DeadlineExceeded, DidNotReproduce, FailedHealthCheck, Flaky, Found, HypothesisDeprecationWarning, HypothesisWarning, InvalidArgument, MultipleFailures, NoSuchExample, Unsatisfiable, UnsatisfiedAssumption
  from hypothesis.executors import new_style_executor
  from hypothesis.internal.compat import PY2, bad_django_TestCase, benchmark_time, binary_type, get_type_hints, getfullargspec, hbytes, int_from_bytes, qualname
  from hypothesis.internal.conjecture.data import ConjectureData, StopTest
  from hypothesis.internal.conjecture.engine import ConjectureRunner, sort_key
  from hypothesis.internal.entropy import deterministic_PRNG
  from hypothesis.internal.escalation import escalate_hypothesis_internal_error, get_trimmed_traceback
  from hypothesis.internal.healthcheck import fail_health_check
  from hypothesis.internal.reflection import arg_string, convert_positional_arguments, define_function_signature, function_digest, get_pretty_function_description, impersonate, is_mock, proxies
  from hypothesis.reporting import current_verbosity, report, verbose_report, with_reporter
  from hypothesis.statistics import note_engine_for_statistics
  from hypothesis.strategies._internal.collections import TupleStrategy
  from hypothesis.strategies._internal.strategies import MappedSearchStrategy, SearchStrategy
  from hypothesis.utils.conventions import infer
  from hypothesis.vendor.pretty import CUnicodeIO, RepresentationPrinter
  from hypothesis.version import __version__
label_desc: Use image node_id 14 for calling a global function with example usage: given() and returns: run_test_as_given, wrapped_test, check_invalid