code: def _clean_source(src: str) -> bytes:
      """Return the source code as bytes, without decorators or comments.
  
      Because this is part of our database key, we reduce the cache invalidation
      rate by ignoring decorators, comments, trailing whitespace, and empty lines.
      We can't just use the (dumped) AST directly because it changes between Python
      versions (e.g. ast.Constant)
      """
      # Get the (one-indexed) line number of the function definition, and drop preceding
      # lines - i.e. any decorators, so that adding `@example()`s keeps the same key.
      try:
          funcdef = ast.parse(src).body[0]
          if sys.version_info[:2] == (3, 8) and PYPY:
              # We can't get a line number of the (async) def here, so as a best-effort
              # approximation we'll use str.split instead and hope for the best.
              tag = (
                  "async def "
                  if isinstance(funcdef, ast.AsyncFunctionDef)
                  else "def "
              )
              if tag in src:
                  src = tag + src.split(tag, maxsplit=1)[1]
          else:
              src = "".join(
                  src.splitlines(keepends=True)[funcdef.lineno - 1 :]
              )
      except Exception:
          pass
      # Remove blank lines and use the tokenize module to strip out comments,
      # so that those can be changed without changing the database key.
      try:
          src = untokenize(
              t
              for t in generate_tokens(StringIO(src).readline)
              if t.type != COMMENT
          )
      except Exception:
          pass
      # Finally, remove any trailing whitespace and empty lines as a last cleanup.
      return "\n".join(
          x.rstrip() for x in src.splitlines() if x.rstrip()
      ).encode()
  
imports: import ast
  import hashlib
  import inspect
  import os
  import re
  import sys
  import textwrap
  import types
  from functools import wraps
  from io import StringIO
  from keyword import iskeyword
  from tokenize import COMMENT, detect_encoding, generate_tokens, untokenize
  from types import ModuleType
  from typing import TYPE_CHECKING, Any, Callable
  from unittest.mock import _patch
  from hypothesis.internal.compat import PYPY, is_typed_named_tuple
  from hypothesis.utils.conventions import not_set
  from hypothesis.vendor.pretty import pretty
label_desc: Use image node_id 2 for calling a global function with example usage: _clean_source(src) and returns: str