Return a list of all filenames marked as flagged.
489706
def get_flagged_names():
    """"""

    l = []
    for w in _widget_cache.values():
        if w.flagged:
            l.append(w.get_node().get_value())
    return l
827392
def get_relavent_flags(self):
        '''
        
        '''
        relavent_flags = {}

        for code, flags_list in self.flags.items():
            relavent_flags[code] = []
            for flag in flags_list:
                if self.flag_is_related(flag):
                    relavent_flags[code].append(flag)
            # Remove that flag level if no error exists
            if not relavent_flags[code]:
                del relavent_flags[code]

        return relavent_flags
580704
def names(cls):
        """"""
        if not cls._files:
            for f in os.listdir(cls._image_path):
                if(not f.startswith('.') and
                   os.path.isfile(os.path.join(cls._image_path, f))):
                    cls._files.append(os.path.splitext(f)[0])

        return cls._files
470378
def saved_xids(self):
        """"""
        if self._saved_xids is None:
            self._saved_xids = []
            if self.debug:
                fpfn = os.path.join(self.tcex.args.tc_temp_path, 'xids-saved')
                if os.path.isfile(fpfn) and os.access(fpfn, os.R_OK):
                    with open(fpfn) as fh:
                        self._saved_xids = fh.read().splitlines()
        return self._saved_xids
470430
def _get_cropped_file_names(self):
        """"""
        files = [ff.name for ff in self.files]
        prefix = commonprefix(files)
        suffix = commonprefix([f[::-1] for f in files])[::-1]
        cropped = [f[len(prefix):-len(suffix)] for f in files]
        return cropped
108434
def flags(flags):
        
        names = sorted(
            descr for key, descr in OpCodeDebug.STREAM_CONSTANT.items() if key & flags
        )
        return ", ".join(names)
216369
def get_file_list(self):
        
        if os.path.isdir(self.root_path):
            return [os.path.join(self.root_path, f) for f in os.listdir(self.root_path)
                    if os.path.isfile(os.path.join(self.root_path, f))]
        else:
            return [self.root_path]
964716
def flags(self, index):
        """"""
        column = index.column()

        if index.isValid():
            if column in [C.COL_START, C.COL_END]:
#                return Qt.ItemFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
                return Qt.ItemFlags(Qt.ItemIsEnabled)
            else:
                return Qt.ItemFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
#                return Qt.ItemFlags(Qt.ItemIsEnabled)
        else:
            return Qt.ItemFlags(Qt.ItemIsEnabled)
406007
def get_filenames(directory):
    """"""
    for filename in os.listdir(directory):
        if re.search(r"cp\d{2}mu?-manylinux1_\S+\.whl", filename):
            yield filename
1267008
def filenames(self):
        
        return [os.path.basename(source) for source in self.sources if source]
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
933697
def get_open_filenames(self):
        """"""
        editorstack = self.editorstacks[0]
        filenames = []
        filenames += [finfo.filename for finfo in editorstack.data]
        return filenames
541737
def _list_files(self, path):
        """"""
        files = []
        for f in glob.glob(pathname=path):
            files.append(f)
        files.sort()
        return files
474166
def pathNames(self) -> [str]:
        

        return [f.pathName for f in list(self._files.values())]
1373859
def list_installed_files(self):
        

        def _md5(path):
            f = open(path, 'rb')
            try:
                content = f.read()
            finally:
                f.close()
            return hashlib.md5(content).hexdigest()

        def _size(path):
            return os.stat(path).st_size

        record_path = os.path.join(self.path, 'installed-files.txt')
        result = []
        if os.path.exists(record_path):
            with codecs.open(record_path, 'r', encoding='utf-8') as f:
                for line in f:
                    line = line.strip()
                    p = os.path.normpath(os.path.join(self.path, line))
                    # "./" is present as a marker between installed files
                    # and installation metadata files
                    if not os.path.exists(p):
                        logger.warning('Non-existent file: %s', p)
                        if p.endswith(('.pyc', '.pyo')):
                            continue
                        #otherwise fall through and fail
                    if not os.path.isdir(p):
                        result.append((p, _md5(p), _size(p)))
            result.append((record_path, None, None))
        return result
