[Predator] Add TouchCrashedFileMetaFeature.

appengine/findit/crash/loglinear/feature.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.
 
 from collections import namedtuple
 import logging
 import math
 
 import libs.math.logarithms as lmath
 from libs.math.vectors import vsum
@@ skipping 96 matching lines @@
   @property
   def name(self):
     return self._name
 
   @property
   def value(self):
     return self._value
 
   @property
   def reason(self):
-    return self._reason
+    return ('%s: %f -- %s' % (self._name, self._value, self._reason)
+            if self._reason else None)
 
   @property
   def changed_files(self):
     return self._changed_files
 
   def __str__(self):
     return ('%s(name = %s, value = %f, reason = %s, changed_files = %s)'
         % (self.__class__.__name__, self.name, self.value, self.reason,
            self.changed_files))
 
@@ skipping 62 matching lines @@
       value. However, this isn't the best thing for UX reasons. In the
       future it might be replaced by the normal-domain score, or by
       the probability.
     """
     if self._reason:
       return self._reason
 
     formatted_reasons = []
     for feature in self.itervalues():
       if feature.reason:
-        formatted_reasons.append('%s: %f -- %s' % (feature.name,
-                                                   feature.value,
-                                                   feature.reason))
+        formatted_reasons.append(feature.reason)
 
     formatted_reasons.sort()
     self._reason = '\n'.join(formatted_reasons)
     return self._reason
 
   @property
   def changed_files(self):
     """Merge multiple``FeatureValue.changed_files`` lists into one.
 
     Returns:
@@ skipping 139 matching lines @@
     """Fuction mapping ``X -> Y -> dict(FeatureValue.name to FeatureValue).
 
     Returns:
       A function ``X -> Y -> dict(FeatureValue.name to FeatureValue)`` where for
       all ``x``, ``y``, and for a feature f in fs, we have
       ``FeatureFunction(fs)(x)(y)[f.name] == f(x)(y)``.
     """
     fxs = {name: f(x) for name, f in self.iteritems()}
     return lambda y: MetaFeatureValue(
         self.name, {name: fx(y) for name, fx in fxs.iteritems()})