[Predator] renamed "Result" to "Suspect"

appengine/findit/crash/changelist_classifier.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import logging
 from collections import defaultdict
 from collections import namedtuple
 
 from common import chrome_dependency_fetcher
 from crash import crash_util
-from crash.results import MatchResults
+from crash.suspect import Suspect
+from crash.suspect import Suspects
 from crash.scorers.aggregated_scorer import AggregatedScorer
 from crash.scorers.min_distance import MinDistance
 from crash.scorers.top_frame_index import TopFrameIndex
 from crash.stacktrace import CallStack
 from crash.stacktrace import Stacktrace
 from libs.gitiles.diff import ChangeType
 
 
 class ChangelistClassifier(namedtuple('ChangelistClassifier',
     ['repository', 'top_n_frames', 'top_n_results', 'confidence_threshold'])):
   __slots__ = ()
 
   def __new__(cls, repository,
       top_n_frames, top_n_results=3, confidence_threshold=0.999):
     """Args:
       repository (Repository): the Git repository for getting CLs to classify.
       top_n_frames (int): how many frames of each callstack to look at.
-      top_n_results (int): maximum number of results to return.
+      top_n_results (int): maximum number of suspects to return.
       confidence_threshold (float): In [0,1], above which we only return
-        the first result.
+        the first suspect.
     """
     return super(cls, ChangelistClassifier).__new__(cls,
         repository, top_n_frames, top_n_results, confidence_threshold)
 
   def __str__(self): # pragma: no cover
     return ('%s(top_n_frames=%d, top_n_results=%d, confidence_threshold=%g)'
         % (self.__class__.__name__,
            self.top_n_frames,
            self.top_n_results,
            self.confidence_threshold))
 
   def __call__(self, report):
     """Finds changelists suspected of being responsible for the crash report.
 
     Args:
       report (CrashReport): the report to be analyzed.
 
     Returns:
-      List of Results, sorted by confidence from highest to lowest.
+      List of ``Suspect``s, sorted by confidence from highest to lowest.
     """
     if not report.regression_range:
       logging.warning('ChangelistClassifier.__call__: Missing regression range '
           'for report: %s', str(report))
       return []
     last_good_version, first_bad_version = report.regression_range
     logging.info('ChangelistClassifier.__call__: Regression range %s:%s',
         last_good_version, first_bad_version)
 
     # Restrict analysis to just the top n frames in each callstack.
@@ skipping 28 matching lines @@
         continue
       regression_deps_rolls[dep_path] = dep_roll
 
     dep_to_file_to_changelogs, ignore_cls = GetChangeLogsForFilesGroupedByDeps(
         regression_deps_rolls, stack_deps, self.repository)
     dep_to_file_to_stack_infos = GetStackInfosForFilesGroupedByDeps(
         stacktrace, stack_deps)
 
     # TODO: argument order is inconsistent from others. Repository should
     # be last argument.
-    results = FindMatchResults(dep_to_file_to_changelogs,
-                               dep_to_file_to_stack_infos,
-                               stack_deps, self.repository, ignore_cls)
-    if not results:
+    suspects = FindSuspects(dep_to_file_to_changelogs,
+                            dep_to_file_to_stack_infos,
+                            stack_deps, self.repository, ignore_cls)
+    if not suspects:
       return []
 
-    # TODO(wrengr): we should be able to do this map/filter/sort in one pass.
-    # Set result.confidence, result.reasons and result.changed_files.
+    # Set confidence, reasons, and changed_files.
     aggregated_scorer = AggregatedScorer([TopFrameIndex(), MinDistance()])
-    map(aggregated_scorer.Score, results)
+    map(aggregated_scorer.Score, suspects)
 
     # Filter all the 0 confidence results.
-    results = filter(lambda r: r.confidence != 0, results)
-    if not results:
+    suspects = filter(lambda suspect: suspect.confidence != 0, suspects)
+    if not suspects:
       return []
 
-    sorted_results = sorted(results, key=lambda r: -r.confidence)
+    suspects.sort(key=lambda suspect: -suspect.confidence)
 
-    max_results = (1 if sorted_results[0].confidence > self.confidence_threshold
+    max_results = (1 if suspects[0].confidence > self.confidence_threshold
       else self.top_n_results)
 
-    return sorted_results[:max_results]
+    return suspects[:max_results]
 
 
 def GetDepsInCrashStack(crash_stack, crash_deps):
   """Gets Dependencies in crash stack."""
   if not crash_stack:
     return {}
 
   stack_deps = {}
   for frame in crash_stack:
     if frame.dep_path:
@@ skipping 126 matching lines @@
       if frame.dep_path not in stack_deps:
         continue
 
       dep_to_file_to_stack_infos[frame.dep_path][frame.file_path].append((
           frame, callstack.priority))
 
   return dep_to_file_to_stack_infos
 
 
 # TODO(katesonia): Remove the repository argument after refatoring cl committed.
-def FindMatchResults(dep_to_file_to_changelogs,
-                     dep_to_file_to_stack_infos,
-                     stack_deps, repository,
-                     ignore_cls=None):
-  """Finds results by matching stacktrace and changelogs in regression range.
+def FindSuspects(dep_to_file_to_changelogs,
+                 dep_to_file_to_stack_infos,
+                 stack_deps, repository,
+                 ignore_cls=None):
+  """Finds suspects by matching stacktrace and changelogs in regression range.
 
   This method only applies to those crashes with regression range.
 
   Args:
     dep_to_file_to_changelogs (dict): Maps dep_path to a dict mapping file path
       to ChangeLogs that touched this file.
     dep_to_file_to_stack_infos (dict): Maps dep path to a dict mapping file path
       to a list of stack information of this file. A file may occur in several
       frames, one stack info consist of a StackFrame and the callstack priority
       of it.
     stack_deps (dict): Represents all the dependencies shown in the crash stack.
     repository (Repository): Repository to get changelogs and blame from.
     ignore_cls (set): Set of reverted revisions.
 
   Returns:
-    A list of MatchResult instances with confidence and reason unset.
+    A list of ``Suspect`` instances with confidence and reason unset.
   """
-  match_results = MatchResults(ignore_cls)
+  suspects = Suspects(ignore_cls)
 
   for dep, file_to_stack_infos in dep_to_file_to_stack_infos.iteritems():
     file_to_changelogs = dep_to_file_to_changelogs[dep]
 
     for crashed_file_path, stack_infos in file_to_stack_infos.iteritems():
       for touched_file_path, changelogs in file_to_changelogs.iteritems():
         if not crash_util.IsSameFilePath(crashed_file_path, touched_file_path):
           continue
 
         repository.repo_url = stack_deps[dep].repo_url
         blame = repository.GetBlame(touched_file_path,
                                     stack_deps[dep].revision)
 
-        # Generate/update each result(changelog) in changelogs, blame is used
+        # Generate/update each suspect(changelog) in changelogs, blame is used
         # to calculate distance between touched lines and crashed lines in file.
-        match_results.GenerateMatchResults(
+        suspects.GenerateSuspects(
             touched_file_path, dep, stack_infos, changelogs, blame)
 
-  return match_results.values()
+  return suspects.values()