Python rarfile.is_rarfile函数代码示例

def get_image_format(filename, arguments):
    """gets the image format"""
    image = None
    bad_image = 1
    image_format = NONE_FORMAT
    sequenced = False
    try:
        image = Image.open(filename)
        bad_image = image.verify()
        image_format = image.format
        sequenced = is_image_sequenced(image)
    except (OSError, IOError):
        pass

    if sequenced:
        image_format = SEQUENCED_TEMPLATE % image_format
    elif image is None or bad_image or image_format == NONE_FORMAT:
        image_format = ERROR_FORMAT
        filename_ext = os.path.splitext(filename)[-1].lower()
        if filename_ext in COMIC_EXTS:
            if zipfile.is_zipfile(filename):
                image_format = CBZ_FORMAT
            elif rarfile.is_rarfile(filename):
                image_format = CBR_FORMAT
        if (arguments.verbose > 1) and image_format == ERROR_FORMAT and (not arguments.list_only):
            print(filename, "doesn't look like an image or comic archive.")
    return image_format

    def findVideo(self):
        fullpath = self.config['file']['path'] + self.config['file']['name']
        files = False
        if os.path.isdir(fullpath):
            os.chdir(fullpath)
            files = {"path": os.getcwd(), "files": []}
            archive = False
            for file in os.listdir(files['path']):
                if zipfile.is_zipfile(file):
                    print "Unzip..."
                    zip = zipfile.ZipFile(file)
                    zip.extractall()
                    archive = True
                elif rarfile.is_rarfile(file):
                    try:
                        print "Unrar..."
                        rar = rarfile.RarFile(file)
                        rar.extractall()
                        archive = True
                    except rarfile.NeedFirstVolume:
                        pass
                self.config['file']['name'] = file
                if self.isVideo():
                    files['files'].append(file)
            if archive:
                allFiles = os.listdir(files['path'])
                for file in allFiles:
                    self.config['file']['name'] = file
                    if not file in files['files'] and self.isVideo():
                        files['files'].append(file)

        return files

def main():
    parser = optparse.OptionParser("Usage: pyUnCompress.py " +
                                   "-f <zipfile | rarfile> -d <dictionary>")
    parser.add_option('-f', dest='zname', type='string',
                      help='specify zip | rar file')
    parser.add_option('-d', dest='dname', type='string',
                      help='specify dictionary file')
    (options, args) = parser.parse_args()

    if (options.zname == None) | (options.dname == None):
        print parser.usage
        exit(0)
    else:
        zname = options.zname
        dname = options.dname

    flag = 0  # filetype -- rar = 1 | zip = 2

    if (rarfile.is_rarfile(zname)):
        compressFile = rarfile.RarFile(zname)
    elif (zipfile.is_zipfile(zname)):
        compressFile = zipfile.ZipFile(zname)
    else:
        print 'Unrecognized file'
        exit(0)

    passFile = open(dname)

    for line in passFile.readlines():
        if (ALIVE == False):
            exit(0)
        password = line.strip('\n')
        t = Thread(target=extractFile, args=(compressFile, password))
        t.start()

    def download_subtitle(self, subtitle):
        r = self.session.get(subtitle.download_link, timeout=10)
        r.raise_for_status()

        # open the archive
        archive_stream = io.BytesIO(r.content)
        if is_rarfile(archive_stream):
            logger.debug('Archive identified as rar')
            archive = RarFile(archive_stream)
        elif is_zipfile(archive_stream):
            logger.debug('Archive identified as zip')
            archive = ZipFile(archive_stream)
        else:
            subtitle.content = r.content
            if subtitle.is_valid():
                return
            subtitle.content = None

            raise ProviderError('Unidentified archive type')

        subs_in_archive = archive.namelist()

        # if Serbian lat and cyr versions are packed together, try to find right version
        if len(subs_in_archive) > 1 and (subtitle.language == 'sr' or subtitle.language == 'sr-Cyrl'):
            self.get_subtitle_from_bundled_archive(subtitle, subs_in_archive, archive)
        else:
            # use default method for everything else
            subtitle.content = self.get_subtitle_from_archive(subtitle, archive)

