rebaseline_server: allow live queries to examine JSONKEY_EXPECTEDRESULTS or JSONKEY_ACTUALRESULTS

gm/rebaseline_server/compare_rendered_pictures.py

 #!/usr/bin/python
 
 """
 Copyright 2014 Google Inc.
 
 Use of this source code is governed by a BSD-style license that can be
 found in the LICENSE file.
 
 Compare results of two render_pictures runs.
 
@@ skipping 43 matching lines @@
     COLUMN__TILED_OR_WHOLE,
     COLUMN__TILENUM,
 ]
 
 # A special "repo:" URL type that we use to refer to Skia repo contents.
 # (Useful for comparing against expectations files we store in our repo.)
 REPO_URL_PREFIX = 'repo:'
 REPO_BASEPATH = os.path.abspath(os.path.join(
     os.path.dirname(os.path.abspath(__file__)), os.pardir, os.pardir))
 
+# Which sections within a JSON summary file can contain results.
+ALLOWED_SECTION_NAMES = [
+    gm_json.JSONKEY_ACTUALRESULTS,
+    gm_json.JSONKEY_EXPECTEDRESULTS,
+]
+
 
 class RenderedPicturesComparisons(results.BaseComparisons):
   """Loads results from multiple render_pictures runs into an ImagePairSet.
   """
 
-  def __init__(self, setA_dirs, setB_dirs, image_diff_db,
-               image_base_gs_url=DEFAULT_IMAGE_BASE_GS_URL,
-               diff_base_url=None, setA_label='setA',
-               setB_label='setB', gs=None,
-               truncate_results=False, prefetch_only=False,
+  def __init__(self,
+               setA_dirs, setB_dirs,

[epoger, 2014/08/07 17:27:36]

Added some extra linefeeds here to visually group the parameters.  Let me know
if you find this offensive.

[rmistry, 2014/08/07 18:57:05]

makes sense to me.

+               setA_section, setB_section,
+               image_diff_db,
+               image_base_gs_url=DEFAULT_IMAGE_BASE_GS_URL, diff_base_url=None,
+               setA_label='setA', setB_label='setB',
+               gs=None, truncate_results=False, prefetch_only=False,
                download_all_images=False):
     """Constructor: downloads images and generates diffs.
 
     Once the object has been created (which may take a while), you can call its
     get_packaged_results_of_type() method to quickly retrieve the results...
     unless you have set prefetch_only to True, in which case we will
     asynchronously warm up the ImageDiffDB cache but not fill in self._results.
 
     Args:
       setA_dirs: list of root directories to copy all JSON summaries from,
           and to use as setA within the comparisons. These directories may be
           gs:// URLs, special "repo:" URLs, or local filepaths.
       setB_dirs: list of root directories to copy all JSON summaries from,
           and to use as setB within the comparisons. These directories may be
           gs:// URLs, special "repo:" URLs, or local filepaths.
+      setA_section: which section within setA to examine; must be one of
+          ALLOWED_SECTION_NAMES
+      setB_section: which section within setB to examine; must be one of
+          ALLOWED_SECTION_NAMES
       image_diff_db: ImageDiffDB instance
       image_base_gs_url: "gs://" URL pointing at the Google Storage bucket/dir
           under which all render_pictures result images can
           be found; this will be used to read images for comparison within
           this code, and included in the ImagePairSet (as an HTTP URL) so its
           consumers know where to download the images from
       diff_base_url: base URL within which the client should look for diff
           images; if not specified, defaults to a "file:///" URL representation
           of image_diff_db's storage_root
       setA_label: description to use for results in setA
@@ skipping 26 matching lines @@
     tempdir = tempfile.mkdtemp()
     try:
       setA_root = os.path.join(tempdir, 'setA')
       setB_root = os.path.join(tempdir, 'setB')
       for source_dir in setA_dirs:
         self._copy_dir_contents(source_dir=source_dir, dest_dir=setA_root)
       for source_dir in setB_dirs:
         self._copy_dir_contents(source_dir=source_dir, dest_dir=setB_root)
 
       time_start = int(time.time())
