class_docstr: A finder and loader that produces "accelerated" modules.
  
  When someone attempts to import the specified slow library with
  this finder enabled, we intercept the import and deliver an
  equivalent, accelerated, version of the module. This provides
  attributes and modules that check if they are being used from
  "within" the slow (or fast) library themselves. If this is the
  case, the implementation is forwarded to the actual slow library
  implementation, otherwise a proxy implementation is used (which
  attempts to call the fast version first).
code: def __new__(
      cls,
      fast_lib,
      slow_lib,
  ):
      self = super().__new__(
          cls,
          slow_lib,
          fast_lib,
          slow_lib,
      )
      # Import the real versions of the modules so that we can
      # rewrite the sys.modules cache.
      slow_module = importlib.import_module(slow_lib)
      fast_module = importlib.import_module(fast_lib)
      # Note, this is not thread safe, but install() below grabs the
      # lock for the whole initialisation and modification of
      # sys.meta_path.
      for mod in sys.modules.copy():
          if mod.startswith(self.slow_lib):
              sys.modules[
                  self._module_cache_prefix + mod
              ] = sys.modules[mod]
              del sys.modules[mod]
      self._denylist = [*slow_module.__path__, *fast_module.__path__]
  
      # Lock to manage temporarily disabling delivering wrapped attributes
      self._use_fast_lib_lock = threading.RLock()
      self._use_fast_lib = True
      return self
  
imports: from __future__ import annotations
  import contextlib
  import functools
  import importlib
  import importlib.abc
  import importlib.machinery
  import os
  import pathlib
  import sys
  import threading
  import warnings
  from abc import abstractmethod
  from importlib._bootstrap import _ImportLockContext
  from types import ModuleType
  from typing import Any, ContextManager, Dict, List, NamedTuple
  from typing_extensions import Self
  from .fast_slow_proxy import _FunctionProxy, _is_function_or_method, _Unusable, get_final_type_map, get_intermediate_type_map, get_registered_functions
label_desc: Use image node_id 1 for calling the ModuleAccelerator obj's underlying member method code with example usage: obj.__new__(cls, fast_lib, slow_lib) and returns: self