Python ZipFile.read方法代码示例

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
def readZip(f, **kwargs):
	from mien.parsers.nmpml import elements as dialect
	f=ZipFile(f, 'r')
	xml=f.read('xml')
	xml=StringIO(xml)
	doc=xm.readTree(xml)
	xml.close()
	doc=xm.assignClasses(doc, dialect)	
	try:
		dat=f.read('data')
	except:
		print "No data archive in zip file"
		return doc
	from mien.parsers.datahash import readMD	
	dat=StringIO(dat)
	dat=readMD(dat, return_raw_hash=True)
	des=doc.getElements('Data')
	for de in des:
		try:
			d, h=dat[de.upath()]
		except:
			print "can't find data for element %s" % (de.upath(),)
			d, h=(zeros(0), {})
		de.datinit(d, h)
	f.close()	
	return doc		

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
def find_plugin_yaml(dataobj):
    """
        """
    yml = False
    try:
        # The first thing we are going to try to do is create a ZipFile
        # object with the StringIO data that we have.
        zfile = ZipFile(dataobj)
    except:
        print "[DEBUG] ZipFile Library Failed to Parse DataObject"
    else:
        # Before we start recursively jumping through hoops, lets first
        # check to see if the plugin.yml exists at this level.  If so, then
        # just set the yaml variable.  Otherwise we are gonna look for more
        # zip and jar files and dig into them.
        if "plugin.yml" in zfile.namelist():
            try:
                yml = yaml.load(zfile.read("plugin.yml"))
            except:
                return False
        else:
            for filename in zfile.namelist():
                if not yml and filename[-3:].lower() in ["zip", "jar"]:
                    print "[DEBUG] Found Zip/Jar file " + filename
                    data = StringIO()
                    data.write(zfile.read(filename))
                    yml = find_plugin_yaml(data)
                    data.close()
            zfile.close()
    return yml

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
def get_story_url_from_epub_html(inputio,_is_good_url=None):
    # print("get_story_url_from_epub_html called")
    epub = ZipFile(inputio, 'r') # works equally well with inputio as a path or a blob

    ## Find the .opf file.
    container = epub.read("META-INF/container.xml")
    containerdom = parseString(container)
    rootfilenodelist = containerdom.getElementsByTagName("rootfile")
    rootfilename = rootfilenodelist[0].getAttribute("full-path")

    contentdom = parseString(epub.read(rootfilename))
    #firstmetadom = contentdom.getElementsByTagName("metadata")[0]

    ## Save the path to the .opf file--hrefs inside it are relative to it.
    relpath = get_path_part(rootfilename)

    # spin through the manifest--only place there are item tags.
    for item in contentdom.getElementsByTagName("item"):
        if( item.getAttribute("media-type") == "application/xhtml+xml" ):
            filehref=relpath+item.getAttribute("href")
            soup = make_soup(epub.read(filehref).decode("utf-8"))
            for link in soup.findAll('a',href=re.compile(r'^http.*')):
                ahref=link['href']
                # print("href:(%s)"%ahref)
                # hack for bad ficsaver ffnet URLs.
                m = re.match(r"^http://www.fanfiction.net/s(?P<id>\d+)//$",ahref)
                if m != None:
                    ahref="http://www.fanfiction.net/s/%s/1/"%m.group('id')
                if _is_good_url == None or _is_good_url(ahref):
                    return ahref
    return None

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
    def open(zipname):
        zf = ZipFile(zipname, 'r')
        m = zf.read('META-INF/manifest.xml')
        manifest = Manifest.parse(m)

        def warn(resource):
            print(u"Warning: bundle {} does not contain resource {}, which is referred in its manifest.".format(zipname, resource).encode('utf-8'))

        result = Bundle()
        result.presets_data = []
        for preset in manifest.get_resources('paintoppresets'):
            if preset in zf.namelist():
                result.presets.append(preset)
                data = zf.read(preset)
                kpp = KPP(preset, data)
                result.presets_data.append(kpp)
            else:
                warn(preset)

        result.meta_string = zf.read("meta.xml")
        result.preview_data = zf.read("preview.png")

        for brush in manifest.get_resources('brushes'):
            if brush in zf.namelist():
                result.brushes.append(brush)
            else:
                warn(brush)
        for pattern in manifest.get_resources('patterns'):
            if pattern in zf.namelist():
                result.patterns.append(pattern)
            else:
                warn(pattern)
            
        zf.close()
        return result

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
    def test_export_mixed_encodings(self):
        self.test_folder.zip_import.do_import(data=mac_zip)
        addNyDocument(self.test_folder, id='html_document')
        self.test_folder['html_document'].body = u'<p>Html document</p>'
        self.test_folder['html_document'].approved = 1
        export_value = self.test_folder.zip_export.do_export()
        self.assertFalse(isinstance(export_value, list),
                         ('Errors are raised: ', export_value))

        zip = ZipFile(export_value, 'r')

        expected_namelist = ['index.txt',
                             'zip_export_folder/picture-1.png',
                             'zip_export_folder/picture-2.png',
                             'zip_export_folder/html_document.html']

        self.assertEqual(sorted(zip.namelist()), sorted(expected_namelist))
        self.assertTrue('<p>Html document</p>' in \
                         zip.read('zip_export_folder/html_document.html'))

        picture1_data = IZipExportObject(self.test_folder['picture-1'])()[0]
        picture2_data = IZipExportObject(self.test_folder['picture-2'])()[0]

        self.assertEqual(zip.read('zip_export_folder/picture-1.png'),
                         picture1_data)
        self.assertEqual(zip.read('zip_export_folder/picture-2.png'),
                         picture2_data)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
 def test_graph_export_csv(self):
     create_graph(self)
     create_schema(self)
     create_type(self)
     create_data(self)
     self.browser.find_by_id('toolsMenu').first.click()
     cookies = {self.browser.cookies.all()[0]["name"]: self.browser.cookies.all()[0]["value"], self.browser.cookies.all()[1]["name"]: self.browser.cookies.all()[1]["value"]}
     result = requests.get(self.live_server_url + '/tools/bobs-graph/export/csv/', cookies=cookies)
     spin_assert(lambda: self.assertEqual(
         result.headers['content-type'], 'application/zip'))
     spin_assert(lambda: self.assertEqual(
         self.browser.status_code.is_success(), True))
     test_file = StringIO(result.content)
     csv_zip = ZipFile(test_file)
     for name in csv_zip.namelist():
         fw = open('sylva/sylva/tests/files/' + name, 'w')
         fw.write(csv_zip.read(name))
         fw.close()
     for name in csv_zip.namelist():
         f = open('sylva/sylva/tests/files/' + name)
         csvFile = ""
         for line in f:
             csvFile += line
         f.close()
         spin_assert(lambda: self.assertEqual(csv_zip.read(name), csvFile))
     Graph.objects.get(name="Bob's graph").destroy()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
    def unpack_zipdata(self, zipdata):
        stream = BytesIO(zipdata)
        fzip = ZipFile(stream)
        pdfs = [x.filename for x in fzip.filelist
                if x.filename.endswith('.pdf')]
        if not pdfs:
            raise ServerError(
                'Conversion returned zip containing no pdf files')

        thumbnails = sorted(
            [x.filename for x in fzip.filelist
                if x.filename.startswith('small/') and x.filename != 'small/'],
            key=lambda x: int(x.split('.')[0].split('_')[-1]))
        previews = sorted(
            [x.filename for x in fzip.filelist
                if x.filename.startswith('large/') and x.filename != 'large/'],
            key=lambda x: int(x.split('.')[0].split('_')[-1]))
        converted = {
            'pdfs': [fzip.read(pdfs[0])],
            'thumbnails': [fzip.read(filename)
                           for filename in thumbnails[:20]],
            'previews': [fzip.read(filename) for filename in previews[:20]],
        }
        fzip.close()
        stream.close()
        return converted

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
class PebbleSystemResources(object):
    def __init__(self, firmware_path):
        self._firmware_path = firmware_path
        self._zipfile = ZipFile(firmware_path)
        self._manifest = json.loads(self._zipfile.read("manifest.json"))
        self._resource_data = self._zipfile.read("system_resources.pbpack")
        self.resources = PebbleResources(self._resource_data)
        self.resource_id_mapping = self.get_resource_id_mapping()

    def get_resource_id_mapping(self):
        resource_id_mapping = {}
        media = self._manifest["debug"]["resourceMap"]["media"]
        file_id = 0
        for media_entry in media:
            file_id += 1
            resource_name = "RESOURCE_ID_" + media_entry["defName"]
            if media_entry["type"] == "png-trans":
                resource_id_mapping[resource_name + "_WHITE"] = file_id
                file_id += 1
                resource_id_mapping[resource_name + "_BLACK"] = file_id
            else:
                resource_id_mapping[resource_name] = file_id
        return resource_id_mapping

    def verify_data(self):
        return self.resources.verify_data()

    def get_file_id(self, def_name):
        return self.resource_id_mapping[def_name]

    def get_chunk(self, file_id):
        return self.resources.get_chunk(file_id)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
	def load_and_save_scopes(self):
		scopes = set()
		for x in os.walk(sublime.packages_path() + '/..'):
			for f in glob.glob(os.path.join(x[0], '*.tmLanguage')):
				for s in self.get_scopes_from(plistlib.readPlist(f)):
					scopes.add(s.strip())

		for x in os.walk(os.path.dirname(sublime.executable_path())):
			for f in glob.glob(os.path.join(x[0], '*.sublime-package')):
				input_zip = ZipFile(f)
				for name in input_zip.namelist():
					if name.endswith('.tmLanguage'):
						for s in self.get_scopes_from(plistlib.readPlistFromBytes(input_zip.read(name))):
							scopes.add(s.strip())

		for x in os.walk(sublime.packages_path() + '/..'):
			for f in glob.glob(os.path.join(x[0], '*.sublime-package')):
				input_zip = ZipFile(f)
				for name in input_zip.namelist():
					if name.endswith('.tmLanguage'):
						for s in self.get_scopes_from(plistlib.readPlistFromBytes(input_zip.read(name))):
							scopes.add(s.strip())
		names = list(scopes)
		scopes = dict()
		for name in names:
			value = name
			if value.startswith('source.'):
				value = value[7:]
			elif value.startswith('text.'):
				value = value[5:]
			scopes[name] = value
		self.settings.set('scopes', scopes)
		sublime.save_settings('smart-pieces.sublime-settings')

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
def parseZip( fn ):
	date_time = ''
	members = dict()
	removemembers = False
	zipfile = ZipFile( fn )
	cache.invalidate(recordlist.output, 'list_output', )
	files_of_interest = ['infolog.txt','ext.txt','platform.txt','script.txt','settings.txt','unitsync.log','client.txt','information.txt','demo.sdf']
	
	for info in zipfile.infolist():
		if info.filename in files_of_interest and info.file_size < 5 * 1024 * 1024:
			members[info.filename] = zipfile.read( info.filename )
			if info.filename == 'infolog.txt':
				date_time = info.date_time
		else:
			removemembers = True
	
	if removemembers:
		newzipfile = ZipFile (fn + '.new', 'w')
		tmpfilename = '/tmp/' + os.path.basename (fn) + '.tmp'
		for file in members.keys ():
			tmpfile = open (tmpfilename, 'w')
			tmpfile.write (zipfile.read (file))
			tmpfile.close ()
			newzipfile.write (tmpfilename, file)
			os.remove (tmpfilename)
		newzipfile.close ()
		zipfile.close ()
		os.rename (fn, fn + '.orig')
		os.rename (fn + '.new', fn)
	else:
		zipfile.close ()
	
	return db.parseZipMembers( fn, members, date_time )

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
class Stick(object):

    def __init__(self,stickfaceFileLoc,iniName,pos=(0,0)):
        self.iniName = iniName
        self.stickfaceFileLoc = stickfaceFileLoc
        self.loadStickfaceFile(self.stickfaceFileLoc)
        self.buttons = [0] * len(self.stickfaceIni['buttons'])
        self.hat = (0,0)
        self.pos = pos
        self.cutoff = 1

    def loadStickfaceFile(self,stickfaceFileLoc):
        load = pygame.image.load
        self.stickfaceZip = ZipFile(stickfaceFileLoc,'r')
        self.stickfaceIni = yamlLoad(self.stickfaceZip.read(self.iniName))
        self.controllerSize = tuple(self.stickfaceIni['controllerSize'])
        self.buttonImages = [load(StringIO(self.stickfaceZip.read(i))) for i in self.stickfaceIni['buttonImages']]
        self.controllerImg = load(StringIO(self.stickfaceZip.read(self.stickfaceIni['controllerImage'])))
        self.buttonLoc = [tuple(i) for i in self.stickfaceIni['buttonLocs']]
        self.buttonSize = [tuple(i) for i in self.stickfaceIni['buttonSizes']]

    def drawController(self):
        finalImg = pygame.Surface(self.controllerSize).convert_alpha()
        finalImg.blit(self.controllerImg,(0,0))
        for b in range(12):
            if self.buttons[b] >= self.cutoff:
                finalImg.blit(self.buttonImages[b],self.buttonLoc[b])
        return finalImg

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
 def _find_plugin_yaml(self, dataobj):
     '''
     '''
     yml = False
     try:
         # The first thing we are going to try to do is create a ZipFile
         # object with the StringIO data that we have.
         zfile = ZipFile(dataobj)
     except:
         pass
     else:
         # Before we start recursively jumping through hoops, lets first
         # check to see if the plugin.yml exists at this level.  If so, then
         # just set the yaml variable.  Otherwise we are gonna look for more
         # zip and jar files and dig into them.
         if 'plugin.yml' in zfile.namelist():
             try:
                 yml = yaml.load(zfile.read('plugin.yml'))
             except:
                 return False
         else:
             for filename in zfile.namelist():
                 if not yml and filename[-3:].lower() in ['zip', 'jar']:
                     data = StringIO()
                     data.write(zfile.read(filename))
                     yml = self._find_plugin_yaml(data)
                     data.close()
             zfile.close()
     return yml

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
class OdfDocument(object):
  """Manipulates odf documents in memory"""

  implements(IOdfDocument)

  def __init__(self, data, source_format):
    """Open the the file in memory.

    Keyword arguments:
    data -- Content of the document
    source_format -- Document Extension
    """
    self._zipfile = ZipFile(StringIO(data))

    self.source_format = source_format
    # XXX - Maybe parsed_content should not be here, but on OOGranulate
    self.parsed_content = etree.fromstring(self.getContentXml())

  def getContentXml(self):
    """Returns the content.xml file as string"""
    return self._zipfile.read('content.xml')

  def getFile(self, path):
    """If exists, returns file as string, else return an empty string"""
    try:
      return self._zipfile.read(path)
    except KeyError:
      return ''

  def trash(self):
    """Remove the file in memory."""
    self._zipfile.close()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
