# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT

""" (Extremely) low-level import machinery bits as used by importlib. """

__doc__ = '(Extremely) low-level import machinery bits as used by importlib.'

class __loader__(object):
  """ Meta path import for built-in modules.
  
      All methods are either class or static methods to avoid the need to
      instantiate the class.
  
       """

  _ORIGIN = 'built-in'

  def create_module(self, spec):
    """ Create a built-in module """
    pass

  def exec_module(self, module):
    """ Exec a built-in module """
    pass

  def find_spec(self, fullname, path=None, target=None):
    pass

  def get_code(self, fullname):
    """ Return None as built-in modules do not have code objects. """
    pass

  def get_source(self, fullname):
    """ Return None as built-in modules do not have source code. """
    pass

  def is_package(self, fullname):
    """ Return False as built-in modules are never packages. """
    pass

  def load_module(self, fullname):
    """ Load the specified module into sys.modules and return it.
    
        This method is deprecated.  Use loader.exec_module() instead.
    
         """
    pass

__name__ = '_imp'
__package__ = ''
__spec__ = None

def _fix_co_filename(code, path):
  """ Changes code.co_filename to specify the passed-in file path.
  
    code
      Code object to change.
    path
      File path to use. """
  pass

def _frozen_module_names():
  """ Returns the list of available frozen modules. """
  pass

def _override_frozen_modules_for_tests(override):
  """ (internal-only) Override PyConfig.use_frozen_modules.
  
  (-1: "off", 1: "on", 0: no override)
  See frozen_modules() in Lib/test/support/import_helper.py. """
  pass

def _override_multi_interp_extensions_check(override):
  """ (internal-only) Override PyInterpreterConfig.check_multi_interp_extensions.
  
  (-1: "never", 1: "always", 0: no override) """
  pass

def acquire_lock():
  """ Acquires the interpreter's import lock for the current thread.
  
  This lock should be used by import hooks to ensure thread-safety when importing
  modules. On platforms without threads, this function does nothing. """
  pass

check_hash_based_pycs = 'default'

def create_builtin(spec):
  """ Create an extension module. """
  pass

def create_dynamic():
  """ Create an extension module. """
  pass

def exec_builtin(mod):
  """ Initialize a built-in module. """
  pass

def exec_dynamic(mod):
  """ Initialize an extension module. """
  pass

def extension_suffixes():
  """ Returns the list of file suffixes used to identify extension modules. """
  pass

def find_frozen(name, withdata=False):
  """ Return info about the corresponding frozen module (if there is one) or None.
  
  The returned info (a 2-tuple):
  
   * data         the raw marshalled bytes
   * is_package   whether or not it is a package
   * origname     the originally frozen module's name, or None if not
                  a stdlib module (this will usually be the same as
                  the module's current name) """
  pass

def get_frozen_object(name, data=None):
  """ Create a code object for a frozen module. """
  pass

def init_frozen(name):
  """ Initializes a frozen module. """
  pass

def is_builtin(name):
  """ Returns True if the module name corresponds to a built-in module. """
  pass

def is_frozen(name):
  """ Returns True if the module name corresponds to a frozen module. """
  pass

def is_frozen_package(name):
  """ Returns True if the module name is of a frozen package. """
  pass

def lock_held():
  """ Return True if the import lock is currently held, else False.
  
  On platforms without threads, return False. """
  pass

def release_lock():
  """ Release the interpreter's import lock.
  
  On platforms without threads, this function does nothing. """
  pass

def source_hash(key, source):
  pass