def download_src(self, url, source=None, archive=True):
        """ Download source and return path to it.

        :param url: url to source distribution
        :type url: string

        :param source_dir: source directory after unpacking (optional)
        :type source_dir: string

        :param archive: is source archive file or not
        :type archive: boolean

        :return: path to source directory
        """

        tmp_dir = tempfile.gettempdir()
        source_file = os.path.join(tmp_dir, url.split('/')[-1])
        urllib.request.urlretrieve(url, source_file)

        if source is None:
            source = source_file

        if archive:
            unpack_archive(source_file, tmp_dir)
            source = os.path.splitext(source)[0]
            if 'tar' in source:
                source = os.path.splitext(source)[0]

        return os.path.join(tmp_dir, source)

 def local_distribution(self):
     if self._local_dist is None:
         ensure_directory(os.path.join(self.tmpdir, "dummy"))
         info("Fetching %s from %s..." % (str(self.distribution),
             self.location))
         dist = self.repository.environment.fetch_distribution(self.requirement,
             self.tmpdir, source=self.source, develop_ok=self.develop)
         location = dist.location
         distros = list(find_distributions(location))
         if distros:
             self._local_dist = distros[0]
         elif os.path.isfile(location) and os.path.splitext(location) != \
                 ".py":
             # try to unpack the file
             unpack_dir = os.path.join(self.tmpdir, "unpack")
             info("Unpacking to %s..." % unpack_dir)
             unpack_archive(location, unpack_dir)
             distros = list(find_distributions(unpack_dir))
             if distros:
                 self._local_dist = distros[0]
             else:
                 for path in glob(os.path.join(unpack_dir, "*")):
                     distros = list(find_distributions(path))
                     if distros:
                         self._local_dist = distros[0]
                         break
                 else:
                     self._local_dist = Distribution.from_filename(location)
     return self._local_dist

 def _get_new(self, allow_redirects=True, chunk_size=512):
     """Retrieves the new archive and extracts it to self.updatedir."""
     self.log.info("Retrieving new version")
     newurl = self.url+self.newfiles
     # Get new files
     http_get = requests.get(newurl, stream=True,
                             allow_redirects=allow_redirects)
     http_get.raise_for_status()
     with open(self.newfiles, 'wb') as filehandle:
         for chunk in http_get.iter_content(chunk_size=chunk_size):
             if chunk:
                 filehandle.write(chunk)
     # Unpack archive and remove it after extraction
     try:
         self.log.info("Unpacking downloaded archive")
         unpack_archive(self.newfiles, self.updatedir)
     except UnrecognizedFormat:
         self.log.error("Retrieved version archive is invalid!\n"
                        "Please contact the software authors.\n"
                        "Please include the invalid archive "
                        "in a bug report.")
         os.rename(self.newfiles,self.newfiles+".dump")
     else:
         # Remove archive only if unpack operation succeeded
         self.log.info("Removing archive after extraction")
         os.remove(self.newfiles)
         # Signal that update is ready
         self.log.debug("Creating downloaded file marker")
         open(self.queue_replace,"w").close()

    def extract_gz(self, archive_path,
                   archivedir_write_path,
                   file_name=None,
                   open_archive_file=None,
                   archive=None):
        """Extract gz files.

        Extracts a given file name or all the files in the gz.
        """
        if file_name:
            open_archive_file = gzip.open(archive_path, 'r')
            file_obj = open_archive_file
            open_object = False
            self.write_fileobject(archivedir_write_path,
                                  file_name,
                                  file_obj=open_archive_file,
                                  open_object=False)
            if 'archive' in locals() and archive:
                archive.close()
            return [file_name]
        files_before = set(walk_relative_path(archivedir_write_path))
        archive_util.unpack_archive(archive_path, archivedir_write_path)
        files_after = set(walk_relative_path(archivedir_write_path))
        unpacked_files = files_after - files_before
        return list(unpacked_files)

 def get_filelist(self):
     '''
     Unpack the archive if it is an archive, and return a list of 
     file names that should be examined by OGR to determine if they are
     OGR supported file types.
     
     Cache the result to speed up subsequent calls.
     '''
     if not hasattr(self, '_files'):
         name, extension=os.path.splitext(self.filename)
         # only handle a few types, since some of the others might mess 
         # up some processing...like xlsx (which this will unpack.)
         logger.debug('Extension is %s', extension)
         if extension.lower() in ('.zip','.gz','.tgz'):
             try:
                 # Ensure that the files are output in the working dir, and 
                 # subdirectories are omitted (so it's a flat dir structure)
                 archive_util.unpack_archive(self.filename, self.working_dir,
                                             progress_filter=self._progress_filter)
                 logger.debug('Unpacked archive %s to %s', self.filename, 
                              self.working_dir)
                 files=[fn for fn in map(lambda dir: os.path.join(self.working_dir, 
                                                                  dir),
                                         os.listdir(self.working_dir)) 
                                         if not os.path.isdir(fn)]
                 self._files=files
             except archive_util.UnrecognizedFormat, e:
                 logger.debug('Specified file (%s) is not a recognized archive',
                              self.filename)
                 self._files=[self.filename,]
         else:
             self._files=[self.filename,]

 def _extract_file_to_file_server(cls, file_server_root, archive_target_path):
     # extract application to file server
     tempdir = tempfile.mkdtemp("-blueprint-submit")
     try:
         try:
             archive_util.unpack_archive(archive_target_path, tempdir)
         except archive_util.UnrecognizedFormat:
             raise manager_exceptions.BadParametersError(
                 "Blueprint archive is of an unrecognized format. "
                 "Supported formats are: {0}".format(SUPPORTED_ARCHIVE_TYPES)
             )
         archive_file_list = os.listdir(tempdir)
         if len(archive_file_list) != 1 or not path.isdir(path.join(tempdir, archive_file_list[0])):
             raise manager_exceptions.BadParametersError("archive must contain exactly 1 directory")
         application_dir_base_name = archive_file_list[0]
         # generating temporary unique name for app dir, to allow multiple
         # uploads of apps with the same name (as it appears in the file
         # system, not the app name field inside the blueprint.
         # the latter is guaranteed to be unique).
         generated_app_dir_name = "{0}-{1}".format(application_dir_base_name, uuid.uuid4())
         temp_application_dir = path.join(tempdir, application_dir_base_name)
         temp_application_target_dir = path.join(tempdir, generated_app_dir_name)
         shutil.move(temp_application_dir, temp_application_target_dir)
         shutil.move(temp_application_target_dir, file_server_root)
         return generated_app_dir_name
     finally:
         shutil.rmtree(tempdir)

