Python ZipFile.infolist方法代码示例

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
    def test_replace_metadata(self):
        old_zip_file = get_test_zipfile('LotsOfFiles')

        metadata = models.parse_zipfile_metadata(old_zip_file)
        old_zip_file.seek(0)

        extension = models.Extension.objects.create_from_metadata(metadata, creator=self.user)
        version = models.ExtensionVersion(extension=extension,
                                          source=File(old_zip_file))

        version.parse_metadata_json(metadata)

        new_zip = version.get_zipfile('r')

        old_zip = ZipFile(File(old_zip_file), 'r')
        self.assertEqual(len(old_zip.infolist()), len(new_zip.infolist()))
        self.assertEqual(new_zip.read("metadata.json"),
                         version.make_metadata_json_string())

        for old_info in old_zip.infolist():
            if old_info.filename == "metadata.json":
                continue

            new_info = new_zip.getinfo(old_info.filename)
            self.assertEqual(old_zip.read(old_info), new_zip.read(new_info))
            self.assertEqual(old_info.date_time, new_info.date_time)

        old_zip.close()
        new_zip.close()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
class RemoteZipFile(object):
    """A potentially remote ZIP file"""

    def __init__(self, name_or_url):  # Holes smaller than 5MB will be read anyway.
        if name_or_url.startswith("http:"):
            self._f = httpopen(name_or_url)
            self._use_read_buffer = True
            # prefetch the last MB to capture most of the index
            self._f.prefetch([(self._f.size - 1024 * 1024, self._f.size)])
        else:
            self._f = open(name_or_url)
            self._use_read_buffer = False

        self._zf = ZipFile(self._f)
        if self._use_read_buffer:
            self._sinfo = sorted((i.header_offset, i) for i in self._zf.infolist())
            self._dict = dict((i.filename, i) for i in self._zf.infolist())

    def keys(self):
        return self._zf.namelist()

    def require(self, required):
        if self._use_read_buffer:

            def get_block_range(block_id):
                s = self._sinfo[block_id][1].header_offset
                if block_id != len(self._sinfo) - 1:
                    e = self._sinfo[block_id + 1][1].header_offset
                else:
                    e = self._f.size - 1
                return (s, e)

            blocks = [j for j, (_, i) in enumerate(self._sinfo) if i.filename in required]
            read_blocks = []
            for i in blocks:
                if not read_blocks:
                    read_blocks.append(get_block_range(i))
                else:
                    start, end = read_blocks[-1]
                    b_start, b_end = get_block_range(i)
                    if b_start > end + MIN_HOLE_SIZE:
                        read_blocks.append((b_start, b_end))
                    else:
                        read_blocks[-1] = (start, b_end)
            self._f.prefetch(read_blocks)

        rset = set(required)
        for i in self._zf.infolist():
            if i.filename in rset:
                rset.remove(i.filename)
                x = self._zf.open(i)
                write(1, struct.pack("i", len(i.filename)))
                write(1, i.filename)
                write(1, struct.pack("i", i.file_size))
                write(1, x.read())
                # x.read1(i.file_size)
                # x.read()#1(i.file_size)
        assert not rset, rset

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
class ExtractFile(object):
    def __init__(self, fp, work_path, regex_util=None, show_info=False, progress=None, eu_text=None):
        self.fp = fp
        self.work_path = work_path
        self.zf = ZipFile(self.fp, mode="r")
        self.regex_util = regex_util
        self.progress = progress
        self.uncompress_size = sum((f.file_size for f in self.zf.infolist()))
        self.show_info = show_info
        self.eu_text = eu_text

    def clean_work_path(self):
        if os.path.exists(self.work_path):
            shutil.rmtree(self.work_path)
        os.mkdir(self.work_path)

    def extract(self):
        members = self.zf.infolist()
        if self.show_info:
            self.start_extract()
        total = 0
        for zip_info in members:
            total += zip_info.file_size
            if not self.regex_util or not self.regex_util.do_match(spit_filename(zip_info.filename, True)):
                if len(zip_info.filename) + len(self.work_path) + 1 < 255:
                    self.zf.extract(zip_info.filename, self.work_path)
                    if self.eu_text and spit_filename(zip_info.filename, True) == "important.properties":
                        file_path = os.path.join(self.work_path, zip_info.filename)
                        try:
                            cf = MyConfigParser(file_path, file_error=True)
                            regrex = ["\$\{" + key + "\}" for key in cf.keys()]
                            self.eu_text.add_regex(regrex)
                        except Exception as exe:
                            print exe
                            print self.work_path + "/" + zip_info.filename
                    if self.show_info:
                        self.update_extract(total)
                else:
                    print "path len > 255   ", self.work_path, zip_info.filename
            else:
                pass
        if self.show_info:
            self.finish_extract()
        self.zf.close()

    def start_extract(self):
        if self.progress:
            self.progress.start_extract(fp=self.fp, uncompress_size=self.uncompress_size)

    def finish_extract(self):
        if self.progress:
            self.progress.finish_extract(fp=self.fp)

    def update_extract(self, extract_size):
        if self.progress:
            self.progress.update_extract(extract_size=extract_size)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
    def _build_trek_ressources(self, trek, language, force):
        logger.info("Build %s ressources file for trek '%s'..." % (language, trek.properties.name))

        output_folder = os.path.join(settings.INPUT_DATA_ROOT, language, 'api/trek')
        if not os.path.exists(output_folder):
            logger.info("Create folder %s" % output_folder)
            os.makedirs(output_folder)
        zipfilename = os.path.join(output_folder, 'trek-%u.zip' % trek.id)
        zipfile = ZipFile(zipfilename + '.new', 'w')

        media = set()
        missing_media = set()

        trek_dest = 'trek/{trek.pk}'.format(trek=trek)
        # All pictures
        for picture in trek.properties.pictures:
            media.add((picture['url'], trek_dest))
        # Information desks picture
        for desk in trek.properties.information_desks:
            if desk['photo_url']:
                media.add((desk['photo_url'], trek_dest))
        # Only one picture per POI
        for poi in trek.pois.all():
            poi_dest = 'poi/{poi.pk}'.format(poi=poi)
            if poi.properties.pictures:
                media.add((poi.properties.pictures[0]['url'], poi_dest))

        if missing_media:
            logger.warning('Missing media: ' + ', '.join(missing_media))

        for url, dest in media:
            url = unquote(url).lstrip('/')
            fullpath = os.path.join(settings.INPUT_DATA_ROOT, url)
            arcname = os.path.join(dest, os.path.basename(url))
            zipfile.write(fullpath, arcname)

        try:
            oldzipfile = ZipFile(zipfilename, 'r')
        except IOError:
            uptodate = False
        else:
            old = set([(zi.filename, zi.CRC) for zi in oldzipfile.infolist()])
            new = set([(zi.filename, zi.CRC) for zi in zipfile.infolist()])
            uptodate = (old == new) and not force
            oldzipfile.close()

        zipfile.close()
        if uptodate:
            os.unlink(zipfilename + '.new')
            logger.info('%s was up to date.' % zipfilename)
        else:
            os.rename(zipfilename + '.new', zipfilename)
            logger.info('%s done.' % zipfilename)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
