text: # Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0
  # For details: https://bitbucket.org/ned/coveragepy/src/default/NOTICE.txt
  
  """Results of coverage measurement."""
  
  import collections
  
  from coverage.backward import iitems
  from coverage.misc import format_lines
  
  
  class Analysis(object):
      """The results of analyzing a FileReporter."""
  
      def __init__(self, data, file_reporter):
          self.data = data
          self.file_reporter = file_reporter
          self.filename = self.file_reporter.filename
          self.statements = self.file_reporter.lines()
          self.excluded = self.file_reporter.excluded_lines()
  
          # Identify missing statements.
          executed = self.data.lines(self.filename) or []
          executed = self.file_reporter.translate_lines(executed)
          self.missing = self.statements - executed
  
          if self.data.has_arcs():
              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_missing_branches = sum(len(v) for k,v in iitems(mba))
          else:
              self._arc_possibilities = []
              self.exit_counts = {}
              self.no_branch = set()
              n_branches = n_partial_branches = n_missing_branches = 0
  
          self.numbers = Numbers(
              n_files=1,
              n_statements=len(self.statements),
              n_excluded=len(self.excluded),
              n_missing=len(self.missing),
              n_branches=n_branches,
              n_partial_branches=n_partial_branches,
              n_missing_branches=n_missing_branches,
              )
  
      def missing_formatted(self):
          """The missing line numbers, formatted nicely.
  
          Returns a string like "1-2, 5-11, 13-14".
  
          """
          return format_lines(self.statements, self.missing)
  
      def has_arcs(self):
          """Were arcs measured in this result?"""
          return self.data.has_arcs()
  
      def arc_possibilities(self):
          """Returns a sorted list of the arcs in the code."""
          return self._arc_possibilities
  
      def arcs_executed(self):
          """Returns a sorted list of the arcs actually executed in the code."""
          executed = self.data.arcs(self.filename) or []
          executed = self.file_reporter.translate_arcs(executed)
          return sorted(executed)
  
      def arcs_missing(self):
          """Returns a sorted list of the arcs in the code not executed."""
          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
          )
          return sorted(missing)
  
      def arcs_missing_formatted(self):
          """ The missing branch arcs, formatted nicely.
  
          Returns a string like "1->2, 1->3, 16->20". Omits any mention of
          branches from missing lines, so if line 17 is missing, then 17->18
          won't be included.
  
          """
          arcs = self.missing_branch_arcs()
          missing = self.missing
          line_exits = sorted(iitems(arcs))
          pairs = []
          for line, exits in line_exits:
              for ex in sorted(exits):
                  if line not in missing:
                      pairs.append('%d->%d' % (line, ex))
          return ', '.join(pairs)
  
      def arcs_unpredicted(self):
          """Returns a sorted list of the executed arcs missing from the code."""
          possible = self.arc_possibilities()
          executed = self.arcs_executed()
          # Exclude arcs here which connect a line to itself.  They can occur
          # in executed data in some cases.  This is where they can cause
          # trouble, and here is where it's the least burden to remove them.
          # Also, generators can somehow cause arcs from "enter" to "exit", so
          # make sure we have at least one positive value.
          unpredicted = (
              e for e in executed
                  if e not in possible
                      and e[0] != e[1]
                      and (e[0] > 0 or e[1] > 0)
          )
          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]
  
      def total_branches(self):
          """How many total branches are there?"""
          return sum(count for count in self.exit_counts.values() if count > 1)
  
      def missing_branch_arcs(self):
          """Return arcs that weren't executed from branch lines.
  
          Returns {l1:[l2a,l2b,...], ...}
  
          """
          missing = self.arcs_missing()
          branch_lines = set(self.branch_lines())
          mba = collections.defaultdict(list)
          for l1, l2 in missing:
              if l1 in branch_lines:
                  mba[l1].append(l2)
          return mba
  
      def branch_stats(self):
          """Get stats about branches.
  
          Returns a dict mapping line numbers to a tuple:
          (total_exits, taken_exits).
          """
  
          missing_arcs = self.missing_branch_arcs()
          stats = {}
          for lnum in self.branch_lines():
              exits = self.exit_counts[lnum]
              try:
                  missing = len(missing_arcs[lnum])
              except KeyError:
                  missing = 0
              stats[lnum] = (exits, exits - missing)
          return stats
  
  
  class Numbers(object):
      """The numerical results of measuring coverage.
  
      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.
      _precision = 0
      _near0 = 1.0              # These will change when _precision is changed.
      _near100 = 99.0
  
      def __init__(self, n_files=0, n_statements=0, n_excluded=0, n_missing=0,
                      n_branches=0, n_partial_branches=0, n_missing_branches=0
                      ):
          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_partial_branches = n_partial_branches
          self.n_missing_branches = n_missing_branches
  
      def init_args(self):
          """Return a list for __init__(*args) to recreate this object."""
          return [
              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
  
      @property
      def n_executed_branches(self):
          """Returns the number of executed branches."""
          return self.n_branches - self.n_missing_branches
  
      @property
      def pc_covered(self):
          """Returns a single percentage value for coverage."""
          if self.n_statements > 0:
              numerator, denominator = self.ratio_covered
              pc_cov = (100.0 * numerator) / denominator
          else:
              pc_cov = 100.0
          return pc_cov
  
      @property
      def pc_covered_str(self):
          """Returns the percent covered, as a string, without a percent sign.
  
          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
          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(cls):
          """How many characters wide can pc_covered_str be?"""
          width = 3   # "100"
          if cls._precision > 0:
              width += 1 + cls._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.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
          nums.n_partial_branches = (
              self.n_partial_branches + other.n_partial_branches
              )
          nums.n_missing_branches = (
              self.n_missing_branches + other.n_missing_branches
              )
          return nums
  
      def __radd__(self, other):
          # Implementing 0+Numbers allows us to sum() a list of Numbers.
          if other == 0:
              return self
          return NotImplemented
  