Python ZipFile.writestr方法代码示例

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
def _trombino_zip(context, T, REQUEST ):
    "Send photos as zip archive"
    data = StringIO()
    Z = ZipFile( data, 'w' )                        
    # assume we have the photos (or the user acknowledged the fact)
    # Archive originals (not reduced) images, in JPEG
    for t in T:
        rel_path = sco_photos.has_photo(context, t)
        if not rel_path:
            continue
        path = SCO_SRCDIR + '/' + rel_path
        img = open(path).read()
        code_nip = t['code_nip']
        if code_nip:
            filename = code_nip + '.jpg'
        else:
            filename = t['nom'] + '_' + t['prenom'] + '_' + t['etudid'] + '.jpg'
        Z.writestr( filename, img )
    Z.close()
    size = data.tell()
    log('trombino_zip: %d bytes'%size)
    content_type = 'application/zip'
    REQUEST.RESPONSE.setHeader('content-disposition',
                               'attachement; filename="trombi.zip"'  )
    REQUEST.RESPONSE.setHeader('content-type', content_type)
    REQUEST.RESPONSE.setHeader('content-length', size)
    return data.getvalue()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
class WikiArchiver(BaseWikiManager):
    def _serialize_page(self, page):
        pdict = dict(id=page.id, name=page.name, type=page.type,
                     created=page.created, modified=page.modified)
        return pdict
    
    def create_new_zipfile(self):
        fields = ['id', 'name', 'type', 'created', 'modified']
        self.zipfileobj = BytesIO()
        self.csvfileobj = StringIO()
        self.zipfile = ZipFile(self.zipfileobj, 'w')
        self.csvfile = csv.DictWriter(self.csvfileobj, fields)
        
    def archive_pages(self):
        for page in self.query().all():
            pdict = self._serialize_page(page)
            self.csvfile.writerow(pdict)
            filename = 'tutwiki-page-%04d.txt' % page.id
            self.zipfile.writestr(filename, bytes(page.content))
        csvfilename = 'tutwiki-dbinfo.csv'
        self.zipfile.writestr(csvfilename, self.csvfileobj.getvalue())
        self.zipfile.close()
        #self.zipfileobj.seek(0)
        #return self.zipfileobj.read()
        return self.zipfileobj.getvalue()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
    def doTest(self, expected_ext, files, *modules, **kw):
        z = ZipFile(TEMP_ZIP, "w")
        try:
            for name, (mtime, data) in files.items():
                zinfo = ZipInfo(name, time.localtime(mtime))
                zinfo.compress_type = self.compression
                z.writestr(zinfo, data)
            z.close()

            stuff = kw.get("stuff", None)
            if stuff is not None:
                # Prepend 'stuff' to the start of the zipfile
                f = open(TEMP_ZIP, "rb")
                data = f.read()
                f.close()

                f = open(TEMP_ZIP, "wb")
                f.write(stuff)
                f.write(data)
                f.close()

            sys.path.insert(0, TEMP_ZIP)

            mod = __import__(".".join(modules), globals(), locals(),
                             ["__dummy__"])
            if expected_ext:
                file = mod.get_file()
                self.assertEquals(file, os.path.join(TEMP_ZIP,
                                  *modules) + expected_ext)
        finally:
            z.close()
            os.remove(TEMP_ZIP)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
    def export_gtfs(self, gtfs_file):
        """Export a GTFS file as feed

        Keyword arguments:
        gtfs_file - A path or file-like object for the GTFS feed

        This function will close the file in order to finalize it.
        """
        z = ZipFile(gtfs_file, 'w')

        gtfs_order = (
            ('agency.txt', Agency),
            ('calendar.txt', Service),
            ('calendar_dates.txt', ServiceDate),
            ('fare_attributes.txt', Fare),
            ('fare_rules.txt', FareRule),
            ('feed_info.txt', FeedInfo),
            ('frequencies.txt', Frequency),
            ('routes.txt', Route),
            ('shapes.txt', ShapePoint),
            ('stop_times.txt', StopTime),
            ('stops.txt', Stop),
            ('transfers.txt', Transfer),
            ('trips.txt', Trip),
        )

        for filename, exporter in gtfs_order:
            content = exporter.objects.in_feed(self).export_txt()
            if content:
                z.writestr(filename, content)
        z.close()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
    def testZipImporterMethodsInSubDirectory(self):
        packdir = TESTPACK + os.sep
        packdir2 = packdir + TESTPACK2 + os.sep
        files = {packdir2 + "__init__" + pyc_ext: (NOW, test_pyc),
                 packdir2 + TESTMOD + pyc_ext: (NOW, test_pyc)}

        z = ZipFile(TEMP_ZIP, "w")
        try:
            for name, (mtime, data) in files.items():
                zinfo = ZipInfo(name, time.localtime(mtime))
                zinfo.compress_type = self.compression
                z.writestr(zinfo, data)
            z.close()

            zi = zipimport.zipimporter(TEMP_ZIP + os.sep + packdir)
            self.assertEquals(zi.archive, TEMP_ZIP)
            self.assertEquals(zi.prefix, packdir)
            self.assertEquals(zi.is_package(TESTPACK2), True)
            zi.load_module(TESTPACK2)

            self.assertEquals(zi.is_package(TESTPACK2 + os.sep + '__init__'), False)
            self.assertEquals(zi.is_package(TESTPACK2 + os.sep + TESTMOD), False)

            mod_name = TESTPACK2 + os.sep + TESTMOD
            mod = __import__(module_path_to_dotted_name(mod_name))
            self.assertEquals(zi.get_source(TESTPACK2), None)
            self.assertEquals(zi.get_source(mod_name), None)
        finally:
            z.close()
            os.remove(TEMP_ZIP)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
