redisbench-admin 0.11.1__py3-none-any.whl → 0.11.3__py3-none-any.whl

redisbench_admin/run/ann/pkg/run.py

@@ -0,0 +1,12 @@
+import os
+import pathlib
+
+from ann_benchmarks.main import main
+from multiprocessing import freeze_support
+
+if __name__ == "__main__":
+    workdir = pathlib.Path(__file__).parent.absolute()
+    print("Changing the workdir to {}".format(workdir))
+    os.chdir(workdir)
+    freeze_support()
+    main()

redisbench_admin/run/ann/pkg/run_algorithm.py

@@ -0,0 +1,3 @@
+from ann_benchmarks.runner import run_from_cmdline
+
+run_from_cmdline()

redisbench_admin/run/ann/pkg/templates/chartjs.template

@@ -0,0 +1,102 @@
+            <h3>{{xlabel}}/{{ylabel}}</h3>
+            <div id="{{ xlabel }}{{ ylabel }}{{ label }}">
+            <canvas id="chart{{ xlabel }}{{ ylabel }}{{ label }}" width="800" height="600"></canvas>
+            <script>
+                var ctx = document.getElementById("chart{{ xlabel }}{{ ylabel }}{{ label }}");
+                var chart = new Chart(ctx, {
+                    {% if not render_all_points %}
+                    type: "line",
+                    {% else %}
+                    type: "bubble",
+                    {% endif %}
+                    data: { datasets: [
+                        {% for run in data_points %}
+                        {
+                            label: "{{ run["name"] }}",
+                            fill: false,
+                            pointStyle: "{{ linestyle[run["name"]][3] }}",
+                            borderColor: "{{ linestyle[run["name"]][0] }}",
+                            data: [
+                                {% for (x, y), l in zip(run["coords"], run["labels"]) %}
+                                    { x: {{ x }} , y: {{ y }}, label: "{{ l }}" },
+                                {% endfor %}
+                            ]
+                        },
+                        {% endfor %}
+                        ]},
+                        options: {
+                            responsive: false,
+                            title:{
+                                display:true,
+                                text: '{{ plot_label }}'
+                            },
+                            scales: {
+                                xAxes: [{
+                                    display: true,
+                                    type: 'linear',
+                                    max: '1',
+                                    position: 'bottom',
+                                    scaleLabel: {
+                                        display: true,
+                                        labelString: ' {{ xlabel }}   '
+                                    }
+                                }],
+                                yAxes: [{
+                                    display: true,
+                                    type: 'logarithmic',
+                                    scaleLabel: {
+                                        display: true,
+                                        labelString: ' {{ ylabel }} '
+                                    }
+                                }]
+                            }
+                        }
+                    });
+                function pushOrConcat(base, toPush) {
+                        if (toPush) {
+                                if (Chart.helpers.isArray(toPush)) {
+                                        // base = base.concat(toPush);
+                                        Array.prototype.push.apply(base, toPush);
+                                } else {
+                                        base.push(toPush);
+                                }
+                        }
+
+                        return base;
+                }
+                Chart.Tooltip.prototype.getFooter = function(tooltipItem, data) {
+                    var me = this;
+                    var callbacks = me._options.callbacks;
+                    var item = tooltipItem[0];
+
+                    var beforeFooter = callbacks.beforeFooter.apply(me, arguments);
+                    var footer = "Parameters: " + data.datasets[item.datasetIndex].data[item.index].label || '';
+                    var afterFooter = callbacks.afterFooter.apply(me, arguments);
+
+                    var lines = [];
+                    lines = pushOrConcat(lines, beforeFooter);
+                    lines = pushOrConcat(lines, footer);
+                    lines = pushOrConcat(lines, afterFooter);
+
+                    return lines;
+                }
+
+                </script>
+            </div>
+            {% if args.latex %}
+                <div class="row">
+                    <div class="col-md-4 text-center">
+                        <button type="button" id="button_{{button_label}}" class="btn btn-default" >Toggle latex code</button>
+                    </div>
+                </div>
+                <script>
+                    $("#button_{{button_label}}").click(function() {
+                        $("#plot_{{button_label}}").toggle();
+                    });
+                </script>
+                <div id="plot_{{button_label}}" style="display:none">
+                    <pre>
+                    {{latex_code}}
+                    </pre>
+                </div>
+            {% endif %}

