Python ZipFile.write方法代码示例

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
def generate_zip_package(directory, session, cards):

	if not os.path.exists(directory):
		os.makedirs(directory)

	for lemma, card in cards.iteritems():

		if card.has_key('image'):
			imagepath = directory + ('/%s-%s-%s.%s' % (card['language'], card['pos'], card['lemma'], card['image'].split('.')[-1]))
			card['imagepath'] = os.path.basename(imagepath)
			urlretrieve(card['image'], imagepath)
		if card.has_key('audiosample'):
			print card['audiosample']
			audiopath = directory + ('/%s-%s-%s.%s' % (card['language'], card['pos'], card['lemma'], 'mp3'))
			card['audiopath'] = os.path.basename(audiopath)
			if os.path.exists(card['audiosample'][1:]):
				os.rename(card['audiosample'][1:], audiopath)
			else:
				print 'Audiosample ' + audiopath + ' for "' + card['lemma'] +'" not found.'

	csvpath = directory + '/%s.csv' % (session,)
	generate_csv(csvpath, cards)

	files = os.listdir(directory)
	if 'cache' in files:
		files.remove('cache')
	zippath = 'static/downloads/%s.zip' % (session,)
	zipfile = ZipFile(zippath, 'w')

	for f in files:
		zipfile.write(directory + '/' + f, f)
	zipfile.close()

	return zippath

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
    def pack(self, output_dir, devel=False, force=False, keep_temp=False):
        self.output_dir = os.path.realpath(output_dir)
        if not os.path.exists(self.output_dir):
            os.makedirs(self.output_dir)
        self.force = force
        self.keep_temp = keep_temp

        paths = []
        self.merge_modules = {}

        # create runtime package
        p = self._create_msi_installer(PackageType.RUNTIME)
        paths.append(p)

        # create devel package
        if devel and not isinstance(self.package, App):
            p = self._create_msi_installer(PackageType.DEVEL)
            paths.append(p)

        # create zip with merge modules
        self.package.set_mode(PackageType.RUNTIME)
        zipf = ZipFile(os.path.join(self.output_dir, '%s-merge-modules.zip' %
                                    self._package_name()), 'w')
        for p in self.merge_modules[PackageType.RUNTIME]:
            zipf.write(p)
        zipf.close()

        if not keep_temp:
            for msms in self.merge_modules.values():
                for p in msms:
                    os.remove(p)

        return paths

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
	def on_get(self, req, resp, eval_id):
		try:
			user = req.context['user']

			if (not user.is_logged_in()) or (not user.is_org()):
				resp.status = falcon.HTTP_400
				return

			inMemoryOutputFile = StringIO()
			zipFile = ZipFile(inMemoryOutputFile, 'w')

			files = [ r for (r, ) in session.query(model.SubmittedFile.path).\
				filter(model.SubmittedFile.evaluation == eval_id).distinct() ]

			for fname in files:
				if os.path.isfile(fname):
					zipFile.write(fname, os.path.basename(fname))

			zipFile.close()

			resp.set_header('Content-Disposition', "inline; filename=\"eval_" + str(eval_id) + ".zip\"")
			resp.content_type = "application/zip"
			resp.stream_len = inMemoryOutputFile.len
			resp.body = inMemoryOutputFile.getvalue()

			inMemoryOutputFile.close()
		except SQLAlchemyError:
			session.rollback()
			raise
		finally:
			session.close()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
    def upload_analyzer(self):
        """Upload analyzer to guest.
        @return: operation status.
        """
        zip_data = StringIO()
        zip_file = ZipFile(zip_data, "w", ZIP_DEFLATED)

        root = os.path.join("analyzer", self.platform)
        root_len = len(os.path.abspath(root))

        if not os.path.exists(root):
            log.error("No valid analyzer found at path: %s" % root)
            return False

        for root, dirs, files in os.walk(root):
            archive_root = os.path.abspath(root)[root_len:]
            for name in files:
                path = os.path.join(root, name)
                archive_name = os.path.join(archive_root, name)
                zip_file.write(path, archive_name, ZIP_DEFLATED)

        zip_file.close()
        data = xmlrpclib.Binary(zip_data.getvalue())
        zip_data.close()

        log.debug("Uploading analyzer to guest (ip=%s)" % self.ip)
        self.server.add_analyzer(data)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
