Returns a deque object full of local file system items.

        :returns: ``deque``
320756
def _index_fs(self):
        

        indexed_objects = self._return_deque()

        directory = self.job_args.get('directory')
        if directory:
            indexed_objects = self._return_deque(
                deque=indexed_objects,
                item=self._drectory_local_files(
                    directory=directory
                )
            )

        object_names = self.job_args.get('object')
        if object_names:
            indexed_objects = self._return_deque(
                deque=indexed_objects,
                item=self._named_local_files(
                    object_names=object_names
                )
            )

        return indexed_objects
839954
def _get_containers(self):
        """"""

        def full_fn(path):
            return os.path.join(self.abs_root, path)
        return [self.cont_cls.from_path(self, d)
                for d in os.listdir(self.abs_root) if is_dir(full_fn(d))]
961947
def get(self):
        
        res = self.fs.get_filesystem_details()
        res = res.to_dict()
        self.write(res)
432969
def get(hdfs_path, local_path):
    
    cmd = "hadoop fs -get %s %s" % (hdfs_path, local_path)
    rcode, stdout, stderr = _checked_hadoop_fs_command(cmd)
434582
function LocalFilesystemHandler(req, res, next, local = false) {
            if (!self.settings.localFilesystem) {
                return next();
            }
            return FilesystemHandler(req, res, next, self.localFilesystemUrl, undefined, local);
        }
786461
def files(self, dry_run):
        # type: (LocalSourcePaths, bool) -> LocalPath
        
        for _path in self._paths:
            _ppath = os.path.expandvars(os.path.expanduser(str(_path)))
            # check of path is stdin
            if blobxfer.models.upload.LocalSourcePath.is_stdin(_ppath):
                yield LocalPath(
                    parent_path=pathlib.Path(),
                    relative_path=pathlib.Path('stdin'),
                    use_stdin=True,
                )
                continue
            # resolve path
            _expath = pathlib.Path(_ppath).resolve()
            # check if path is a single file
            tmp = pathlib.Path(_ppath)
            if tmp.is_file():
                if self._inclusion_check(tmp.name):
                    yield LocalPath(
                        parent_path=tmp.parent,
                        relative_path=pathlib.Path(tmp.name),
                        use_stdin=False,
                    )
                elif dry_run:
                    logger.info(
                        '[DRY RUN] skipping due to filters: {}'.format(tmp))
            else:
                del tmp
                for entry in blobxfer.util.scantree(_ppath):
                    _rpath = pathlib.Path(entry.path).relative_to(_ppath)
                    if not self._inclusion_check(_rpath):
                        if dry_run:
                            logger.info(
                                '[DRY RUN] skipping due to filters: {}'.format(
                                    _rpath))
                        continue
                    yield LocalPath(
                        parent_path=_expath,
                        relative_path=_rpath,
                        use_stdin=False,
                    )
1339710
def _catalog_local_files_for_deletion(self):
        # type: (Downloader) -> None
        
        if not (self._spec.options.delete_extraneous_destination and
                self._spec.destination.is_dir):
            return
        dst = str(self._spec.destination.path)
        for file in blobxfer.util.scantree(dst):
            self._delete_after.add(pathlib.Path(file.path))
811111
def fetch_items_from_filesystem_or_zip
      unless in_zip?
        @items = Dir.foreach(current_dir).map {|fn|
          load_item dir: current_dir, name: fn
        }.to_a.partition {|i| %w(. ..).include? i.name}.flatten
      else
        @items = [load_item(dir: current_dir, name: '.', stat: File.stat(current_dir)),
          load_item(dir: current_dir, name: '..', stat: File.stat(File.dirname(current_dir)))]
        zf = Zip::File.new current_dir
        zf.each {|entry|
          next if entry.name_is_directory?
          stat = zf.file.stat entry.name
          @items << load_item(dir: current_dir, name: entry.name, stat: stat)
        }
      end
    end
592468
def purge(self):
        
        def partial_file(item):
            "Filter out partial files"
            #print "???", repr(item)
            return item.completed_chunks < item.size_chunks

        self.cull(file_filter=partial_file, attrs=["get_completed_chunks", "get_size_chunks"])
643786
def files(self):
        
        res = None
        if not res:
            res = glob.glob(self.path)
        if not res and self.is_glob:
            res = glob.glob(self.magic_path)
        if not res:
            res = glob.glob(self.alias)
        if not res:
            raise ValueError('No files match. %s' % self)
        return res
404123
def list(self, remote='.', extra=False, remove_relative_paths=False):
        
        if extra:
            self.tmp_output = []
            self.conn.dir(remote, self._collector)
            directory_list = split_file_info(self.tmp_output)
        else:
            directory_list = self.conn.nlst(remote)

        if remove_relative_paths:
            return list(filter(self.is_not_relative_path, directory_list))

        return directory_list
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
739526
def _get_next_files(self):
        
        fnlist = self.__files[:16]
        self.__files = self.__files[16:]
        return fnlist
362679
def get_file(self,
                 path,
                 dest='',
                 makedirs=False,
                 saltenv='base',
                 gzip=None,
                 cachedir=None):
        '''
        
        '''
        raise NotImplementedError
586269
def get_local_file_list(self):
        
        file_list = []
        for (dirpath, dirnames, filenames) in os.walk(self.build_dir):
            for fname in filenames:
                # relative path, to sync with the S3 key
                local_key = os.path.join(
                    os.path.relpath(dirpath, self.build_dir),
                    fname
                )
                if local_key.startswith('./'):
                    local_key = local_key[2:]
                file_list.append(local_key)
        return file_list
100304
def cache_local_file(self, path, **kwargs):
        '''
        
        '''
        dest = os.path.join(self.opts['cachedir'], 'localfiles',
                            path.lstrip('/'))
        destdir = os.path.dirname(dest)

        if not os.path.isdir(destdir):
            os.makedirs(destdir)

        shutil.copyfile(path, dest)
        return dest
1337425
def dequeue(self, block=True):
        """"""
        return self.queue.get(block, self.queue_get_timeout)