Python ZipFile.namelist方法代码示例

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import namelist [as 别名]
    def _read(self) :
        global MANIFEST_FNAME

        z = ZipFile(self.fname, 'r', compression=self.compression)
    
        def _err(msg) :
            z.close()
            raise GluttonImportantFileNotFoundError(msg)
    
        # without the manifest all is lost
        # we need this to get the names of the other
        # XML files
        if MANIFEST_FNAME not in z.namelist() :
            _err('manifest not found in %s' % self.fname)

        self.metadata = json.load(z.open(MANIFEST_FNAME))
        
        self.log.info("read manifest - created on %s using glutton version %.1f" % \
            (time.strftime('%d/%m/%y at %H:%M:%S', time.localtime(self.download_time)), \
             self.version))

        # the data file is the raw data grouped into gene families
        # when we do a local alignment we need to get the gene id
        # of the best hit and find out which gene family it belongs to 
        if self.metadata['data-file'] not in z.namelist() :
            _err('data file (%s) not found in %s' % (self.metadata['data-file'], self.fname))

        self.data = json_to_glutton(json.load(z.open(self.metadata['data-file'])))
        self.seq2famid = self._create_lookup_table(self.data)

        self.log.info("read %d gene families (%d genes)" % (len(self.data), len(self.seq2famid)))

        z.close()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import namelist [as 别名]
