Retrieves the presets information.

    Returns:
      list[tuple]: containing:

        str: preset name
        str: comma separated parser names that are defined by the preset
965160
def GetPresetsInformation(cls):
    
    parser_presets_information = []
    for preset_definition in ParsersManager.GetPresets():
      preset_information_tuple = (
          preset_definition.name, ', '.join(preset_definition.parsers))
      # TODO: refactor to pass PresetDefinition.
      parser_presets_information.append(preset_information_tuple)

    return parser_presets_information
868154
def prior_model_name_prior_tuples_dict(self):
        
        return {name: list(prior_model.prior_tuples) for name, prior_model in self.prior_model_tuples}
727939
def contents_list_pairs(self):
        ''''''
        return (tuple(getattr(self.generator, name) for name in names)
                for names in self.info.get('contents_lists', []))
412361
def get_properties(self):
        

        names = inspect.getmembers(self, predicate=lambda x: not inspect.ismethod(x))
        return [x[0] for x in names if not x[0].startswith("_") and x[0] not in self._ignored_properties]
758473
def get_settings(self):
        
        uri = "{}/settings".format(self.data["uri"])
        return self._helper.do_get(uri)
532595
function includesPresetName(preset) {
	return _.isString(preset) ||
		_.isArray(preset) && _.isString(_.head(preset));
}
621722
public java.util.List<Preset> getPresets() {
        if (presets == null) {
            presets = new com.amazonaws.internal.SdkInternalList<Preset>();
        }
        return presets;
    }
486471
def type_names(prefix, sizerange):
        
        namelist = []
        for i in sizerange: namelist.append(prefix + str(i))
        return tuple(namelist)
492593
def defaults(self):
        
        defaults = ConfigParser.defaults(self).copy()
        for key, val in iteritems(defaults):
            defaults[key] = self.get('DEFAULT', key) or val
        return defaults
639273
def _GetPluginData(self):
    
    return_dict = {}

    return_dict['Versions'] = [
        ('plaso engine', plaso.__version__),
        ('python', sys.version)]

    hashers_information = hashers_manager.HashersManager.GetHashersInformation()
    parsers_information = parsers_manager.ParsersManager.GetParsersInformation()
    plugins_information = (
        parsers_manager.ParsersManager.GetParserPluginsInformation())
    presets_information = parsers_manager.ParsersManager.GetPresetsInformation()

    return_dict['Hashers'] = hashers_information
    return_dict['Parsers'] = parsers_information
    return_dict['Parser Plugins'] = plugins_information
    return_dict['Parser Presets'] = presets_information

    return return_dict
34798
def prior_model_name_constant_tuples_dict(self):
        
        return {name: list(prior_model.constant_tuples) for name, prior_model in self.prior_model_tuples}
156991
def list_presets(cfg, out=sys.stdout):
    
    for section in cfg.sections():
        if section.startswith("preset:"):
            out.write((section.replace("preset:", "")) + os.linesep)
            for k, v in cfg.items(section):
                out.write("\t%s = %s" % (k, v) + os.linesep)
1329120
def load_presets(self, presets_path=None):
        
        presets_path = presets_path or self.presets_path
        if not os.path.exists(presets_path):
            return
        for preset_path in os.listdir(presets_path):
            preset_path = os.path.join(presets_path, preset_path)

            try:
                preset_data = json.load(open(preset_path))
            except ValueError:
                continue

            for preset in preset_data.keys():
                pd = PresetDefaults(preset, opts=SoSOptions())
                data = preset_data[preset]
                pd.desc = data[DESC] if DESC in data else ""
                pd.note = data[NOTE] if NOTE in data else ""

                if OPTS in data:
                    for arg in _arg_names:
                        if arg in data[OPTS]:
                            setattr(pd.opts, arg, data[OPTS][arg])
                pd.builtin = False
                self.presets[preset] = pd
16316
def constant_tuples(self):
        
        return [constant_tuple for tuple_prior in self.tuple_prior_tuples for constant_tuple in
                tuple_prior[1].constant_tuples] + self.direct_constant_tuples
3047
def _prepare_nameparser_constants():
    
    constants = Constants()
    roman_numeral_suffixes = [u'v', u'vi', u'vii', u'viii', u'ix', u'x',
                              u'xii', u'xiii', u'xiv', u'xv']
    titles = [u'Dr', u'Prof', u'Professor', u'Sir', u'Editor', u'Ed', u'Mr',
              u'Mrs', u'Ms', u'Chair', u'Co-Chair', u'Chairs', u'co-Chairs']
    constants.titles.remove(*constants.titles).add(*titles)
    constants.suffix_not_acronyms.add(*roman_numeral_suffixes)
    return constants
1218007
def variable_names(self):
        
        if self._variable_names is None:

            if self._operator is None:
                if self._operands is None:
                    self._variable_names = tuple()
                else:
                    self._variable_names = self._get_variable_names(self._operands)

            elif self._operator == 'NOT':
                self._variable_names = self._operands.variable_names

            else:
                v = list()
                for op in self._operands:
                    v.extend(op.variable_names)
                self._variable_names = tuple(set(v))

        return self._variable_names
118326
def _tables(self) -> List[Tuple[str, str]]:
        
        return [(k.rsplit('.', 1)[1] if '.' in k else k, k) for k in self._ont_tables.keys()]