Python zipfile.read函数代码示例

def read_metadata(zipfile):
    for info in zipfile.infolist():
        basename = os.path.basename(info.filename)
        if basename == METADATA_FILENAME:
            meta_file = zipfile.read(info.filename)
            return kbjson.loads(meta_file)
    return {}

 def save_extracted_file(self, zipfile, filename):
     "Extract the file to a temp directory for viewing"
     try:
         filebytes = zipfile.read(filename)
     except BadZipfile, err:
         print 'Error opening the zip file: %s' % (err)
         return False

def read_info_file(zipfile, path, section):
    """Return a dictionary matching the contents of the config file at
    path in zipfile"""
    cp = SafeConfigParser()
    info = StringIO(zipfile.read(path))
    cp.readfp(info)
    return dict(cp.items(section))

def extract_member(zipfile, member, dstdir):
    """Copied and adjusted from Python 2.6 stdlib zipfile.py module.

       Extract the ZipInfo object 'member' to a physical
       file on the path targetpath.
    """

    assert dstdir.endswith(os.path.sep), "/ missing at end"

    fn = member.filename
    if isinstance(fn, str):
        fn = unicode(fn, "utf-8")
    targetpath = os.path.normpath(os.path.join(dstdir, fn))

    if not targetpath.startswith(dstdir):
        raise RuntimeError("bad filename in zipfile %r" % (targetpath,))

    # Create all upper directories if necessary.
    if member.filename.endswith("/"):
        upperdirs = targetpath
    else:
        upperdirs = os.path.dirname(targetpath)

    if not os.path.isdir(upperdirs):
        os.makedirs(upperdirs)

    if not member.filename.endswith("/"):
        open(targetpath, "wb").write(zipfile.read(member.filename))

    def _get_app_zip(self, abs_nb_path):
        '''
        Creates a zip file containing a dashboard application bundle.

        :param abs_nb_path:
        '''
        md = self._create_app_bundle(abs_nb_path)
        converter.add_cf_manifest(
            md['bundle_dir'],
            md['kernel_server'],
            md['notebook_basename'],
            md['tmpnb_mode']
        )
        converter.add_dockerfile(
            md['bundle_dir'],
            md['kernel_server'],
            md['tmpnb_mode']
        )
        # Make the zip Archive
        converter.to_zip(md['bundle_dir'], md['bundle_dir'])
        self.set_header('Content-Disposition', 'attachment; filename={}.zip'.format(md['notebook_basename']))
        self.set_header('Content-Type', 'application/zip')
        with open(md['bundle_dir'] + '.zip', 'rb') as zipfile:
            self.write(zipfile.read())
        self.flush()
        self.finish()

def read_metadata(zipfile):
    """Reads and returns metadata from a backup zipfile."""
    for info in zipfile.infolist():
        basename = os.path.basename(info.filename)
        if basename == METADATA_FILENAME:
            meta_file = zipfile.read(info.filename)
            return kbjson.loads(meta_file)
    return {}

