redisbench-admin 0.11.63__py3-none-any.whl → 0.11.65__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_async/run_async.py

@@ -313,7 +313,7 @@ def ro_benchmark_reuse(
 ):
     assert benchmark_type == "read-only"
     logging.info(
-        "Given the benchmark for this setup is ready-only, and this setup was already spinned we will reuse the previous, conns and process info."
+        "Given the benchmark for this setup is read-only, and this setup was already spinned we will reuse the previous, conns and process info."
     )
     artifact_version = setup_details["env"]["artifact_version"]
     cluster_enabled = setup_details["env"]["cluster_enabled"]
@@ -349,7 +349,7 @@ def ro_benchmark_set(
     full_logfiles,
 ):
     logging.info(
-        "Given the benchmark for this setup is ready-only we will prepare to reuse it on the next read-only benchmarks (if any )."
+        "Given the benchmark for this setup is read-only we will prepare to reuse it on the next read-only benchmarks (if any )."
     )
     setup_details["env"] = {}
     setup_details["env"]["full_logfiles"] = full_logfiles

redisbench_admin/run_local/run_local.py

@@ -237,7 +237,7 @@ def run_local_command_logic(args, project_name, project_version):
                                         continue
                                     if benchmark_type == "read-only":
                                         logging.info(
-                                            "Given the benchmark for this setup is ready-only we will prepare to reuse it on the next read-only benchmarks (if any )."
+                                            "Given the benchmark for this setup is read-only we will prepare to reuse it on the next read-only benchmarks (if any )."
                                         )
                                         setup_details["env"] = {}
                                         setup_details["env"][
@@ -252,7 +252,7 @@ def run_local_command_logic(args, project_name, project_version):
                                 else:
                                     assert benchmark_type == "read-only"
                                     logging.info(
-                                        "Given the benchmark for this setup is ready-only, and this setup was already spinned we will reuse the previous, conns and process info."
+                                        "Given the benchmark for this setup is read-only, and this setup was already spinned we will reuse the previous, conns and process info."
                                     )
                                     cluster_api_enabled = setup_details["env"][
                                         "cluster_api_enabled"

redisbench_admin/run_remote/run_remote.py

@@ -404,7 +404,7 @@ def run_remote_command_logic(args, project_name, project_version):
     ts_key_spot_price = f"ts:{tf_triggering_env}:tests:spot_price"
     ts_key_full_price = f"ts:{tf_triggering_env}:tests:full_price"
     ts_key_architecture = f"ts:{tf_triggering_env}:tests:arch:{architecture}"
-    reused_mixed = False
+    reuse_mixed = False
     for benchmark_type, bench_by_dataset_map in ensure_mixed_types_first(benchmark_runs_plan):
         if benchmark_type == "mixed" and "read-only" in benchmark_runs_plan:
             reuse_mixed = True
@@ -440,7 +440,11 @@ def run_remote_command_logic(args, project_name, project_version):
                 setup_settings = setup_details["setup_settings"]
                 benchmarks_map = setup_details["benchmarks"]
                 # we start with an empty per bench-type/setup-name
-                setup_details["env"] = None
+                if not reuse_mixed:
+                    logging.info(
+                        "Given we are not reusing a mixed setup we will reset the setup details."
+                    )
+                    setup_details["env"] = None
 
                 # map from setup name to overall target-tables ( if any target is defined )
                 overall_tables[setup_name] = {}
@@ -660,7 +664,7 @@ def run_remote_command_logic(args, project_name, project_version):
                                             ld_library_paths,
                                             extra_libs,
                                         )
-                                        if benchmark_type == "read-only" or reused_mixed:
+                                        if benchmark_type == "read-only" or reuse_mixed:
                                             ro_benchmark_set(
                                                 artifact_version,
                                                 cluster_enabled,
@@ -1398,7 +1402,7 @@ def ro_benchmark_reuse(
 ):
     assert benchmark_type == "read-only"
     logging.info(
-        "Given the benchmark for this setup is ready-only, and this setup was already spinned we will reuse the previous, conns and process info."
+        "Given the benchmark for this setup is read-only, and this setup was already spinned we will reuse the previous, conns and process info."
     )
     artifact_version = setup_details["env"]["artifact_version"]
     cluster_enabled = setup_details["env"]["cluster_enabled"]
@@ -1434,7 +1438,7 @@ def ro_benchmark_set(
     full_logfiles,
 ):
     logging.info(
-        "Given the benchmark for this setup is ready-only we will prepare to reuse it on the next read-only benchmarks (if any )."
+        "Given the benchmark for this setup is read-only we will prepare to reuse it on the next read-only benchmarks (if any )."
     )
     setup_details["env"] = {}
     setup_details["env"]["full_logfiles"] = full_logfiles

{redisbench_admin-0.11.63.dist-info → redisbench_admin-0.11.65.dist-info}/METADATA

@@ -1,8 +1,7 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: redisbench-admin
-Version: 0.11.63
+Version: 0.11.65
 Summary: Redis benchmark run helper. A wrapper around Redis and Redis Modules benchmark tools ( ftsb_redisearch, memtier_benchmark, redis-benchmark, aibench, etc... ).
-License-File: LICENSE
 Author: filipecosta90
 Author-email: filipecosta.90@gmail.com
 Requires-Python: >=3.10.0,<4.0.0
@@ -10,8 +9,6 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: Flask (>=2.0.1,<3.0.0)
 Requires-Dist: Flask-HTTPAuth (>=4.4.0,<5.0.0)
 Requires-Dist: GitPython (>=3.1.12,<4.0.0)