[Telemetry] Introduce SummarizableValue.

tools/telemetry/telemetry/value/list_of_scalar_values.py

 # Copyright 2013 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 numbers
 import math
 
 from telemetry import value as value_module
 from telemetry.value import none_values
+from telemetry.value import summarizable
 
 
 def Variance(sample):
   """ Compute the population variance.
 
     Args:
       sample: a list of numbers.
   """
   k = len(sample) - 1  # Bessel correction
   if k <= 0:
@@ skipping 34 matching lines @@
     total_degrees_of_freedom += k
   if total_degrees_of_freedom:
     return (pooled_variance/total_degrees_of_freedom) ** 0.5
   return 0
 
 
 def _Mean(values):
   return float(sum(values)) / len(values) if len(values) > 0 else 0.0
 
 
-class ListOfScalarValues(value_module.Value):
+class ListOfScalarValues(summarizable.SummarizableValue):
   """ ListOfScalarValues represents a list of numbers.
 
   By default, std is the standard deviation of all numbers in the list. Std can
   also be specified in the constructor if the numbers are not from the same
   population.
   """
   def __init__(self, page, name, units, values,
                important=True, description=None,
                tir_label=None, none_value_reason=None,
-               std=None, same_page_merge_policy=value_module.CONCATENATE):
+               std=None, same_page_merge_policy=value_module.CONCATENATE,
+               improvement_direction=None):
     super(ListOfScalarValues, self).__init__(page, name, units, important,
-                                             description, tir_label)
+                                             description, tir_label,
+                                             improvement_direction)
     if values is not None:
       assert isinstance(values, list)
       assert len(values) > 0
       assert all(isinstance(v, numbers.Number) for v in values)
       assert std is None or isinstance(std, numbers.Number)
     else:
       assert std is None
     none_values.ValidateNoneValueReason(values, none_value_reason)
     self.values = values
     self.none_value_reason = none_value_reason
@@ skipping 16 matching lines @@
     if self.page:
       page_name = self.page.display_name
     else:
       page_name = 'None'
     if self.same_page_merge_policy == value_module.CONCATENATE:
       merge_policy = 'CONCATENATE'
     else:
       merge_policy = 'PICK_FIRST'
     return ('ListOfScalarValues(%s, %s, %s, %s, '
             'important=%s, description=%s, tir_label=%s, '
-            'same_page_merge_policy=%s)') % (
-              page_name,
-              self.name,
-              self.units,
-              repr(self.values),
-              self.important,
-              self.description,
-              self.tir_label,
-              merge_policy)
+            'same_page_merge_policy=%s, improvement_direction=%s)') % (
+                page_name,
+                self.name,
+                self.units,
+                repr(self.values),
+                self.important,
+                self.description,
+                self.tir_label,
+                merge_policy,
+                self.improvement_direction)
 
   def GetBuildbotDataType(self, output_context):
     if self._IsImportantGivenOutputIntent(output_context):
       return 'default'
     return 'unimportant'
 
   def GetBuildbotValue(self):
     return self.values
 
   def GetRepresentativeNumber(self):
@@ skipping 18 matching lines @@
     if self.none_value_reason is not None:
       d['none_value_reason'] = self.none_value_reason
 
     return d
 
   @staticmethod
   def FromDict(value_dict, page_dict):
     kwargs = value_module.Value.GetConstructorKwArgs(value_dict, page_dict)
     kwargs['values'] = value_dict['values']
     kwargs['std'] = value_dict['std']
+    kwargs['improvement_direction'] = value_dict['improvement_direction']
 
     if 'none_value_reason' in value_dict:
       kwargs['none_value_reason'] = value_dict['none_value_reason']
     if 'tir_label' in value_dict:
       kwargs['tir_label'] = value_dict['tir_label']
 
     return ListOfScalarValues(**kwargs)
 
   @classmethod
   def MergeLikeValuesFromSamePage(cls, values):
     assert len(values) > 0
     v0 = values[0]
 
     if v0.same_page_merge_policy == value_module.PICK_FIRST:
       return ListOfScalarValues(
           v0.page, v0.name, v0.units,
           values[0].values,
           important=v0.important,
           same_page_merge_policy=v0.same_page_merge_policy,
-          none_value_reason=v0.none_value_reason)
+          none_value_reason=v0.none_value_reason,
+          improvement_direction=v0.improvement_direction)
 
     assert v0.same_page_merge_policy == value_module.CONCATENATE
     return cls._MergeLikeValues(values, v0.page, v0.name, v0.tir_label)
 
   @classmethod
   def MergeLikeValuesFromDifferentPages(cls, values):
     assert len(values) > 0
     v0 = values[0]
     return cls._MergeLikeValues(values, None, v0.name, v0.tir_label)
 
@@ skipping 14 matching lines @@
     if merged_values:
       pooled_std = PooledStandardDeviation(
           list_of_samples, list_of_variances=[v.variance for v in values])
     return ListOfScalarValues(
         page, name, v0.units,
         merged_values,
         important=v0.important,
         tir_label=tir_label,
         same_page_merge_policy=v0.same_page_merge_policy,
         std=pooled_std,
-        none_value_reason=none_value_reason)
+        none_value_reason=none_value_reason,
+        improvement_direction=v0.improvement_direction)