Returns a list of the filepaths for this edit.
        
        :return     [<str>, ..]
542877
def filepaths(self):
        
        return nativestring(self._filepathEdit.text()).split(os.path.pathsep)
1182069
def getFilePathsWithExtensionsInDirectory(dirTree, patterns, sort=True):
    
    filePaths = []
    for root, dirs, files in os.walk(dirTree):
        for filePath in files:
            for pattern in patterns:
                if fnmatch.fnmatch(filePath, pattern):
                    fullPath = os.path.join(root, filePath)
                    filePaths.append(fullPath)
                    break
    if sort:
        filePaths.sort()
    return filePaths
81481
def get_works(self):
        
        return [os.path.split(filepath)[1] for filepath in
                glob.glob(os.path.join(self._path, '*'))
                if os.path.isdir(filepath)]
846451
def path_placeholders(self):
        

        parser = string.Formatter()
        return [placeholder_name for _, placeholder_name, _, _ in parser.parse(self.path) if placeholder_name]
640412
def get_current_path(self):
        
        path = self.tree_view.fileInfo(
            self.tree_view.currentIndex()).filePath()
        # https://github.com/pyQode/pyQode/issues/6
        if not path:
            path = self.tree_view.root_path
        return path
1121918
def get_file_fields():
    

    # get models

    all_models = apps.get_models()

    # get fields

    fields = []

    for model in all_models:
        for field in model._meta.get_fields():
            if isinstance(field, models.FileField):
                fields.append(field)

    return fields
858238
def runtime_paths(self):  # TODO: memoize
        """"""
        runtimepath = self._vim.options['runtimepath']
        plugin = "ensime-vim"
        paths = []

        for path in runtimepath.split(','):
            if plugin in path:
                paths.append(os.path.expanduser(path))

        return paths
975692
def getSRTemplates(self):
        
        this_dir = os.path.dirname(os.path.abspath(__file__))
        templates_dir = os.path.join(this_dir, self._TEMPLATES_DIR)
        tempath = '%s/%s' % (templates_dir, '*.pt')
        templates = [t.split('/')[-1] for t in glob.glob(tempath)]
        out = []
        for template in templates:
            out.append({'id': template, 'title': template[:-3]})
        for templates_resource in iterDirectoriesOfType(self._TEMPLATES_ADDON_DIR):
            prefix = templates_resource.__name__
            templates = [
                tpl for tpl in templates_resource.listDirectory()
                if tpl.endswith('.pt')
                ]
            for template in templates:
                out.append({
                    'id': '{0}:{1}'.format(prefix, template),
                    'title': '{0} ({1})'.format(template[:-3], prefix),
                })
        return out
900109
def _get_paths(self):
        """"""
        ret = []
        ret += ['%s/library/' % os.path.dirname(os.path.dirname(__file__))]        
        
        ret += self._extra_dirs
        for basedir in _basedirs:
            fullpath = os.path.join(basedir, self.subdir)
            if fullpath not in ret:
                ret.append(fullpath)
        ret += self.config.split(os.pathsep)
        ret += self._get_package_path()
        return ret
263979
def get_edited(self, ):
        
        modified = []
        for i in range(len(self.__edited)):
            if self.__edited[i]:
                modified.append(self.__configs[i])
        return modified
869385
def get_thumbnail_paths(self):
        
        thumbnail_path_tuples = []
        # channel thumbnail
        channel_info = self.get_channel_info()
        chthumbnail_path = channel_info.get('thumbnail_chan_path', None)
        if chthumbnail_path:
            chthumbnail_path_tuple = path_to_tuple(chthumbnail_path, windows=self.winpaths)
            thumbnail_path_tuples.append(chthumbnail_path_tuple)
        # content thumbnails
        for content_file_path_tuple, row in self.contentcache.items():
            thumbnail_path = row.get('thumbnail_chan_path', None)
            if thumbnail_path:
                thumbnail_path_tuple = path_to_tuple(thumbnail_path, windows=self.winpaths)
                thumbnail_path_tuples.append(thumbnail_path_tuple)
        return thumbnail_path_tuples
118885
def listing(self):
        ""
        return ['.'.join([f,ext]) if ext else f for (f,ext) in self._files.keys()]
1335002
def get_unused_paths(self):
        
        return [path for path in self.filter.paths if path not in self.seen_paths]
558901
def _tpl_possibilities(self):
        
        tpl_possibilities = [
            os.path.realpath(self.tpl)
        ]
        for tpl_dir in self.tpl_dirs:
            tpl_possibilities.append(os.path.realpath(os.path.join(tpl_dir, "{0}.tpl".format(self.tpl))))
            tpl_possibilities.append(os.path.realpath(os.path.join(tpl_dir, "{0}.py".format(self.tpl))))

        return tpl_possibilities
1264690
def get_choices(self):
        
        choices = []
        for label_prefix, templates_dir, template_name_prefix in \
                appsettings.LAYOUT_TEMPLATES:
            source_dir = os.path.join(templates_dir, template_name_prefix)
            # Walk directories, appending a choice for each source file.
            for local, dirs, files in os.walk(source_dir, followlinks=True):
                for source_file in files:
                    template_name = os.path.join(
                        template_name_prefix, source_file)
                    label = '%s: %s' % (label_prefix, source_file)
                    choices.append((template_name, label))
        return choices
550937
def demo_paths(self):
        
        base_path = os.path.join(self.module.__path__[0], 'demo')
        paths = []
        if os.path.isdir(base_path):
            for item in os.listdir(base_path):
                # TODO: support examples which is not auto-loaded
                if not os.path.isdir(os.path.join(base_path, 'examples')):
                    paths.append(os.path.join(base_path, item))
        return paths
1170372
def src_paths(self):
        
        return {src for src, summary in self._diff_violations().items()
                   if len(summary.measured_lines) > 0}