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

-:d728227e8ebb
+:0802ae193343
 """Results of coverage measurement."""
 import collections
-from coverage.backward import iitems
 from coverage.debug import SimpleReprMixin
-from coverage.misc import contract, CoverageException, nice_pair
+from coverage.exceptions import CoverageException
+from coverage.misc import contract, nice_pair
-class Analysis(object):
+class Analysis:
 """The results of analyzing a FileReporter."""
-def __init__(self, data, file_reporter, file_mapper):
+def __init__(self, data, precision, file_reporter, file_mapper):
 self.data = data
 self.file_reporter = file_reporter
 self.filename = file_mapper(self.file_reporter.filename)
 self.statements = self.file_reporter.lines()
 self.excluded = self.file_reporter.excluded_lines()
 self._arc_possibilities = sorted(self.file_reporter.arcs())
 self.exit_counts = self.file_reporter.exit_counts()
 self.no_branch = self.file_reporter.no_branch_lines()
 n_branches = self._total_branches()
 mba = self.missing_branch_arcs()
-n_partial_branches = sum(len(v) for k,v in iitems(mba) if k not in self.missing)
+n_partial_branches = sum(len(v) for k,v in mba.items() if k not in self.missing)
-n_missing_branches = sum(len(v) for k,v in iitems(mba))
+n_missing_branches = sum(len(v) for k,v in mba.items())
 else:
 self._arc_possibilities = []
 self.exit_counts = {}
 self.no_branch = set()
 n_branches = n_partial_branches = n_missing_branches = 0
 self.numbers = Numbers(
+precision=precision,
 n_files=1,
 n_statements=len(self.statements),
 n_excluded=len(self.excluded),
 n_missing=len(self.missing),
 n_branches=n_branches,
 If `branches` is true, includes the missing branch arcs also.
 """
 if branches and self.has_arcs():
-arcs = iitems(self.missing_branch_arcs())
+arcs = self.missing_branch_arcs().items()
 else:
 arcs = None
 return format_lines(self.statements, self.missing, arcs=arcs)
 executed = self.file_reporter.translate_arcs(executed)
 return sorted(executed)
 @contract(returns='list(tuple(int, int))')
 def arcs_missing(self):
-"""Returns a sorted list of the arcs in the code not executed."""
+"""Returns a sorted list of the unexecuted arcs in the code."""
 possible = self.arc_possibilities()
 executed = self.arcs_executed()
 missing = (
 p for p in possible
 if p not in executed
 and p[0] not in self.no_branch
+and p[1] not in self.excluded
 )
 return sorted(missing)
 @contract(returns='list(tuple(int, int))')
 def arcs_unpredicted(self):
 )
 return sorted(unpredicted)
 def _branch_lines(self):
 """Returns a list of line numbers that have more than one exit."""
-return [l1 for l1,count in iitems(self.exit_counts) if count > 1]
+return [l1 for l1,count in self.exit_counts.items() if count > 1]
 def _total_branches(self):
 """How many total branches are there?"""
 return sum(count for count in self.exit_counts.values() if count > 1)
 This holds the basic statistics from `Analysis`, and is used to roll
 up statistics across files.
 """
-# A global to determine the precision on coverage percentages, the number
-# of decimal places.
+def __init__(self,
-_precision = 0
+precision=0,
-_near0 = 1.0              # These will change when _precision is changed.
+n_files=0, n_statements=0, n_excluded=0, n_missing=0,
-_near100 = 99.0
+n_branches=0, n_partial_branches=0, n_missing_branches=0
+):
-def __init__(self, n_files=0, n_statements=0, n_excluded=0, n_missing=0,
+assert 0 <= precision < 10
-n_branches=0, n_partial_branches=0, n_missing_branches=0
+self._precision = precision
-):
+self._near0 = 1.0 / 10**precision
+self._near100 = 100.0 - self._near0
 self.n_files = n_files
 self.n_statements = n_statements
 self.n_excluded = n_excluded
 self.n_missing = n_missing
 self.n_branches = n_branches
 self.n_missing_branches = n_missing_branches
 def init_args(self):
 """Return a list for __init__(*args) to recreate this object."""
 return [
+self._precision,
 self.n_files, self.n_statements, self.n_excluded, self.n_missing,
 self.n_branches, self.n_partial_branches, self.n_missing_branches,
 ]
-@classmethod
-def set_precision(cls, precision):
-"""Set the number of decimal places used to report percentages."""
-assert 0 <= precision < 10
-cls._precision = precision
-cls._near0 = 1.0 / 10**precision
-cls._near100 = 100.0 - cls._near0
 @property
 def n_executed(self):
 """Returns the number of executed statements."""
 return self.n_statements - self.n_missing
 Note that "0" is only returned when the value is truly zero, and "100"
 is only returned when the value is truly 100.  Rounding can never
 result in either "0" or "100".
 """
-pc = self.pc_covered
+return self.display_covered(self.pc_covered)
+def display_covered(self, pc):
+"""Return a displayable total percentage, as a string.
+Note that "0" is only returned when the value is truly zero, and "100"
+is only returned when the value is truly 100.  Rounding can never
+result in either "0" or "100".
+"""
 if 0 < pc < self._near0:
 pc = self._near0
 elif self._near100 < pc < 100:
 pc = self._near100
 else:
 pc = round(pc, self._precision)
 return "%.*f" % (self._precision, pc)
-@classmethod
+def pc_str_width(self):
-def pc_str_width(cls):
 """How many characters wide can pc_covered_str be?"""
 width = 3   # "100"
-if cls._precision > 0:
+if self._precision > 0:
-width += 1 + cls._precision
+width += 1 + self._precision
 return width
 @property
 def ratio_covered(self):
 """Return a numerator and denominator for the coverage ratio."""
 numerator = self.n_executed + self.n_executed_branches
 denominator = self.n_statements + self.n_branches
 return numerator, denominator
 def __add__(self, other):
-nums = Numbers()
+nums = Numbers(precision=self._precision)
 nums.n_files = self.n_files + other.n_files
 nums.n_statements = self.n_statements + other.n_statements
 nums.n_excluded = self.n_excluded + other.n_excluded
 nums.n_missing = self.n_missing + other.n_missing
 nums.n_branches = self.n_branches + other.n_branches
 )
 return nums
 def __radd__(self, other):
 # Implementing 0+Numbers allows us to sum() a list of Numbers.
-if other == 0:
+assert other == 0   # we only ever call it this way.
 return self
-return NotImplemented       # pragma: not covered (we never call it this way)
 def _line_ranges(statements, lines):
 """Produce a list of ranges for `format_lines`."""
 statements = sorted(statements)
 Returns True if the total should fail.
 """
 # We can never achieve higher than 100% coverage, or less than zero.
 if not (0 <= fail_under <= 100.0):
-msg = "fail_under={} is invalid. Must be between 0 and 100.".format(fail_under)
+msg = f"fail_under={fail_under} is invalid. Must be between 0 and 100."
 raise CoverageException(msg)
 # Special case for fail_under=100, it must really be 100.
 if fail_under == 100.0 and total != 100.0:
 return True

Mercurial Repositories > eric / file comparison

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

eric7/DebugClients/Python/coverage/results.py