def getzflo(zipfile, member_path):
    # GET a Zipfile File-Like Object for passing to
    # an XML parser
    try:
        return zipfile.open(member_path) # CPython 2.6 onwards
    except AttributeError:
        # old way
        return BYTES_IO(zipfile.read(member_path))

 def ziptodict(self,zipfile):
     contentdict ={}
     list = zipfile.namelist()
     for name in list:
         if not name[-1] == '/':
             contentdict[name]=zipfile.read(name)
             print name
     return contentdict

 def save_extracted_file(self, zipfile, filename):
     "Extract the file to a temp directory for viewing"
     filebytes = zipfile.read(filename)
     f = open("/tmp/" + filename, 'w')
     try:
         f.write(filebytes)
     finally:
         f.close()

	def get_zip_data( self, zipfile ):
		#data = data.replace( b'\xb5', b'\xc2\xb5' )
		#data = data.replace( b'\xe9', b'\xc3\xa9' )
		data = zipfile.read( self.fileName )
		data = data.decode( encoding='ISO-8859-1' )
		#data = data.encode( 'UTF-8' ).decode( 'UTF-8' )
		#print( data )
		data = data.splitlines()
		return data

    def verify(self, zipfile=None):
        """Configure the VerifyingZipFile `zipfile` by verifying its signature
        and setting expected hashes for every hash in RECORD.
        Caller must complete the verification process by completely reading
        every file in the archive (e.g. with extractall)."""
        sig = None
        if zipfile is None:
            zipfile = self.zipfile
        zipfile.strict = True

        record_name = '/'.join((self.distinfo_name, 'RECORD'))
        sig_name = '/'.join((self.distinfo_name, 'RECORD.jws'))
        # tolerate s/mime signatures:
        smime_sig_name = '/'.join((self.distinfo_name, 'RECORD.p7s'))
        zipfile.set_expected_hash(record_name, None)
        zipfile.set_expected_hash(sig_name, None)
        zipfile.set_expected_hash(smime_sig_name, None)
        record = zipfile.read(record_name)

        record_digest = urlsafe_b64encode(hashlib.sha256(record).digest())
        try:
            sig = from_json(native(zipfile.read(sig_name)))
        except KeyError:  # no signature
            pass
        if sig:
            headers, payload = signatures.verify(sig)
            if payload['hash'] != "sha256=" + native(record_digest):
                msg = "RECORD.jws claimed RECORD hash {} != computed hash {}."
                raise BadWheelFile(msg.format(payload['hash'],
                                              native(record_digest)))

        reader = csv.reader((native(r, 'utf-8') for r in record.splitlines()))

        for row in reader:
            filename = row[0]
            hash = row[1]
            if not hash:
                if filename not in (record_name, sig_name):
                    print("%s has no hash!" % filename, file=sys.stderr)
                continue

            algo, data = row[1].split('=', 1)
            assert algo == "sha256", "Unsupported hash algorithm"
            zipfile.set_expected_hash(filename, urlsafe_b64decode(binary(data)))

 def load(self, srcpath):
     """Reads the metadata from an ebook file.
     """
     content_xml = self._load_metadata(srcpath)
     if content_xml is not None:
         book = self._load_ops_data(content_xml)
         if self._configuration['import']['hash']:
             with open(srcpath, 'rb') as zipfile:
                 book['_sha_hash'] = sha1(zipfile.read()).hexdigest()
         return book

def importzip(conn,filename,zipfile):
    print 'Import ' + filename
    files = filelist(zipfile)
    cur = conn.cursor()
    meta = metadata(zipfile.read(files['OPERDAY']))
    if datetime.strptime(meta['ValidThru'].replace('-',''),'%Y%m%d') < (datetime.now() - timedelta(days=1)):
        return meta
    header = (zipfile.read(files['DEST']).split('\n')[0].split('|')[1] in versionheaders)
    encoding = encodingof(meta['DataOwnerCode'])
    for table in importorder:
        if table in files:
            f = zipfile.open(files[table])
            table = table+'_delta'
            if header:
                cur.copy_expert("COPY %s FROM STDIN WITH DELIMITER AS '|' NULL AS '' CSV HEADER ENCODING '%s'" % (table,encoding),f)
            else:
                cur.copy_expert("COPY %s FROM STDIN WITH DELIMITER AS '|' NULL AS '' CSV ENCODING '%s'" % (table,encoding),f)
    conn.commit()
    cur.close()
    return meta

 def save_extracted_file(self, zipfile, filename):
     "Extract the file to a temp directory for viewing"
     filebytes = zipfile.read(filename)
     outfn = self.make_new_filename(filename)
     if (outfn == ''):
         return False
     f = open(os.path.join(self.get_activity_root(), 'tmp',  outfn),  'w')
     try:
         f.write(filebytes)
     finally:
         f.close()

def importzip(conn,zipfile):
    files = filelist(zipfile)
    cur = conn.cursor()
    if 'OPERDAY' in files:
        meta = metadata(zipfile.read(files['OPERDAY']))
    elif 'PUJO' in files:
        meta = metadata(zipfile.read(files['PUJO']))
    else:
        raise Exception('OPERDAY mist')
    header = (zipfile.read(files['DEST']).split('\r\n')[0].split('|')[1] in versionheaders)
    encoding = encodingof(meta['dataownercode'])
    del(meta['dataownercode'])
    for table in importorder:
        if table in files:
            f = zipfile.open(files[table])
            if header:
                cur.copy_expert("COPY %s FROM STDIN WITH DELIMITER AS '|' NULL AS '' CSV HEADER ENCODING '%s'" % (table,encoding),f)
            else:
                cur.copy_expert("COPY %s FROM STDIN WITH DELIMITER AS '|' NULL AS '' CSV ENCODING '%s'" % (table,encoding),f)
    cur.close()
    return meta