def get_shp_from_zip(zip_file):
    """
    extract components file parts of a shapefile from a zip file

    zip_file -- zip file
    """
    try:
        zip_f = ZipFile(zip_file, 'r')
    except BadZipfile:
        return None
    list_names = zip_f.namelist()
    d = {}
    for elem in list_names:
        t = elem.split('.')
        d[t[1].lower()] = t[0]
        ll = d.values()
    # shp name validation (same name)
    if all(x == ll[0] for x in ll):
        k = d.keys()
        # shp file  type validation
        if len(k) == 4 and (
                'shp' in k and 'dbf' in k and 'shx' in k and 'prj' in k):
            res = {}
        for name in zip_f.namelist():
            io = StringIO.StringIO()
            zo = zip_f.open(name, 'r')
            io.write(zo.read())  # .decode('ISO8859-1').encode('utf-8'))
            zo.close()
            res_file = InMemoryUploadedFile(
                io, None, name.lower(), 'text', io.len, None)
            res_file.seek(0)
            res[name.split('.')[1].lower()] = res_file
        return res
    else:
        return None

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import namelist [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 namelist [as 别名]
class ZipfileReader:
    """ Reads files from an imported zip file. """

    def __init__(self, files):
        self.files = ZipFile(files)
        self.fullpath = ''


    def readManifest(self):
        """ Get the maifest file if it exists. """
        for x in self.files.namelist():
            index = x.find('imsmanifest.xml')
            if index != -1:
                self.fullpath = x[:index]
                return self.files.read(x)
        return None
    

    def readFile(self, path):
        """ Get file data from the zip file. """
        fn = '%s%s' %(self.fullpath, str(path))
        if fn not in self.files.namelist():
            fn = fn.replace('/', '\\')
            if fn not in self.files.namelist():
                return None
        return self.files.read(fn)

    def listFiles(self):
        """ List files in the package. """
        return self.files.namelist()

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import namelist [as 别名]
def run(file_name):
    config_dict = False
    jar = ZipFile(file_name, 'r')
    # Version A
    if 'a.txt' and 'b.txt' in jar.namelist():
        pre_key = jar.read('a.txt')
        enckey = ['{0}{1}{0}{1}a'.format('plowkmsssssPosq34r', pre_key),
                  '{0}{1}{0}{1}a'.format('kevthehermitisaGAYXD', pre_key)
                  ]
        coded_jar = jar.read('b.txt')
        config_dict = version_a(enckey, coded_jar)

    # Version B
    if 'ID' and 'MANIFEST.MF' in jar.namelist():
        pre_key = jar.read('ID')
        enckey = ['{0}H3SUW7E82IKQK2J2J2IISIS'.format(pre_key)]
        coded_jar = jar.read('MANIFEST.MF')
        config_dict = version_b(enckey, coded_jar)

    # Version C
    if 'resource/password.txt' and 'resource/server.dll' in jar.namelist():
        pre_key = jar.read('resource/password.txt')
        enckey = ['CJDKSIWKSJDKEIUSYEIDWE{0}'.format(pre_key)]
        coded_jar = jar.read('resource/server.dll')
        config_dict = version_c(enckey, coded_jar)

    # Version D
    if 'java/stubcito.opp' and 'java/textito.isn' in jar.namelist():
        pre_key = jar.read('java/textito.isn')
        enckey = ['TVDKSIWKSJDKEIUSYEIDWE{0}'.format(pre_key)]
        coded_jar = jar.read('java/stubcito.opp')
        config_dict = version_c(enckey, coded_jar)

    return config_dict

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import namelist [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 namelist [as 别名]
    def _create_resource(self, data_set, site, file_):
        """ Creates a new resource or file associated with its data set
        :param data_set:
        :param site:
        :param file_:
        """
        #content of the zip file
        zip_file_name = file_.filename
        zip_path = os.path.join(config.DATA_SETS_DIR, zip_file_name)
        file_.save(zip_path)
        sourcezip = ZipFile(zip_path)
        i = 0
        while i < len(sourcezip.namelist()):
            zip_entry_path = os.path.join(os.path.abspath(os.path.dirname(zip_path)), sourcezip.namelist()[i])
            sourcezip.extract(sourcezip.namelist()[i], config.DATA_SETS_DIR)
            url = self.parser.get_file_name().replace(".zip","") + "_" + str(i)
            site.action.resource_create(package_id=data_set, upload=open(zip_entry_path),
                                        name=sourcezip.namelist()[i], url=url)
            i += 1

        #xml content
        xml_file_name = self.parser.get_dataset().id + ".xml"
        path = os.path.join(config.DATA_SETS_DIR, xml_file_name)
        with open(path, "w") as ttmp:
            ttmp.write(self._content.encode(encoding="utf-8"))
        url = xml_file_name
        site.action.resource_create(package_id=data_set, upload=open(path),
                                    name=xml_file_name, url=url)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import namelist [as 别名]
def get_rasters(url, downloaddir='./Inputs'):
    """Download file and handle nonexist file.
       If not exist, an empty list returned. Hack...
       TODO: more elegent solution
    """
    try:
        fname = site.saveFile(url, dir=downloaddir)
        zipfname = '%s/%s' % (downloaddir, fname)
        print "***%s found, downloading as %s..." % (fname, zipfname)
        z = ZipFile(zipfname)
    except BadZipfile:
        print "***bad zip file"
        return [fname, ]
    # TODO fix error handling ???
    except:
        print "***empty zip file"
        return []

    rasters = []
    print "     zipped file namelist: ", z.namelist()
    for fname in z.namelist():
        if fname.endswith('/'):
            continue
        else:
            fname = os.path.basename(fname)
            rasters.append(fname)
            outfname = '%s/%s' % (downloaddir, fname)
            print "***get_raster: %s" % outfname
            with open(outfname, 'wb') as f:
                f.write(z.read(fname))
    os.remove(zipfname)
    print "***remove %s" % zipfname
    return rasters

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import namelist [as 别名]
    def test_periodadmin_has_access(self):
        with self.settings(DEVILRY_COMPRESSED_ARCHIVES_DIRECTORY=self.backend_path):
            testassignment = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
                                               short_name='learn-python-basics',
                                               first_deadline=timezone.now() + timezone.timedelta(days=1))

            # Period admin
            periodpermissiongroup = mommy.make('devilry_account.PeriodPermissionGroup',
                                               period=testassignment.period)
            testuser = mommy.make(settings.AUTH_USER_MODEL)
            mommy.make('devilry_account.PermissionGroupUser',
                       user=testuser, permissiongroup=periodpermissiongroup.permissiongroup)

            self.__make_simple_setup(assignment=testassignment)

            # run actiongroup
            self._run_actiongroup(name='batchframework_assignment',
                                  task=tasks.AssignmentCompressAction,
                                  context_object=testassignment,
                                  started_by=testuser)

            archive_meta = archivemodels.CompressedArchiveMeta.objects.get(content_object_id=testassignment.id)
            zipfileobject = ZipFile(archive_meta.archive_path)
            self.assertEqual(1, len(zipfileobject.namelist()))
            self.assertTrue(zipfileobject.namelist()[0].startswith('{}'.format('april')))

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import namelist [as 别名]
 def test_tarball_aware_of_branches(self):
     rev = '19'
     branch_content = sorted(['test-svn-tags-19-branches-aaa/',
                              'test-svn-tags-19-branches-aaa/aaa.txt',
                              'test-svn-tags-19-branches-aaa/svn-commit.tmp',
                              'test-svn-tags-19-branches-aaa/README'])
     h.set_context('test', 'svn-tags', neighborhood='Projects')
     tmpdir = tg.config['scm.repos.tarball.root']
     tarball_path = os.path.join(tmpdir, 'svn/t/te/test/testsvn-trunk-tags-branches/')
     fn = tarball_path + 'test-svn-tags-19-branches-aaa.zip'
     self.svn_tags.tarball(rev, '/branches/aaa/')
     assert os.path.isfile(fn), fn
     snapshot = ZipFile(fn, 'r')
     assert_equal(sorted(snapshot.namelist()), branch_content)
     os.remove(fn)
     self.svn_tags.tarball(rev, '/branches/aaa/some/path/')
     assert os.path.isfile(fn), fn
     snapshot = ZipFile(fn, 'r')
     assert_equal(sorted(snapshot.namelist()), branch_content)
     os.remove(fn)
     # if inside of branches, but no branch is specified
     # expect snapshot of trunk
     fn = tarball_path + 'test-svn-tags-19-trunk.zip'
     self.svn_tags.tarball(rev, '/branches/')
     assert os.path.isfile(fn), fn
     snapshot = ZipFile(fn, 'r')
     assert_equal(sorted(snapshot.namelist()),
                  sorted(['test-svn-tags-19-trunk/',
                          'test-svn-tags-19-trunk/aaa.txt',
                          'test-svn-tags-19-trunk/bbb.txt',
                          'test-svn-tags-19-trunk/ccc.txt',
                          'test-svn-tags-19-trunk/README']))
     shutil.rmtree(tarball_path, ignore_errors=True)

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import namelist [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 namelist [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 namelist [as 别名]
def test_multi_layer_dataset(multi_layer_app, temp_file):
    req = Request.blank("/")
    resp = req.get_response(multi_layer_app)
    assert resp.status == "200 OK"

    for chunk in resp.app_iter:
        temp_file.write(chunk)
    temp_file.flush()

    z = ZipFile(temp_file.name, "r", ZIP_DEFLATED)
    assert z

    # Should be 2 files for each layer
    assert len(z.namelist()) == 2 * 4
    assert "my_grid_0.asc" in z.namelist()

    # find the first asc file
    asc_filename = filter(lambda x: x.endswith(".asc"), z.namelist())[0]

    with z.open(asc_filename, "r") as f:
        data = f.read()

    assert (
        data
        == """ncols        3
nrows        2
xllcorner    -122.500000000000
yllcorner    53.000000000000
dx           -0.500000000000
dy           1.000000000000
NODATA_value  -9999
 0 1 2
 3 4 5
"""
    )

# 需要导入模块: from zipfile import ZipFile [as 别名]
# 或者: from zipfile.ZipFile import namelist [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 namelist [as 别名]
def fetch(arch,version,path,save=True):
    version = normalize_ver(version)
    path = path.lstrip('/')
    key = 'zip%s%s' % (version,path)
    base_url = get_base_url(arch, 0)
    base_url2 = get_base_url(arch, 1)
    #zdata = memcache.get(key)
    path = path.replace(' ','%20')
    zdata = get_from_storage(key,arch)
    if zdata is None:
        result = urlfetch.fetch('%s/%s/%s.zip' % (base_url,version,path),deadline=10)
        #print result.status_code
        if result.status_code != 200:
            result = urlfetch.fetch('%s/%s/%s.zip' % (base_url2,version,path))
        if result.status_code == 200:
            zdata = result.content
            #memcache.set(key,zdata)
            if save:
                try:
                    put_into_storage(key,zdata,arch)
                except:pass
            zdata = StringIO(zdata)
    if zdata is None:
        return None
    #zfp = ZipFile(StringIO(zdata), "r")
    #data = zfp.read(zfp.namelist()[0])#.decode("cp1251")
    #del zfp
    #return data
    zfp = ZipFile(zdata)
    try :
        #python 2.6+
        return zfp.open(zfp.namelist()[0])
    except:
        return StringIO(zfp.read(zfp.namelist()[0]))#.decode("cp1251")