eric: comparison eric7/DebugClients/Python/coverage/config.py

-:d728227e8ebb
+:0802ae193343
 # For details: https://github.com/nedbat/coveragepy/blob/master/NOTICE.txt
 """Config file for coverage.py"""
 import collections
+import configparser
 import copy
 import os
 import os.path
 import re
-from coverage import env
+from coverage.exceptions import CoverageException
-from coverage.backward import configparser, iitems, string_class
+from coverage.misc import contract, isolate_module, substitute_variables
-from coverage.misc import contract, CoverageException, isolate_module
-from coverage.misc import substitute_variables
 from coverage.tomlconfig import TomlConfigParser, TomlDecodeError
 os = isolate_module(os)
 configparser.RawConfigParser.__init__(self)
 self.section_prefixes = ["coverage:"]
 if our_file:
 self.section_prefixes.append("")
-def read(self, filenames, encoding=None):
+def read(self, filenames, encoding_unused=None):
 """Read a file name as UTF-8 configuration data."""
-kwargs = {}
+return configparser.RawConfigParser.read(self, filenames, encoding="utf-8")
-if env.PYVERSION >= (3, 2):
-kwargs['encoding'] = encoding or "utf-8"
-return configparser.RawConfigParser.read(self, filenames, **kwargs)
 def has_option(self, section, option):
 for section_prefix in self.section_prefixes:
 real_section = section_prefix + section
 has = configparser.RawConfigParser.has_option(self, real_section, option)
 value = value.strip()
 try:
 re.compile(value)
 except re.error as e:
 raise CoverageException(
-"Invalid [%s].%s value %r: %s" % (section, option, value, e)
+f"Invalid [{section}].{option} value {value!r}: {e}"
-)
+) from e
 if value:
 value_list.append(value)
 return value_list
 'while (True|1|False|0):',
 'if (True|1|False|0):',
 ]
-class CoverageConfig(object):
+class CoverageConfig:
 """Coverage.py configuration.
 The attributes of this class are the various settings that control the
 operation of coverage.py.
 "run_omit", "run_include",
 ]
 def from_args(self, **kwargs):
 """Read config values from `kwargs`."""
-for k, v in iitems(kwargs):
+for k, v in kwargs.items():
 if v is not None:
-if k in self.MUST_BE_LIST and isinstance(v, string_class):
+if k in self.MUST_BE_LIST and isinstance(v, str):
 v = [v]
 setattr(self, k, v)
 @contract(filename=str)
-def from_file(self, filename, our_file):
+def from_file(self, filename, warn, our_file):
 """Read configuration from a .rc file.
 `filename` is a file name to read.
 `our_file` is True if this config file is specifically for coverage,
 self.attempted_config_files.append(filename)
 try:
 files_read = cp.read(filename)
 except (configparser.Error, TomlDecodeError) as err:
-raise CoverageException("Couldn't read config file %s: %s" % (filename, err))
+raise CoverageException(f"Couldn't read config file {filename}: {err}") from err
 if not files_read:
 return False
 self.config_files_read.extend(map(os.path.abspath, files_read))
 for option_spec in self.CONFIG_FILE_OPTIONS:
 was_set = self._set_attr_from_config_option(cp, *option_spec)
 if was_set:
 any_set = True
 except ValueError as err:
-raise CoverageException("Couldn't read config file %s: %s" % (filename, err))
+raise CoverageException(f"Couldn't read config file {filename}: {err}") from err
 # Check that there are no unrecognized options.
 all_options = collections.defaultdict(set)
 for option_spec in self.CONFIG_FILE_OPTIONS:
 section, option = option_spec[1].split(":")
 all_options[section].add(option)
-for section, options in iitems(all_options):
+for section, options in all_options.items():
 real_section = cp.has_section(section)
 if real_section:
 for unknown in set(cp.options(section)) - options:
-raise CoverageException(
+warn(
-"Unrecognized option '[%s] %s=' in config file %s" % (
+"Unrecognized option '[{}] {}=' in config file {}".format(
 real_section, unknown, filename
 )
 )
 # [paths] is special
 if key and plugin_name in self.plugins:
 self.plugin_options.setdefault(plugin_name, {})[key] = value
 return
 # If we get here, we didn't find the option.
-raise CoverageException("No such option: %r" % option_name)
+raise CoverageException(f"No such option: {option_name!r}")
 def get_option(self, option_name):
 """Get an option from the configuration.
 `option_name` is a colon-separated string indicating the section and
 plugin_name, _, key = option_name.partition(":")
 if key and plugin_name in self.plugins:
 return self.plugin_options.get(plugin_name, {}).get(key)
 # If we get here, we didn't find the option.
-raise CoverageException("No such option: %r" % option_name)
+raise CoverageException(f"No such option: {option_name!r}")
 def post_process_file(self, path):
 """Make final adjustments to a file path to make it usable."""
 return os.path.expanduser(path)
 ("pyproject.toml", False, False),
 ]
 return files_to_try
-def read_coverage_config(config_file, **kwargs):
+def read_coverage_config(config_file, warn, **kwargs):
 """Read the coverage.py configuration.
 Arguments:
 config_file: a boolean or string, see the `Coverage` class for the
 tricky details.
+warn: a function to issue warnings.
 all others: keyword arguments from the `Coverage` class, used for
 setting values in the configuration.
 Returns:
 config:
 # 2) from a file:
 if config_file:
 files_to_try = config_files_to_try(config_file)
 for fname, our_file, specified_file in files_to_try:
-config_read = config.from_file(fname, our_file=our_file)
+config_read = config.from_file(fname, warn, our_file=our_file)
 if config_read:
 break
 if specified_file:
-raise CoverageException("Couldn't read '%s' as a config file" % fname)
+raise CoverageException(f"Couldn't read {fname!r} as a config file")
 # $set_env.py: COVERAGE_DEBUG - Options for --debug.
 # 3) from environment variables:
 env_data_file = os.environ.get('COVERAGE_FILE')
 if env_data_file:

Mercurial Repositories > eric / file comparison

comparison: eric7/DebugClients/Python/coverage/config.py

eric7/DebugClients/Python/coverage/config.py