[LNT] Refactored plot_parameters

[kpdev42]

Summary

Arguments like plot.0=1.2.3 are the same for the pages Graph and Matrix.
The class MatrixDataRequest has been renamed to PlotParameter
The common code has been moved to helper functions assert_field_idx_valid(), load_plot_parameter(), parse_plot_parameters(),parse_and_load_plot_parameters(), parse_mean_parameter().
Renamed graph_parameters and data_parameters to plot_parameters.

OS Laboratory. Huawei Russian Research Institute. Saint-Petersburg

[thopre]

LGTM, but that patch introduces some flake8 regressions:

./lnt/server/ui/views.py:23:1: F401 'typing.List' imported but unused
./lnt/server/ui/views.py:765:13: E128 continuation line under-indented for visual indent
./lnt/server/ui/views.py:765:88: E502 the backslash is redundant between brackets
./lnt/server/ui/views.py:766:13: E128 continuation line under-indented for visual indent
./lnt/server/ui/views.py:815:84: E502 the backslash is redundant between brackets
./lnt/server/ui/views.py:819:9: E303 too many blank lines (2)
./lnt/server/ui/views.py:838:1: W293 blank line contains whitespace
./lnt/server/ui/views.py:854:13: E128 continuation line under-indented for visual indent
./lnt/server/ui/views.py:881:23: E128 continuation line under-indented for visual indent
./lnt/server/ui/views.py:903:23: E128 continuation line under-indented for visual indent
./lnt/server/ui/views.py:904:23: E128 continuation line under-indented for visual indent
6 E128 continuation line under-indented for visual indent
1 E303 too many blank lines (2)
2 E502 the backslash is redundant between brackets
1 F401 'typing.List' imported but unused
1 W293 blank line contains whitespace

Please fix those and run tox to check that it's happy.

[kpdev42]

Add cosmetics

[thopre]

Still have the following when running tox:

./lnt/server/ui/views.py:852:13: E128 continuation line under-indented for visual indent
./lnt/server/ui/views.py:880:28: E127 continuation line over-indented for visual indent
./lnt/server/ui/views.py:903:28: E127 continuation line over-indented for visual indent
2     E127 continuation line over-indented for visual indent
1     E128 continuation line under-indented for visual indent

[thopre]

lnt/server/ui/views.py

851–852

878–883

I think that's what flake8 wants, but do check by running tox.

[thopre]

lnt/server/ui/views.py

900–906

I think that's what tox wants.

[thopre]

LGTM with the proposed changes. I'll land it for you with them.

[kpdev42]

Fixed flake8 regressions

[kpdev42]

In D112607#3092853, @thopre wrote:

LGTM with the proposed changes. I'll land it for you with them.

Please check, thank you

[thopre]

In D112607#3092898, @kpdev42 wrote:

In D112607#3092853, @thopre wrote:

LGTM with the proposed changes. I'll land it for you with them.

Please check, thank you

Looks better than what I did but I've already landed the change.

lnt/server/ui/views.py

 from flask import flash
 from flask import g
 from flask import make_response
 from flask import render_template
 from flask import request, url_for
 from flask_wtf import Form
 from sqlalchemy.orm import joinedload
 from sqlalchemy.orm.exc import NoResultFound
-from typing import List, Optional
+from typing import Optional
 from wtforms import SelectField, StringField, SubmitField
 from wtforms.validators import DataRequired, Length
 
 import lnt.server.db.rules_manager
 import lnt.server.db.search
 import lnt.server.reporting.analysis
 import lnt.server.reporting.dailyreport
 import lnt.server.reporting.latestrunsreport
kwargs = {'plot.0': '{machine_id}.{test_id}.{field_index}'.format(
         field_index=field_index)}
     # Pass request args through, so you can add graph options.
     kwargs.update(request.args)
 
     graph_url = v4_url_for('.v4_graph', **kwargs)
     return v4_redirect(graph_url)
 
 
