Return the list of files inside an archive file.
334051
def archive_filenames(self):
        """"""
        try:
            return _bfd.archive_list_filenames(self._ptr)
        except TypeError, err:
            raise BfdException(err)
93483
def _get_archive_listing(self, archive_name):
        '''
        
        '''

        res = self.collection.find_one({'_id': archive_name})

        if res is None:
            raise KeyError

        return res
893632
def read_files(filenames):
    """"""
    if isinstance(filenames, list):
        for filename in filenames:
            with open(filename, 'r') as infile:
                return infile.read()
    else:
        with open(filenames, 'r') as infile:
            return infile.read()
1316798
def files(self, *args, **kwargs):
        

        return [p for p in self.listdir(*args, **kwargs) if p.isfile()]
61754
def get_archives_to_prune(archives, hook_data):
    """"""
    files_to_skip = []
    for i in ['current_archive_filename', 'old_archive_filename']:
        if hook_data.get(i):
            files_to_skip.append(hook_data[i])
    archives.sort(key=itemgetter('LastModified'),
                  reverse=False)  # sort from oldest to newest
    # Drop all but last 15 files
    return [i['Key'] for i in archives[:-15] if i['Key'] not in files_to_skip]
720541
def files(self):
        """"""
        if self._files is None:
            self._files = SeriesZipTifPhasics._index_files(self.path)
        return self._files
237725
def internal_files(self):
        
        ret_list = []
        for key, val in self.file_dict.items():
            # For internal files we only want files that were marked as
            # internal
            if val & FileFlags.internal_mask:
                ret_list.append(key)
        return ret_list
422270
def all(self, archived=False, limit=None, page=None):
        """"""
        path = partial(_path, self.adapter)
        if not archived:
            path = _path(self.adapter)
        else:
            path = _path(self.adapter, 'archived')
        return self._get(path, limit=limit, page=page)
694600
def files(self):
        """"""
        contents = self.paths
        contents = (VenvFile(path.path) for path in contents if path.is_file)
        return contents
329845
def list_tar (archive, compression, cmd, verbosity, interactive):
    """"""
    cmdlist = [cmd, '--list']
    add_tar_opts(cmdlist, compression, verbosity)
    cmdlist.extend(["--file", archive])
    return cmdlist
940497
def ListFiles(self, ext_attrs=False):
    """"""
    if not self.IsDirectory():
      raise IOError("%s is not a directory." % self.path)

    for path in self.files:
      try:
        filepath = utils.JoinPath(self.path, path)
        response = self._Stat(filepath, ext_attrs=ext_attrs)
        pathspec = self.pathspec.Copy()
        pathspec.last.path = utils.JoinPath(pathspec.last.path, path)
        response.pathspec = pathspec

        yield response
      except OSError:
        pass
951528
def get_archive_formats():
    
    formats = [(name, registry[2]) for name, registry in
               _ARCHIVE_FORMATS.items()]
    formats.sort()
    return formats
981164
def extractall(filename, directory, backend='auto', auto_create_dir=False):
    '''
    
    '''
    Archive(filename, backend).extractall(directory,
                                          auto_create_dir=auto_create_dir)
1072364
def get_list_from_file(file_name):
    """"""
    with open(file_name, mode='r', encoding='utf-8') as f1:
        lst = f1.readlines()
    return lst
787976
private void listContainer(File container,
                               RelativeDirectory subdirectory,
                               Set<JavaFileObject.Kind> fileKinds,
                               boolean recurse,
                               ListBuffer<JavaFileObject> resultList) {
        Archive archive = archives.get(container);
        if (archive == null) {
            // archives are not created for directories.
            if  (fsInfo.isDirectory(container)) {
                listDirectory(container,
                              subdirectory,
                              fileKinds,
                              recurse,
                              resultList);
                return;
            }

            // Not a directory; either a file or non-existant, create the archive
            try {
                archive = openArchive(container);
            } catch (IOException ex) {
                log.error("error.reading.file",
                          container, getMessage(ex));
                return;
            }
        }
        listArchive(archive,
                    subdirectory,
                    fileKinds,
                    recurse,
                    resultList);
    }
42743
def get_entries(path):
    """"""
    dirs, files = [], []
    for entry in os.listdir(path):
        # Categorize entry as directory or file.
        if os.path.isdir(os.path.join(path, entry)):
            dirs.append(entry)
        else:
            files.append(entry)
    dirs.sort()
    files.sort()
    return dirs, files
1029949
def get_file_list():
    """"""

    if len(sys.argv) > 1:
        file_list = list(sys.argv[1:])  # make copy
    else:
        files_str = input('Select the files you want to process and drag and drop them onto this window, '
                          'or type their names separated by spaces. Paths containing spaces should be '
                          'surrounded by quotation marks.\nPress ENTER when you\'re done: ')

        if "win" in sys.platform:
            # the POSIX shlex.split uses backslashes for escape sequences, so Windows paths need to set posix=False
            file_list = shlex.split(files_str, posix=False)

            # the non-POSIX shlex.split does not automatically clean quotation marks from the final product
            file_list = [f.replace('"', '').replace("'", "") for f in file_list]
        else:
            file_list = shlex.split(files_str, posix=True)

    # substitute in shell variables and get absolute paths
    for i in range(len(file_list)):
        file_list[i] = os.path.abspath( os.path.expanduser(os.path.expandvars(file_list[i])) )

    return file_list