def download_zipfile(request,doc_id):  
    """打包下载公文附件""" 
    doc = get_object_or_404(Document,id=doc_id)
    files = doc.files.all()

    in_memory = StringIO()  
    zip = ZipFile(in_memory, "a")  
    for f in files: 
        
        f_name = f.name + '.' + str(f.file).split('.')[-1]
        opener1 = urllib2.build_opener()
        page1 = opener1.open(f.file.url)
        zip.writestr(f_name,page1.read()) 

    for file in zip.filelist:  
        file.create_system = 0      
          
    zip.close()  
    
    filename = doc.title + '.zip'
    if "MSIE" in request.META['HTTP_USER_AGENT']:
        filename=urlquote(filename)
    else:
        filename=smart_str(filename)
  
    response = HttpResponse(mimetype="application/zip")  
    response["Content-Disposition"] = 'attachment; filename=%s' % filename
      
    in_memory.seek(0)      
    response.write(in_memory.read())
      
    return response  

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
def save_uploadfile_in_zipfile(
    upload_file, upload_filename,
    dest_zipfile_name, dest_filename_in_zip=None):

    nzf = ZipFile(dest_zipfile_name, mode='w', **ZIP_WRITE_OPTS)

    if upload_filename[-3:].lower() == u'zip':
        # 'zipfile, check and rename content'
        zf = ZipFile(StringIO(upload_file.read()), 'r')
        file_names = zf.namelist()
        for filename in file_names:
            #write file to new
            a = get_new_filename(filename, dest_filename_in_zip)

            nzf.writestr(a, zf.read(filename))
        zf.close()
    else:
        # 'normal file'
        nzf.writestr(
            get_new_filename(upload_filename, dest_filename_in_zip),
            upload_file.read())

    nzf.close()

    # Remove comment line from .asc and .inc files after uploading
    remove_comments_from_asc_files(os.path.dirname(dest_zipfile_name))

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
def writeCSV(outfile, CSV):
    print "writting CSV"
    zf = ZipFile(outfile, "w", ZIP_DEFLATED)
    for SeqName in CSV.keys():
        content = "\n".join(CSV[SeqName])
        zf.writestr(SeqName + ".csv", content)
    zf.close()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