+class PlotParameter(object):
+    def __init__(self, machine, test, field, field_index):
+        self.machine = machine
+        self.test = test
+        self.field = field
+        self.field_index = field_index
+        self.samples = None
+
+    def __repr__(self):
+        return "{}:{}({} samples)" \
+            .format(self.machine.name,
+                    self.test.name,
+                    len(self.samples) if self.samples else "No")
+
+
+def assert_field_idx_valid(field_idx, count):
+    if not (0 <= field_idx < count):
+        return abort(404, "Invalid field index {}. Total sample_fileds for "
+                          "the current suite is {}.".format(field_idx, count))
+
+
+def load_plot_parameter(machine_id, test_id, field_index, session, ts):
+    try:
+        machine_id = int(machine_id)
+        test_id = int(test_id)
+        field_index = int(field_index)
+    except ValueError:
+        return abort(400, "Invalid plot arguments.")
+
+    try:
+        machine = session.query(ts.Machine) \
+            .filter(ts.Machine.id == machine_id) \
+            .one()
+    except NoResultFound:
+        return abort(404, "Invalid machine id {}".format(machine_id))
+    try:
+        test = session.query(ts.Test).filter(ts.Test.id == test_id).one()
+    except NoResultFound:
+        return abort(404, "Invalid test id {}".format(test_id))
+
+    assert_field_idx_valid(field_index, len(ts.sample_fields))
+    try:
+        field = ts.sample_fields[field_index]
+    except NoResultFound:
+        return abort(404, "Invalid field_index {}".format(field_index))
+
+    return PlotParameter(machine, test, field, field_index)
+
+
+def parse_plot_parameters(args):
+    """
+    Returns a list of tuples of integers (machine_id, test_id, field_index).
+    :param args: The request parameters dictionary.
+    """
+    plot_parameters = []
+    for name, value in args.items():
+        # Plots are passed as::
+        #
+        #  plot.<unused>=<machine id>.<test id>.<field index>
+        if not name.startswith('plot.'):
+            continue
+
+        # Ignore the extra part of the key, it is unused.
+
+        try:
+            machine_id, test_id, field_index = map(int, value.split('.'))
+        except ValueError:
+            return abort(400, "Parameter {} was malformed. {} must be int.int.int"
+                              .format(name, value))
+
+        plot_parameters.append((machine_id, test_id, field_index))
+
+    return plot_parameters
+
+
+def parse_and_load_plot_parameters(args, session, ts):
+    """
+    Parses plot parameters and loads the corresponding entities from the database.
+    Returns a list of PlotParameter instances sorted by machine name, test name and then field.
+    :param args: The request parameters dictionary.
+    :param session: The database session.
+    :param ts: The test suite.
+    """
+    plot_parameters = [load_plot_parameter(machine_id, test_id, field_index, session, ts)
+                       for (machine_id, test_id, field_index) in parse_plot_parameters(args)]
+    # Order the plots by machine name, test name and then field.
+    plot_parameters.sort(key=lambda plot_parameter:
+                         (plot_parameter.machine.name, plot_parameter.test.name,
+                          plot_parameter.field.name, plot_parameter.field_index))
+
+    return plot_parameters
+
+
+def parse_mean_parameter(args, session, ts):
+    # Mean to graph is passed as:
+    #
+    #  mean=<machine id>.<field index>
+    value = args.get('mean')
+    if not value:
+        return None
+
+    try:
+        machine_id, field_index = map(int, value.split('.'))
+    except ValueError:
+        return abort(400, "Invalid format of 'mean={}', expected "
+                          "mean=<machine id>.<field index>".format(value))
+
+    try:
+        machine = session.query(ts.Machine) \
+            .filter(ts.Machine.id == machine_id) \
+            .one()
+    except NoResultFound:
+        return abort(404, "Invalid machine id {}".format(machine_id))
+
+    assert_field_idx_valid(field_index, len(ts.sample_fields))
+    field = ts.sample_fields[field_index]
+
+    return machine, field
+
+
+def load_graph_data(plot_parameter, show_failures, revision_cache=None):
+
+    session = request.session
+    ts = request.get_testsuite()
+
+    # Load all the field values for this test on the same machine.
+    #
+    # FIXME: Don't join to Order here, aggregate this across all the tests
+    # we want to load. Actually, we should just make this a single query.
+    #
+    # FIXME: Don't hard code field name.
+    values = session.query(plot_parameter.field.column, ts.Order.llvm_project_revision,
+                           ts.Run.start_time, ts.Run.id) \
+                    .join(ts.Run).join(ts.Order) \
+                    .filter(ts.Run.machine_id == plot_parameter.machine.id) \
+                    .filter(ts.Sample.test == plot_parameter.test) \
+                    .filter(plot_parameter.field.column.isnot(None))
+    # Unless all samples requested, filter out failing tests.
+    if not show_failures:
+        if plot_parameter.field.status_field:
+            values = values.filter((plot_parameter.field.status_field.column == PASS) |
+                                   (plot_parameter.field.status_field.column.is_(None)))
+
+    # Aggregate by revision.
+    data = list(multidict.multidict((rev, (val, date, run_id))
+                                    for val, rev, date, run_id in values).items())
+    data.sort(key=lambda sample: convert_revision(sample[0], cache=revision_cache))
+    return data
+
+
+def load_geomean_data(field, machine):
+    session = request.session
+    ts = request.get_testsuite()
+    values = session.query(sqlalchemy.sql.func.min(field.column),
+                           ts.Order.llvm_project_revision,
+                           sqlalchemy.sql.func.min(ts.Run.start_time)) \
+                    .join(ts.Run).join(ts.Order).join(ts.Test) \
+                    .filter(ts.Run.machine_id == machine.id) \
+                    .filter(field.column.isnot(None)) \
+                    .group_by(ts.Order.llvm_project_revision, ts.Test)
+
+    # Calculate geomean of each revision.
+    data = multidict.multidict(((rev, date), val) for val, rev, date in values).items()
+    data = [(rev, [(calc_geomean(vals), date)]) for ((rev, date), vals) in data]
+    # Sort data points according to revision number.
+    data.sort(key=lambda sample: convert_revision(sample[0]))
+    return data
+
+
 @v4_route("/graph")
 def v4_graph():
 
     session = request.session
     ts = request.get_testsuite()
     switch_min_mean_local = False
 
     if 'switch_min_mean_session' not in flask.session:
def v4_graph():
     options['hide_highlight'] = bool(
         request.args.get('hide_highlight'))
     options['logarithmic_scale'] = bool(
         request.args.get('logarithmic_scale'))
 
     show_highlight = not options['hide_highlight']
 
     # Load the graph parameters.
-    GraphParameter = namedtuple('GraphParameter',
-                                ['machine', 'test', 'field', 'field_index'])
-    graph_parameters = []
-    for name, value in request.args.items():
-        # Plots to graph are passed as::
-        #
-        #  plot.<unused>=<machine id>.<test id>.<field index>
-        if not name.startswith(str('plot.')):
-            continue
-
-        # Ignore the extra part of the key, it is unused.
-        try:
-            machine_id_str, test_id_str, field_index_str = value.split('.')
-            machine_id = int(machine_id_str)
-            test_id = int(test_id_str)
-            field_index = int(field_index_str)
-        except ValueError:
-            return abort(400, "Parameter {} was malformed. {} must be int.int.int" \
-                              .format(name, value))
-
-        if not (0 <= field_index < len(ts.sample_fields)):
-            return abort(404, "Invalid field index {}".format(field_index))
-
-        try:
-            machine = session.query(ts.Machine) \
-                             .filter(ts.Machine.id == machine_id) \
-                             .one()
-        except NoResultFound:
-            return abort(404, "Invalid machine id {}".format(machine_id))
-        try:
-            test = session.query(ts.Test).filter(ts.Test.id == test_id).one()
-        except NoResultFound:
-            return abort(404, "Invalid test id {}".format(test_id))
-        try:
-            field = ts.sample_fields[field_index]
-        except NoResultFound:
-            return abort(404, "Invalid field_index {}".format(field_index))
-        graph_parameters.append(GraphParameter(machine, test, field, field_index))
-
-    # Order the plots by machine name, test name and then field.
-    graph_parameters.sort(key=lambda graph_parameter:
-                          (graph_parameter.machine.name, graph_parameter.test.name,
-                           graph_parameter.field.name, graph_parameter.field_index))
+    plot_parameters = parse_and_load_plot_parameters(request.args, session, ts)
 
     # Extract requested mean trend.