def do(zip_file_name, include):
    print('zip_file_name:', zip_file_name)
    print('Include files:', include)

    # Измененный zip
    out_zip_file_name = '_' + zip_file_name

    try:
        print('open {} and {} zip arhives'.format(zip_file_name, out_zip_file_name))
        zin = ZipFile(zip_file_name, 'r')
        zout = ZipFile(out_zip_file_name, 'w')

        print('start fill {} zip arhive'.format(out_zip_file_name))

        for item in zin.infolist():
            buffer = zin.read(item.filename)

            if any((fnmatch.fnmatch(item.filename, pattern) for pattern in include)):
                zout.writestr(item, buffer)
            else:
                print('Delete', item.filename)

        print('finish fill {} zip arhive'.format(out_zip_file_name))

    finally:
        zout.close()
        zin.close()

        # Удаляем оригинальный
        print('remove original {} zip file'.format(zip_file_name))
        os.remove(zip_file_name)

        # Переименновываем измененный zip в оригинальный
        print('rename {} zip file as original {}'.format(out_zip_file_name, zip_file_name))
        os.rename(out_zip_file_name, zip_file_name)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
def _download_biogrid_data(url):
    """Downloads zipped, tab-separated Biogrid data in .tab2 format.

    Parameters:
    -----------
    url : str
        URL of the BioGrid zip file.

    Returns
    -------
    csv.reader
        A csv.reader object for iterating over the rows (header has already
        been skipped).
    """
    res = requests.get(biogrid_file_url)
    if res.status_code != 200:
        raise Exception('Unable to download Biogrid data: status code %s'
                        % res.status_code)
    zip_bytes = BytesIO(res.content)
    zip_file = ZipFile(zip_bytes)
    zip_info_list = zip_file.infolist()
    # There should be only one file in this zip archive
    if len(zip_info_list) != 1:
        raise Exception('There should be exactly zipfile in BioGrid zip '
                        'archive: %s' % str(zip_info_list))
    unzipped_bytes = zip_file.read(zip_info_list[0]) # Unzip the file
    biogrid_str = StringIO(unzipped_bytes.decode('utf8')) # Make file-like obj
    csv_reader = csv.reader(biogrid_str, delimiter='\t') # Get csv reader
    next(csv_reader) # Skip the header
    return csv_reader

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
def extract_subfiles(source_path, dest_path, verbose=False):
    if os.path.isdir(source_path):
        for dirpath, dirnames, filenames in os.walk(source_path):
            relpath = os.path.relpath(dirpath, source_path)
            new_dir_path = os.path.join(dest_path, relpath)
            if not os.path.isdir(new_dir_path):
                os.mkdir(new_dir_path)
            for filename in filenames:
                try:
                    source_file_path = os.path.join(dirpath, filename)
                    relpath = os.path.relpath(source_file_path, source_path)
                    dest_file_path = os.path.join(dest_path, relpath)
                    print dest_file_path
                    if dest_file_path.endswith('.cod'):
                        zip = ZipFile(source_file_path)
                        for info in zip.infolist():
                            if verbose:
                                print '    %s (extracted)' % info.filename
                            dest_unzip_path = os.path.split(dest_file_path)[0] 
                            if not os.path.realpath(os.path.join(dest_unzip_path, info.filename)).startswith(os.path.realpath(dest_unzip_path)):
                                raise(Exception('Security exception: zip file %s attempted to extract to a non-local location' % info.filename))
                            zip.extract(info, path = dest_unzip_path)
                    else:
                        shutil.copyfile(source_file_path, dest_file_path)
                except Exception, e:
                    if str(e) == 'File is not a zip file':
                        # this is a cod file or some other file
                        shutil.copyfile(source_file_path, dest_file_path)
                    else:
                        if verbose:
                            print >>sys.stderr, 'Error:',
                            print >>sys.stderr, str(e)
                        raise(e)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
    def openZip(cls, fo):
        z = ZipFile(fo)
        zfiles = z.infolist()
        if len(zfiles) == 1:
            return z.open(zfiles[0].filename)

        raise NotAFBZException()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
    def save_file_data(settle_date, data, temp_path, merchant_id, temp_prefix='unionpay_'):
        '''
        @settle_date:   like 1216 for generate filename
        @data:          fileContent from request
        @temp_path:     save data to a temp path

        '''
        timeRandomString = datetime.now().strftime("%Y%m%d%H%M%S")
        path = os.path.join(
            temp_path, "%s%s%s" % (temp_prefix, datetime.now().year, settle_date))

        if not os.path.exists(path):
            os.mkdir(path)

        fileWholePath = "%s/SMT_%s.zip" % (path, timeRandomString)
        with open(fileWholePath, 'wb') as f:
            f.write(data)
        logger.debug("temp file <%s> created！" % fileWholePath)
        zfile = ZipFile(fileWholePath, 'r')
        zfile.extractall(path)
        files_list = zfile.infolist()
        logger.debug("file <%s> unziped！" % ','.join(zfile.namelist()))
        zfile.close()
        logger.debug("balance file <%s> saved!" % path)
        os.unlink(fileWholePath)
        logger.debug("temp file deleted")

        balance_files = []

        for item in files_list:
            if Signer.accept_filetype(item.filename, merchant_id):
                balance_files.append(os.path.join(path, item.filename))
        return balance_files

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
def zip_data(source, modified_files):
    file = StringIO()
    outzip = ZipFile(file, 'w')
    zip = ZipFile(StringIO(source))
    for info in zip.infolist():
        # Replace the data from the map
        if info.filename in modified_files:
            data = modified_files[info.filename]
            if data is None:
                continue
        else:
            data = zip.read(info.filename)

        # Section 17.4 says the mimetype file shall not include an extra
        # field.  So we remove it even if present in the source.
        if info.filename == 'mimetype':
            info.extra = ''

        # Ok
        outzip.writestr(info, data)

    # Ok
    outzip.close()
    content = file.getvalue()
    file.close()
    return content

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
 def extractAll(self):
     logger.info('extracting now.')
     # Open database and check existing files.
     optimizer = ExtractionOptimizer(self.optimizeFile)
     try:
         optimizer.scanDir(self.unpackDir)
         zipFile = ZipFile(self.zip, 'r')
         try:
             # Register new files.
             for zipInfo in zipFile.infolist():
                 if Extractor.__isFile(zipInfo):
                     fileInfo = FileInfo.fromZipInfo(zipInfo, 1)
                     optimizer.registerFile(fileInfo)
             # Update file storage.
             extractor = RawExtractor(self.unpackDir, zipFile)
             for op in optimizer.operations():
                 extractor.extract(op)
         except IOError:
             return Extractor.RESULT_ERROR
         finally:
             zipFile.close()
         
     finally:
         optimizer.close()
     logger.info('extract completed.')
     return Extractor.RESULT_EXTRACTED

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
def unzip(filename, match_dir=False, destdir=None):
    """
    Extract all files from a zip archive
    filename: The path to the zip file
    match_dir: If True all files in the zip must be contained in a subdirectory
      named after the archive file with extension removed
    destdir: Extract the zip into this directory, default current directory

    return: If match_dir is True then returns the subdirectory (including
      destdir), otherwise returns destdir or '.'
    """
    if not destdir:
        destdir = '.'

    z = ZipFile(filename)
    unzipped = '.'

    if match_dir:
        if not filename.endswith('.zip'):
            raise FileException('Expected .zip file extension', filename)
        unzipped = os.path.basename(filename)[:-4]
        check_extracted_paths(z.namelist(), unzipped)
    else:
        check_extracted_paths(z.namelist())

    # File permissions, see
    # http://stackoverflow.com/a/6297838
    # http://stackoverflow.com/a/3015466
    for info in z.infolist():
        log.debug('Extracting %s to %s', info.filename, destdir)
        z.extract(info, destdir)
        os.chmod(os.path.join(destdir, info.filename),
                 info.external_attr >> 16 & 4095)

    return os.path.join(destdir, unzipped)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