def testPath(path):
  print("testing path: %s" % path)
  #is it file or folder ?
  if os.path.isfile(path):
    print("manga: path is a file")
    desc = getFileDescription(path)
    print("file type: %s" % desc)
    mime = getFilePathMime(path)
    print("file mime: %s" % mime)
    mimeSplit = mime.split('/')
    m1 = mimeSplit[0]
    m2 = mimeSplit[1]
    if m1 == 'image':
      print("image file selected,\ncontaining folder could be loaded as a manga")
      (folderPath, tail) = os.path.split(path)
      return "folder", folderPath, desc, mime
    elif mime == 'application/zip' or mime == 'application/x-zip' or zipfile.is_zipfile(path):
      print("file is probably a zip file")
      return "zip", path, desc, mime
    elif mime == 'application/rar' or mime == 'application/x-rar' or rarfile.is_rarfile(path):
      print("file is probably a rar file")
      return 'rar', path, desc, mime
    else:
      print("the path: %s is an unsupported file")
      print("it has this mime: %s" % mime)
      print("and this description: %s" % desc)
      return False
      
  elif os.path.isdir(path):
    print("manga: path is a directory")
    return "folder", path, None, "a folder"
  else:
    print("manga: loading failed, path is neither file nor directory")
    return False

def main():
	
	target_dir = sys.argv[1]

	newsdomains = set([])
	
	with open(sys.argv[2], 'r') as newssites:
		for line in newssites:
			newsdomains.add(line.strip())

	if len(sys.argv) < 3:
		print 'Usage: ' + sys.argv[0] + ' + <traversal dir> + <news domains text file>'
		sys.exit(1)

	for item in os.listdir(target_dir):
		item_path = os.path.join(target_dir, item)
		if item.startswith('web-') and rarfile.is_rarfile(item_path):
			rf = rarfile.RarFile(item_path)
			
			try:
			    tmp_dir = tempfile.mkdtemp()
			    rf.extractall(path=tmp_dir)
			    filename = rf.namelist()[0]
			    flatsnap = process_file(os.path.join(tmp_dir, filename), filename, newsdomains)
			    archive_name = os.path.splitext(filename)[0] + '_news.gz'
			    with gzip.open(archive_name, 'wb') as archive:
			    	for item in flatsnap:
			    		archive.write('%s\n' % item)
			finally:
			    try:
				shutil.rmtree(tmp_dir)
			    except OSError, e:
				if e.errno != 2: # code 2 - no such file or directory
				    raise

 def is_rar(path, file):
     try:
         if rarfile.is_rarfile(os.path.join(path, file)):
             return True
     except OSError, e:
         logging.error("Error in is_rar for '%s': %s" % (file, e))
         raise OSError

def is_archive(filename):
    """
    test if file is a valid archive (zip, tar or rar)
    """
    return tarfile.is_tarfile(filename) or \
           zipfile.is_zipfile(filename) or \
           (ARCHIVE_RAR_AVAILABLE and rarfile.is_rarfile(filename))