def _unpack_eggs(egg_list):
    import os
    for pkg in egg_list:
        import pkg_resources
        eggs = pkg_resources.require(pkg)
        from setuptools.archive_util import unpack_archive
        for egg in eggs:
           if os.path.isdir(egg.location):
               sys.path.insert(0, egg.location)
               continue
           unpack_archive(egg.location, os.path.abspath(os.path.dirname(egg.location)))

 def copytree(self):
     # Copy the .egg-info tree to site-packages
     def skimmer(src,dst):
         # filter out source-control directories; note that 'src' is always
         # a '/'-separated path, regardless of platform.  'dst' is a
         # platform-specific path.
         for skip in '.svn/','CVS/':
             if src.startswith(skip) or '/'+skip in src:
                 return None
         self.outputs.append(dst)
         log.debug("Copying %s to %s", src, dst)
         return dst
     unpack_archive(self.source, self.target, skimmer)

def checkout_extension(name):
    log('Downloading extension %s to temporary folder', name)
    root = os.path.join(tdir, name)
    os.mkdir(root)
    checkout_path = PackageIndex().download(name, root)

    unpack_archive(checkout_path, root)
    path = None
    for fn in os.listdir(root):
        path = os.path.join(root, fn)
        if os.path.isdir(path):
            break
    log('Downloaded to %s', path)
    return path

