code: def pep440(cached=False):
      cache_path = os.path.join(CACHE, "pep440.json")
  
      # If we were given --cached, then we want to attempt to use cached data if
      # possible
      if cached:
          try:
              with open(cache_path) as fp:
                  data = json.load(fp)
          except Exception:
              data = None
      else:
          data = None
  
      # If we don't have data, then let's go fetch it from PyPI
      if data is None:
          bar = progress.bar.ShadyBar("Fetching Versions")
          client = xmlrpc.client.Server("https://pypi.python.org/pypi")
  
          data = {
              project: client.package_releases(project, True)
              for project in bar.iter(client.list_packages())
          }
  
          os.makedirs(os.path.dirname(cache_path), exist_ok=True)
          with open(cache_path, "w") as fp:
              json.dump(data, fp)
  
      # Get a list of all of the version numbers on PyPI
      all_versions = list(itertools.chain.from_iterable(data.values()))
  
      # Determine the total number of versions which are compatible with the
      # current routine
      parsed_versions = [
          _parse_version(v)
          for v in all_versions
          if _parse_version(v) is not None
      ]
  
      # Determine a list of projects that sort exactly the same between
      # pkg_resources and PEP 440
      compatible_sorting = [
          project
          for project, versions in data.items()
          if (
              sorted(versions, key=pkg_resources.parse_version)
              == sorted(
                  (x for x in versions if _parse_version(x)),
                  key=Version,
              )
          )
      ]
  
      # Determine a list of projects that sort exactly the same between
      # pkg_resources and PEP 440 when invalid versions are filtered out
      filtered_compatible_sorting = [
          project
          for project, versions in (
              (p, [v for v in vs if _parse_version(v) is not None])
              for p, vs in data.items()
          )
          if (
              sorted(versions, key=pkg_resources.parse_version)
              == sorted(versions, key=Version)
          )
      ]
  
      # Determine a list of projects which do not have any versions that are
      # valid with PEP 440 and which have any versions registered
      only_invalid_versions = [
          project
          for project, versions in data.items()
          if (
              versions
              and not [
                  v for v in versions if _parse_version(v) is not None
              ]
          )
      ]
  
      # Determine a list of projects which have matching latest versions between
      # pkg_resources and PEP 440
      differing_latest_versions = [
          project
          for project, versions in data.items()
          if (
              sorted(versions, key=pkg_resources.parse_version)[-1:]
              != sorted(
                  (x for x in versions if _parse_version(x)),
                  key=Version,
              )[-1:]
          )
      ]
  
      # Print out our findings
      print(
          "Total Version Compatibility:              {}/{} ({:.2%})".format(
              len(parsed_versions),
              len(all_versions),
              len(parsed_versions) / len(all_versions),
          )
      )
      print(
          "Total Sorting Compatibility (Unfiltered): {}/{} ({:.2%})".format(
              len(compatible_sorting),
              len(data),
              len(compatible_sorting) / len(data),
          )
      )
      print(
          "Total Sorting Compatibility (Filtered):   {}/{} ({:.2%})".format(
              len(filtered_compatible_sorting),
              len(data),
              len(filtered_compatible_sorting) / len(data),
          )
      )
      print(
          "Projects with No Compatible Versions:     {}/{} ({:.2%})".format(
              len(only_invalid_versions),
              len(data),
              len(only_invalid_versions) / len(data),
          )
      )
      print(
          "Projects with Differing Latest Version:   {}/{} ({:.2%})".format(
              len(differing_latest_versions),
              len(data),
              len(differing_latest_versions) / len(data),
          )
      )
  
file_path: py-packaging/tasks/check.py
imports: import itertools
  import json
  import os.path
  import xmlrpc.client
  import invoke
  import pkg_resources
  import progress.bar
  from packaging.version import Version
  from .paths import CACHE
label_desc: Use image node_id 2 for calling a global function with example usage: pep440(cached) without return types