diff options
Diffstat (limited to 'src/main/python/venv/Lib/site-packages/pylint/config.py')
| -rw-r--r-- | src/main/python/venv/Lib/site-packages/pylint/config.py | 913 |
1 files changed, 0 insertions, 913 deletions
diff --git a/src/main/python/venv/Lib/site-packages/pylint/config.py b/src/main/python/venv/Lib/site-packages/pylint/config.py deleted file mode 100644 index 0925575..0000000 --- a/src/main/python/venv/Lib/site-packages/pylint/config.py +++ /dev/null @@ -1,913 +0,0 @@ -# -*- coding: utf-8 -*- -# Copyright (c) 2006-2010, 2012-2014 LOGILAB S.A. (Paris, FRANCE) <contact@logilab.fr> -# Copyright (c) 2008 pyves@crater.logilab.fr <pyves@crater.logilab.fr> -# Copyright (c) 2010 Julien Jehannet <julien.jehannet@logilab.fr> -# Copyright (c) 2013 Google, Inc. -# Copyright (c) 2013 John McGehee <jmcgehee@altera.com> -# Copyright (c) 2014-2018 Claudiu Popa <pcmanticore@gmail.com> -# Copyright (c) 2014 Brett Cannon <brett@python.org> -# Copyright (c) 2014 Arun Persaud <arun@nubati.net> -# Copyright (c) 2015 Aru Sahni <arusahni@gmail.com> -# Copyright (c) 2015 John Kirkham <jakirkham@gmail.com> -# Copyright (c) 2015 Ionel Cristian Maries <contact@ionelmc.ro> -# Copyright (c) 2016 Erik <erik.eriksson@yahoo.com> -# Copyright (c) 2016 Alexander Todorov <atodorov@otb.bg> -# Copyright (c) 2016 Moises Lopez <moylop260@vauxoo.com> -# Copyright (c) 2017-2018 Ville Skyttä <ville.skytta@iki.fi> -# Copyright (c) 2017 hippo91 <guillaume.peillex@gmail.com> -# Copyright (c) 2017 ahirnish <ahirnish@gmail.com> -# Copyright (c) 2017 Łukasz Rogalski <rogalski.91@gmail.com> -# Copyright (c) 2018 Bryce Guinta <bryce.paul.guinta@gmail.com> -# Copyright (c) 2018 ssolanki <sushobhitsolanki@gmail.com> -# Copyright (c) 2018 Sushobhit <31987769+sushobhit27@users.noreply.github.com> -# Copyright (c) 2018 Anthony Sottile <asottile@umich.edu> -# Copyright (c) 2018 Gary Tyler McLeod <mail@garytyler.com> -# Copyright (c) 2018 Konstantin <Github@pheanex.de> -# Copyright (c) 2018 Nick Drozd <nicholasdrozd@gmail.com> - -# Licensed under the GPL: https://www.gnu.org/licenses/old-licenses/gpl-2.0.html -# For details: https://github.com/PyCQA/pylint/blob/master/COPYING - -"""utilities for Pylint configuration : - -* pylintrc -* pylint.d (PYLINTHOME) -""" -import collections -import configparser -import contextlib -import copy -import io -import optparse -import os -import pickle -import re -import sys -import time -from typing import Any, Dict, Tuple - -from pylint import utils - -USER_HOME = os.path.expanduser("~") -if "PYLINTHOME" in os.environ: - PYLINT_HOME = os.environ["PYLINTHOME"] - if USER_HOME == "~": - USER_HOME = os.path.dirname(PYLINT_HOME) -elif USER_HOME == "~": - PYLINT_HOME = ".pylint.d" -else: - PYLINT_HOME = os.path.join(USER_HOME, ".pylint.d") - - -def _get_pdata_path(base_name, recurs): - base_name = base_name.replace(os.sep, "_") - return os.path.join(PYLINT_HOME, "%s%s%s" % (base_name, recurs, ".stats")) - - -def load_results(base): - data_file = _get_pdata_path(base, 1) - try: - with open(data_file, "rb") as stream: - return pickle.load(stream) - except Exception: # pylint: disable=broad-except - return {} - - -def save_results(results, base): - if not os.path.exists(PYLINT_HOME): - try: - os.mkdir(PYLINT_HOME) - except OSError: - print("Unable to create directory %s" % PYLINT_HOME, file=sys.stderr) - data_file = _get_pdata_path(base, 1) - try: - with open(data_file, "wb") as stream: - pickle.dump(results, stream) - except (IOError, OSError) as ex: - print("Unable to create file %s: %s" % (data_file, ex), file=sys.stderr) - - -def find_pylintrc(): - """search the pylint rc file and return its path if it find it, else None - """ - # is there a pylint rc file in the current directory ? - if os.path.exists("pylintrc"): - return os.path.abspath("pylintrc") - if os.path.exists(".pylintrc"): - return os.path.abspath(".pylintrc") - if os.path.isfile("__init__.py"): - curdir = os.path.abspath(os.getcwd()) - while os.path.isfile(os.path.join(curdir, "__init__.py")): - curdir = os.path.abspath(os.path.join(curdir, "..")) - if os.path.isfile(os.path.join(curdir, "pylintrc")): - return os.path.join(curdir, "pylintrc") - if os.path.isfile(os.path.join(curdir, ".pylintrc")): - return os.path.join(curdir, ".pylintrc") - if "PYLINTRC" in os.environ and os.path.exists(os.environ["PYLINTRC"]): - pylintrc = os.environ["PYLINTRC"] - else: - user_home = os.path.expanduser("~") - if user_home in ("~", "/root"): - pylintrc = ".pylintrc" - else: - pylintrc = os.path.join(user_home, ".pylintrc") - if not os.path.isfile(pylintrc): - pylintrc = os.path.join(user_home, ".config", "pylintrc") - if not os.path.isfile(pylintrc): - if os.path.isfile("/etc/pylintrc"): - pylintrc = "/etc/pylintrc" - else: - pylintrc = None - return pylintrc - - -PYLINTRC = find_pylintrc() - -ENV_HELP = ( - """ -The following environment variables are used: - * PYLINTHOME - Path to the directory where persistent data for the run will be stored. If -not found, it defaults to ~/.pylint.d/ or .pylint.d (in the current working -directory). - * PYLINTRC - Path to the configuration file. See the documentation for the method used -to search for configuration file. -""" - % globals() # type: ignore -) - - -class UnsupportedAction(Exception): - """raised by set_option when it doesn't know what to do for an action""" - - -def _multiple_choice_validator(choices, name, value): - values = utils._check_csv(value) - for csv_value in values: - if csv_value not in choices: - msg = "option %s: invalid value: %r, should be in %s" - raise optparse.OptionValueError(msg % (name, csv_value, choices)) - return values - - -def _choice_validator(choices, name, value): - if value not in choices: - msg = "option %s: invalid value: %r, should be in %s" - raise optparse.OptionValueError(msg % (name, value, choices)) - return value - - -# pylint: disable=unused-argument -def _csv_validator(_, name, value): - return utils._check_csv(value) - - -# pylint: disable=unused-argument -def _regexp_validator(_, name, value): - if hasattr(value, "pattern"): - return value - return re.compile(value) - - -# pylint: disable=unused-argument -def _regexp_csv_validator(_, name, value): - return [_regexp_validator(_, name, val) for val in _csv_validator(_, name, value)] - - -def _yn_validator(opt, _, value): - if isinstance(value, int): - return bool(value) - if value in ("y", "yes"): - return True - if value in ("n", "no"): - return False - msg = "option %s: invalid yn value %r, should be in (y, yes, n, no)" - raise optparse.OptionValueError(msg % (opt, value)) - - -def _non_empty_string_validator(opt, _, value): - if not value: - msg = "indent string can't be empty." - raise optparse.OptionValueError(msg) - return utils._unquote(value) - - -VALIDATORS = { - "string": utils._unquote, - "int": int, - "regexp": re.compile, - "regexp_csv": _regexp_csv_validator, - "csv": _csv_validator, - "yn": _yn_validator, - "choice": lambda opt, name, value: _choice_validator(opt["choices"], name, value), - "multiple_choice": lambda opt, name, value: _multiple_choice_validator( - opt["choices"], name, value - ), - "non_empty_string": _non_empty_string_validator, -} - - -def _call_validator(opttype, optdict, option, value): - if opttype not in VALIDATORS: - raise Exception('Unsupported type "%s"' % opttype) - try: - return VALIDATORS[opttype](optdict, option, value) - except TypeError: - try: - return VALIDATORS[opttype](value) - except Exception: - raise optparse.OptionValueError( - "%s value (%r) should be of type %s" % (option, value, opttype) - ) - - -def _validate(value, optdict, name=""): - """return a validated value for an option according to its type - - optional argument name is only used for error message formatting - """ - try: - _type = optdict["type"] - except KeyError: - return value - return _call_validator(_type, optdict, name, value) - - -def _level_options(group, outputlevel): - return [ - option - for option in group.option_list - if (getattr(option, "level", 0) or 0) <= outputlevel - and option.help is not optparse.SUPPRESS_HELP - ] - - -def _expand_default(self, option): - """Patch OptionParser.expand_default with custom behaviour - - This will handle defaults to avoid overriding values in the - configuration file. - """ - if self.parser is None or not self.default_tag: - return option.help - optname = option._long_opts[0][2:] - try: - provider = self.parser.options_manager._all_options[optname] - except KeyError: - value = None - else: - optdict = provider.get_option_def(optname) - optname = provider.option_attrname(optname, optdict) - value = getattr(provider.config, optname, optdict) - value = utils._format_option_value(optdict, value) - if value is optparse.NO_DEFAULT or not value: - value = self.NO_DEFAULT_VALUE - return option.help.replace(self.default_tag, str(value)) - - -@contextlib.contextmanager -def _patch_optparse(): - orig_default = optparse.HelpFormatter - try: - optparse.HelpFormatter.expand_default = _expand_default - yield - finally: - optparse.HelpFormatter.expand_default = orig_default - - -def _multiple_choices_validating_option(opt, name, value): - return _multiple_choice_validator(opt.choices, name, value) - - -# pylint: disable=no-member -class Option(optparse.Option): - TYPES = optparse.Option.TYPES + ( - "regexp", - "regexp_csv", - "csv", - "yn", - "multiple_choice", - "non_empty_string", - ) - ATTRS = optparse.Option.ATTRS + ["hide", "level"] - TYPE_CHECKER = copy.copy(optparse.Option.TYPE_CHECKER) - TYPE_CHECKER["regexp"] = _regexp_validator - TYPE_CHECKER["regexp_csv"] = _regexp_csv_validator - TYPE_CHECKER["csv"] = _csv_validator - TYPE_CHECKER["yn"] = _yn_validator - TYPE_CHECKER["multiple_choice"] = _multiple_choices_validating_option - TYPE_CHECKER["non_empty_string"] = _non_empty_string_validator - - def __init__(self, *opts, **attrs): - optparse.Option.__init__(self, *opts, **attrs) - if hasattr(self, "hide") and self.hide: - self.help = optparse.SUPPRESS_HELP - - def _check_choice(self): - if self.type in ("choice", "multiple_choice"): - if self.choices is None: - raise optparse.OptionError( - "must supply a list of choices for type 'choice'", self - ) - if not isinstance(self.choices, (tuple, list)): - raise optparse.OptionError( - "choices must be a list of strings ('%s' supplied)" - % str(type(self.choices)).split("'")[1], - self, - ) - elif self.choices is not None: - raise optparse.OptionError( - "must not supply choices for type %r" % self.type, self - ) - - # pylint: disable=unsupported-assignment-operation - optparse.Option.CHECK_METHODS[2] = _check_choice # type: ignore - - def process(self, opt, value, values, parser): - # First, convert the value(s) to the right type. Howl if any - # value(s) are bogus. - value = self.convert_value(opt, value) - if self.type == "named": - existent = getattr(values, self.dest) - if existent: - existent.update(value) - value = existent - # And then take whatever action is expected of us. - # This is a separate method to make life easier for - # subclasses to add new actions. - return self.take_action(self.action, self.dest, opt, value, values, parser) - - -class OptionParser(optparse.OptionParser): - def __init__(self, option_class, *args, **kwargs): - optparse.OptionParser.__init__(self, option_class=Option, *args, **kwargs) - - def format_option_help(self, formatter=None): - if formatter is None: - formatter = self.formatter - outputlevel = getattr(formatter, "output_level", 0) - formatter.store_option_strings(self) - result = [] - result.append(formatter.format_heading("Options")) - formatter.indent() - if self.option_list: - result.append(optparse.OptionContainer.format_option_help(self, formatter)) - result.append("\n") - for group in self.option_groups: - if group.level <= outputlevel and ( - group.description or _level_options(group, outputlevel) - ): - result.append(group.format_help(formatter)) - result.append("\n") - formatter.dedent() - # Drop the last "\n", or the header if no options or option groups: - return "".join(result[:-1]) - - def _match_long_opt(self, opt): - """Disable abbreviations.""" - if opt not in self._long_opt: - raise optparse.BadOptionError(opt) - return opt - - -# pylint: disable=abstract-method; by design? -class _ManHelpFormatter(optparse.HelpFormatter): - def __init__( - self, indent_increment=0, max_help_position=24, width=79, short_first=0 - ): - optparse.HelpFormatter.__init__( - self, indent_increment, max_help_position, width, short_first - ) - - def format_heading(self, heading): - return ".SH %s\n" % heading.upper() - - def format_description(self, description): - return description - - def format_option(self, option): - try: - optstring = option.option_strings - except AttributeError: - optstring = self.format_option_strings(option) - if option.help: - help_text = self.expand_default(option) - help_string = " ".join([l.strip() for l in help_text.splitlines()]) - help_string = help_string.replace("\\", "\\\\") - help_string = help_string.replace("[current:", "[default:") - else: - help_string = "" - return """.IP "%s" -%s -""" % ( - optstring, - help_string, - ) - - def format_head(self, optparser, pkginfo, section=1): - long_desc = "" - try: - pgm = optparser._get_prog_name() - except AttributeError: - # py >= 2.4.X (dunno which X exactly, at least 2) - pgm = optparser.get_prog_name() - short_desc = self.format_short_description(pgm, pkginfo.description) - if hasattr(pkginfo, "long_desc"): - long_desc = self.format_long_description(pgm, pkginfo.long_desc) - return "%s\n%s\n%s\n%s" % ( - self.format_title(pgm, section), - short_desc, - self.format_synopsis(pgm), - long_desc, - ) - - @staticmethod - def format_title(pgm, section): - date = "%d-%02d-%02d" % time.localtime()[:3] - return '.TH %s %s "%s" %s' % (pgm, section, date, pgm) - - @staticmethod - def format_short_description(pgm, short_desc): - return """.SH NAME -.B %s -\\- %s -""" % ( - pgm, - short_desc.strip(), - ) - - @staticmethod - def format_synopsis(pgm): - return ( - """.SH SYNOPSIS -.B %s -[ -.I OPTIONS -] [ -.I <arguments> -] -""" - % pgm - ) - - @staticmethod - def format_long_description(pgm, long_desc): - long_desc = "\n".join(line.lstrip() for line in long_desc.splitlines()) - long_desc = long_desc.replace("\n.\n", "\n\n") - if long_desc.lower().startswith(pgm): - long_desc = long_desc[len(pgm) :] - return """.SH DESCRIPTION -.B %s -%s -""" % ( - pgm, - long_desc.strip(), - ) - - @staticmethod - def format_tail(pkginfo): - tail = """.SH SEE ALSO -/usr/share/doc/pythonX.Y-%s/ - -.SH BUGS -Please report bugs on the project\'s mailing list: -%s - -.SH AUTHOR -%s <%s> -""" % ( - getattr(pkginfo, "debian_name", pkginfo.modname), - pkginfo.mailinglist, - pkginfo.author, - pkginfo.author_email, - ) - - if hasattr(pkginfo, "copyright"): - tail += ( - """ -.SH COPYRIGHT -%s -""" - % pkginfo.copyright - ) - - return tail - - -class OptionsManagerMixIn: - """Handle configuration from both a configuration file and command line options""" - - def __init__(self, usage, config_file=None, version=None): - self.config_file = config_file - self.reset_parsers(usage, version=version) - # list of registered options providers - self.options_providers = [] - # dictionary associating option name to checker - self._all_options = collections.OrderedDict() - self._short_options = {} - self._nocallback_options = {} - self._mygroups = {} - # verbosity - self._maxlevel = 0 - - def reset_parsers(self, usage="", version=None): - # configuration file parser - self.cfgfile_parser = configparser.ConfigParser( - inline_comment_prefixes=("#", ";") - ) - # command line parser - self.cmdline_parser = OptionParser(Option, usage=usage, version=version) - self.cmdline_parser.options_manager = self - self._optik_option_attrs = set(self.cmdline_parser.option_class.ATTRS) - - def register_options_provider(self, provider, own_group=True): - """register an options provider""" - assert provider.priority <= 0, "provider's priority can't be >= 0" - for i in range(len(self.options_providers)): - if provider.priority > self.options_providers[i].priority: - self.options_providers.insert(i, provider) - break - else: - self.options_providers.append(provider) - non_group_spec_options = [ - option for option in provider.options if "group" not in option[1] - ] - groups = getattr(provider, "option_groups", ()) - if own_group and non_group_spec_options: - self.add_option_group( - provider.name.upper(), - provider.__doc__, - non_group_spec_options, - provider, - ) - else: - for opt, optdict in non_group_spec_options: - self.add_optik_option(provider, self.cmdline_parser, opt, optdict) - for gname, gdoc in groups: - gname = gname.upper() - goptions = [ - option - for option in provider.options - if option[1].get("group", "").upper() == gname - ] - self.add_option_group(gname, gdoc, goptions, provider) - - def add_option_group(self, group_name, _, options, provider): - # add option group to the command line parser - if group_name in self._mygroups: - group = self._mygroups[group_name] - else: - group = optparse.OptionGroup( - self.cmdline_parser, title=group_name.capitalize() - ) - self.cmdline_parser.add_option_group(group) - group.level = provider.level - self._mygroups[group_name] = group - # add section to the config file - if ( - group_name != "DEFAULT" - and group_name not in self.cfgfile_parser._sections - ): - self.cfgfile_parser.add_section(group_name) - # add provider's specific options - for opt, optdict in options: - self.add_optik_option(provider, group, opt, optdict) - - def add_optik_option(self, provider, optikcontainer, opt, optdict): - args, optdict = self.optik_option(provider, opt, optdict) - option = optikcontainer.add_option(*args, **optdict) - self._all_options[opt] = provider - self._maxlevel = max(self._maxlevel, option.level or 0) - - def optik_option(self, provider, opt, optdict): - """get our personal option definition and return a suitable form for - use with optik/optparse - """ - optdict = copy.copy(optdict) - if "action" in optdict: - self._nocallback_options[provider] = opt - else: - optdict["action"] = "callback" - optdict["callback"] = self.cb_set_provider_option - # default is handled here and *must not* be given to optik if you - # want the whole machinery to work - if "default" in optdict: - if ( - "help" in optdict - and optdict.get("default") is not None - and optdict["action"] not in ("store_true", "store_false") - ): - optdict["help"] += " [current: %default]" - del optdict["default"] - args = ["--" + str(opt)] - if "short" in optdict: - self._short_options[optdict["short"]] = opt - args.append("-" + optdict["short"]) - del optdict["short"] - # cleanup option definition dict before giving it to optik - for key in list(optdict.keys()): - if key not in self._optik_option_attrs: - optdict.pop(key) - return args, optdict - - def cb_set_provider_option(self, option, opt, value, parser): - """optik callback for option setting""" - if opt.startswith("--"): - # remove -- on long option - opt = opt[2:] - else: - # short option, get its long equivalent - opt = self._short_options[opt[1:]] - # trick since we can't set action='store_true' on options - if value is None: - value = 1 - self.global_set_option(opt, value) - - def global_set_option(self, opt, value): - """set option on the correct option provider""" - self._all_options[opt].set_option(opt, value) - - def generate_config(self, stream=None, skipsections=(), encoding=None): - """write a configuration file according to the current configuration - into the given stream or stdout - """ - options_by_section = {} - sections = [] - for provider in self.options_providers: - for section, options in provider.options_by_section(): - if section is None: - section = provider.name - if section in skipsections: - continue - options = [ - (n, d, v) - for (n, d, v) in options - if d.get("type") is not None and not d.get("deprecated") - ] - if not options: - continue - if section not in sections: - sections.append(section) - alloptions = options_by_section.setdefault(section, []) - alloptions += options - stream = stream or sys.stdout - printed = False - for section in sections: - if printed: - print("\n", file=stream) - utils.format_section( - stream, section.upper(), sorted(options_by_section[section]) - ) - printed = True - - def generate_manpage(self, pkginfo, section=1, stream=None): - with _patch_optparse(): - _generate_manpage( - self.cmdline_parser, - pkginfo, - section, - stream=stream or sys.stdout, - level=self._maxlevel, - ) - - def load_provider_defaults(self): - """initialize configuration using default values""" - for provider in self.options_providers: - provider.load_defaults() - - def read_config_file(self, config_file=None, verbose=None): - """read the configuration file but do not load it (i.e. dispatching - values to each options provider) - """ - helplevel = 1 - while helplevel <= self._maxlevel: - opt = "-".join(["long"] * helplevel) + "-help" - if opt in self._all_options: - break # already processed - # pylint: disable=unused-argument - def helpfunc(option, opt, val, p, level=helplevel): - print(self.help(level)) - sys.exit(0) - - helpmsg = "%s verbose help." % " ".join(["more"] * helplevel) - optdict = {"action": "callback", "callback": helpfunc, "help": helpmsg} - provider = self.options_providers[0] - self.add_optik_option(provider, self.cmdline_parser, opt, optdict) - provider.options += ((opt, optdict),) - helplevel += 1 - if config_file is None: - config_file = self.config_file - if config_file is not None: - config_file = os.path.expanduser(config_file) - if not os.path.exists(config_file): - raise IOError("The config file {:s} doesn't exist!".format(config_file)) - - use_config_file = config_file and os.path.exists(config_file) - if use_config_file: - parser = self.cfgfile_parser - - # Use this encoding in order to strip the BOM marker, if any. - with io.open(config_file, "r", encoding="utf_8_sig") as fp: - parser.read_file(fp) - - # normalize sections'title - for sect, values in list(parser._sections.items()): - if not sect.isupper() and values: - parser._sections[sect.upper()] = values - - if not verbose: - return - - if use_config_file: - msg = "Using config file {}".format(os.path.abspath(config_file)) - else: - msg = "No config file found, using default configuration" - print(msg, file=sys.stderr) - - def load_config_file(self): - """dispatch values previously read from a configuration file to each - options provider) - """ - parser = self.cfgfile_parser - for section in parser.sections(): - for option, value in parser.items(section): - try: - self.global_set_option(option, value) - except (KeyError, optparse.OptionError): - continue - - def load_configuration(self, **kwargs): - """override configuration according to given parameters""" - return self.load_configuration_from_config(kwargs) - - def load_configuration_from_config(self, config): - for opt, opt_value in config.items(): - opt = opt.replace("_", "-") - provider = self._all_options[opt] - provider.set_option(opt, opt_value) - - def load_command_line_configuration(self, args=None): - """Override configuration according to command line parameters - - return additional arguments - """ - with _patch_optparse(): - if args is None: - args = sys.argv[1:] - else: - args = list(args) - (options, args) = self.cmdline_parser.parse_args(args=args) - for provider in self._nocallback_options: - config = provider.config - for attr in config.__dict__.keys(): - value = getattr(options, attr, None) - if value is None: - continue - setattr(config, attr, value) - return args - - def add_help_section(self, title, description, level=0): - """add a dummy option section for help purpose """ - group = optparse.OptionGroup( - self.cmdline_parser, title=title.capitalize(), description=description - ) - group.level = level - self._maxlevel = max(self._maxlevel, level) - self.cmdline_parser.add_option_group(group) - - def help(self, level=0): - """return the usage string for available options """ - self.cmdline_parser.formatter.output_level = level - with _patch_optparse(): - return self.cmdline_parser.format_help() - - -class OptionsProviderMixIn: - """Mixin to provide options to an OptionsManager""" - - # those attributes should be overridden - priority = -1 - name = "default" - options = () # type: Tuple[Tuple[str, Dict[str, Any]], ...] - level = 0 - - def __init__(self): - self.config = optparse.Values() - self.load_defaults() - - def load_defaults(self): - """initialize the provider using default values""" - for opt, optdict in self.options: - action = optdict.get("action") - if action != "callback": - # callback action have no default - if optdict is None: - optdict = self.get_option_def(opt) - default = optdict.get("default") - self.set_option(opt, default, action, optdict) - - def option_attrname(self, opt, optdict=None): - """get the config attribute corresponding to opt""" - if optdict is None: - optdict = self.get_option_def(opt) - return optdict.get("dest", opt.replace("-", "_")) - - def option_value(self, opt): - """get the current value for the given option""" - return getattr(self.config, self.option_attrname(opt), None) - - def set_option(self, optname, value, action=None, optdict=None): - """method called to set an option (registered in the options list)""" - if optdict is None: - optdict = self.get_option_def(optname) - if value is not None: - value = _validate(value, optdict, optname) - if action is None: - action = optdict.get("action", "store") - if action == "store": - setattr(self.config, self.option_attrname(optname, optdict), value) - elif action in ("store_true", "count"): - setattr(self.config, self.option_attrname(optname, optdict), 0) - elif action == "store_false": - setattr(self.config, self.option_attrname(optname, optdict), 1) - elif action == "append": - optname = self.option_attrname(optname, optdict) - _list = getattr(self.config, optname, None) - if _list is None: - if isinstance(value, (list, tuple)): - _list = value - elif value is not None: - _list = [] - _list.append(value) - setattr(self.config, optname, _list) - elif isinstance(_list, tuple): - setattr(self.config, optname, _list + (value,)) - else: - _list.append(value) - elif action == "callback": - optdict["callback"](None, optname, value, None) - else: - raise UnsupportedAction(action) - - def get_option_def(self, opt): - """return the dictionary defining an option given its name""" - assert self.options - for option in self.options: - if option[0] == opt: - return option[1] - raise optparse.OptionError( - "no such option %s in section %r" % (opt, self.name), opt - ) - - def options_by_section(self): - """return an iterator on options grouped by section - - (section, [list of (optname, optdict, optvalue)]) - """ - sections = {} - for optname, optdict in self.options: - sections.setdefault(optdict.get("group"), []).append( - (optname, optdict, self.option_value(optname)) - ) - if None in sections: - yield None, sections.pop(None) - for section, options in sorted(sections.items()): - yield section.upper(), options - - def options_and_values(self, options=None): - if options is None: - options = self.options - for optname, optdict in options: - yield (optname, optdict, self.option_value(optname)) - - -class ConfigurationMixIn(OptionsManagerMixIn, OptionsProviderMixIn): - """basic mixin for simple configurations which don't need the - manager / providers model - """ - - def __init__(self, *args, **kwargs): - if not args: - kwargs.setdefault("usage", "") - OptionsManagerMixIn.__init__(self, *args, **kwargs) - OptionsProviderMixIn.__init__(self) - if not getattr(self, "option_groups", None): - self.option_groups = [] - for _, optdict in self.options: - try: - gdef = (optdict["group"].upper(), "") - except KeyError: - continue - if gdef not in self.option_groups: - self.option_groups.append(gdef) - self.register_options_provider(self, own_group=False) - - -def _generate_manpage(optparser, pkginfo, section=1, stream=sys.stdout, level=0): - formatter = _ManHelpFormatter() - formatter.output_level = level - formatter.parser = optparser - print(formatter.format_head(optparser, pkginfo, section), file=stream) - print(optparser.format_option_help(formatter), file=stream) - print(formatter.format_tail(pkginfo), file=stream) |