redisbench_admin/run/ann/pkg/templates/detail_page.html

@@ -0,0 +1,23 @@
+{% extends "general.html" %}
+{% block content %}
+        <div class="container">
+        {% for item in plot_data.keys() %}
+            {% if item=="normal" %}
+                {% if batch %}
+                    <h2>Plots for {{title}} in batch mode</h2>
+                {% else %}
+                    <h2>Plots for {{title}}</h2>
+                {% endif %}
+            {% elif item=="scatter" and args.scatter %}
+                {% if batch %}
+                    <h2>Scatterplots for {{title}} in batch mode</h2>
+                {% else %}
+                    <h2>Scatterplots for {{title}}</h2>
+                {% endif %}
+            {% endif %}
+            {% for plot in plot_data[item] %}
+            {{ plot }}
+            {% endfor %}
+            <hr />
+        {% endfor %}
+{% endblock %}

redisbench_admin/run/ann/pkg/templates/general.html

@@ -0,0 +1,58 @@
+<!DOCTYPE html>
+    <html lang="en">
+      <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="IE=edge">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <!-- The above 3 meta tags *must* come first in the head; any other head content must come *after* these tags -->
+        <title>{{ title }}</title>
+        <script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/2.5.0/Chart.js"></script>
+        <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.4/jquery.min.js"></script>
+        <!-- Include all compiled plugins (below), or include individual files as needed -->
+        <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
+        <!-- Bootstrap -->
+        <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js" integrity="sha384-Tc5IQib027qvyjSMfHjOMaLkfuWVxZxUPnCJA7l2mCWNIpG9mGCD8wGNIcPD7Txa" crossorigin="anonymous"></script>
+        <style>
+            body { padding-top: 50px; }
+        </style>
+        <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
+        <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
+        <!--[if lt IE 9]>
+          <script src="https://oss.maxcdn.com/html5shiv/3.7.3/html5shiv.min.js"></script>
+          <script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
+        <![endif]-->
+      </head>
+         <body>
+
+            <nav class="navbar navbar-inverse navbar-fixed-top">
+              <div class="container">
+                <div class="navbar-header">
+                  <a class="navbar-brand" href="index.html">ANN Benchmarks</a>
+                </div>
+                <div id="navbar" class="collapse navbar-collapse">
+                  <ul class="nav navbar-nav">
+                    <li class="active"><a href="index.html">Home</a></li>
+                  </ul>
+                  <ul class="nav navbar-nav">
+                    <li class="active"><a href="index.html#datasets">Datasets</a></li>
+                  </ul>
+                  <ul class="nav navbar-nav">
+                    <li class="active"><a href="index.html#algorithms">Algorithms</a></li>
+                  </ul>
+                  <ul class="nav navbar-nav">
+                    <li class="active"><a href="index.html#contact">Contact</a></li>
+                  </ul>
+                </div><!--/.nav-collapse -->
+              </div>
+            </nav>
+
+            {% block content %} {% endblock %}
+
+            <div id="contact">
+            <h2>Contact</h2>
+            <p>ANN-Benchmarks has been developed by Martin Aumueller (maau@itu.dk), Erik Bernhardsson (mail@erikbern.com), and Alec Faitfull (alef@itu.dk). Please use
+            <a href="https://github.com/erikbern/ann-benchmarks/">Github</a> to submit your implementation or improvements.</p>
+            </div>
+        </div>
+    </body>
+</html>

redisbench_admin/run/ann/pkg/templates/latex.template