def automerge(params):
    print "Resourcepack Auto-Merge Begin"
    os.mkdir('myresourcepack')
    
    pack1 = ZipFile(params[0])
    pack2 = ZipFile(params[1])

    print "Extracting "+pack1.filename+"..."
    pack1.extractall('myresourcepack/')
    print "Extracting "+pack2.filename+"..."
    pack2.extractall('myresourcepack/')
    
    print "Creating pack.mcmeta file..."
    
    packMeta1 = getPackMeta(pack1)
    packMeta2 = getPackMeta(pack2)
    resultMeta = mergePackMeta(packMeta1,packMeta2)
    with open('myresourcepack/pack.mcmeta','w') as f:
        f.write(json.dumps(resultMeta))
    print "pack.mcmeta created"
    
    print "Creating final zip..."
    # Begin: Thanks to http://stackoverflow.com/a/3612455
    target_dir = 'myresourcepack'
    zip = ZipFile('myresourcepack.zip', 'w')
    rootlen = len(target_dir) + 1
    for base, dirs, files in os.walk(target_dir):
        for file in files:
            fn = os.path.join(base, file)
            zip.write(fn, fn[rootlen:])
    # End stackoverflow thing
    print "Auto-Merge done!"

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
 def addFile(self, filePath):
     """ Add other file type. """
     acceptedFormats = ('png','jpg','jpeg','pdf','txt','csv','dat')
     contents = self.listContents()
     fileBase = os.path.basename(filePath)
     fileName, fileFormat = os.path.splitext(fileBase)
     zf = ZipFile(self.combinePath, 'a')
     if os.path.exists(filePath):
         if filePath.lower().endswith(acceptedFormats):
             if filePath.lower().endswith(('png', 'jpg', 'jpeg')):
                 numSame = 0
                 while contents.count("fig/" + fileName + fileFormat) == 1:
                     fileName = fileName + '_' + str(numSame)
                     numSame += 1
                 zf.write(filePath, arcname="fig/" + fileName + fileFormat)
             if filePath.lower().endswith(('pdf', 'txt', 'csv', 'dat')):
                 numSame = 0
                 while contents.count("data/" + fileName + fileFormat) == 1:
                     fileName = fileName + '_' + str(numSame)
                     numSame += 1
                 zf.write(filePath, arcname="data/" + fileName + fileFormat)
         else:
             raise Exception("Unsupported file format")
     else:
         raise Exception("Cannot find the file")
     zf.close()
     self.updateManifest(fileName + fileFormat, fileFormat[1:])

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
    def addFile(self, filePath):
        """ Adds other file into COMBINE archive.

        Currently, png, jpg, pdf, txt, csv, dat formats are supported.

        :param filePath: path to the file
        """
        warnings.warn('Use inline_omex instead.', DeprecationWarning)
        acceptedFormats = ('png','jpg','jpeg','pdf','txt','csv','dat')
        contents = self.listContents()
        fileBase = os.path.basename(filePath)
        fileName, fileFormat = os.path.splitext(fileBase)
        zf = ZipFile(self.combinePath, 'a')
        if os.path.exists(filePath):
            if filePath.lower().endswith(acceptedFormats):
                if filePath.lower().endswith(('png', 'jpg', 'jpeg')):
                    numSame = 0
                    while contents.count("fig/" + fileName + fileFormat) == 1:
                        fileName = fileName + '_' + str(numSame)
                        numSame += 1
                    zf.write(filePath, arcname="fig/" + fileName + fileFormat)
                if filePath.lower().endswith(('pdf', 'txt', 'csv', 'dat')):
                    numSame = 0
                    while contents.count("data/" + fileName + fileFormat) == 1:
                        fileName = fileName + '_' + str(numSame)
                        numSame += 1
                    zf.write(filePath, arcname="data/" + fileName + fileFormat)
            else:
                raise Exception("Unsupported file format")
        else:
            raise Exception("Cannot find the file")
        zf.close()
        self.updateManifest(fileName + fileFormat, fileFormat[1:])

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
def zipdir(dirpath, zippath, keep_meta = False):
	archive = ZipFile(zippath, 'w')
	for root, dirs, files in os.walk(dirpath):
		for filepath in files:
			if keep_meta or not 'META-INF' in root:
				archive.write(os.path.join(root, filepath), os.path.join(root, filepath)[len(dirpath):])
	archive.close()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
    def build_cache_file(self, format, version):

        cache_file_path = self.get_cache_file_path(format, version)

        logger.info('building cache for: %s' % (cache_file_path))

        try:
            os.remove(cache_file_path)

        except Exception as e:
            pass


        archive_file = ZipFile(cache_file_path, "w")

        """
        adding corresponding media files
        """
        for media in self.get_media():
            media_cache_file = media.inject_metadata(format, version)

            # filename for the file archive
            file_name = '%02d - %s - %s' % (media.tracknumber, media.artist.name, media.name)
            file_name = '%s.%s' % (file_name.encode('ascii', 'ignore'), format)

            archive_file.write(media_cache_file.path, file_name)


        return cache_file_path

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
 def addSBML(self, sbmlPath, filename=None):
     """ Adds SBML file into COMBINE archive.
     :param sbmlPath: path to SBML file or full SBML file string
     """
     warnings.warn('Use inline_omex instead.', DeprecationWarning)
     modelname = self.getModelName(sbmlPath)
     contents = self.listContents()
     zf = ZipFile(self.combinePath, 'a')
     if os.path.exists(sbmlPath):
         numSame = 0
         while contents.count(modelname + '.xml') == 1:
             # This should never happen (breaks the SEDML files)
             modelname = modelname + '_' + str(numSame) + '.xml'
             numSame += 1
         if filename != None:
             if filename[-3:] != ('xml' or 'sbml'):
                 filename = filename + '.xml'
             modelname = filename
         zf.write(sbmlPath, arcname=modelname)
     elif sbmlPath.startswith(r'<?xml'):
         numSame = 0
         while contents.count(modelname + '.xml') == 1:
             modelname = modelname + '_' + str(numSame) + '.xml'
             numSame += 1
         if filename != None:
             if filename[-3:] != ('xml' or 'sbml'):
                 filename = filename + '.xml'
             modelname = filename
         zf.writestr(modelname, sbmlPath)
     else:
         raise Exception("Invalid string for sbml: Check the path of the file")
     zf.close()
     self.updateManifest(modelname, 'sbml')

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
def do_zip(filename):
    zip = ZipFile(filename, "w")
    for dirpath, dirname, filename in os.walk("./"):
        for fn in filename:
            if fn != ZIP_NAME:
                zip.write(os.path.join(dirpath, fn))
    zip.close()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