-      # TODO(epoger): For now, this assumes that we are always comparing two
-      # sets of actual results, not actuals vs expectations.  Allow the user
-      # to control this.
       self._results = self._load_result_pairs(
-          setA_root=setA_root, setA_section=gm_json.JSONKEY_ACTUALRESULTS,
-          setB_root=setB_root, setB_section=gm_json.JSONKEY_ACTUALRESULTS)
+          setA_root=setA_root, setA_section=setA_section,
+          setB_root=setB_root, setB_section=setB_section)
       if self._results:
         self._timestamp = int(time.time())
         logging.info('Number of download file collisions: %s' %
                      imagediffdb.global_file_collisions)
         logging.info('Results complete; took %d seconds.' %
                      (self._timestamp - time_start))
     finally:
       shutil.rmtree(tempdir)
 
   def _load_result_pairs(self, setA_root, setA_section, setB_root,
@@ skipping 73 matching lines @@
             dictA_results, None,
             skp_name, gm_json.JSONKEY_SOURCE_WHOLEIMAGE)
         whole_image_B = self.get_default(
             dictB_results, None,
             skp_name, gm_json.JSONKEY_SOURCE_WHOLEIMAGE)
         imagepairs_for_this_skp.append(self._create_image_pair(
             image_dict_A=whole_image_A, image_dict_B=whole_image_B,
             source_skp_name=skp_name, tilenum=None))
 
         tiled_images_A = self.get_default(
-            dictA_results, None,
+            dictA_results, [],
             skp_name, gm_json.JSONKEY_SOURCE_TILEDIMAGES)
         tiled_images_B = self.get_default(
-            dictB_results, None,
+            dictB_results, [],
             skp_name, gm_json.JSONKEY_SOURCE_TILEDIMAGES)
-        # TODO(epoger): Report an error if we find tiles for A but not B?
-        if tiled_images_A and tiled_images_B:
-          # TODO(epoger): Report an error if we find a different number of tiles
-          # for A and B?
-          num_tiles = len(tiled_images_A)
+        if tiled_images_A or tiled_images_B:

[epoger, 2014/08/07 17:27:36]

Made these changes so that empty expectations show up as lots of no-comparison
results, not a completely blank list.

[rmistry, 2014/08/07 18:57:05]

Acknowledged.

+          num_tiles_A = len(tiled_images_A)
+          num_tiles_B = len(tiled_images_B)
+          num_tiles = max(num_tiles_A, num_tiles_B)
           for tile_num in range(num_tiles):
             imagepairs_for_this_skp.append(self._create_image_pair(
-                image_dict_A=tiled_images_A[tile_num],
-                image_dict_B=tiled_images_B[tile_num],
+                image_dict_A=(tiled_images_A[tile_num]
+                              if tile_num < num_tiles_A else None),
+                image_dict_B=(tiled_images_B[tile_num]
+                              if tile_num < num_tiles_B else None),
                 source_skp_name=skp_name, tilenum=tile_num))
 
         for one_imagepair in imagepairs_for_this_skp:
           if one_imagepair:
             all_image_pairs.add_image_pair(one_imagepair)
             result_type = one_imagepair.extra_columns_dict\
                 [COLUMN__RESULT_TYPE]
             if result_type != results.KEY__RESULT_TYPE__SUCCEEDED:
               failing_image_pairs.add_image_pair(one_imagepair)
 
@@ skipping 109 matching lines @@
     """
     if gs_utils.GSUtils.is_gs_url(source_dir):
       (bucket, path) = gs_utils.GSUtils.split_gs_url(source_dir)
       self._gs.download_dir_contents(source_bucket=bucket, source_dir=path,
                                      dest_dir=dest_dir)
     elif source_dir.lower().startswith(REPO_URL_PREFIX):
       repo_dir = os.path.join(REPO_BASEPATH, source_dir[len(REPO_URL_PREFIX):])
       shutil.copytree(repo_dir, dest_dir)
     else:
       shutil.copytree(source_dir, dest_dir)