def GetParserFilterListsFromString(cls, parser_filter_string): """Determines an include and exclude list of parser names. Takes a comma separated string and splits it up into two lists, of parsers to include and to exclude from selection. If a particular filter is prepended with a minus sign it will be included in the exclude section, otherwise in the include. Args: parser_filter_string: The parser filter string. Returns: A tuple of two lists, include and exclude. """ if not parser_filter_string: return [], [] # Build the plugin to parser map, which cannot be a class member # otherwise the map will become invalid if a parser with plugins # is deregistered. plugin_to_parser_map = {} for parser_name, parser_class in cls._parser_classes.iteritems(): if parser_class.SupportsPlugins(): for plugin_name in parser_class.GetPluginNames(): plugin_to_parser_map[plugin_name] = parser_name includes = set() excludes = set() preset_categories = presets.categories.keys() for filter_string in parser_filter_string.split(u','): filter_string = filter_string.strip() if not filter_string: continue if filter_string.startswith(u'-'): active_list = excludes filter_string = filter_string[1:] else: active_list = includes filter_string = filter_string.lower() if filter_string in cls._parser_classes: active_list.add(filter_string) elif filter_string in preset_categories: for entry in presets.GetParsersFromCategory(filter_string): active_list.add(plugin_to_parser_map.get(entry, entry)) else: active_list.add( plugin_to_parser_map.get(filter_string, filter_string)) return list(includes), list(excludes)
def _GetParserFilters(cls, parser_filter_expression): """Retrieves the parsers and plugins to include and exclude. Takes a comma separated string and splits it up into two dictionaries, of parsers and plugins to include and to exclude from selection. If a particular filter is prepended with an exclamation point it will be added to the exclude section, otherwise in the include. Args: parser_filter_expression: a string containing the parser filter expression, where None represents all parsers and plugins. Returns: A tuple containing dictionaries of the names of the included and excluded parsers and plugins. Where the keys contain the names of the parser and the corresponding value the names of the plugins. """ if not parser_filter_expression: return {}, {} includes = {} excludes = {} preset_categories = presets.categories.keys() for parser_filter in parser_filter_expression.split(u','): parser_filter = parser_filter.strip() if not parser_filter: continue if parser_filter.startswith(u'!'): parser_filter = parser_filter[1:] active_dict = excludes else: active_dict = includes parser_filter = parser_filter.lower() if parser_filter in preset_categories: for parser_in_category in presets.GetParsersFromCategory( parser_filter): parser, _, plugin = parser_in_category.partition(u'/') active_dict.setdefault(parser, []) if plugin: active_dict[parser].append(plugin) else: parser, _, plugin = parser_filter.partition(u'/') active_dict.setdefault(parser, []) if plugin: active_dict[parser].append(plugin) cls._ReduceParserFilters(includes, excludes) return includes, excludes
def GetFilterListsFromString(cls, parser_filter_string): """Determines an include and exclude list of parser and plugin names. Takes a comma separated string and splits it up into two lists, of parsers, those to include and exclude from selection. If a particular filter is prepended with a minus sign it will be included in the exclude section, otherwise it is placed in the include. Args: parser_filter_string: The parser filter string. Returns: A tuple of two lists, include and exclude. """ includes = [] excludes = [] if not parser_filter_string: return includes, excludes preset_categories = presets.categories.keys() for filter_string in parser_filter_string.split(u','): filter_string = filter_string.strip() if not filter_string: continue if filter_string.startswith(u'-'): active_list = excludes filter_string = filter_string[1:] else: active_list = includes filter_string = filter_string.lower() if filter_string in cls._parser_classes: parser_class = cls._parser_classes[filter_string] active_list.append(filter_string) if parser_class.SupportsPlugins(): active_list.extend(parser_class.GetPluginNames()) elif filter_string in preset_categories: active_list.extend( presets.GetParsersFromCategory(filter_string)) else: active_list.append(filter_string) return includes, excludes
def GetParserListsFromString(parser_string): """Return a list of parsers to include and exclude from a string. Takes a comma separated string and splits it up into two lists, of parsers or plugins to include and to exclude from selection. If a particular filter is prepended with a minus sign it will be included int he exclude section, otherwise in the include. Args: parser_string: The comma separated string. Returns: A tuple of two lists, include and exclude. """ include = [] exclude = [] preset_categories = presets.categories.keys() for filter_string in parser_string.split(','): filter_string = filter_string.strip() if not filter_string: continue if filter_string.startswith('-'): filter_strings_use = exclude filter_string = filter_string[1:] else: filter_strings_use = include filter_string_lower = filter_string.lower() if filter_string_lower in preset_categories: filter_strings_use.extend( presets.GetParsersFromCategory(filter_string_lower)) else: filter_strings_use.append(filter_string_lower) return include, exclude