def cache_package(spec, own_url):
    try:
        spec = Requirement.parse(spec)

    except ValueError:
        raise ArgumentError("Not a URL, existing file, or requirement spec: %r"
                                                                      % (spec,))

    try:
        # download and unpack source package
        path = tempfile.mkdtemp('.spynepi')
        logger.info("Downloading %r" % spec)
        dist = PackageIndex().fetch_distribution(spec, path, force_scan=True, source=True)
        archive_path = dist.location
        logger.info("Unpacking %r" % archive_path)
        unpack_archive(dist.location, path)

        # generate pypirc if possible
        if os.environ.has_key('HOME'):
            _generate_pypirc(own_url)
        else: # FIXME: ??? No idea. Hopefully setuptools knows better.
            pass # raise NotImplementedError("$HOME not defined, .pypirc not found.")

        # find setup.py in package. plagiarized from setuptools.
        setups = glob(os.path.join(path, '*', 'setup.py'))
        if not setups:
            raise ValidationError(
                "Couldn't find a setup script in %r editable distribution: %r" %
                                    (spec, os.path.join(path,'*', 'setup.py'))
            )

        if len(setups)>1:
            raise ValidationError(
                "Multiple setup scripts found in %r editable distribution: %r" %
                                    (spec, setups)
            )

        # self-register the package.
        lib_dir = os.path.dirname(setups[0])
        command = ["python", "setup.py", "register", "-r", REPO_NAME]
        logger.info('calling %r', command)
        subprocess.call(command, cwd=lib_dir, stdout=sys.stdout)

        # self-upload the package
        command = ["python", "-m", "spynepi.util.pypi.upload", archive_path]
        logger.info('calling %r', command)
        subprocess.call(command, cwd=lib_dir, stdin=sys.stdin, stdout=sys.stdout)

    finally:
        shutil.rmtree(path)

def unpackEgg(modulo):
    eggs = pkg_resources.require(modulo)
    for egg in eggs:
        if os.path.isdir(egg.location):
            sys.path.insert(0, egg.location)
            continue
        unpack_archive(egg.location, ".")
    eggpacks = set()
    eggspth = open("./eggs.pth", "w")
    for egg in eggs:
        eggspth.write(os.path.basename(egg.location))
        eggspth.write("\n")
        eggpacks.update(egg.get_metadata_lines("top_level.txt"))
    eggspth.close()

    eggpacks.clear()

    def copytree(self):
        # Copy the .egg-info tree to site-packages
        def skimmer(src, dst):
            # filter out source-control directories; note that 'src' is always
            # a '/'-separated path, regardless of platform.  'dst' is a
            # platform-specific path.
            for skip in ".svn/", "CVS/":
                if src.startswith(skip) or "/" + skip in src:
                    return None
            if self.install_layout and self.install_layout in ["deb"] and src.startswith("SOURCES.txt"):
                log.info("Skipping SOURCES.txt")
                return None
            self.outputs.append(dst)
            log.debug("Copying %s to %s", src, dst)
            return dst

        unpack_archive(self.source, self.target, skimmer)

def extract_blueprint_archive_to_mgr(archive_path, destination_root):
    """
    Extracting a package.

    :param destination_root: the root destination for the unzipped archive
    :param archive_path: the archive path
    :return: the full path for the extracted archive
    """
    # Importing this archives in the global scope causes import loop
    from manager_rest.resources import SUPPORTED_ARCHIVE_TYPES
    # extract application to file server
    tempdir = tempfile.mkdtemp('-blueprint-submit')
    try:
        try:
            archive_util.unpack_archive(archive_path, tempdir)
        except archive_util.UnrecognizedFormat:
            raise manager_exceptions.BadParametersError(
                    'Blueprint archive is of an unrecognized format. '
                    'Supported formats are: {0}'.format(
                            SUPPORTED_ARCHIVE_TYPES))
        archive_file_list = listdir(tempdir)
        if len(archive_file_list) != 1 or not path.isdir(
                path.join(tempdir, archive_file_list[0])):
            raise manager_exceptions.BadParametersError(
                    'archive must contain exactly 1 directory')
        application_dir_base_name = archive_file_list[0]
        # generating temporary unique name for app dir, to allow multiple
        # uploads of apps with the same name (as it appears in the file
        # system, not the app name field inside the blueprint.
        # the latter is guaranteed to be unique).
        generated_app_dir_name = '{0}-{1}'.format(
                application_dir_base_name, uuid.uuid4())
        temp_application_dir = path.join(tempdir,
                                         application_dir_base_name)
        temp_application_target_dir = path.join(tempdir,
                                                generated_app_dir_name)
        shutil.move(temp_application_dir, temp_application_target_dir)
        shutil.move(temp_application_target_dir, destination_root)
        return generated_app_dir_name
    finally:
        shutil.rmtree(tempdir)