@@ -0,0 +1,30 @@
+
+\begin{figure}
+    \centering
+    \begin{tikzpicture}
+        \begin{axis}[
+            xlabel={ {{xlabel}} },
+            ylabel={ {{ylabel}} },
+            ymode = log,
+            yticklabel style={/pgf/number format/fixed,
+                              /pgf/number format/precision=3},
+            legend style = { anchor=west},
+            cycle list name = black white
+            ]
+        {% for algo in plot_data %}
+            {% if algo.scatter %}
+            \addplot [only marks] coordinates {
+            {% else %}
+            \addplot coordinates {
+            {% endif %}
+                {% for coord in algo.coords %}
+                    ({{ coord[0]}}, {{ coord[1] }})
+                {% endfor %}
+            };
+            \addlegendentry{ {{algo.name}} };
+        {% endfor %}
+    \end{axis}
+    \end{tikzpicture}
+    \caption{ {{caption}} }
+    \label{}
+\end{figure}

redisbench_admin/run/ann/pkg/templates/summary.html

@@ -0,0 +1,60 @@
+{% extends "general.html" %}
+{% block content %}
+        <div class="container">
+            <h1>Info</h1>
+            <p>ANN-Benchmarks is a benchmarking environment for approximate nearest neighbor algorithms search. This website contains the current benchmarking results. Please visit <a href="http://github.com/erikbern/ann-benchmarks/">http://github.com/erikbern/ann-benchmarks/</a> to get an overview over evaluated data sets and algorithms. Make a pull request on <a href="http://github.com/erikbern/ann-benchmarks/">Github</a> to add your own code or improvements to the
+            benchmarking system.
+            </p>
+            <div id="results">
+            <h1>Benchmarking Results</h1>
+            <p>Results are split by distance measure and dataset. In the bottom, you can find an overview of an algorithm's performance on all datasets. Each dataset is annoted
+            by <em>(k = ...)</em>, the number of nearest neighbors an algorithm was supposed to return. The plot shown depicts <em>Recall</em> (the fraction
+            of true nearest neighbors found, on average over all queries) against <em>Queries per second</em>.  Clicking on a plot reveils detailled interactive plots, including
+            approximate recall, index size, and build time.</p>
+            {% for type in ['non-batch', 'batch'] %}
+                {% if len(dataset_with_distances[type]) > 0 %}
+                    {% if type == 'batch' %}
+                        <h2>Benchmarks for Batched Queries</h2>
+                    {% else %}
+                        <h2>Benchmarks for Single Queries</h2>
+                    {% endif %}
+
+                    <h2 id ="datasets">Results by Dataset</h2>
+                    {% for distance_data in dataset_with_distances[type] %}
+                        <h3>Distance: {{ distance_data.name }} </h3>
+                        {% for entry in distance_data.entries %}
+                            <a href="./{{ entry.name }}.html">
+                            <div class="row" id="{{entry.name}}">
+                                <div class = "col-md-4 bg-success">
+                                    <h4>{{entry.desc}}</h4>
+                            </div>
+                            <div class = "col-md-8">
+                                <img class = "img-responsive" src="{{ entry.name }}.png" />
+                            </div>
+                        </div>
+                        </a>
+                        <hr />
+                        {% endfor %}
+                    {% endfor %}
+                    <h2 id="algorithms">Results by Algorithm</h2>
+                    <ul class="list-inline"><b>Algorithms:</b>
+                        {% for algo in algorithms[type].keys() %}
+                            <li><a href="#{{algo}}">{{algo}}</a></li>
+                        {% endfor %}
+                    </ul>
+                    {% for algo in algorithms[type].keys()%}
+                    <a href="./{{ algo }}.html">
+                        <div class="row" id="{{algo}}">
+                            <div class = "col-md-4 bg-success">
+                                <h4>{{algo}}</h4>
+                        </div>
+                        <div class = "col-md-8">
+                            <img class = "img-responsive" src="{{ algo }}.png" />
+                        </div>
+                    </div>
+                    </a>
+                    <hr />
+                    {% endfor %}
+                {% endif %}
+            {% endfor %}
+{% endblock %}

redisbench_admin/run/ann/pkg/test/test-jaccard.py

@@ -0,0 +1,19 @@
+import unittest
+import numpy
+from ann_benchmarks.distance import jaccard
+
+class TestJaccard(unittest.TestCase):
+    def setUp(self):
+        pass
+
+    def test_similarity(self):
+        a = [1, 2, 3, 4]
+        b = []
+        c = [1, 2]
+        d = [5, 6]
+
+        self.assertAlmostEqual(jaccard(a, b), 0.0)
+        self.assertAlmostEqual(jaccard(a, a), 1.0)
+        self.assertAlmostEqual(jaccard(a, c), 0.5)
+        self.assertAlmostEqual(jaccard(c, d), 0.0)
+

redisbench_admin/run/ann/pkg/test/test-metrics.py

@@ -0,0 +1,99 @@
+import unittest
+from ann_benchmarks.plotting.metrics import (
+    knn, queries_per_second, index_size, build_time, candidates,
+    epsilon, rel)
+
+
+class DummyMetric():
+
+    def __init__(self):
+        self.attrs = {}
+        self.d = {}
+
+    def __getitem__(self, key):
+        return self.d.get(key, None)
+
+    def __setitem__(self, key, value):
+        self.d[key] = value
+
+    def __contains__(self, key):
+        return key in self.d
+
+    def create_group(self, name):
+        self.d[name] = DummyMetric()
+        return self.d[name]
+
+
+class TestMetrics(unittest.TestCase):
+
+    def setUp(self):
+        pass
+
+    def test_recall(self):
+        exact_queries = [[0.1, 0.25]]
+        run1 = [[]]
+        run2 = [[0.2, 0.3]]
+        run3 = [[0.2]]
+        run4 = [[0.2, 0.25]]
+
+        self.assertAlmostEqual(
+            knn(exact_queries, run1, 2, DummyMetric()).attrs['mean'], 0.0)
+        self.assertAlmostEqual(
+            knn(exact_queries, run2, 2, DummyMetric()).attrs['mean'], 0.5)
+        self.assertAlmostEqual(
+            knn(exact_queries, run3, 2, DummyMetric()).attrs['mean'], 0.5)
+        self.assertAlmostEqual(
+            knn(exact_queries, run4, 2, DummyMetric()).attrs['mean'], 1.0)
+
+    def test_epsilon_recall(self):
+        exact_queries = [[0.05, 0.08, 0.24, 0.3]]
+        run1 = [[]]
+        run2 = [[0.1, 0.2, 0.55, 0.7]]
+
+        self.assertAlmostEqual(
+            epsilon(exact_queries, run1, 4, DummyMetric(), 1).attrs['mean'],
+            0.0)
+
+        self.assertAlmostEqual(
+            epsilon(exact_queries, run2, 4,
+                    DummyMetric(), 0.0001).attrs['mean'],
+            0.5)
+        # distance can be off by factor (1 + 1) * 0.3 = 0.6 => recall .75
+        self.assertAlmostEqual(
+            epsilon(exact_queries, run2, 4, DummyMetric(), 1).attrs['mean'],
+            0.75)
+        # distance can be off by factor (1 + 2) * 0.3 = 0.9 => recall 1
+        self.assertAlmostEqual(
+            epsilon(exact_queries, run2, 4, DummyMetric(), 2).attrs['mean'],
+            1.0)
+
+    def test_relative(self):
+        exact_queries = [[0.1, 0.2, 0.25, 0.3]]
+        run1 = []
+        run2 = [[0.1, 0.2, 0.25, 0.3]]
+        run3 = [[0.1, 0.2, 0.55, 0.9]]
+
+        self.assertAlmostEqual(
+            rel(exact_queries, run1, DummyMetric()), float("inf"))
+        self.assertAlmostEqual(rel(exact_queries, run2, DummyMetric()), 1)
+        # total distance exact: 0.85, total distance run3: 1.75
+        self.assertAlmostEqual(rel(exact_queries, run3, DummyMetric()),
+                               1.75 / 0.85)
+
+    def test_queries_per_second(self):
+        self.assertAlmostEqual(
+            queries_per_second([], {"best_search_time": 0.01}),
+            100)
+
+    def test_index_size(self):
+        self.assertEqual(index_size([], {"index_size": 100}), 100)
+
+    def test_build_time(self):
+        self.assertEqual(build_time([], {"build_time": 100}), 100)
+
+    def test_candidates(self):
+        self.assertEqual(candidates([], {"candidates": 10}), 10)
+
+
+if __name__ == '__main__':
+    unittest.main()

redisbench_admin/run/common.py

@@ -206,10 +206,7 @@ def prepare_benchmark_parameters_specif_tooling(
         if isremote is True:
             benchmark_tool = "/tmp/{}".format(benchmark_tool)
             input_data_file = "/tmp/input.data"
-        (
-            command_arr,
-            command_str,
-        ) = prepare_tsbs_benchmark_command(
+        (command_arr, command_str,) = prepare_tsbs_benchmark_command(
             benchmark_tool,
             server_private_ip,
             server_plaintext_port,
@@ -221,10 +218,7 @@ def prepare_benchmark_parameters_specif_tooling(
             cluster_api_enabled,
         )
     if "memtier_benchmark" in benchmark_tool:
-        (
-            command_arr,
-            command_str,
-        ) = prepare_memtier_benchmark_command(
+        (command_arr, command_str,) = prepare_memtier_benchmark_command(
             benchmark_tool,
             server_private_ip,
             server_plaintext_port,
@@ -242,10 +236,7 @@ def prepare_benchmark_parameters_specif_tooling(
             ann_path = stdout[0].strip() + "/run/ann/pkg/multirun.py"
             logging.info("Remote ann-benchmark path: {}".format(ann_path))
 
-        (
-            command_arr,
-            command_str,
-        ) = prepare_ann_benchmark_command(
+        (command_arr, command_str,) = prepare_ann_benchmark_command(
             server_private_ip,
             server_plaintext_port,
             cluster_api_enabled,
@@ -259,10 +250,7 @@ def prepare_benchmark_parameters_specif_tooling(
         if isremote is True:
             benchmark_tool = "/tmp/{}".format(benchmark_tool)
             input_data_file = "/tmp/input.data"
-        (
-            command_arr,
-            command_str,
-        ) = prepare_ftsb_benchmark_command(
+        (command_arr, command_str,) = prepare_ftsb_benchmark_command(
             benchmark_tool,
             server_private_ip,
             server_plaintext_port,
@@ -279,10 +267,7 @@ def prepare_benchmark_parameters_specif_tooling(
         if isremote is True:
             benchmark_tool = "/tmp/{}".format(benchmark_tool)
             input_data_file = "/tmp/input.data"
-        (
-            command_arr,
-            command_str,
-        ) = prepare_aibench_benchmark_command(
+        (command_arr, command_str,) = prepare_aibench_benchmark_command(
             benchmark_tool,
             server_private_ip,
             server_plaintext_port,
@@ -778,10 +763,7 @@ def print_results_table_stdout(
     metric_names=[],
 ):
     # check which metrics to extract
-    (
-        _,
-        metrics,
-    ) = merge_default_and_config_metrics(
+    (_, metrics,) = merge_default_and_config_metrics(
         benchmark_config,
         default_metrics,
         None,

redisbench_admin/run/run.py

@@ -57,9 +57,13 @@ def define_benchmark_plan(benchmark_definitions, default_specs):
             benchmark_runs_plan[benchmark_type] = {}
 
         # extract dataset-name
-        benchmark_contains_dbconfig, dataset_name, _, _, _ = (
-            extract_redis_dbconfig_parameters(benchmark_config, "dbconfig")
-        )
+        (
+            benchmark_contains_dbconfig,
+            dataset_name,
+            _,
+            _,
+            _,
+        ) = extract_redis_dbconfig_parameters(benchmark_config, "dbconfig")
         logging.info(
             f"Benchmark contains specific dbconfig on test {test_name}: {benchmark_contains_dbconfig}"
         )

redisbench_admin/run_async/async_terraform.py

@@ -114,11 +114,7 @@ class TerraformClass:
     def async_runner_setup(
         self,
     ):
-        (
-            remote_setup,
-            deployment_type,
-            remote_id,
-        ) = fetch_remote_setup_from_config(
+        (remote_setup, deployment_type, remote_id,) = fetch_remote_setup_from_config(
             [{"type": "async", "setup": "runner"}],
             "https://github.com/RedisLabsModules/testing-infrastructure.git",
             "master",
@@ -233,11 +229,7 @@ def terraform_spin_or_reuse_env(
     tf_override_name=None,
     tf_folder_path=None,
 ):
-    (
-        remote_setup,
-        deployment_type,
-        remote_id,
-    ) = fetch_remote_setup_from_config(
+    (remote_setup, deployment_type, remote_id,) = fetch_remote_setup_from_config(
         benchmark_config["remote"],
         "https://github.com/RedisLabsModules/testing-infrastructure.git",
         "master",

redisbench_admin/run_async/render_files.py

@@ -28,9 +28,9 @@ WantedBy=multi-user.target
         argv.append("--private_key")
         argv.append("/home/ubuntu/work_dir/tests/benchmarks/benchmarks.redislabs.pem")
     else:
-        argv[argv.index(args.private_key)] = (
-            "/home/ubuntu/work_dir/tests/benchmarks/benchmarks.redislabs.pem"
-        )
+        argv[
+            argv.index(args.private_key)
+        ] = "/home/ubuntu/work_dir/tests/benchmarks/benchmarks.redislabs.pem"
     if len(args.module_path) != 0:
         argv[argv.index(args.module_path[0])] = (
             "/home/ubuntu/work_dir/tests/benchmarks/"

redisbench_admin/run_local/run_local.py

@@ -680,17 +680,17 @@ def commandstats_latencystats_process_name(
             branch = variant_labels_dict["branch"]
 
         if version is not None:
-            variant_labels_dict["command_and_metric_and_version"] = (
-                "{} - {} - {}".format(command, metric, version)
-            )
-            variant_labels_dict["command_and_metric_and_setup_and_version"] = (
-                "{} - {} - {} - {}".format(command, metric, setup_name, version)
-            )
+            variant_labels_dict[
+                "command_and_metric_and_version"
+            ] = "{} - {} - {}".format(command, metric, version)
+            variant_labels_dict[
+                "command_and_metric_and_setup_and_version"
+            ] = "{} - {} - {} - {}".format(command, metric, setup_name, version)
 
         if branch is not None:
-            variant_labels_dict["command_and_metric_and_branch"] = (
-                "{} - {} - {}".format(command, metric, branch)
-            )
-            variant_labels_dict["command_and_metric_and_setup_and_branch"] = (
-                "{} - {} - {} - {}".format(command, metric, setup_name, branch)
-            )
+            variant_labels_dict[
+                "command_and_metric_and_branch"
+            ] = "{} - {} - {}".format(command, metric, branch)
+            variant_labels_dict[
+                "command_and_metric_and_setup_and_branch"
+            ] = "{} - {} - {} - {}".format(command, metric, setup_name, branch)

redisbench_admin/run_remote/run_remote.py

@@ -346,7 +346,10 @@ def run_remote_command_logic(args, project_name, project_version):
 
                 # map from setup name to overall target-tables ( if any target is defined )
                 overall_tables[setup_name] = {}
+                total_benchmarks = len(benchmarks_map.keys())
+                import tqdm
 
+                pbar = tqdm.tqdm(total=total_benchmarks, unit="benchmarks")
                 for test_name, benchmark_config in benchmarks_map.items():
                     if return_code != 0 and args.fail_fast:
                         logging.warning(
@@ -371,9 +374,7 @@ def run_remote_command_logic(args, project_name, project_version):
                             continue
                         remote_perf = None
                         logging.info(
-                            "Repetition {} of {}. Running test {}".format(
-                                repetition, BENCHMARK_REPETITIONS, test_name
-                            )
+                            f"Repetition {repetition} of {BENCHMARK_REPETITIONS}. Running test {test_name}. Total benchmarks {total_benchmarks}"
                         )
                         (
                             setup_name,
@@ -1092,6 +1093,7 @@ def run_remote_command_logic(args, project_name, project_version):
                                     f"Test {test_name} does not have remote config. Skipping test."
                                 )
 
+                    pbar.update()
     if len(benchmark_artifacts_links) > 0:
         writer = MarkdownTableWriter(
             table_name=benchmark_artifacts_table_name,
@@ -1374,20 +1376,20 @@ def commandstats_latencystats_process_name(
             branch = variant_labels_dict["branch"]
 
         if version is not None:
-            variant_labels_dict["command_and_metric_and_version"] = (
-                "{} - {} - {}".format(command, metric, version)
-            )
-            variant_labels_dict["command_and_metric_and_setup_and_version"] = (
-                "{} - {} - {} - {}".format(command, metric, setup_name, version)
-            )
+            variant_labels_dict[
+                "command_and_metric_and_version"
+            ] = "{} - {} - {}".format(command, metric, version)
+            variant_labels_dict[
+                "command_and_metric_and_setup_and_version"
+            ] = "{} - {} - {} - {}".format(command, metric, setup_name, version)
 
         if branch is not None:
-            variant_labels_dict["command_and_metric_and_branch"] = (
-                "{} - {} - {}".format(command, metric, branch)
-            )
-            variant_labels_dict["command_and_metric_and_setup_and_branch"] = (
-                "{} - {} - {} - {}".format(command, metric, setup_name, branch)
-            )
+            variant_labels_dict[
+                "command_and_metric_and_branch"
+            ] = "{} - {} - {}".format(command, metric, branch)
+            variant_labels_dict[
+                "command_and_metric_and_setup_and_branch"
+            ] = "{} - {} - {} - {}".format(command, metric, setup_name, branch)
 
 
 def shutdown_remote_redis(redis_conns, ssh_tunnel):