-    mean_parameter = None
-    for name, value in request.args.items():
-        # Mean to graph is passed as:
-        #
-        #  mean=<machine id>.<field index>
-        if name != 'mean':
-            continue
-
-        machine_id_str, field_index_str = value.split('.')
-        try:
-            machine_id = int(machine_id_str)
-            field_index = int(field_index_str)
-        except ValueError:
-            return abort(400, "Parameter {} was malformed. {} must be int.int" \
-                              .format(name, value))
-
-        if not (0 <= field_index < len(ts.sample_fields)):
-            return abort(404, "Invalid field index {}".format(field_index))
-
-        try:
-            machine = session.query(ts.Machine) \
-                .filter(ts.Machine.id == machine_id) \
-                .one()
-        except NoResultFound:
-            return abort(404, "Invalid machine id {}".format(machine_id))
-        field = ts.sample_fields[field_index]
-
-        mean_parameter = (machine, field)
+    mean_parameter = parse_mean_parameter(request.args, session, ts)
 
     # Sanity check the arguments.
-    if not graph_parameters and not mean_parameter:
+    if not plot_parameters and not mean_parameter:
         return render_template("error.html", message="Nothing to graph.")
 
     # Extract requested baselines, and their titles.
     baseline_parameters = []
     for name, value in request.args.items():
         # Baselines to graph are passed as:
         #
         #  baseline.title=<run id>
def v4_graph():
 
     # Build the graph data.
     legend = []
     graph_plots = []
     graph_datum = []
     overview_plots = []
     baseline_plots = []
     revision_cache = {}
-    num_plots = len(graph_parameters)
-    for i, (machine, test, field, field_index) in enumerate(graph_parameters):
+    num_plots = len(plot_parameters)
+    for i, req in enumerate(plot_parameters):
         # Determine the base plot color.
         col = list(util.makeDarkColor(float(i) / num_plots))