def save_file(url, filename):
    filename = "out/" + filename

    # Check if we already have it
    if os.path.isfile(filename + ".zip") or os.path.isfile(filename + ".rar") or os.path.isfile(filename + ".zip"):
        print "We already have " + filename + ", skipping"
        return

    print("Downloading... " + filename)

    try:
        f = open(filename, 'wb')
        f.write(urllib2.urlopen(url).read())
        f.close()

        if zipfile.is_zipfile(filename):
            print(filename + " is a zip file")
            shutil.move(filename, filename + ".zip")
        elif rarfile.is_rarfile(filename):
            print(filename + " is a rar file")
            shutil.move(filename, filename + ".rar")
        else:
            print(filename + " is an nds file")
            shutil.move(filename, filename + ".nds")
    except urllib2.URLError:
        print "Failed to download: " + filename

    def openFile(self):
        '''
        Open a file stream to either a rar/cbr or zip/cbz file
        '''
        inFile, _ = QtGui.QFileDialog.getOpenFileName(self, 'Open file',
                    QtCore.QDir.currentPath())

        self.currentPage = 0

        if zipfile.is_zipfile(inFile) == True:      #Check if its a zip file (.zip, .cbz)
            self.z = zipfile.ZipFile(inFile, "r")    
        elif rarfile.is_rarfile(inFile) == True:    #Check if its a rar file (.rar, .cbr)
            self.z = rarfile.RarFile(inFile)
        else:
            msgBox = QtGui.QMessageBox()
            msgBox.setText("This is not a valid CBZ or CBR file!")
            msgBox.setStandardButtons(QtGui.QMessageBox.Ok)
            msgBox.setDefaultButton(QtGui.QMessageBox.Ok)
            ret = msgBox.exec_()

            #if statement is probably unecessary
            if ret == QtGui.QMessageBox.Ok:
                self.openFile()

        self.showImage(self.currentPage)

        #Make the label clickable to go forward pages
        Utility.clickable(self.lbl).connect(self.changePage)

        self.scaleFactor = 1.0
        self.scaleImage(self.scaleFactor)
        self.updateActions()

 def __init__(self, origFileName):
     self.origFileName = origFileName
     if zipfile.is_zipfile(origFileName):
         self.compressor = 'zip'
     elif rarfile.is_rarfile(origFileName):
         self.compressor = 'rar'
     else:
         self.compressor = None

 def __init__(self, path):
   Container.__init__(self, path)
   self.rf = None
   if rarfile.is_rarfile(path):
     try:
       self.rf = rarfile.RarFile(path,'r')
     except Exception, e:
       "error, loading rar file failed: %s" % e

def extract(archive_file, path=".", delete_on_success=False,
            enable_rar=False):
    """
    Automatically detect archive type and extract all files to specified path.

    .. code:: python

        import os

        os.listdir(".")
        # ['test_structure.zip']

        reusables.extract("test_structure.zip")

        os.listdir(".")
        # [ 'test_structure', 'test_structure.zip']


    :param archive_file: path to file to extract
    :param path: location to extract to
    :param delete_on_success: Will delete the original archive if set to True
    :param enable_rar: include the rarfile import and extract
    :return: path to extracted files
    """

    if not os.path.exists(archive_file) or not os.path.getsize(archive_file):
        logger.error("File {0} unextractable".format(archive_file))
        raise OSError("File does not exist or has zero size")

    arch = None
    if zipfile.is_zipfile(archive_file):
        logger.debug("File {0} detected as a zip file".format(archive_file))
        arch = zipfile.ZipFile(archive_file)
    elif tarfile.is_tarfile(archive_file):
        logger.debug("File {0} detected as a tar file".format(archive_file))
        arch = tarfile.open(archive_file)
    elif enable_rar:
        import rarfile
        if rarfile.is_rarfile(archive_file):
            logger.debug("File {0} detected as "
                         "a rar file".format(archive_file))
            arch = rarfile.RarFile(archive_file)

    if not arch:
        raise TypeError("File is not a known archive")

    logger.debug("Extracting files to {0}".format(path))

    try:
        arch.extractall(path=path)
    finally:
        arch.close()

    if delete_on_success:
        logger.debug("Archive {0} will now be deleted".format(archive_file))
        os.unlink(archive_file)

    return os.path.abspath(path)

def getrarlist(rarname):
    rarfile.NEED_COMMENTS = 0
    filelist = []
    if not rarfile.is_rarfile(rarname):
        return filelist
    rararc = rarfile.RarFile(rarname)
    for rarentry in rararc.infolist():
        filelist.append(rarentry.filename)
    return filelist

 def __init__(self, origFileName):
     self.origFileName = origFileName
     if zipfile.is_zipfile(origFileName):
         self.compressor = 'zip'
     elif rarfile.is_rarfile(origFileName):
         self.compressor = 'rar'
     elif origFileName.endswith('.7z') or origFileName.endswith('.cb7'):
         self.compressor = '7z'
     else:
         self.compressor = None