fname stringlengths 63 176 | rel_fname stringclasses 706
values | line int64 -1 4.5k | name stringlengths 1 81 | kind stringclasses 2
values | category stringclasses 2
values | info stringlengths 0 77.9k ⌀ |
|---|---|---|---|---|---|---|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 48 | _patch_optparse | def | function | def _patch_optparse():
# pylint: disable = redefined-variable-type
orig_default = optparse.HelpFormatter
try:
optparse.HelpFormatter.expand_default = _expand_default
yield
finally:
optparse.HelpFormatter.expand_default = orig_default
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 58 | OptionsManagerMixIn | def | class | __init__ reset_parsers register_options_provider add_option_group add_optik_option optik_option cb_set_provider_option global_set_option generate_config generate_manpage load_provider_defaults read_config_file _parse_toml load_config_file load_configuration load_configuration_from_config load_command_line_configuration add_help_section help helpfunc |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 63 | reset_parsers | ref | function | self.reset_parsers(usage)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 74 | reset_parsers | def | function | def reset_parsers(self, usage=""):
# configuration file parser
self.cfgfile_parser = configparser.ConfigParser(
inline_comment_prefixes=("#", ";")
)
# command line parser
self.cmdline_parser = OptionParser(Option, usage=usage)
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, options_provider in enumerate(self.options_providers):
if provider.priority > options_provider.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: Optional[TextIO] = None, skipsections: Tuple[str, ...] = ()
) -> None:
"""Write a configuration file according to the current configuration
into the given stream or stdout
"""
options_by_section: Dict[str, List[Tuple]] = {}
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)
all_options = options_by_section.setdefault(section, [])
all_options += 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: ModuleType, section: int = 1, stream: TextIO = sys.stdout
) -> None:
with _patch_optparse():
formatter = _ManHelpFormatter()
formatter.output_level = self._maxlevel
formatter.parser = self.cmdline_parser
print(
formatter.format_head(self.cmdline_parser, pkginfo, section),
file=stream,
)
print(self.cmdline_parser.format_option_help(formatter), file=stream)
print(formatter.format_tail(pkginfo), file=stream)
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 option's provider)
"""
for help_level in range(1, self._maxlevel + 1):
opt = "-".join(["long"] * help_level) + "-help"
if opt in self._all_options:
break # already processed
help_function = functools.partial(self.helpfunc, level=help_level)
help_msg = f"{' '.join(['more'] * help_level)} verbose help."
optdict = {
"action": "callback",
"callback": help_function,
"help": help_msg,
}
provider = self.options_providers[0]
self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
provider.options += ((opt, optdict),)
if config_file is None:
config_file = self.config_file
if config_file is not None:
config_file = os.path.expandvars(os.path.expanduser(config_file))
if not os.path.exists(config_file):
raise OSError(f"The config file {config_file} doesn't exist!")
use_config_file = config_file and os.path.exists(config_file)
if use_config_file:
self.set_current_module(config_file)
parser = self.cfgfile_parser
if config_file.endswith(".toml"):
try:
self._parse_toml(config_file, parser)
except toml.TomlDecodeError as e:
self.add_message("config-parse-error", line=0, args=str(e))
else:
# Use this encoding in order to strip the BOM marker, if any.
with open(config_file, encoding="utf_8_sig") as fp:
parser.read_file(fp)
# normalize each section's title
for sect, values in list(parser._sections.items()):
if sect.startswith("pylint."):
sect = sect[len("pylint.") :]
if not sect.isupper() and values:
parser._sections[sect.upper()] = values
if not verbose:
return
if use_config_file:
msg = f"Using config file {os.path.abspath(config_file)}"
else:
msg = "No config file found, using default configuration"
print(msg, file=sys.stderr)
def _parse_toml(
self, config_file: Union[Path, str], parser: configparser.ConfigParser
) -> None:
"""Parse and handle errors of a toml configuration file."""
with open(config_file, encoding="utf-8") as fp:
content = toml.load(fp)
try:
sections_values = content["tool"]["pylint"]
except KeyError:
return
for section, values in sections_values.items():
section_name = section.upper()
# TOML has rich types, convert values to
# strings as ConfigParser expects.
if not isinstance(values, dict):
# This class is a mixin: add_message comes from the `PyLinter` class
self.add_message( # type: ignore[attr-defined]
"bad-configuration-section", line=0, args=(section, values)
)
continue
for option, value in values.items():
if isinstance(value, bool):
values[option] = "yes" if value else "no"
elif isinstance(value, list):
values[option] = ",".join(value)
else:
values[option] = str(value)
for option, value in values.items():
try:
parser.set(section_name, option, value=value)
except configparser.NoSectionError:
parser.add_section(section_name)
parser.set(section_name, option, value=value)
def load_config_file(self):
"""Dispatch values previously read from a configuration file to each
option's 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 84 | register_options_provider | def | function | null |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 98 | add_option_group | ref | function | self.add_option_group(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 106 | add_optik_option | ref | function | self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 114 | add_option_group | ref | function | self.add_option_group(gname, gdoc, goptions, provider)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 116 | add_option_group | def | function | 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: Optional[TextIO] = None, skipsections: Tuple[str, ...] = ()
) -> None:
"""Write a configuration file according to the current configuration
into the given stream or stdout
"""
options_by_section: Dict[str, List[Tuple]] = {}
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)
all_options = options_by_section.setdefault(section, [])
all_options += 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: ModuleType, section: int = 1, stream: TextIO = sys.stdout
) -> None:
with _patch_optparse():
formatter = _ManHelpFormatter()
formatter.output_level = self._maxlevel
formatter.parser = self.cmdline_parser
print(
formatter.format_head(self.cmdline_parser, pkginfo, section),
file=stream,
)
print(self.cmdline_parser.format_option_help(formatter), file=stream)
print(formatter.format_tail(pkginfo), file=stream)
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 option's provider)
"""
for help_level in range(1, self._maxlevel + 1):
opt = "-".join(["long"] * help_level) + "-help"
if opt in self._all_options:
break # already processed
help_function = functools.partial(self.helpfunc, level=help_level)
help_msg = f"{' '.join(['more'] * help_level)} verbose help."
optdict = {
"action": "callback",
"callback": help_function,
"help": help_msg,
}
provider = self.options_providers[0]
self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
provider.options += ((opt, optdict),)
if config_file is None:
config_file = self.config_file
if config_file is not None:
config_file = os.path.expandvars(os.path.expanduser(config_file))
if not os.path.exists(config_file):
raise OSError(f"The config file {config_file} doesn't exist!")
use_config_file = config_file and os.path.exists(config_file)
if use_config_file:
self.set_current_module(config_file)
parser = self.cfgfile_parser
if config_file.endswith(".toml"):
try:
self._parse_toml(config_file, parser)
except toml.TomlDecodeError as e:
self.add_message("config-parse-error", line=0, args=str(e))
else:
# Use this encoding in order to strip the BOM marker, if any.
with open(config_file, encoding="utf_8_sig") as fp:
parser.read_file(fp)
# normalize each section's title
for sect, values in list(parser._sections.items()):
if sect.startswith("pylint."):
sect = sect[len("pylint.") :]
if not sect.isupper() and values:
parser._sections[sect.upper()] = values
if not verbose:
return
if use_config_file:
msg = f"Using config file {os.path.abspath(config_file)}"
else:
msg = "No config file found, using default configuration"
print(msg, file=sys.stderr)
def _parse_toml(
self, config_file: Union[Path, str], parser: configparser.ConfigParser
) -> None:
"""Parse and handle errors of a toml configuration file."""
with open(config_file, encoding="utf-8") as fp:
content = toml.load(fp)
try:
sections_values = content["tool"]["pylint"]
except KeyError:
return
for section, values in sections_values.items():
section_name = section.upper()
# TOML has rich types, convert values to
# strings as ConfigParser expects.
if not isinstance(values, dict):
# This class is a mixin: add_message comes from the `PyLinter` class
self.add_message( # type: ignore[attr-defined]
"bad-configuration-section", line=0, args=(section, values)
)
continue
for option, value in values.items():
if isinstance(value, bool):
values[option] = "yes" if value else "no"
elif isinstance(value, list):
values[option] = ",".join(value)
else:
values[option] = str(value)
for option, value in values.items():
try:
parser.set(section_name, option, value=value)
except configparser.NoSectionError:
parser.add_section(section_name)
parser.set(section_name, option, value=value)
def load_config_file(self):
"""Dispatch values previously read from a configuration file to each
option's 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 124 | add_option_group | ref | function | self.cmdline_parser.add_option_group(group)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 132 | add_section | ref | function | self.cfgfile_parser.add_section(group_name)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 135 | add_optik_option | ref | function | self.add_optik_option(provider, group, opt, optdict)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 137 | add_optik_option | def | function | 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: Optional[TextIO] = None, skipsections: Tuple[str, ...] = ()
) -> None:
"""Write a configuration file according to the current configuration
into the given stream or stdout
"""
options_by_section: Dict[str, List[Tuple]] = {}
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)
all_options = options_by_section.setdefault(section, [])
all_options += 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: ModuleType, section: int = 1, stream: TextIO = sys.stdout
) -> None:
with _patch_optparse():
formatter = _ManHelpFormatter()
formatter.output_level = self._maxlevel
formatter.parser = self.cmdline_parser
print(
formatter.format_head(self.cmdline_parser, pkginfo, section),
file=stream,
)
print(self.cmdline_parser.format_option_help(formatter), file=stream)
print(formatter.format_tail(pkginfo), file=stream)
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 option's provider)
"""
for help_level in range(1, self._maxlevel + 1):
opt = "-".join(["long"] * help_level) + "-help"
if opt in self._all_options:
break # already processed
help_function = functools.partial(self.helpfunc, level=help_level)
help_msg = f"{' '.join(['more'] * help_level)} verbose help."
optdict = {
"action": "callback",
"callback": help_function,
"help": help_msg,
}
provider = self.options_providers[0]
self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
provider.options += ((opt, optdict),)
if config_file is None:
config_file = self.config_file
if config_file is not None:
config_file = os.path.expandvars(os.path.expanduser(config_file))
if not os.path.exists(config_file):
raise OSError(f"The config file {config_file} doesn't exist!")
use_config_file = config_file and os.path.exists(config_file)
if use_config_file:
self.set_current_module(config_file)
parser = self.cfgfile_parser
if config_file.endswith(".toml"):
try:
self._parse_toml(config_file, parser)
except toml.TomlDecodeError as e:
self.add_message("config-parse-error", line=0, args=str(e))
else:
# Use this encoding in order to strip the BOM marker, if any.
with open(config_file, encoding="utf_8_sig") as fp:
parser.read_file(fp)
# normalize each section's title
for sect, values in list(parser._sections.items()):
if sect.startswith("pylint."):
sect = sect[len("pylint.") :]
if not sect.isupper() and values:
parser._sections[sect.upper()] = values
if not verbose:
return
if use_config_file:
msg = f"Using config file {os.path.abspath(config_file)}"
else:
msg = "No config file found, using default configuration"
print(msg, file=sys.stderr)
def _parse_toml(
self, config_file: Union[Path, str], parser: configparser.ConfigParser
) -> None:
"""Parse and handle errors of a toml configuration file."""
with open(config_file, encoding="utf-8") as fp:
content = toml.load(fp)
try:
sections_values = content["tool"]["pylint"]
except KeyError:
return
for section, values in sections_values.items():
section_name = section.upper()
# TOML has rich types, convert values to
# strings as ConfigParser expects.
if not isinstance(values, dict):
# This class is a mixin: add_message comes from the `PyLinter` class
self.add_message( # type: ignore[attr-defined]
"bad-configuration-section", line=0, args=(section, values)
)
continue
for option, value in values.items():
if isinstance(value, bool):
values[option] = "yes" if value else "no"
elif isinstance(value, list):
values[option] = ",".join(value)
else:
values[option] = str(value)
for option, value in values.items():
try:
parser.set(section_name, option, value=value)
except configparser.NoSectionError:
parser.add_section(section_name)
parser.set(section_name, option, value=value)
def load_config_file(self):
"""Dispatch values previously read from a configuration file to each
option's 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 138 | optik_option | ref | function | args, optdict = self.optik_option(provider, opt, optdict)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 139 | add_option | ref | function | option = optikcontainer.add_option(*args, **optdict)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 143 | optik_option | def | function | 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: Optional[TextIO] = None, skipsections: Tuple[str, ...] = ()
) -> None:
"""Write a configuration file according to the current configuration
into the given stream or stdout
"""
options_by_section: Dict[str, List[Tuple]] = {}
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)
all_options = options_by_section.setdefault(section, [])
all_options += 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: ModuleType, section: int = 1, stream: TextIO = sys.stdout
) -> None:
with _patch_optparse():
formatter = _ManHelpFormatter()
formatter.output_level = self._maxlevel
formatter.parser = self.cmdline_parser
print(
formatter.format_head(self.cmdline_parser, pkginfo, section),
file=stream,
)
print(self.cmdline_parser.format_option_help(formatter), file=stream)
print(formatter.format_tail(pkginfo), file=stream)
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 option's provider)
"""
for help_level in range(1, self._maxlevel + 1):
opt = "-".join(["long"] * help_level) + "-help"
if opt in self._all_options:
break # already processed
help_function = functools.partial(self.helpfunc, level=help_level)
help_msg = f"{' '.join(['more'] * help_level)} verbose help."
optdict = {
"action": "callback",
"callback": help_function,
"help": help_msg,
}
provider = self.options_providers[0]
self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
provider.options += ((opt, optdict),)
if config_file is None:
config_file = self.config_file
if config_file is not None:
config_file = os.path.expandvars(os.path.expanduser(config_file))
if not os.path.exists(config_file):
raise OSError(f"The config file {config_file} doesn't exist!")
use_config_file = config_file and os.path.exists(config_file)
if use_config_file:
self.set_current_module(config_file)
parser = self.cfgfile_parser
if config_file.endswith(".toml"):
try:
self._parse_toml(config_file, parser)
except toml.TomlDecodeError as e:
self.add_message("config-parse-error", line=0, args=str(e))
else:
# Use this encoding in order to strip the BOM marker, if any.
with open(config_file, encoding="utf_8_sig") as fp:
parser.read_file(fp)
# normalize each section's title
for sect, values in list(parser._sections.items()):
if sect.startswith("pylint."):
sect = sect[len("pylint.") :]
if not sect.isupper() and values:
parser._sections[sect.upper()] = values
if not verbose:
return
if use_config_file:
msg = f"Using config file {os.path.abspath(config_file)}"
else:
msg = "No config file found, using default configuration"
print(msg, file=sys.stderr)
def _parse_toml(
self, config_file: Union[Path, str], parser: configparser.ConfigParser
) -> None:
"""Parse and handle errors of a toml configuration file."""
with open(config_file, encoding="utf-8") as fp:
content = toml.load(fp)
try:
sections_values = content["tool"]["pylint"]
except KeyError:
return
for section, values in sections_values.items():
section_name = section.upper()
# TOML has rich types, convert values to
# strings as ConfigParser expects.
if not isinstance(values, dict):
# This class is a mixin: add_message comes from the `PyLinter` class
self.add_message( # type: ignore[attr-defined]
"bad-configuration-section", line=0, args=(section, values)
)
continue
for option, value in values.items():
if isinstance(value, bool):
values[option] = "yes" if value else "no"
elif isinstance(value, list):
values[option] = ",".join(value)
else:
values[option] = str(value)
for option, value in values.items():
try:
parser.set(section_name, option, value=value)
except configparser.NoSectionError:
parser.add_section(section_name)
parser.set(section_name, option, value=value)
def load_config_file(self):
"""Dispatch values previously read from a configuration file to each
option's 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 174 | cb_set_provider_option | def | function | 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: Optional[TextIO] = None, skipsections: Tuple[str, ...] = ()
) -> None:
"""Write a configuration file according to the current configuration
into the given stream or stdout
"""
options_by_section: Dict[str, List[Tuple]] = {}
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)
all_options = options_by_section.setdefault(section, [])
all_options += 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: ModuleType, section: int = 1, stream: TextIO = sys.stdout
) -> None:
with _patch_optparse():
formatter = _ManHelpFormatter()
formatter.output_level = self._maxlevel
formatter.parser = self.cmdline_parser
print(
formatter.format_head(self.cmdline_parser, pkginfo, section),
file=stream,
)
print(self.cmdline_parser.format_option_help(formatter), file=stream)
print(formatter.format_tail(pkginfo), file=stream)
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 option's provider)
"""
for help_level in range(1, self._maxlevel + 1):
opt = "-".join(["long"] * help_level) + "-help"
if opt in self._all_options:
break # already processed
help_function = functools.partial(self.helpfunc, level=help_level)
help_msg = f"{' '.join(['more'] * help_level)} verbose help."
optdict = {
"action": "callback",
"callback": help_function,
"help": help_msg,
}
provider = self.options_providers[0]
self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
provider.options += ((opt, optdict),)
if config_file is None:
config_file = self.config_file
if config_file is not None:
config_file = os.path.expandvars(os.path.expanduser(config_file))
if not os.path.exists(config_file):
raise OSError(f"The config file {config_file} doesn't exist!")
use_config_file = config_file and os.path.exists(config_file)
if use_config_file:
self.set_current_module(config_file)
parser = self.cfgfile_parser
if config_file.endswith(".toml"):
try:
self._parse_toml(config_file, parser)
except toml.TomlDecodeError as e:
self.add_message("config-parse-error", line=0, args=str(e))
else:
# Use this encoding in order to strip the BOM marker, if any.
with open(config_file, encoding="utf_8_sig") as fp:
parser.read_file(fp)
# normalize each section's title
for sect, values in list(parser._sections.items()):
if sect.startswith("pylint."):
sect = sect[len("pylint.") :]
if not sect.isupper() and values:
parser._sections[sect.upper()] = values
if not verbose:
return
if use_config_file:
msg = f"Using config file {os.path.abspath(config_file)}"
else:
msg = "No config file found, using default configuration"
print(msg, file=sys.stderr)
def _parse_toml(
self, config_file: Union[Path, str], parser: configparser.ConfigParser
) -> None:
"""Parse and handle errors of a toml configuration file."""
with open(config_file, encoding="utf-8") as fp:
content = toml.load(fp)
try:
sections_values = content["tool"]["pylint"]
except KeyError:
return
for section, values in sections_values.items():
section_name = section.upper()
# TOML has rich types, convert values to
# strings as ConfigParser expects.
if not isinstance(values, dict):
# This class is a mixin: add_message comes from the `PyLinter` class
self.add_message( # type: ignore[attr-defined]
"bad-configuration-section", line=0, args=(section, values)
)
continue
for option, value in values.items():
if isinstance(value, bool):
values[option] = "yes" if value else "no"
elif isinstance(value, list):
values[option] = ",".join(value)
else:
values[option] = str(value)
for option, value in values.items():
try:
parser.set(section_name, option, value=value)
except configparser.NoSectionError:
parser.add_section(section_name)
parser.set(section_name, option, value=value)
def load_config_file(self):
"""Dispatch values previously read from a configuration file to each
option's 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 185 | global_set_option | ref | function | self.global_set_option(opt, value)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 187 | global_set_option | def | function | 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: Optional[TextIO] = None, skipsections: Tuple[str, ...] = ()
) -> None:
"""Write a configuration file according to the current configuration
into the given stream or stdout
"""
options_by_section: Dict[str, List[Tuple]] = {}
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)
all_options = options_by_section.setdefault(section, [])
all_options += 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: ModuleType, section: int = 1, stream: TextIO = sys.stdout
) -> None:
with _patch_optparse():
formatter = _ManHelpFormatter()
formatter.output_level = self._maxlevel
formatter.parser = self.cmdline_parser
print(
formatter.format_head(self.cmdline_parser, pkginfo, section),
file=stream,
)
print(self.cmdline_parser.format_option_help(formatter), file=stream)
print(formatter.format_tail(pkginfo), file=stream)
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 option's provider)
"""
for help_level in range(1, self._maxlevel + 1):
opt = "-".join(["long"] * help_level) + "-help"
if opt in self._all_options:
break # already processed
help_function = functools.partial(self.helpfunc, level=help_level)
help_msg = f"{' '.join(['more'] * help_level)} verbose help."
optdict = {
"action": "callback",
"callback": help_function,
"help": help_msg,
}
provider = self.options_providers[0]
self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
provider.options += ((opt, optdict),)
if config_file is None:
config_file = self.config_file
if config_file is not None:
config_file = os.path.expandvars(os.path.expanduser(config_file))
if not os.path.exists(config_file):
raise OSError(f"The config file {config_file} doesn't exist!")
use_config_file = config_file and os.path.exists(config_file)
if use_config_file:
self.set_current_module(config_file)
parser = self.cfgfile_parser
if config_file.endswith(".toml"):
try:
self._parse_toml(config_file, parser)
except toml.TomlDecodeError as e:
self.add_message("config-parse-error", line=0, args=str(e))
else:
# Use this encoding in order to strip the BOM marker, if any.
with open(config_file, encoding="utf_8_sig") as fp:
parser.read_file(fp)
# normalize each section's title
for sect, values in list(parser._sections.items()):
if sect.startswith("pylint."):
sect = sect[len("pylint.") :]
if not sect.isupper() and values:
parser._sections[sect.upper()] = values
if not verbose:
return
if use_config_file:
msg = f"Using config file {os.path.abspath(config_file)}"
else:
msg = "No config file found, using default configuration"
print(msg, file=sys.stderr)
def _parse_toml(
self, config_file: Union[Path, str], parser: configparser.ConfigParser
) -> None:
"""Parse and handle errors of a toml configuration file."""
with open(config_file, encoding="utf-8") as fp:
content = toml.load(fp)
try:
sections_values = content["tool"]["pylint"]
except KeyError:
return
for section, values in sections_values.items():
section_name = section.upper()
# TOML has rich types, convert values to
# strings as ConfigParser expects.
if not isinstance(values, dict):
# This class is a mixin: add_message comes from the `PyLinter` class
self.add_message( # type: ignore[attr-defined]
"bad-configuration-section", line=0, args=(section, values)
)
continue
for option, value in values.items():
if isinstance(value, bool):
values[option] = "yes" if value else "no"
elif isinstance(value, list):
values[option] = ",".join(value)
else:
values[option] = str(value)
for option, value in values.items():
try:
parser.set(section_name, option, value=value)
except configparser.NoSectionError:
parser.add_section(section_name)
parser.set(section_name, option, value=value)
def load_config_file(self):
"""Dispatch values previously read from a configuration file to each
option's 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 189 | set_option | ref | function | self._all_options[opt].set_option(opt, value)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 191 | generate_config | def | function | def generate_config(
self, stream: Optional[TextIO] = None, skipsections: Tuple[str, ...] = ()
) -> None:
"""Write a configuration file according to the current configuration
into the given stream or stdout
"""
options_by_section: Dict[str, List[Tuple]] = {}
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)
all_options = options_by_section.setdefault(section, [])
all_options += 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: ModuleType, section: int = 1, stream: TextIO = sys.stdout
) -> None:
with _patch_optparse():
formatter = _ManHelpFormatter()
formatter.output_level = self._maxlevel
formatter.parser = self.cmdline_parser
print(
formatter.format_head(self.cmdline_parser, pkginfo, section),
file=stream,
)
print(self.cmdline_parser.format_option_help(formatter), file=stream)
print(formatter.format_tail(pkginfo), file=stream)
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 option's provider)
"""
for help_level in range(1, self._maxlevel + 1):
opt = "-".join(["long"] * help_level) + "-help"
if opt in self._all_options:
break # already processed
help_function = functools.partial(self.helpfunc, level=help_level)
help_msg = f"{' '.join(['more'] * help_level)} verbose help."
optdict = {
"action": "callback",
"callback": help_function,
"help": help_msg,
}
provider = self.options_providers[0]
self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
provider.options += ((opt, optdict),)
if config_file is None:
config_file = self.config_file
if config_file is not None:
config_file = os.path.expandvars(os.path.expanduser(config_file))
if not os.path.exists(config_file):
raise OSError(f"The config file {config_file} doesn't exist!")
use_config_file = config_file and os.path.exists(config_file)
if use_config_file:
self.set_current_module(config_file)
parser = self.cfgfile_parser
if config_file.endswith(".toml"):
try:
self._parse_toml(config_file, parser)
except toml.TomlDecodeError as e:
self.add_message("config-parse-error", line=0, args=str(e))
else:
# Use this encoding in order to strip the BOM marker, if any.
with open(config_file, encoding="utf_8_sig") as fp:
parser.read_file(fp)
# normalize each section's title
for sect, values in list(parser._sections.items()):
if sect.startswith("pylint."):
sect = sect[len("pylint.") :]
if not sect.isupper() and values:
parser._sections[sect.upper()] = values
if not verbose:
return
if use_config_file:
msg = f"Using config file {os.path.abspath(config_file)}"
else:
msg = "No config file found, using default configuration"
print(msg, file=sys.stderr)
def _parse_toml(
self, config_file: Union[Path, str], parser: configparser.ConfigParser
) -> None:
"""Parse and handle errors of a toml configuration file."""
with open(config_file, encoding="utf-8") as fp:
content = toml.load(fp)
try:
sections_values = content["tool"]["pylint"]
except KeyError:
return
for section, values in sections_values.items():
section_name = section.upper()
# TOML has rich types, convert values to
# strings as ConfigParser expects.
if not isinstance(values, dict):
# This class is a mixin: add_message comes from the `PyLinter` class
self.add_message( # type: ignore[attr-defined]
"bad-configuration-section", line=0, args=(section, values)
)
continue
for option, value in values.items():
if isinstance(value, bool):
values[option] = "yes" if value else "no"
elif isinstance(value, list):
values[option] = ",".join(value)
else:
values[option] = str(value)
for option, value in values.items():
try:
parser.set(section_name, option, value=value)
except configparser.NoSectionError:
parser.add_section(section_name)
parser.set(section_name, option, value=value)
def load_config_file(self):
"""Dispatch values previously read from a configuration file to each
option's 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 200 | options_by_section | ref | function | for section, options in provider.options_by_section():
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 221 | format_section | ref | function | utils.format_section(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 226 | generate_manpage | def | function | def generate_manpage(
self, pkginfo: ModuleType, section: int = 1, stream: TextIO = sys.stdout
) -> None:
with _patch_optparse():
formatter = _ManHelpFormatter()
formatter.output_level = self._maxlevel
formatter.parser = self.cmdline_parser
print(
formatter.format_head(self.cmdline_parser, pkginfo, section),
file=stream,
)
print(self.cmdline_parser.format_option_help(formatter), file=stream)
print(formatter.format_tail(pkginfo), file=stream)
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 option's provider)
"""
for help_level in range(1, self._maxlevel + 1):
opt = "-".join(["long"] * help_level) + "-help"
if opt in self._all_options:
break # already processed
help_function = functools.partial(self.helpfunc, level=help_level)
help_msg = f"{' '.join(['more'] * help_level)} verbose help."
optdict = {
"action": "callback",
"callback": help_function,
"help": help_msg,
}
provider = self.options_providers[0]
self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
provider.options += ((opt, optdict),)
if config_file is None:
config_file = self.config_file
if config_file is not None:
config_file = os.path.expandvars(os.path.expanduser(config_file))
if not os.path.exists(config_file):
raise OSError(f"The config file {config_file} doesn't exist!")
use_config_file = config_file and os.path.exists(config_file)
if use_config_file:
self.set_current_module(config_file)
parser = self.cfgfile_parser
if config_file.endswith(".toml"):
try:
self._parse_toml(config_file, parser)
except toml.TomlDecodeError as e:
self.add_message("config-parse-error", line=0, args=str(e))
else:
# Use this encoding in order to strip the BOM marker, if any.
with open(config_file, encoding="utf_8_sig") as fp:
parser.read_file(fp)
# normalize each section's title
for sect, values in list(parser._sections.items()):
if sect.startswith("pylint."):
sect = sect[len("pylint.") :]
if not sect.isupper() and values:
parser._sections[sect.upper()] = values
if not verbose:
return
if use_config_file:
msg = f"Using config file {os.path.abspath(config_file)}"
else:
msg = "No config file found, using default configuration"
print(msg, file=sys.stderr)
def _parse_toml(
self, config_file: Union[Path, str], parser: configparser.ConfigParser
) -> None:
"""Parse and handle errors of a toml configuration file."""
with open(config_file, encoding="utf-8") as fp:
content = toml.load(fp)
try:
sections_values = content["tool"]["pylint"]
except KeyError:
return
for section, values in sections_values.items():
section_name = section.upper()
# TOML has rich types, convert values to
# strings as ConfigParser expects.
if not isinstance(values, dict):
# This class is a mixin: add_message comes from the `PyLinter` class
self.add_message( # type: ignore[attr-defined]
"bad-configuration-section", line=0, args=(section, values)
)
continue
for option, value in values.items():
if isinstance(value, bool):
values[option] = "yes" if value else "no"
elif isinstance(value, list):
values[option] = ",".join(value)
else:
values[option] = str(value)
for option, value in values.items():
try:
parser.set(section_name, option, value=value)
except configparser.NoSectionError:
parser.add_section(section_name)
parser.set(section_name, option, value=value)
def load_config_file(self):
"""Dispatch values previously read from a configuration file to each
option's 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 229 | _patch_optparse | ref | function | with _patch_optparse():
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 230 | _ManHelpFormatter | ref | function | formatter = _ManHelpFormatter()
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 234 | format_head | ref | function | formatter.format_head(self.cmdline_parser, pkginfo, section),
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 237 | format_option_help | ref | function | print(self.cmdline_parser.format_option_help(formatter), file=stream)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 238 | format_tail | ref | function | print(formatter.format_tail(pkginfo), file=stream)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 240 | load_provider_defaults | def | function | 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 option's provider)
"""
for help_level in range(1, self._maxlevel + 1):
opt = "-".join(["long"] * help_level) + "-help"
if opt in self._all_options:
break # already processed
help_function = functools.partial(self.helpfunc, level=help_level)
help_msg = f"{' '.join(['more'] * help_level)} verbose help."
optdict = {
"action": "callback",
"callback": help_function,
"help": help_msg,
}
provider = self.options_providers[0]
self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
provider.options += ((opt, optdict),)
if config_file is None:
config_file = self.config_file
if config_file is not None:
config_file = os.path.expandvars(os.path.expanduser(config_file))
if not os.path.exists(config_file):
raise OSError(f"The config file {config_file} doesn't exist!")
use_config_file = config_file and os.path.exists(config_file)
if use_config_file:
self.set_current_module(config_file)
parser = self.cfgfile_parser
if config_file.endswith(".toml"):
try:
self._parse_toml(config_file, parser)
except toml.TomlDecodeError as e:
self.add_message("config-parse-error", line=0, args=str(e))
else:
# Use this encoding in order to strip the BOM marker, if any.
with open(config_file, encoding="utf_8_sig") as fp:
parser.read_file(fp)
# normalize each section's title
for sect, values in list(parser._sections.items()):
if sect.startswith("pylint."):
sect = sect[len("pylint.") :]
if not sect.isupper() and values:
parser._sections[sect.upper()] = values
if not verbose:
return
if use_config_file:
msg = f"Using config file {os.path.abspath(config_file)}"
else:
msg = "No config file found, using default configuration"
print(msg, file=sys.stderr)
def _parse_toml(
self, config_file: Union[Path, str], parser: configparser.ConfigParser
) -> None:
"""Parse and handle errors of a toml configuration file."""
with open(config_file, encoding="utf-8") as fp:
content = toml.load(fp)
try:
sections_values = content["tool"]["pylint"]
except KeyError:
return
for section, values in sections_values.items():
section_name = section.upper()
# TOML has rich types, convert values to
# strings as ConfigParser expects.
if not isinstance(values, dict):
# This class is a mixin: add_message comes from the `PyLinter` class
self.add_message( # type: ignore[attr-defined]
"bad-configuration-section", line=0, args=(section, values)
)
continue
for option, value in values.items():
if isinstance(value, bool):
values[option] = "yes" if value else "no"
elif isinstance(value, list):
values[option] = ",".join(value)
else:
values[option] = str(value)
for option, value in values.items():
try:
parser.set(section_name, option, value=value)
except configparser.NoSectionError:
parser.add_section(section_name)
parser.set(section_name, option, value=value)
def load_config_file(self):
"""Dispatch values previously read from a configuration file to each
option's 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 243 | load_defaults | ref | function | provider.load_defaults()
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 245 | read_config_file | def | function | 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 option's provider)
"""
for help_level in range(1, self._maxlevel + 1):
opt = "-".join(["long"] * help_level) + "-help"
if opt in self._all_options:
break # already processed
help_function = functools.partial(self.helpfunc, level=help_level)
help_msg = f"{' '.join(['more'] * help_level)} verbose help."
optdict = {
"action": "callback",
"callback": help_function,
"help": help_msg,
}
provider = self.options_providers[0]
self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
provider.options += ((opt, optdict),)
if config_file is None:
config_file = self.config_file
if config_file is not None:
config_file = os.path.expandvars(os.path.expanduser(config_file))
if not os.path.exists(config_file):
raise OSError(f"The config file {config_file} doesn't exist!")
use_config_file = config_file and os.path.exists(config_file)
if use_config_file:
self.set_current_module(config_file)
parser = self.cfgfile_parser
if config_file.endswith(".toml"):
try:
self._parse_toml(config_file, parser)
except toml.TomlDecodeError as e:
self.add_message("config-parse-error", line=0, args=str(e))
else:
# Use this encoding in order to strip the BOM marker, if any.
with open(config_file, encoding="utf_8_sig") as fp:
parser.read_file(fp)
# normalize each section's title
for sect, values in list(parser._sections.items()):
if sect.startswith("pylint."):
sect = sect[len("pylint.") :]
if not sect.isupper() and values:
parser._sections[sect.upper()] = values
if not verbose:
return
if use_config_file:
msg = f"Using config file {os.path.abspath(config_file)}"
else:
msg = "No config file found, using default configuration"
print(msg, file=sys.stderr)
def _parse_toml(
self, config_file: Union[Path, str], parser: configparser.ConfigParser
) -> None:
"""Parse and handle errors of a toml configuration file."""
with open(config_file, encoding="utf-8") as fp:
content = toml.load(fp)
try:
sections_values = content["tool"]["pylint"]
except KeyError:
return
for section, values in sections_values.items():
section_name = section.upper()
# TOML has rich types, convert values to
# strings as ConfigParser expects.
if not isinstance(values, dict):
# This class is a mixin: add_message comes from the `PyLinter` class
self.add_message( # type: ignore[attr-defined]
"bad-configuration-section", line=0, args=(section, values)
)
continue
for option, value in values.items():
if isinstance(value, bool):
values[option] = "yes" if value else "no"
elif isinstance(value, list):
values[option] = ",".join(value)
else:
values[option] = str(value)
for option, value in values.items():
try:
parser.set(section_name, option, value=value)
except configparser.NoSectionError:
parser.add_section(section_name)
parser.set(section_name, option, value=value)
def load_config_file(self):
"""Dispatch values previously read from a configuration file to each
option's 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 261 | add_optik_option | ref | function | self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 267 | expandvars | ref | function | config_file = os.path.expandvars(os.path.expanduser(config_file))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 273 | set_current_module | ref | function | self.set_current_module(config_file)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 277 | _parse_toml | ref | function | self._parse_toml(config_file, parser)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 279 | add_message | ref | function | self.add_message("config-parse-error", line=0, args=str(e))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 283 | read_file | ref | function | parser.read_file(fp)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 293 | abspath | ref | function | msg = f"Using config file {os.path.abspath(config_file)}"
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 298 | _parse_toml | def | function | def _parse_toml(
self, config_file: Union[Path, str], parser: configparser.ConfigParser
) -> None:
"""Parse and handle errors of a toml configuration file."""
with open(config_file, encoding="utf-8") as fp:
content = toml.load(fp)
try:
sections_values = content["tool"]["pylint"]
except KeyError:
return
for section, values in sections_values.items():
section_name = section.upper()
# TOML has rich types, convert values to
# strings as ConfigParser expects.
if not isinstance(values, dict):
# This class is a mixin: add_message comes from the `PyLinter` class
self.add_message( # type: ignore[attr-defined]
"bad-configuration-section", line=0, args=(section, values)
)
continue
for option, value in values.items():
if isinstance(value, bool):
values[option] = "yes" if value else "no"
elif isinstance(value, list):
values[option] = ",".join(value)
else:
values[option] = str(value)
for option, value in values.items():
try:
parser.set(section_name, option, value=value)
except configparser.NoSectionError:
parser.add_section(section_name)
parser.set(section_name, option, value=value)
def load_config_file(self):
"""Dispatch values previously read from a configuration file to each
option's 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 314 | add_message | ref | function | self.add_message( # type: ignore[attr-defined]
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 329 | add_section | ref | function | parser.add_section(section_name)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 332 | load_config_file | def | function | def load_config_file(self):
"""Dispatch values previously read from a configuration file to each
option's 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 337 | sections | ref | function | for section in parser.sections():
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 340 | global_set_option | ref | function | self.global_set_option(option, value)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 344 | load_configuration | def | function | 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 346 | load_configuration_from_config | ref | function | return self.load_configuration_from_config(kwargs)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 348 | load_configuration_from_config | def | function | 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) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 352 | set_option | ref | function | provider.set_option(opt, opt_value)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 354 | load_command_line_configuration | def | function | def load_command_line_configuration(self, args=None) -> List[str]:
"""Override configuration according to command line parameters.
return additional arguments
"""
with _patch_optparse():
args = sys.argv[1:] if args is None else 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 359 | _patch_optparse | ref | function | with _patch_optparse():
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 361 | parse_args | ref | function | (options, args) = self.cmdline_parser.parse_args(args=args)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 371 | add_help_section | def | function | 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()
def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 378 | add_option_group | ref | function | self.cmdline_parser.add_option_group(group)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 383 | _patch_optparse | ref | function | with _patch_optparse():
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 384 | format_help | ref | function | return self.cmdline_parser.format_help()
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_manager_mixin.py | pylint/config/option_manager_mixin.py | 386 | helpfunc | def | function | def helpfunc(self, option, opt, val, p, level): # pylint: disable=unused-argument
print(self.help(level))
sys.exit(0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_parser.py | pylint/config/option_parser.py | 8 | _level_options | def | function | 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
]
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_parser.py | pylint/config/option_parser.py | 21 | format_option_help | def | function | 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 = [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
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_parser.py | pylint/config/option_parser.py | 25 | store_option_strings | ref | function | formatter.store_option_strings(self)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_parser.py | pylint/config/option_parser.py | 26 | format_heading | ref | function | result = [formatter.format_heading("Options")]
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_parser.py | pylint/config/option_parser.py | 27 | indent | ref | function | formatter.indent()
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_parser.py | pylint/config/option_parser.py | 29 | format_option_help | ref | function | result.append(optparse.OptionContainer.format_option_help(self, formatter))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_parser.py | pylint/config/option_parser.py | 33 | _level_options | ref | function | group.description or _level_options(group, outputlevel)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_parser.py | pylint/config/option_parser.py | 35 | format_help | ref | function | result.append(group.format_help(formatter))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_parser.py | pylint/config/option_parser.py | 37 | dedent | ref | function | formatter.dedent()
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/option_parser.py | pylint/config/option_parser.py | 41 | _match_long_opt | def | function | def _match_long_opt(self, opt):
"""Disable abbreviations."""
if opt not in self._long_opt:
raise optparse.BadOptionError(opt)
return opt
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 10 | UnsupportedAction | def | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 14 | OptionsProviderMixIn | def | class | __init__ load_defaults option_attrname option_value set_option get_option_def options_by_section options_and_values |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 25 | load_defaults | ref | function | self.load_defaults()
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 27 | load_defaults | def | function | 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(
f"no such option {opt} in section {self.name!r}", 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))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 34 | get_option_def | ref | function | optdict = self.get_option_def(opt)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 36 | set_option | ref | function | self.set_option(opt, default, action, optdict)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 38 | option_attrname | def | function | 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(
f"no such option {opt} in section {self.name!r}", 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))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 41 | get_option_def | ref | function | optdict = self.get_option_def(opt)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 44 | option_value | def | function | 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(
f"no such option {opt} in section {self.name!r}", 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))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 46 | option_attrname | ref | function | return getattr(self.config, self.option_attrname(opt), None)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 48 | set_option | def | function | 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(
f"no such option {opt} in section {self.name!r}", 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))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 51 | get_option_def | ref | function | optdict = self.get_option_def(optname)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 53 | _validate | ref | function | value = _validate(value, optdict, optname)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 57 | option_attrname | ref | function | setattr(self.config, self.option_attrname(optname, optdict), value)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 59 | option_attrname | ref | function | setattr(self.config, self.option_attrname(optname, optdict), 0)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 61 | option_attrname | ref | function | setattr(self.config, self.option_attrname(optname, optdict), 1)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 63 | option_attrname | ref | function | optname = self.option_attrname(optname, optdict)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 79 | UnsupportedAction | ref | function | raise UnsupportedAction(action)
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 81 | get_option_def | def | function | 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(
f"no such option {opt} in section {self.name!r}", 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))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 91 | options_by_section | def | function | 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))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 99 | option_value | ref | function | (optname, optdict, self.option_value(optname))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 106 | options_and_values | def | function | 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))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/config/options_provider_mixin.py | pylint/config/options_provider_mixin.py | 110 | option_value | ref | function | yield (optname, optdict, self.option_value(optname))
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/constants.py | pylint/constants.py | 51 | WarningScope | def | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/constants.py | pylint/constants.py | 76 | DeletedMessage | def | class | |
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/constants.py | pylint/constants.py | 89 | DeletedMessage | ref | function | DeletedMessage("W1601", "apply-builtin"),
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/constants.py | pylint/constants.py | 90 | DeletedMessage | ref | function | DeletedMessage("E1601", "print-statement"),
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/constants.py | pylint/constants.py | 91 | DeletedMessage | ref | function | DeletedMessage("E1602", "parameter-unpacking"),
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/constants.py | pylint/constants.py | 92 | DeletedMessage | ref | function | DeletedMessage(
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/constants.py | pylint/constants.py | 95 | DeletedMessage | ref | function | DeletedMessage("E1604", "old-raise-syntax", [("W0121", "old-old-raise-syntax")]),
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/constants.py | pylint/constants.py | 96 | DeletedMessage | ref | function | DeletedMessage("E1605", "backtick", [("W0333", "old-backtick")]),
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/constants.py | pylint/constants.py | 97 | DeletedMessage | ref | function | DeletedMessage("E1609", "import-star-module-level"),
|
playground/e9b22a58-260b-483f-88d7-7a5fe9f8b1d4/pylint/pylint/constants.py | pylint/constants.py | 98 | DeletedMessage | ref | function | DeletedMessage("W1601", "apply-builtin"),
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.