def fixed_unpack_and_compile(self, egg_path, destination):
    from setuptools.archive_util import unpack_archive
    to_compile = []; to_chmod = []

    def pf(src,dst):
        if dst.endswith('.py') and not src.startswith('EGG-INFO/'):
            to_compile.append(dst)
            to_chmod.append(dst)
        elif dst.endswith('.dll') or dst.endswith('.so'):
            to_chmod.append(dst)
        self.unpack_progress(src,dst)
        return not self.dry_run and dst or None

    unpack_archive(egg_path, destination, pf)
    self.byte_compile(to_compile)
    if not self.dry_run:
        for f in to_chmod:
#           mode = ((os.stat(f)[stat.ST_MODE]) | 0555) & 07755
            mode = ((os.stat(f)[stat.ST_MODE]) | 0444) & 07755
            chmod(f, mode)

    to_compile = []; to_chmod = []
    return

def update_self():
	if len(sys.argv) > 1 and sys.argv[1] == '--updated':
		del sys.argv[1]
		return

	from setuptools.package_index import PackageIndex
	from setuptools.archive_util import unpack_archive

	tmpdir = tempfile.mkdtemp(prefix=TEMP_DIR_PREFIX)
	print('Downloading %s' % DEFAULT_URL)
	download = PackageIndex().download(DEFAULT_URL, tmpdir)
	print('Downloaded.')
	unpack_archive(download, tmpdir)
	unpack_dir = os.path.join(tmpdir, PACK_FILE_ROOT_DIR)
	move_files(unpack_dir, os.curdir,
		shutil.ignore_patterns('.*', '*.sln', '*.pyproj', '*.sample'))
	shutil.rmtree(tmpdir)
	print('Self updated.')

	if len(sys.argv) == 1:
		# only update self.
		sys.exit(0)
	else:
		restart(with_virtualenv=False)

    def install_eggs(self, spec, dist_filename, tmpdir):
        # Anything else, try to extract and build
        setup_base = tmpdir
        if os.path.isfile(dist_filename) and not dist_filename.endswith('.py'):
            unpack_archive(dist_filename, tmpdir, self.unpack_progress)
        elif os.path.isdir(dist_filename):
            setup_base = os.path.abspath(dist_filename)

        # Find the setup.py file
        setup_script = os.path.join(setup_base, 'setup.py')

        if not os.path.exists(setup_script):
            setups = glob(os.path.join(setup_base, '*', 'setup.py'))
            if not setups:
                raise DistutilsError(
                    "Couldn't find a setup script in %s" % os.path.abspath(dist_filename)
                )
            if len(setups)>1:
                raise DistutilsError(
                    "Multiple setup scripts in %s" % os.path.abspath(dist_filename)
                )
            setup_script = setups[0]

        return self.build_and_install(setup_script, setup_base)

