# 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."""
__name__ = 'zipimport'
__package__ = None
_zip_directory_cache = {}

class zipimporter(object):
  """ zipimporter(archivepath) -> zipimporter object
  
  Create a new zipimporter instance. 'archivepath' must be a path 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 zipimporter objects contains the name of the
  zipfile targeted. """

  def __init__(self, archivepath):
    """ x.__init__(...) initializes x; see help(type(x)) for signature """
    return None

  _files = None
  archive = None

  def find_module(self, fullname, path=None):
    """ find_module(fullname, path=None) -> self or 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. """
    return None

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

  def get_data(self, pathname):
    """ get_data(pathname) -> string with file data.
    
    Return the data associated with 'pathname'. Raise IOError if
    the file wasn't found. """
    return ""

  def get_filename(self, fullname):
    """ get_filename(fullname) -> filename string.
    
    Return the filename for the specified module. """
    return ""

  def get_source(self, fullname):
    """ get_source(fullname) -> source string.
    
    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. """
    return ""

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

  def load_module(self, fullname):
    """ load_module(fullname) -> module.
    
    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. """
    return None

  prefix = None