def springer():
    DIR = 'JHEP/'
    EXT = ('.xml.Meta', '.xml.scoap')
    BASE_DIR = '/eos/project/s/scoap3repo/BETA/harvesting/Springer/download/' + DIR
    zip_list = listdir(BASE_DIR)

    needed_dois = json.loads(open('/tmp/repo_diff_result2', 'r').read())['only_in_old']

    extracted_dois = {}
    for file in zip_list:
        full_path = BASE_DIR + file
        if isfile(full_path) and full_path.endswith('.zip'):
            try:
                zip = ZipFile(full_path)
                for zip_element in zip.infolist():
                    fn = zip_element.filename
                    if fn.endswith(EXT):
                        xml = parseString(zip.read(zip_element))
                        doi = xml.getElementsByTagName('ArticleDOI')[0].firstChild.nodeValue
                        if doi in needed_dois:
                            if full_path not in extracted_dois:
                                extracted_dois[full_path] = []
                            extracted_dois[full_path].append(doi)
            except BadZipfile as e:
                error('file %s: %s' % (file, e))

    info('%s' % json.dumps(extracted_dois, indent=2))

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
def iterate_runs_points(runs):
    ''' Iterate over all the points, skipping share-alike sources.
    '''
    for result in iterate_local_processed_files(runs, sort_on='source_path'):
        if result.run_state.share_alike == 'true':
            continue

        _L.info('Indexing points from {}'.format(result.source_base))
        _L.debug('filename: {}'.format(result.filename))
        _L.debug('run_state: {}'.format(result.run_state))
        _L.debug('code_version: {}'.format(result.code_version))
        with open(result.filename, 'rb') as file:
            result_zip = ZipFile(file)

            csv_infos = [zipinfo for zipinfo in result_zip.infolist()
                         if splitext(zipinfo.filename)[1] == '.csv']

            if not csv_infos:
                break

            zipped_file = result_zip.open(csv_infos[0].filename)
            point_rows = DictReader(TextIOWrapper(zipped_file))

            for row in point_rows:
                try:
                    lat, lon = float(row['LAT']), float(row['LON'])
                except ValueError:
                    # Skip this point if the lat/lon don't parse
                    continue

                # Include this point if it's on Earth
                if -180 <= lon <= 180 and -90 <= lat <= 90:
                    yield Point(lon, lat, result, row)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import infolist [as 别名]
    def read_words_from_anki_pkg(self, anki_pkg_file_path):
        """Reads words from an apkg file into a set

            arguments: 
                anki_pkg_file_path(str): path to the anki pkg file

            returns:
                (set) of words
        """
        pass

        anki_deck_db_url = ''

        #extract the collection database from .pkg file
        if not os.path.exists(anki_pkg_file_path):
            raise ValueError('Path to apkg file is not valid')

        try:
            zf = ZipFile(anki_pkg_file_path, 'r')
            #open the zipfile looking for the collection.anki2 file
            for info in zf.infolist():
                if info.filename == 'collection.anki2':
                    zf.extract(info.filename)
                    anki_deck_db_url = "sqlite:///{0}".format(info.filename)

        except BadZipfile:
            raise ValueError('apkg file is corrupt or not valid')
            return
                
        if len(anki_deck_db_url) == 0:
            raise ValueError('No collection database file found in apkg')

	return Anki().distill_words(anki_deck_db_url)