text: """
  This module houses a utility class for mocking deprecated modules.
  It is for internal use only and should not be used beyond this purpose.
  """
  
  import importlib
  from typing import Iterable
  import warnings
  
  
  class _DeprecatedModule:
      """
      Class for mocking deprecated modules.
  
      Parameters
      ----------
      deprmod : name of module to be deprecated.
      deprmodto : name of module as a replacement, optional.
                  If not given, the __module__ attribute will
                  be used when needed.
      removals : objects or methods in module that will no longer be
                 accessible once module is removed.
      moved : dict, optional
              dictionary of function name -> new location for moved
              objects
      """
  
      def __init__(self, deprmod, deprmodto=None, removals=None, moved=None):
          self.deprmod = deprmod
          self.deprmodto = deprmodto
          self.removals = removals
          if self.removals is not None:
              self.removals = frozenset(self.removals)
          self.moved = moved
  
          # For introspection purposes.
          self.self_dir = frozenset(dir(type(self)))
  
      def __dir__(self) -> Iterable[str]:
          deprmodule = self._import_deprmod()
          return dir(deprmodule)
  
      def __repr__(self) -> str:
          deprmodule = self._import_deprmod()
          return repr(deprmodule)
  
      __str__ = __repr__
  
      def __getattr__(self, name: str):
          if name in self.self_dir:
              return object.__getattribute__(self, name)
  
          try:
              deprmodule = self._import_deprmod(self.deprmod)
          except ImportError:
              if self.deprmodto is None:
                  raise
  
              # a rename
              deprmodule = self._import_deprmod(self.deprmodto)
  
          obj = getattr(deprmodule, name)
  
          if self.removals is not None and name in self.removals:
              warnings.warn(
                  f"{self.deprmod}.{name} is deprecated and will be removed in "
                  "a future version.",
                  FutureWarning,
                  stacklevel=2,
              )
          elif self.moved is not None and name in self.moved:
              warnings.warn(
                  f"{self.deprmod} is deprecated and will be removed in "
                  f"a future version.\nYou can access {name} as {self.moved[name]}",
                  FutureWarning,
                  stacklevel=2,
              )
          else:
              deprmodto = self.deprmodto
              if deprmodto is False:
                  warnings.warn(
                      f"{self.deprmod}.{name} is deprecated and will be removed in "
                      "a future version.",
                      FutureWarning,
                      stacklevel=2,
                  )
              else:
                  if deprmodto is None:
                      deprmodto = obj.__module__
                  # The object is actually located in another module.
                  warnings.warn(
                      f"{self.deprmod}.{name} is deprecated. Please use "
                      f"{deprmodto}.{name} instead.",
                      FutureWarning,
                      stacklevel=2,
                  )
  
          return obj
  
      def _import_deprmod(self, mod=None):
          if mod is None:
              mod = self.deprmod
  
          with warnings.catch_warnings():
              warnings.filterwarnings("ignore", category=FutureWarning)
              deprmodule = importlib.import_module(mod)
              return deprmodule
  