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

    def download_data(self, year, month):
        syear = str(year)
        smonth = str(month)
        if month < 10:
            smonth = "0"+str(month)
        base_url = "http://pogoda.by/zip/"
        citi_code = "34504"
        url = base_url+syear+"/"+citi_code+"_"+syear+"-"+smonth+".zip"
        zip_name = self.zip_name(year, month)
        zipfile = urllib2.urlopen(url)

        with open(zip_name, 'w') as f: 
            f.write(zipfile.read())        

def handle_docs(email, files):
    # Assume zipper always succeed
    docfiles = list_files_by_extension(files, "docx")
    print "List of document files", docfiles
    zipper(ZipFileName, docfiles)

    zipfile = open(ZipFileName, "rb")
    zip = MIMEBase("application", "zip", name=ZipFileName)
    zip.set_payload(zipfile.read())
    zipfile.close()

    encoders.encode_base64(zip)
    email.attach(zip)

    delete_files(docfiles)

def _unzip(zipfile, path):
    """
        Python 2.5 doesn't have extractall()
    """
    isdir = os.path.isdir
    join = os.path.join
    norm = os.path.normpath
    split = os.path.split

    for each in zipfile.namelist():
        if not each.endswith('/'):
            root, name = split(each)
            directory = norm(join(path, root))
            if not isdir(directory):
                os.makedirs(directory)
            file(join(directory, name), 'wb').write(zipfile.read(each))

    def _get_ipynb_with_files(self, abs_nb_path):
        '''
        Creates a zip file containing the ipynb and associated files.

        :param abs_nb_path: absolute path to the notebook file
        '''
        notebook_basename = os.path.basename(abs_nb_path)
        notebook_basename = os.path.splitext(notebook_basename)[0]

        # pick a tmp directory for the "bundle"
        bundle_id = generate_id()
        bundle_dir = os.path.join(self.tmp_dir,
            bundle_id,
            notebook_basename
        )
        zipfile_path = os.path.join(self.tmp_dir,
            bundle_id,
            notebook_basename
        )
        # Try up to three times to make the bundle directory
        for i in range(3):
            try:
                os.makedirs(bundle_dir)
            except OSError as exc:
                if exc.errno == errno.EEXIST:
                    pass
                else:
                    raise exc
            else:
                break
        else:
            raise RuntimeError('could not create bundle directory')

        referenced_files = converter.get_referenced_files(abs_nb_path, 4)
        # make the zip Archive, is there a more efficient way that copy+zip?
        converter.copylist(os.path.dirname(abs_nb_path), bundle_dir, referenced_files)
        shutil.copy2(abs_nb_path, os.path.join(bundle_dir, os.path.basename(abs_nb_path)))
        shutil.make_archive(zipfile_path, 'zip', bundle_dir)

        # send the archive
        self.set_header('Content-Disposition', 'attachment; filename={}.zip'.format(notebook_basename))
        self.set_header('Content-Type', 'application/zip')
        with open(zipfile_path + '.zip', 'rb') as zipfile:
            self.write(zipfile.read())
        self.flush()
        self.finish()

def load(c, zipfile, fn):
    data=zipfile.read(fn).split('\r\n')
    i=0
    stats.setStatName(fn)
    for line in data:
        i=i+1
        datum=parseDatum(line)
        if isinstance(datum, TigerTypes.ParsedField):
            stats.start()
            c.execute(datum.toSql())
            stats.click()
            stats.stop()
            # os.write(1, ".")
            if i % 80 == 0:
                print stats.getStats()
        elif datum == None:
            pass
        else:
            print "WARNING:  " + type(datum).__name__ + " isn't a ParsedField"
    print ''