-        url = "/".join([str(machine.id), str(test.id), str(field_index)])
-        legend.append(LegendItem(machine, test.name, field.name,
+        url = "/".join([str(req.machine.id), str(req.test.id), str(req.field_index)])
+        legend.append(LegendItem(req.machine, req.test.name, req.field.name,
                                  tuple(col), url))
 
         # Load all the field values for this test on the same machine.
-        #
-        # FIXME: Don't join to Order here, aggregate this across all the tests
-        # we want to load. Actually, we should just make this a single query.
-        #
-        # FIXME: Don't hard code field name.
-        q = session.query(field.column, ts.Order.llvm_project_revision,
-                          ts.Run.start_time, ts.Run.id) \
-            .join(ts.Run).join(ts.Order) \
-            .filter(ts.Run.machine_id == machine.id) \
-            .filter(ts.Sample.test == test) \
-            .filter(field.column.isnot(None))
-
-        # Unless all samples requested, filter out failing tests.
-        if not show_failures:
-            if field.status_field:
-                q = q.filter((field.status_field.column == PASS) |
-                             (field.status_field.column.is_(None)))
+        data = load_graph_data(req, show_failures, revision_cache)
 
-        # Aggregate by revision.
-        data = list(multidict.multidict((rev, (val, date, run_id))
-                                        for val, rev, date, run_id in q)
-                    .items())
-
-        data.sort(key=lambda sample: convert_revision(sample[0], cache=revision_cache))
-
-        graph_datum.append((test.name, data, col, field, url, machine))
+        graph_datum.append((req.test.name, data, col, req.field, url, req.machine))
 
         # Get baselines for this line
         num_baselines = len(baseline_parameters)
         for baseline_id, (baseline, baseline_title) in \
                 enumerate(baseline_parameters):
-            q_baseline = session.query(field.column,
+            q_baseline = session.query(req.field.column,
                                        ts.Order.llvm_project_revision,
                                        ts.Run.start_time, ts.Machine.name) \
                          .join(ts.Run).join(ts.Order).join(ts.Machine) \
                          .filter(ts.Run.id == baseline.id) \
-                         .filter(ts.Sample.test == test) \
-                         .filter(field.column.isnot(None))
+                         .filter(ts.Sample.test == req.test) \
+                         .filter(req.field.column.isnot(None))
             # In the event of many samples, use the mean of the samples as the
             # baseline.
             samples = []
             for sample in q_baseline:
                 samples.append(sample[0])
             # Skip this baseline if there is no data.
             if not samples:
                 continue
             mean = sum(samples)/len(samples)
             # Darken the baseline color distinguish from non-baselines.
             # Make a color closer to the sample than its neighbour.
             color_offset = float(baseline_id) / num_baselines / 2
             my_color = (i + color_offset) / num_plots
             dark_col = list(util.makeDarkerColor(my_color))
             str_dark_col = util.toColorString(dark_col)
             baseline_plots.append({
                 'color': str_dark_col,
                 'lineWidth': 2,
                 'yaxis': {'from': mean, 'to': mean},
                 'name': q_baseline[0].llvm_project_revision,
             })
             baseline_name = ("Baseline {} on {}"
                              .format(baseline_title, q_baseline[0].name))
             legend.append(LegendItem(BaselineLegendItem(
-                baseline_name, baseline.id), test.name, field.name, dark_col,
+                baseline_name, baseline.id), req.test.name, req.field.name, dark_col,
                 None))
 
     # Draw mean trend if requested.
     if mean_parameter:
         machine, field = mean_parameter
         test_name = 'Geometric Mean'
 
         col = (0, 0, 0)
         legend.append(LegendItem(machine, test_name, field.name, col, None))
-
-        q = session.query(sqlalchemy.sql.func.min(field.column),
-                          ts.Order.llvm_project_revision,
-                          sqlalchemy.sql.func.min(ts.Run.start_time)) \
-                   .join(ts.Run).join(ts.Order).join(ts.Test) \
-                   .filter(ts.Run.machine_id == machine.id) \
-                   .filter(field.column.isnot(None)) \
-                   .group_by(ts.Order.llvm_project_revision, ts.Test)
-
-        # Calculate geomean of each revision.
-        data = multidict.multidict(
-                    ((rev, date), val) for val, rev, date in q).items()
-        data = [(rev,
-                 [(lnt.server.reporting.analysis.calc_geomean(vals), date)])
-                for ((rev, date), vals) in data]
-
-        # Sort data points according to revision number.
-        data.sort(key=lambda sample: convert_revision(sample[0]))
-
+        data = load_geomean_data(field, machine)
         graph_datum.append((test_name, data, col, field, None, machine))
 
     for name, data, col, field, url, machine in graph_datum:
         # Compute the graph points.
         errorbar_data = []
         points_data = []
         pts = []
         moving_median_data = []
results = lnt.server.db.search.search(session, ts, query,
                                           default_machine=default_machine)
 
     return json.dumps(
         [('%s #%s' % (r.machine.name, r.order.llvm_project_revision),
           r.id)
          for r in results])
 
 
-class MatrixDataRequest(object):
-    def __init__(self, machine, test, field):
-        self.machine = machine
-        self.test = test
-        self.field = field
-
-    def __repr__(self):
-        return "{}:{}({} samples)" \
-            .format(self.machine.name,
-                    self.test.name,
-                    len(self.samples) if self.samples else "No")
-
-
 # How much data to render in the Matrix view.
 MATRIX_LIMITS = [
     ('12', 'Small'),
     ('50', 'Medium'),
     ('250', 'Large'),
     ('-1', 'All'),
 ]
 
def v4_matrix():
     session = request.session
     ts = request.get_testsuite()
     # Load the matrix request parameters.
     form = MatrixOptions(request.form)
     if request.method == 'POST':
         post_limit = form.limit.data
     else:
         post_limit = MATRIX_LIMITS[0][0]
-    data_parameters = []  # type: List[MatrixDataRequest]
-    for name, value in request.args.items():
-        #  plot.<unused>=<machine id>.<test id>.<field index>
-        if not name.startswith(str('plot.')):
-            continue
-
-        # Ignore the extra part of the key, it is unused.
-        machine_id_str, test_id_str, field_index_str = value.split('.')
-        try:
-            machine_id = int(machine_id_str)
-            test_id = int(test_id_str)
-            field_index = int(field_index_str)
-        except ValueError:
-            err_msg = "Parameter {} was malformed. {} must be int.int.int"
-            return abort(400, err_msg.format(name, value))
-
-        if not (0 <= field_index < len(ts.sample_fields)):
-            return abort(404, "Invalid field index {}".format(field_index))
-
-        try:
-            machine = session.query(ts.Machine) \
-                .filter(ts.Machine.id == machine_id) \
-                .one()
-        except NoResultFound:
-            return abort(404, "Invalid machine id {}".format(machine_id))
-        try:
-            test = session.query(ts.Test).filter(ts.Test.id == test_id).one()
-        except NoResultFound:
-            return abort(404, "Invalid test id {}".format(test_id))
-        try:
-            field = ts.sample_fields[field_index]
-        except NoResultFound:
-            return abort(404, "Invalid field_index {}".format(field_index))
-
-        valid_request = MatrixDataRequest(machine, test, field)
-        data_parameters.append(valid_request)
+    plot_parameters = parse_and_load_plot_parameters(request.args, session, ts)
 
-    if not data_parameters:
+    if not plot_parameters:
         abort(404, "Request requires some plot arguments.")
     # Feature: if all of the results are from the same machine, hide the name
     # to make the headers more compact.
     dedup = True
-    for r in data_parameters:
-        if r.machine.id != data_parameters[0].machine.id:
+    for r in plot_parameters:
+        if r.machine.id != plot_parameters[0].machine.id:
             dedup = False
     if dedup:
-        machine_name_common = data_parameters[0].machine.name
-        machine_id_common = data_parameters[0].machine.id
+        machine_name_common = plot_parameters[0].machine.name
+        machine_id_common = plot_parameters[0].machine.id
     else:
         machine_name_common = machine_id_common = None
 
     # It is nice for the columns to be sorted by name.
-    data_parameters.sort(key=lambda x: x.test.name),
+    plot_parameters.sort(key=lambda x: x.test.name),
 
     # Now lets get the data.
     all_orders = set()
     order_to_id = {}
-    for req in data_parameters:
+    for req in plot_parameters:
         q = session.query(req.field.column, ts.Order.llvm_project_revision,
                           ts.Order.id) \
             .join(ts.Run) \
             .join(ts.Order) \
             .filter(ts.Run.machine_id == req.machine.id) \
             .filter(ts.Sample.test == req.test) \
             .filter(req.field.column.isnot(None)) \
             .order_by(ts.Order.llvm_project_revision.desc())
def v4_matrix():
     if user_baseline:
         all_orders.add(user_baseline.order.llvm_project_revision)
         baseline_rev = user_baseline.order.llvm_project_revision
         baseline_name = user_baseline.name
     else:
         baseline_rev = backup_baseline
         baseline_name = backup_baseline
 
-    for req in data_parameters:
+    for req in plot_parameters:
         q_baseline = session.query(req.field.column,
                                    ts.Order.llvm_project_revision,
                                    ts.Order.id) \
                        .join(ts.Run) \
                        .join(ts.Order) \
                        .filter(ts.Run.machine_id == req.machine.id) \
                        .filter(ts.Sample.test == req.test) \
                        .filter(req.field.column.isnot(None)) \
for req in plot_parameters:
             baseline_rev = backup_baseline
             baseline_name = backup_baseline
 
     all_orders = list(all_orders)
     all_orders.sort(reverse=True)
     all_orders.insert(0, baseline_rev)
     # Now calculate Changes between each run.
 
-    for req in data_parameters:
+    for req in plot_parameters:
         req.change = {}
         for order in all_orders:
             cur_samples = req.samples[order]
             prev_samples = req.samples.get(baseline_rev, None)
             cr = ComparisonResult(mean,
                                   False, False,
                                   cur_samples,
                                   prev_samples,
                                   None, None,
                                   confidence_lv=0.05,
                                   bigger_is_better=False)
             req.change[order] = cr
 
     # Calculate Geomean for each order.
     order_to_geomean = {}
     curr_geomean = None
     for order in all_orders:
         curr_samples = []
         prev_samples = []
-        for req in data_parameters:
+        for req in plot_parameters:
             curr_samples.extend(req.samples[order])
             prev_samples.extend(req.samples[baseline_rev])
         prev_geomean = calc_geomean(prev_samples)
         curr_geomean = calc_geomean(curr_samples)
         if prev_geomean:
             cr = ComparisonResult(mean,
                                   False, False,
                                   [curr_geomean],
class FakeOptions(object):
         show_delta = False
         show_stddev = False
         show_mad = False
         show_all_samples = False
         show_sample_counts = False
 
     return render_template("v4_matrix.html",
                            testsuite_name=g.testsuite_name,
-                           associated_runs=data_parameters,
+                           associated_runs=plot_parameters,
                            orders=all_orders,
                            options=FakeOptions(),
                            analysis=lnt.server.reporting.analysis,
                            geomeans=order_to_geomean,
                            order_to_id=order_to_id,
                            form=form,
                            baseline_rev=baseline_rev,
                            baseline_name=baseline_name,