rebaseline.py: add ability to write new expectations to a different file

tools/rebaseline.py

 #!/usr/bin/python
 
 '''
 Copyright 2012 Google Inc.
 
 Use of this source code is governed by a BSD-style license that can be
 found in the LICENSE file.
 '''
 
 '''
@@ skipping 105 matching lines @@
             print >> sys.stderr, ('Encountered %d failures (see above).' %
                                   len(self._failures_encountered))
             self._Exit()
 
 
 # Object that rebaselines a JSON expectations file (not individual image files).
 class JsonRebaseliner(object):
 
     # params:
     #  expectations_root: root directory of all expectations JSON files
-    #  expectations_filename: filename (under expectations_root) of JSON
-    #                         expectations file; typically
-    #                         "expected-results.json"
+    #  expectations_input_filename: filename (under expectations_root) of JSON
+    #                               expectations file to read; typically
+    #                               "expected-results.json"
+    #  expectations_output_filename: filename (under expectations_root) to
+    #                                which updated expectations should be
+    #                                written; typically the same as
+    #                                expectations_input_filename, to overwrite
+    #                                the old content
     #  actuals_base_url: base URL from which to read actual-result JSON files
     #  actuals_filename: filename (under actuals_base_url) from which to read a
     #                    summary of results; typically "actual-results.json"
     #  exception_handler: reference to rebaseline.ExceptionHandler object
     #  tests: list of tests to rebaseline, or None if we should rebaseline
     #         whatever files the JSON results summary file tells us to
     #  configs: which configs to run for each test, or None if we should
     #           rebaseline whatever configs the JSON results summary file tells
     #           us to
     #  add_new: if True, add expectations for tests which don't have any yet
-    def __init__(self, expectations_root, expectations_filename,
-                 actuals_base_url, actuals_filename, exception_handler,
+    def __init__(self, expectations_root, expectations_input_filename,
+                 expectations_output_filename, actuals_base_url,
+                 actuals_filename, exception_handler,
                  tests=None, configs=None, add_new=False):
         self._expectations_root = expectations_root
-        self._expectations_filename = expectations_filename
+        self._expectations_input_filename = expectations_input_filename
+        self._expectations_output_filename = expectations_output_filename
         self._tests = tests
         self._configs = configs
         self._actuals_base_url = actuals_base_url
         self._actuals_filename = actuals_filename
         self._exception_handler = exception_handler
         self._add_new = add_new
         self._image_filename_re = re.compile(gm_json.IMAGE_FILENAME_PATTERN)
         self._using_svn = os.path.isdir(os.path.join(expectations_root, '.svn'))
 
     # Executes subprocess.call(cmd).
@@ skipping 72 matching lines @@
         # succeeding, but including the SUCCEEDED results will allow us to
         # re-record expectations if they somehow get out of sync.
         sections = [gm_json.JSONKEY_ACTUALRESULTS_FAILED,
                     gm_json.JSONKEY_ACTUALRESULTS_SUCCEEDED]
         if self._add_new:
             sections.append(gm_json.JSONKEY_ACTUALRESULTS_NOCOMPARISON)
         results_to_update = self._GetActualResults(json_url=actuals_url,
                                                    sections=sections)
 
         # Read in current expectations.
-        expectations_json_filepath = os.path.join(
-            self._expectations_root, subdir, self._expectations_filename)
-        expectations_dict = gm_json.LoadFromFile(expectations_json_filepath)
+        expectations_input_filepath = os.path.join(
+            self._expectations_root, subdir, self._expectations_input_filename)
+        expectations_dict = gm_json.LoadFromFile(expectations_input_filepath)
         expected_results = expectations_dict[gm_json.JSONKEY_EXPECTEDRESULTS]
 
         # Update the expectations in memory, skipping any tests/configs that
         # the caller asked to exclude.
         skipped_images = []
         if results_to_update:
             for (image_name, image_results) in results_to_update.iteritems():
                 (test, config) = \
                     self._image_filename_re.match(image_name).groups()
                 if self._tests:
                     if test not in self._tests:
                         skipped_images.append(image_name)
                         continue
                 if self._configs:
                     if config not in self._configs:
                         skipped_images.append(image_name)
                         continue
                 if not expected_results.get(image_name):
                     expected_results[image_name] = {}
                 expected_results[image_name] \
                     [gm_json.JSONKEY_EXPECTEDRESULTS_ALLOWEDDIGESTS] = \
                         [image_results]
 
         # Write out updated expectations.
-        gm_json.WriteToFile(expectations_dict, expectations_json_filepath)
+        expectations_output_filepath = os.path.join(
+            self._expectations_root, subdir, self._expectations_output_filename)
+        gm_json.WriteToFile(expectations_dict, expectations_output_filepath)
 
         # Mark the JSON file as plaintext, so text-style diffs can be applied.
         # Fixes https://code.google.com/p/skia/issues/detail?id=1442
         if self._using_svn:
             self._Call(['svn', 'propset', '--quiet', 'svn:mime-type',
-                        'text/x-json', expectations_json_filepath])
+                        'text/x-json', expectations_output_filepath])
 
 # main...
 
 parser = argparse.ArgumentParser()
 parser.add_argument('--actuals-base-url',
                     help='base URL from which to read files containing JSON ' +
                     'summaries of actual GM results; defaults to %(default)s',
                     default='http://skia-autogen.googlecode.com/svn/gm-actual')
 parser.add_argument('--actuals-filename',
                     help='filename (within platform-specific subdirectories ' +
@@ skipping 14 matching lines @@
                     '*all* configs that are available.')
 # TODO(epoger): The --dry-run argument will no longer be needed once we
 # are only rebaselining JSON files.
 parser.add_argument('--dry-run', action='store_true',
                     help='instead of actually downloading files or adding ' +
                     'files to checkout, display a list of operations that ' +
                     'we would normally perform')
 parser.add_argument('--expectations-filename',
                     help='filename (under EXPECTATIONS_ROOT) to read ' +
                     'current expectations from, and to write new ' +
-                    'expectations into; defaults to %(default)s',
+                    'expectations into (unless a separate ' +
+                    'EXPECTATIONS_FILENAME_OUTPUT has been specified); ' +
+                    'defaults to %(default)s',
                     default='expected-results.json')
+parser.add_argument('--expectations-filename-output',

[epoger, 2013/07/24 19:31:34]

Here's what this section of the --help output looks like:

  --expectations-filename EXPECTATIONS_FILENAME
                        filename (under EXPECTATIONS_ROOT) to read current
                        expectations from, and to write new expectations into
                        (unless a separate EXPECTATIONS_FILENAME_OUTPUT has
                        been specified); defaults to expected-results.json
  --expectations-filename-output EXPECTATIONS_FILENAME_OUTPUT
                        filename (under EXPECTATIONS_ROOT) to write updated
                        expectations into; by default, overwrites the input
                        file (EXPECTATIONS_FILENAME)
  --expectations-root EXPECTATIONS_ROOT
                        root of expectations directory to update-- should
                        contain one or more base-* subdirectories. Defaults to
                        expectations/gm

+                    help='filename (under EXPECTATIONS_ROOT) to write ' +
+                    'updated expectations into; by default, overwrites the ' +
+                    'input file (EXPECTATIONS_FILENAME)',
+                    default='')
 parser.add_argument('--expectations-root',
                     help='root of expectations directory to update-- should ' +
                     'contain one or more base-* subdirectories. Defaults to ' +
                     '%(default)s',
                     default=os.path.join('expectations', 'gm'))
 parser.add_argument('--keep-going-on-failure', action='store_true',
                     help='instead of halting at the first error encountered, ' +
                     'keep going and rebaseline as many tests as possible, ' +
                     'and then report the full set of errors at the end')
 parser.add_argument('--subdirs', metavar='SUBDIR', nargs='+',
@@ skipping 27 matching lines @@
     # individual image files.  Different expectations/gm subdirectories may move
     # from individual image files to JSON-format expectations at different
     # times, so we need to make this determination per subdirectory.
     #
     # See https://goto.google.com/ChecksumTransitionDetail
     expectations_json_file = os.path.join(args.expectations_root, subdir,
                                           args.expectations_filename)
     if os.path.isfile(expectations_json_file):
         rebaseliner = JsonRebaseliner(
             expectations_root=args.expectations_root,
-            expectations_filename=args.expectations_filename,
+            expectations_input_filename=args.expectations_filename,
+            expectations_output_filename=(args.expectations_filename_output or
+                                          args.expectations_filename),
             tests=args.tests, configs=args.configs,
             actuals_base_url=args.actuals_base_url,
             actuals_filename=args.actuals_filename,
             exception_handler=exception_handler,
             add_new=args.add_new)
     else:
         # TODO(epoger): When we get rid of the ImageRebaseliner implementation,
         # we should raise an Exception in this case (no JSON expectations file
         # found to update), to prevent a recurrence of
         # https://code.google.com/p/skia/issues/detail?id=1403 ('rebaseline.py
         # script fails with misleading output when run outside of gm-expected
         # dir')
         rebaseliner = rebaseline_imagefiles.ImageRebaseliner(
             expectations_root=args.expectations_root,
             tests=args.tests, configs=args.configs,
             dry_run=args.dry_run,
             json_base_url=args.actuals_base_url,
             json_filename=args.actuals_filename,
             exception_handler=exception_handler,
             add_new=args.add_new,
             missing_json_is_fatal=missing_json_is_fatal)
 
     try:
         rebaseliner.RebaselineSubdir(subdir=subdir, builder=builder)
     except BaseException as e:
         exception_handler.RaiseExceptionOrContinue(e)
 
 exception_handler.ReportAllFailures()