118885
def listing(self):
        ""
        return ['.'.join([f,ext]) if ext else f for (f,ext) in self._files.keys()]
1017257
def parse_flags(*flags, **kwargs):
    """"""

    parsed = {
        'ASFLAGS':       OrderedSet(),
        'CFLAGS':        OrderedSet(),
        'DEFINES':       OrderedSet(),
        'INCLUDES':      OrderedSet(),
        'FRAMEWORKS':    OrderedSet(),
        'FRAMEWORKPATH': OrderedSet(),
        'LDFLAGS':       OrderedSet(),
        'LIBS':          OrderedSet(),
        'LIBPATH':       OrderedSet(),
    }

    def _parse(arg):
        if not arg:
            return

        if not isinstance(arg, STR_TYPES):
            for item in arg:
                _parse(arg)
            return

        def add_define(name):
            part = name.split('=')
            if len(part) == 1:
                parsed['DEFINES'].add(name)
            else:
                parsed['DEFINES'].add([part[0], '='.join(part[1:])])

        part = shlex.split(arg)
        curr = None   # For multiword arguments
        for item in part:
            if curr is not None:
                if curr == 'DEFINES':
                    add_define(item)
                elif curr == '-include':
                    parsed['CFLAGS'].add(('-include', item))
                elif curr == '-isysroot':
                    parsed['CFLAGS'].add(('-isysroot', item))
                    parsed['LDFLAGS'].add(('-isysroot', item))
                elif curr == '-arch':
                    parsed['CFLAGS'].add(('-arch', item))
                    parsed['LDFLAGS'].add(('-arch', item))
                else:
                    parsed[curr].add(item)
                curr = None

            elif not item[0] in '-+':
                parsed['LIBS'].add(item)

            elif item == '-dylib_file':
                parsed['LDFLAGS'].add(item)
                curr = 'LDFLAGS'

            elif item[:2] == '-L':
                if item[2:]:
                    parsed['LIBPATH'].add(item[2:])
                else:
                    curr = 'LIBPATH'

            elif item[:2] == '-l':
                if item[2:]:
                    parsed['LIBS'].add(item[2:])
                else:
                    curr = 'LIBS'

            elif item[:2] == '-I':
                if item[2:]:
                    parsed['INCLUDES'].add(item[2:])
                else:
                    curr = 'INCLUDES'

            elif item[:4] == '-Wa,':
                parsed['ASFLAGS'].add(arg[4:])
                parsed['CFLAGS'].add(item)

            elif item[:4] == '-Wp,':
                parsed['CFLAGS'].add(item)

            elif item[:2] == '-D':
                if item[2:]:
                    parsed['DEFINES'].add(item[2:])
                else:
                    curr = 'DEFINES'

            elif item == '-framework':
                curr = 'FRAMEWORKS'

            elif item[:14] == '-frameworkdir=':
                parsed['FRAMEWORKPATH'].add(item[14:])

            elif item[:2] == '-F':
                if item[2:]:
                    parsed['FRAMEWORKPATH'].add(item[2:])
                else:
                    curr = 'FRAMEWORKPATH'

            elif item in ('-mno-cygwin', '-pthread', '-openmp', '-fopenmp'):
                parsed['CFLAGS'].add(item)
                parsed['LDFLAGS'].add(item)

            elif item == '-mwindows':
                parsed['LDFLAGS'].add(item)

            elif item[:5] == '-std=':
                parsed['CFLAGS'].add(item)

            elif item[0] == '+':
                parsed['CFLAGS'].add(item)
                parsed['LDFLAGS'].add(item)

            elif item in ('-include', '-isysroot', '-arch'):
                curr = item

            else:
                parsed[kwargs.get('origin', 'CFLAGS')].add(item)

    for arg in flags:
        _parse(arg)

    return parsed