def unzip(src, dest, zip_ext=None, create_own_folder=False, tree=False):
    """Extract all content from an archive file to a destination folder.

    Arguments
    ---------
    src: str
        Absolute path to the archive file ('/path/to/archive_filename.zip')
    dest: str
        Asolute path to extract all content to ('/path/to/extract/')

    Keyword Arguments
    -----------------
    zip_ext: list
        Valid zip file extensions. Default: ['.zip', '.gz']
    create_own_folder: bool
        Create a sub-folder in 'dest' with the archive file name if True
        ('/path/to/extract/archive_filename/'). Default: False
    tree: bool
        Extract archive files within archive files (into their own
        sub-directory) if True. Default: False
    """
    zip_ext = list(zip_ext or ['.zip', '.gz'])
    filename, ext = os.path.splitext(os.path.basename(src))
    if ext not in zip_ext:
        raise ValueError("Invalid archive file extension {}: {}".format(ext, src))
    if not check_directory(dest, write=True, execute=True):
        raise OSError("Directory not found or unwritable: {}".format(dest))

    if create_own_folder:
        # double splitext for .tar.gz
        fname, ext = os.path.splitext(os.path.basename(filename))
        if ext == '.tar':
            filename = fname
        dest = os.path.join(dest, filename)
        if not os.path.isdir(dest):
            os.makedirs(dest)

    unpack_archive(src, dest, drivers=(unpack_zipfile, unpack_tarfile))

    # extract flat, don't extract archive files within archive files
    if not tree:
        return

    def find_archive_files(skip):
        found = []
        # find archive files in dest that are not in skip
        for root, _, filenames in os.walk(dest):
            for basename in filenames:
                src_file = os.path.join(root, basename)
                _, ext = os.path.splitext(basename)
                if ext in zip_ext and src_file not in skip:
                    found.append(src_file)
        return found

    skip = []
    new_files = find_archive_files(skip)
    # keep walking dest until no new archive files are found
    while new_files:
        # unzip (flat) new archive files found in dest
        for src_file in new_files:
            dest_path = os.path.split(src_file)[0]
            unzip(
                src_file,
                dest_path,
                zip_ext=zip_ext,
                create_own_folder=True,
                tree=False
            )
            skip.append(src_file)
        new_files = find_archive_files(skip)

		for p in m.__path__[1:]:
		    modulefinder.AddPackagePath(extra, p)
	except ImportError:
	    # no build path setup, no worries.
	    pass

	# hack to include simplejson egg in the build
	if using_simplejson:
		import pkg_resources
		eggs = pkg_resources.require("simplejson")
		from setuptools.archive_util import unpack_archive
		for egg in eggs:
			if os.path.isdir(egg.location):
				copytree(egg.location, ".")
			else:
				unpack_archive(egg.location, ".")
				rmtree("EGG-INFO")
	
	# windows specific options
	options = {
		"script": app + ".py",
		"icon_resources": [(1, os.path.join("resources", "main.ico"))],
	}
	resources = ['resources',]
	
	# horrible monkey patch to make sdl mixer include work (say what?)
	# http://www.python-forum.org/pythonforum/viewtopic.php?f=3&t=19455&start=0
	origIsSystemDLL = py2exe.build_exe.isSystemDLL
	def isSystemDLL(pathname):
	        if os.path.basename(pathname).lower() in ("libogg-0.dll", "sdl_ttf.dll"):
	                return 0

def test_unicode_files(tarfile_with_unicode, tmpdir):
    target = tmpdir / 'out'
    archive_util.unpack_archive(tarfile_with_unicode, six.text_type(target))

    # cx_Freeze can't handle 3rd-party packages packed in .egg files, so we have to extract them for it
    dependency_eggs_to_unpack = [
        'uavcan',
        'qtpy',
        'qtconsole',
    ]
    unpacked_eggs_dir = os.path.join('build', 'hatched_eggs')
    sys.path.insert(0, unpacked_eggs_dir)
    try:
        shutil.rmtree(unpacked_eggs_dir)
    except Exception:
        pass
    for dep in dependency_eggs_to_unpack:
        for egg in pkg_resources.require(dep):
            if not os.path.isdir(egg.location):
                unpack_archive(egg.location, unpacked_eggs_dir)

    import qtawesome
    import qtconsole
    import PyQt5
    import zmq
    import pygments
    import IPython
    import ipykernel
    import jupyter_client
    import traitlets
    import numpy

    # Oh, Windows, never change.
    missing_dlls = glob.glob(os.path.join(os.path.dirname(numpy.core.__file__), '*.dll'))
    print('Missing DLL:', missing_dlls)