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

""" zipimport provides support for importing Python modules from Zip archives.

This module exports three objects:
- zipimporter: a class; its constructor takes a path to a Zip archive.
- ZipImportError: exception raised by zipimporter objects. It's a
  subclass of ImportError, so it can be caught as ImportError, too.
- _zip_directory_cache: a dict, mapping archive paths to zip directory
  info dicts, as used in zipimporter._files.

It is usually not needed to use the zipimport module explicitly; it is
used by the builtin import mechanism for sys.path items that are paths
to Zip archives. """

class ZipImportError(ImportError):

  pass

__doc__ = """zipimport provides support for importing Python modules from Zip archives.

This module exports three objects:
- zipimporter: a class; its constructor takes a path to a Zip archive.
- ZipImportError: exception raised by zipimporter objects. It's a
  subclass of ImportError, so it can be caught as ImportError, too.
- _zip_directory_cache: a dict, mapping archive paths to zip directory
  info dicts, as used in zipimporter._files.

It is usually not needed to use the zipimport module explicitly; it is
used by the builtin import mechanism for sys.path items that are paths
to Zip archives."""

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.
  
       """

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

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

  def find_module(self, fullname, path=None):
    """ Find the built-in module.
    
            If 'path' is ever specified then the search is considered a failure.
    
            This method is deprecated.  Use find_spec() instead.
    
             """
    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

  def module_repr(self, module):
    """ Return repr for the module.
    
            The method is deprecated.  The import machinery does the job itself.
    
             """
    pass

__name__ = 'zipimport'
__package__ = ''
__spec__ = None
_zip_directory_cache = {}

class zipimporter(object):
  """ Create a new zipimporter instance.
  
    archivepath
      A path-like object to a zipfile, or to a specific path inside
      a zipfile.
  
  'archivepath' must be a path-like object to a zipfile, or to a specific path
  inside a zipfile. For example, it can be '/tmp/myimport.zip', or
  '/tmp/myimport.zip/mydirectory', if mydirectory is a valid directory inside
  the archive.
  
  'ZipImportError' is raised if 'archivepath' doesn't point to a valid Zip
  archive.
  
  The 'archive' attribute of the zipimporter object contains the name of the
  zipfile targeted. """

  def __init__(self, *args, **kwargs):
    pass

  _files = None
  archive = None

  def find_loader(self, fullname, path=None):
    """ Search for a module specified by 'fullname'.
    
    'fullname' must be the fully qualified (dotted) module name. It returns the
    zipimporter instance itself if the module was found, a string containing the
    full path name if it's possibly a portion of a namespace package,
    or None otherwise. The optional 'path' argument is ignored -- it's
    there for compatibility with the importer protocol. """
    pass

  def find_module(self, fullname, path=None):
    """ Search for a module specified by 'fullname'.
    
    'fullname' must be the fully qualified (dotted) module name. It returns the
    zipimporter instance itself if the module was found, or None if it wasn't.
    The optional 'path' argument is ignored -- it's there for compatibility
    with the importer protocol. """
    pass

  def get_code(self, fullname):
    """ Return the code object for the specified module.
    
    Raise ZipImportError if the module couldn't be found. """
    pass

  def get_data(self, pathname):
    """ Return the data associated with 'pathname'.
    
    Raise OSError if the file was not found. """
    pass

  def get_filename(self, fullname):
    """ Return the filename for the specified module. """
    pass

  def get_resource_reader(self, fullname):
    """ Return the ResourceReader for a package in a zip file.
    
    If 'fullname' is a package within the zip file, return the 'ResourceReader'
    object for the package.  Otherwise return None. """
    pass

  def get_source(self, fullname):
    """ Return the source code for the specified module.
    
    Raise ZipImportError if the module couldn't be found, return None if the
    archive does contain the module, but has no source for it. """
    pass

  def is_package(self, fullname):
    """ Return True if the module specified by fullname is a package.
    
    Raise ZipImportError if the module couldn't be found. """
    pass

  def load_module(self, fullname):
    """ Load the module specified by 'fullname'.
    
    'fullname' must be the fully qualified (dotted) module name. It returns the
    imported module, or raises ZipImportError if it wasn't found. """
    pass

  prefix = None