def report(request):
    if request.method == "GET":
        exclusions = ['faculty', 'resources']
        hierarchies = Hierarchy.objects.all().exclude(
            name__in=exclusions).order_by("id")
        return {'hierarchies': hierarchies}
    else:
        hierarchy_id = request.POST.get('hierarchy-id', None)
        hierarchy = Hierarchy.objects.get(id=hierarchy_id)

        include_superusers = request.POST.get('include-superusers', False)

        response = HttpResponse(mimetype='application/zip')
        response['Content-Disposition'] = 'attachment; filename=tobacco.zip'

        z = ZipFile(response, 'w')

        output = StringIO()  # temp output file
        _all_results_key(output, hierarchy)
        z.writestr("tobacco_%s_key.csv" % hierarchy.name, output.getvalue())

        output.truncate(0)
        output.seek(0)
        _all_results(output, hierarchy, include_superusers)
        z.writestr("tobacco_%s_values.csv" % hierarchy.name, output.getvalue())

        return response

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
    def _render_zip(self, req, repos, chgset):
        """ZIP archive with all the added and/or modified files."""
        req.send_response(200)
        req.send_header('Content-Type', 'application/zip')
        req.send_header('Content-Disposition', 'attachment;'
                        'filename=Changeset%s.zip' % chgset.rev)
        req.end_headers()

        try:
            from cStringIO import StringIO
        except ImportError:
            from StringIO import StringIO
        from zipfile import ZipFile, ZipInfo, ZIP_DEFLATED

        buf = StringIO()
        zipfile = ZipFile(buf, 'w', ZIP_DEFLATED)
        for path, kind, change, base_path, base_rev in chgset.get_changes():
            if kind == Node.FILE and change != Changeset.DELETE:
                node = repos.get_node(path, chgset.rev)
                zipinfo = ZipInfo()
                zipinfo.filename = node.path
                zipinfo.date_time = time.gmtime(node.last_modified)[:6]
                zipinfo.compress_type = ZIP_DEFLATED
                zipfile.writestr(zipinfo, node.get_content().read())
        zipfile.close()
        req.write(buf.getvalue())

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
  def ticket_patch(self, index):

    if self.tickets.has_key(index):

      z = tempfile.mkstemp()[-1]
      zf = ZipFile(z, mode="w")
      p = index.replace("/","_")
      t = self.tickets[index]

      for l in t.labels.values():
        l_len = len(l.commit_history_keys())

        if l_len > 1:
          l_path = self.label_patch(len(l.commit_history_keys()), l.head.id)
          lf = ZipFile(l_path, mode="r")
          
          for patch in lf.namelist():
            zf.writestr("%s/%s/%s" % (p, l.name, patch), lf.read(patch))

        else:
          zf.writestr("%s/%s/0001-%s.patch" % (p, l.name, l.head.id), self.commit_patch(l.head.id))
      
      zf.close()
      
      return z

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
    def prepareVinaOutputNamesZip(self):
        zin = ZipFile('../gUSE-cloud-vina.zip', 'r')
        zout = ZipFile('../gUSE-cloud-vina-new.zip', 'w')    
        workflow_xml = zin.read('workflow.xml')    
        zin.close()

        import xml.etree.ElementTree as ET
        root = ET.fromstring(workflow_xml)     
        workflow_xml_resourcename = root.find(".//execute[@key='resourcename']")
        workflow_xml_resourcename.set("value", self.app.engine.guseWhichCloudEncoded.get())
        workflow_xml_regionname = root.find(".//execute[@key='regionname']")
        workflow_xml_regionname.set("value", self.app.engine.guseWhichCloudRegionEncoded.get())        
        workflow_xml_instancetypename = root.find(".//execute[@key='instancetypename']")
        workflow_xml_instancetypename.set("value", self.app.engine.guseWhichCloudInstanceEncoded.get())
        
        zout.writestr("workflow.xml", ET.tostring(root, "utf-8"))
        zout.write("../ligands.zip", arcname="vina_output_names/4in1out/inputs/0/0")  
        zout.write("../receptors.zip", arcname="vina_output_names/4in1out/inputs/1/0")
        zout.write("../conf.txt", arcname="vina_output_names/4in1out/inputs/2/0")
        zout.write("../output_names.txt", arcname="vina_output_names/4in1out/inputs/3/0")
        
        zout.close()
        
        os.remove("../gUSE-cloud-vina.zip")
        os.rename("../gUSE-cloud-vina-new.zip", "../gUSE-cloud-vina.zip")    

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
    def upload_models_xml(self, datamodelxml):
        metadataxml = '''<?xml version="1.0" encoding="utf-8"?>
<Metadata xmlns:xsd="http://www.w3.org/2001/XMLSchema"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://schemas.qualisystems.com/PackageMetadataSchema.xsd">
  <CreationDate>05/08/1975 00:05:05</CreationDate>
  <ServerVersion>'''+SERVER_VERSION+'''</ServerVersion>
  <PackageType>CloudShellPackage</PackageType>
</Metadata>'''
        # print datamodelxml
        # inMemoryOutputFile = StringIO()
        memfile = BytesIO()
        # memfile = StringIO()

        zipfile = ZipFile(memfile, 'w')
        zipfile.writestr('DataModel/datamodel.xml', str(datamodelxml))
        zipfile.writestr('metadata.xml', metadataxml)
        zipfile.close()

        memfile.seek(0)

        zipdata = memfile.getvalue()
        # with open("C:/temp/my_zip.zip", "wb") as f: # use `wb` mode
        #     f.write(memfile.getvalue())
        #
        #
        # print len(zipdata)
        # print str(type(zipdata))
        self.upload_environment_zip_data(zipdata)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import writestr [as 别名]
def save_uploadfile_in_zipfile_groupimport(
    upload_zipfile, re_filenames_in_upload_file,
    dest_zipfile_name, dest_filename_in_zip=None):

    nzf = ZipFile(dest_zipfile_name, mode='w', compression=ZIP_DEFLATED)

    zf = upload_zipfile

    reg_ex = '([0-9]*)'.join(
        [b for b in re_filenames_in_upload_file.split('#') if b != ''])
    reg_ex = (reg_ex.replace('\\', '/').replace('+', '\+').
              replace('(', '\(').replace(')', '\)'))

    reg_ex = re.compile(reg_ex, re.I)
    found = False
    for filename in zf.namelist():
        filename = filename.replace('\\', '/')
        # write file to new

        if reg_ex.match(filename):
            # remove path
            new_filename = filename.replace('\\', '/').split('/')[-1]
            a = get_new_filename(new_filename, dest_filename_in_zip)
            nzf.writestr(a.lower(), zf.read(filename))
            found = True

    nzf.close()

    # Remove comment line from .asc and .inc files after uploading
    remove_comments_from_asc_files(os.path.dirname(dest_zipfile_name))

    if not found:
        raise KeyError('File not found')

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

    def __init__(self):
        from io import BytesIO
        from zipfile import ZipFile
        self.buffer = BytesIO()
        self.zip = ZipFile(self.buffer, 'w')

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self.close()

    def writestr(self, name, bytes):
        try:
            self.zip.writestr(name, bytes)
        except:
            log.x(_('Error writing file %(name)r to memory zip'), {'name': name})
            raise

    def getbytes(self):
        return self.buffer.getvalue()

    def close(self):
        self.zip.close()