code: def import_fresh_module(
      name,
      fresh=(),
      blocked=(),
      *,
      deprecated=False,
      usefrozen=False,
  ):
      """Import and return a module, deliberately bypassing sys.modules.
  
      This function imports and returns a fresh copy of the named Python module
      by removing the named module from sys.modules before doing the import.
      Note that unlike reload, the original module is not affected by
      this operation.
  
      *fresh* is an iterable of additional module names that are also removed
      from the sys.modules cache before doing the import. If one of these
      modules can't be imported, None is returned.
  
      *blocked* is an iterable of module names that are replaced with None
      in the module cache during the import to ensure that attempts to import
      them raise ImportError.
  
      The named module and any modules named in the *fresh* and *blocked*
      parameters are saved before starting the import and then reinserted into
      sys.modules when the fresh import is complete.
  
      Module and package deprecation messages are suppressed during this import
      if *deprecated* is True.
  
      This function will raise ImportError if the named module cannot be
      imported.
  
      If "usefrozen" is False (the default) then the frozen importer is
      disabled (except for essential modules like importlib._bootstrap).
      """
      # NOTE: test_heapq, test_json and test_warnings include extra sanity checks
      # to make sure that this utility function is working as expected
      with _ignore_deprecated_imports(deprecated):
          # Keep track of modules saved for later restoration as well
          # as those which just need a blocking entry removed
          fresh = list(fresh)
          blocked = list(blocked)
          names = {name, *fresh, *blocked}
          orig_modules = _save_and_remove_modules(names)
          for modname in blocked:
              sys.modules[modname] = None
  
          try:
              with frozen_modules(usefrozen):
                  # Return None when one of the "fresh" modules can not be imported.
                  try:
                      for modname in fresh:
                          __import__(modname)
                  except ImportError:
                      return None
                  return importlib.import_module(name)
          finally:
              _save_and_remove_modules(names)
              sys.modules.update(orig_modules)
  
imports: import contextlib
  import _imp
  import importlib
  import importlib.util
  import os
  import shutil
  import sys
  import unittest
  import warnings
  from .os_helper import unlink, temp_dir
label_desc: Use image node_id 9 for calling a global function with example usage: import_fresh_module(name, fresh, blocked) and returns: importlib, None