[Predator] Refactor ToPublishResult and fix keyerror 'found'

appengine/findit/crash/findit.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 copy
+import json
 import logging
 
 from google.appengine.ext import ndb
 
 from common import appengine_util
 from common import chrome_dependency_fetcher
 from common import constants
 from crash.crash_report import CrashReport
 from lib import time_util
 from model import analysis_status
@@ skipping 194 matching lines @@
             self._repository).GetDependency(
                 model.crashed_version,
                 model.platform),
         model.signature)
     if not stacktrace:
       logging.warning('Failed to parse the stacktrace %s', model.stack_trace)
       return None
 
     return stacktrace
 
+  def ProcessResultForPublishing(self, result, key):
+    """Client specific processing of result data for publishing."""
+    raise NotImplementedError()
+
+  def GetPublishableResult(self, crash_identifiers, analysis):
+    """Convert a culprit result into a publishable result for client.
+
+    Note, this function must be called by a concrete subclass of CrashAnalysis
+    which implements the ProcessResultForPublishing method.
+
+    Args:
+      crash_identifiers (dict): Dict containing identifiers that can uniquely
+        identify CrashAnalysis entity.
+      analysis (CrashAnalysis model): Model containing culprit result and other
+        analysis information.
+
+    Returns:
+      A dict of the given ``crash_identifiers``, this model's
+      ``client_id``, and a publishable version of this model's ``result``.
+    """
+    result = copy.deepcopy(analysis.result)
+    if result.get('found') and 'suspected_cls' in result:
+      for cl in result['suspected_cls']:
+        cl['confidence'] = round(cl['confidence'], 2)
+        cl.pop('reason', None)
+
+    result = self.ProcessResultForPublishing(result, analysis.key.urlsafe())
+    logging.info('Publish result:\n%s',
+                 json.dumps(result, indent=4, sort_keys=True))
+    return {
+        'crash_identifiers': crash_identifiers,
+        'client_id': self.client_id,
+        'result': result,
+    }
+
   # TODO(wrengr): This is only called by ``CrashAnalysisPipeline.run``;
   # we should be able to adjust things so that we only need to take in
   # ``crash_identifiers``, or a CrashReport, rather than taking in the
   # whole model. And/or, we should just inline this there.
   # TODO(http://crbug.com/659346): coverage tests for this class, not
   # just for FinditForFracas.
   def FindCulprit(self, model): # pragma: no cover
     """Given a CrashAnalysis ndb.Model, return a Culprit."""
     stacktrace = self.ParseStacktrace(model)
     if stacktrace is None:
       return None
 
     return self._predator.FindCulprit(CrashReport(
         crashed_version = model.crashed_version,
         signature = model.signature,
         platform = model.platform,
         stacktrace = stacktrace,
         regression_range = model.regression_range))