rename rebaseline_server JSON constants to be more consistent

gm/rebaseline_server/compare_to_expectations.py

 #!/usr/bin/python
 
 """
 Copyright 2013 Google Inc.
 
 Use of this source code is governed by a BSD-style license that can be
 found in the LICENSE file.
 
 Repackage expected/actual GM results as needed by our HTML rebaseline viewer.
 """
@@ skipping 87 matching lines @@
 
     Note that this will NOT update the results stored in self._results[] ;
     in order to see those updates, you must instantiate a new
     ExpectationComparisons object based on the (now updated) files on disk.
 
     Args:
       modifications: a list of dictionaries, one for each expectation to update:
 
          [
            {
-             imagepair.KEY__EXPECTATIONS_DATA: {
+             imagepair.KEY__IMAGEPAIRS__EXPECTATIONS: {
                results.KEY__EXPECTATIONS__BUGS: [123, 456],
                results.KEY__EXPECTATIONS__IGNOREFAILURE: false,
                results.KEY__EXPECTATIONS__REVIEWED: true,
              },
-             imagepair.KEY__EXTRA_COLUMN_VALUES: {
-               results.KEY__EXTRACOLUMN__BUILDER: 'Test-Mac10.6-MacMini4.1-GeForce320M-x86-Debug',
-               results.KEY__EXTRACOLUMN__CONFIG: '8888',
-               results.KEY__EXTRACOLUMN__TEST: 'bigmatrix',
+             imagepair.KEY__IMAGEPAIRS__EXTRACOLUMNS: {
+               results.KEY__EXTRACOLUMNS__BUILDER: 'Test-Mac10.6-MacMini4.1-GeForce320M-x86-Debug',
+               results.KEY__EXTRACOLUMNS__CONFIG: '8888',
+               results.KEY__EXTRACOLUMNS__TEST: 'bigmatrix',
              },
-             results.KEY__NEW_IMAGE_URL: 'bitmap-64bitMD5/bigmatrix/10894408024079689926.png',
+             results.KEY__IMAGEPAIRS__IMAGE_B_URL: 'bitmap-64bitMD5/bigmatrix/10894408024079689926.png',
            },
            ...
          ]
 
     """
     expected_builder_dicts = self._read_builder_dicts_from_root(
         self._expected_root)
     for mod in modifications:
       image_name = results.IMAGE_FILENAME_FORMATTER % (
-          mod[imagepair.KEY__EXTRA_COLUMN_VALUES]
-             [results.KEY__EXTRACOLUMN__TEST],
-          mod[imagepair.KEY__EXTRA_COLUMN_VALUES]
-             [results.KEY__EXTRACOLUMN__CONFIG])
+          mod[imagepair.KEY__IMAGEPAIRS__EXTRACOLUMNS]
+             [results.KEY__EXTRACOLUMNS__TEST],
+          mod[imagepair.KEY__IMAGEPAIRS__EXTRACOLUMNS]
+             [results.KEY__EXTRACOLUMNS__CONFIG])
       _, hash_type, hash_digest = gm_json.SplitGmRelativeUrl(
-          mod[results.KEY__NEW_IMAGE_URL])
+          mod[imagepair.KEY__IMAGEPAIRS__IMAGE_B_URL])
       allowed_digests = [[hash_type, int(hash_digest)]]
       new_expectations = {
           gm_json.JSONKEY_EXPECTEDRESULTS_ALLOWEDDIGESTS: allowed_digests,
       }
       for field in EXPECTATION_FIELDS_PASSED_THRU_VERBATIM:
-        value = mod[imagepair.KEY__EXPECTATIONS_DATA].get(field)
+        value = mod[imagepair.KEY__IMAGEPAIRS__EXPECTATIONS].get(field)
         if value is not None:
           new_expectations[field] = value
       builder_dict = expected_builder_dicts[
-          mod[imagepair.KEY__EXTRA_COLUMN_VALUES]
-             [results.KEY__EXTRACOLUMN__BUILDER]]
+          mod[imagepair.KEY__IMAGEPAIRS__EXTRACOLUMNS]
+             [results.KEY__EXTRACOLUMNS__BUILDER]]
       builder_expectations = builder_dict.get(gm_json.JSONKEY_EXPECTEDRESULTS)
       if not builder_expectations:
         builder_expectations = {}
         builder_dict[gm_json.JSONKEY_EXPECTEDRESULTS] = builder_expectations
       builder_expectations[image_name] = new_expectations
     ExpectationComparisons._write_dicts_to_root(
         expected_builder_dicts, self._expected_root)
 
   @staticmethod
   def _write_dicts_to_root(meta_dict, root, pattern='*.json'):
@@ skipping 54 matching lines @@
         self._expected_root)
 
     all_image_pairs = imagepairset.ImagePairSet(
         descriptions=IMAGEPAIR_SET_DESCRIPTIONS,
         diff_base_url=self._diff_base_url)
     failing_image_pairs = imagepairset.ImagePairSet(
         descriptions=IMAGEPAIR_SET_DESCRIPTIONS,
         diff_base_url=self._diff_base_url)
 
     all_image_pairs.ensure_extra_column_values_in_summary(
-        column_id=results.KEY__EXTRACOLUMN__RESULT_TYPE, values=[
+        column_id=results.KEY__EXTRACOLUMNS__RESULT_TYPE, values=[
             results.KEY__RESULT_TYPE__FAILED,
             results.KEY__RESULT_TYPE__FAILUREIGNORED,
             results.KEY__RESULT_TYPE__NOCOMPARISON,
             results.KEY__RESULT_TYPE__SUCCEEDED,
         ])
     failing_image_pairs.ensure_extra_column_values_in_summary(
-        column_id=results.KEY__EXTRACOLUMN__RESULT_TYPE, values=[
+        column_id=results.KEY__EXTRACOLUMNS__RESULT_TYPE, values=[
             results.KEY__RESULT_TYPE__FAILED,
             results.KEY__RESULT_TYPE__FAILUREIGNORED,
             results.KEY__RESULT_TYPE__NOCOMPARISON,
         ])
 
     # Only consider builders we have both expected and actual results for.
     # Fixes http://skbug.com/2486 ('rebaseline_server shows actual results
     # (but not expectations) for Test-Ubuntu12-ShuttleA-NoGPU-x86_64-Debug
     # builder')
     actual_builder_set = set(actual_builder_dicts.keys())
@@ skipping 54 matching lines @@
             #   rendering mode even though we don't have explicit expectations
             #   for the test (the implicit expectation is that it must
             #   render the same in all rendering modes).
             #
             # Don't log type 1, because it is common.
             # Log other types, because they are rare and we should know about
             # them, but don't throw an exception, because we need to keep our
             # tools working in the meanwhile!
             if result_type != results.KEY__RESULT_TYPE__NOCOMPARISON:
               logging.warning('No expectations found for test: %s' % {
-                  results.KEY__EXTRACOLUMN__BUILDER: builder,
-                  results.KEY__EXTRACOLUMN__RESULT_TYPE: result_type,
+                  results.KEY__EXTRACOLUMNS__BUILDER: builder,
+                  results.KEY__EXTRACOLUMNS__RESULT_TYPE: result_type,
                   'image_name': image_name,
                   })
 
           # If this test was recently rebaselined, it will remain in
           # the 'failed' set of actuals until all the bots have
           # cycled (although the expectations have indeed been set
           # from the most recent actuals).  Treat these as successes
           # instead of failures.
           #
           # TODO(epoger): Do we need to do something similar in
           # other cases, such as when we have recently marked a test
           # as ignoreFailure but it still shows up in the 'failed'
           # category?  Maybe we should not rely on the result_type
           # categories recorded within the gm_actuals AT ALL, and
           # instead evaluate the result_type ourselves based on what
           # we see in expectations vs actual checksum?
           # See related http://skbug.com/2514 ('rebaseline_server: apply
           # ignored-tests.txt within rebaseline_server, not just on the bots')
           if expected_image_relative_url == actual_image_relative_url:
             updated_result_type = results.KEY__RESULT_TYPE__SUCCEEDED
           else:
             updated_result_type = result_type
           extra_columns_dict = {
-              results.KEY__EXTRACOLUMN__RESULT_TYPE: updated_result_type,
-              results.KEY__EXTRACOLUMN__BUILDER: builder,
-              results.KEY__EXTRACOLUMN__TEST: test,
-              results.KEY__EXTRACOLUMN__CONFIG: config,
+              results.KEY__EXTRACOLUMNS__RESULT_TYPE: updated_result_type,
+              results.KEY__EXTRACOLUMNS__BUILDER: builder,
+              results.KEY__EXTRACOLUMNS__TEST: test,
+              results.KEY__EXTRACOLUMNS__CONFIG: config,
           }
           try:
             image_pair = imagepair.ImagePair(
                 image_diff_db=self._image_diff_db,
                 base_url=gm_json.GM_ACTUALS_ROOT_HTTP_URL,
                 imageA_relative_url=expected_image_relative_url,
                 imageB_relative_url=actual_image_relative_url,
                 expectations=expectations_dict,
                 extra_columns=extra_columns_dict)
             all_image_pairs.add_image_pair(image_pair)
@@ skipping 38 matching lines @@
   results_obj = ExpectationComparisons(actuals_root=args.actuals,
                                        expected_root=args.expectations,
                                        generated_images_root=args.workdir)
   gm_json.WriteToFile(
       results_obj.get_packaged_results_of_type(results_type=args.results),
       args.outfile)
 
 
 if __name__ == '__main__':
   main()