def verifyZipSignature(outerZipFilePath):
   result = MODULE_ZIP_STATUS.Invalid
   try:
      dataToSign = None
      signature = None
      outerZipFile = ZipFile(outerZipFilePath)
      # look for a zip file in the name list.
      # There should only be 2 files in this zip:
      #    The inner zip file and the sig file
      if len(outerZipFile.namelist()) == 3:
         dataToSign = sha256(sha256(outerZipFile.read(INNER_ZIP_FILENAME)) +
                      sha256(outerZipFile.read(PROPERTIES_FILENAME)))
         signature = outerZipFile.read(SIGNATURE_FILENAME)
               
      if dataToSign and signature:
         """
         Signature file contains multiple lines, of the form "key=value\n"
         The last line is the hex-encoded signature, which is over the 
         source code + everything in the sig file up to the last line.
         The key-value lines may contain properties such as signature 
         validity times/expiration, contact info of author, etc.
         """
         dataToSignSBD = SecureBinaryData(dataToSign)
         sigSBD = SecureBinaryData(hex_to_binary(signature.strip()))
         publicKeySBD = SecureBinaryData(hex_to_binary(ARMORY_INFO_SIGN_PUBLICKEY))
         result = MODULE_ZIP_STATUS.Valid if CryptoECDSA().VerifyData(dataToSignSBD, sigSBD, publicKeySBD) else \
                  MODULE_ZIP_STATUS.Unsigned
   except:
      # if anything goes wrong an invalid zip file indicator will get returned 
      pass
   return result

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import read [as 别名]
    def _load(self, stream):
        zf = ZipFile(stream)
        self._load_content_types(zf.read("[Content_Types].xml"))
        rels_path = posixpath.join("_rels", ".rels")
        self._load_rels(zf.read(rels_path))

        def ropen(item):
            "read item and recursively open its children"
            if isinstance(item, Relationships):
                return
            if isinstance(item, Part):
                base, rname = posixpath.split(to_zip_name(item.name))
                relname = posixpath.join(base, "_rels", "%s.rels" % rname)
                if relname in zf.namelist():
                    item._load_rels(zf.read(relname))
            for rel in item.relationships:
                pname = posixpath.join(item.base, rel.target)
                if pname in self:
                    # This item is already in self.
                    continue
                target_path = to_zip_name(pname)
                data = b"".join(self._get_matching_segments(zf, target_path))
                new_part = self._load_part(rel.type, pname, data)
                if new_part:
                    ropen(new_part)

        ropen(self)
        zf.close()