def zipo(request,pk):
    """Constructs a zip file in memory for users to download."""

    p = get_object_or_404(Paper,pk=pk)
    if not(p.should_have_data()):
        raise Http404("Paper has no data.");

    zip_buff=StringIO()
    zip_file=ZipFile(zip_buff,'w')

    rm=settings.README
    if rm and os.path.isfile(rm):
        zip_file.write(rm,os.path.basename(rm))

    dp=p.download_path()
    for root,_,basenames in os.walk(dp):
        for name in basenames:
            path=os.path.join(root,name)
            an=path.replace(dp,'')
            zip_file.write(path,arcname=an)
    zip_file.close()

    out=HttpResponse(zip_buff.getvalue(),content_type="application/zip")
    out['Content-Disposition'] = 'attachment; filename="%s_%d.zip"' % (settings.DOWNLOAD_PREFIX,p.pmid)
    return out

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
  def build(self, path, overwrite=False):
    """Create the project archive.

    :param path: Destination path.
    :param overwrite: Don't throw an error if a file already exists at `path`.

    Triggers the :meth:`~azkaban.job.Job.on_build` method on each job inside the
    project (passing itself and the job's name as two argument). This method
    will be called right before the job file is generated.

    """
    logger.debug('building project')
    # not using a with statement for compatibility with older python versions
    if exists(path) and not overwrite:
      raise AzkabanError('Path %r already exists.' % (path, ))
    if not (len(self._jobs) or len(self._files)):
      raise AzkabanError('Building empty project.')
    writer = ZipFile(path, 'w')
    try:
      for name, job in self._jobs.items():
        job.on_build(self, name)
        with temppath() as fpath:
          job.build(fpath)
          writer.write(fpath, '%s.job' % (name, ))
      for fpath, apath in self._files.items():
        writer.write(fpath, apath)
    finally:
      writer.close()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
class ZippingTestCase(TestCase):

    def setUp(self):
        self.img = create_image()
        self.image_name = 'test_file.jpg'
        self.filename = os.path.join(os.path.dirname(__file__),
                                 self.image_name)
        self.img.save(self.filename, 'JPEG')

        self.file = DjangoFile(open(self.filename), name=self.image_name)

        self.zipfilename = 'test_zip.zip'

        self.zip = ZipFile(self.zipfilename, 'a')
        self.zip.write(self.filename)
        self.zip.close()

    def tearDown(self):
        # Clean up the created zip file
        os.remove(self.zipfilename)
        os.remove(self.filename)

    def test_unzipping_works(self):
        result = unzip(self.zipfilename)
        self.assertEqual(result[0][0].name, self.file.name)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import write [as 别名]
    def close(self):
        if self.__closed:
            return

        tmp_filename = self._fh.name
        self._fh.close()
        self.__closed = True
        try:
            # write everything to the zipfile
            if "w" in self.__mode:
                inner_filename = self.__inner_filename
                if not inner_filename:
                    base, ext = os.path.splitext(self.__filename)
                    inner_filename = os.path.basename(base) + ".txt"

                _log.debug("Compressing %s" % (self.__filename))
                zip_fh = ZipFile(self.__filename, "w", self.__compression)
                try:
                    zip_fh.write(tmp_filename, inner_filename)
                finally:
                    zip_fh.close()
        finally:
            # delete the tempfile
            self.__unlink(tmp_filename)
            self._fh = None