redisbench-admin 0.11.55__py3-none-any.whl → 0.11.57__py3-none-any.whl

redisbench_admin/run/ann/pkg/install/Dockerfile.redisearch

@@ -1,18 +0,0 @@
-FROM redislabs/redisearch:feature-vecsim as redis
-FROM ann-benchmarks
-# COPY --from=redis /usr/local/ /usr/local/
-
-run git clone https://github.com/redis/redis.git
-run cd redis; \
-    git checkout 6.2.5; \
-    make install
-
-
-COPY --from=redis /usr/lib/redis /usr/lib/redis
-
-
-RUN pip3 install redisearch redis
-
-# CMD ["redis-server", "--loadmodule", "/usr/lib/redis/modules/redisearch.so"]
-RUN echo 'redis-server --daemonize yes --loadmodule /usr/lib/redis/modules/redisearch.so && python3 -u run_algorithm.py "$@"' > entrypoint.sh
-ENTRYPOINT ["/bin/bash", "/home/app/entrypoint.sh"]

redisbench_admin/run/ann/pkg/install/Dockerfile.rpforest

@@ -1,5 +0,0 @@
-FROM ann-benchmarks
-
-RUN git clone https://github.com/lyst/rpforest
-RUN cd rpforest && python3 setup.py install
-RUN python3 -c 'import rpforest'

redisbench_admin/run/ann/pkg/install/Dockerfile.scann

@@ -1,5 +0,0 @@
-FROM ann-benchmarks
-
-RUN pip3 install --upgrade pip
-RUN pip3 install scann
-RUN python3 -c 'import scann'

redisbench_admin/run/ann/pkg/install/Dockerfile.scipy

@@ -1,4 +0,0 @@
-FROM ann-benchmarks
-
-RUN pip3 install scipy
-RUN python3 -c 'import scipy'

redisbench_admin/run/ann/pkg/install/Dockerfile.sklearn

@@ -1,4 +0,0 @@
-FROM ann-benchmarks
-
-RUN pip3 install scikit-learn
-RUN python3 -c 'import sklearn'

redisbench_admin/run/ann/pkg/install/Dockerfile.sptag

@@ -1,30 +0,0 @@
-# Adopted from https://github.com/microsoft/SPTAG/blob/master/Dockerfile
-
-FROM ann-benchmarks
-
-RUN git clone https://github.com/microsoft/SPTAG
-RUN apt-get update && apt-get -y install wget build-essential libtbb-dev software-properties-common swig
-
-# cmake >= 3.12 is required
-RUN wget "https://github.com/Kitware/CMake/releases/download/v3.14.4/cmake-3.14.4-Linux-x86_64.tar.gz" -q -O - \
-        | tar -xz --strip-components=1 -C /usr/local
-
-# specific version of boost
-RUN wget "https://boostorg.jfrog.io/artifactory/main/release/1.67.0/source/boost_1_67_0.tar.gz" -q -O - \
-        | tar -xz && \
-        cd boost_1_67_0 && \
-        ./bootstrap.sh && \
-        ./b2 install && \
-        # update ld cache so it finds boost in /usr/local/lib
-        ldconfig && \
-        cd .. && rm -rf boost_1_67_0
-
-# SPTAG defaults to Python 2 if it's found on the system, so as a hack, we remove it. See https://github.com/microsoft/SPTAG/blob/master/Wrappers/CMakeLists.txt
-RUN apt-get -y remove libpython2.7
-
-# Compile
-RUN cd SPTAG && mkdir build && cd build && cmake .. && make && cd ..
-
-# so python can find the SPTAG module
-ENV PYTHONPATH=/home/app/SPTAG/Release
-RUN python3 -c 'import SPTAG'

redisbench_admin/run/ann/pkg/install/Dockerfile.vald

@@ -1,8 +0,0 @@
-ARG VALD_VERSION=v1.3.1
-FROM vdaas/vald-agent-ngt:${VALD_VERSION} as vald
-
-FROM ann-benchmarks
-ARG VALD_CLIENT_VERSION=1.3.1
-COPY --from=vald /go/bin/ngt /go/bin/ngt
-
-RUN pip3 install vald-client-python==${VALD_CLIENT_VERSION}

redisbench_admin/run/ann/pkg/install/Dockerfile.vespa

@@ -1,17 +0,0 @@
-FROM centos:7
-
-RUN yum -y install epel-release && \
-    yum -y install centos-release-scl && \
-    yum -y --setopt=skip_missing_names_on_install=False install gcc make git python3-devel && \
-    python3 -m pip install --upgrade pip setuptools wheel && \
-    yum-config-manager --add-repo https://copr.fedorainfracloud.org/coprs/g/vespa/vespa/repo/epel-7/group_vespa-vespa-epel-7.repo && \
-    yum -y --setopt=skip_missing_names_on_install=False --enablerepo=epel-testing install vespa-ann-benchmark
-
-WORKDIR /home/app
-
-COPY requirements.txt run_algorithm.py ./
-
-RUN python3 -m pip install -r requirements.txt && \
-    python3 -m pip install /opt/vespa/libexec/vespa_ann_benchmark
-
-ENTRYPOINT ["python3", "-u", "run_algorithm.py"]

redisbench_admin/run/ann/pkg/install.py

@@ -1,70 +0,0 @@
-import json
-import os
-import argparse
-import subprocess
-from multiprocessing import Pool
-from ann_benchmarks.main import positive_int
-
-
-def build(library, args):
-    print('Building %s...' % library)
-    if args is not None and len(args) != 0:
-        q = " ".join(["--build-arg " + x.replace(" ", "\\ ") for x in args])
-    else:
-        q = ""
-    
-    try:
-        subprocess.check_call(
-            'docker build %s --rm -t ann-benchmarks-%s -f'
-            ' install/Dockerfile.%s .' % (q, library, library), shell=True)
-        return {library: 'success'}
-    except subprocess.CalledProcessError:
-        return {library: 'fail'}
-
-
-def build_multiprocess(args):
-    return build(*args)
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument(
-        "--proc",
-        default=1,
-        type=positive_int,
-        help="the number of process to build docker images")
-    parser.add_argument(
-        '--algorithm',
-        metavar='NAME',
-        help='build only the named algorithm image',
-        default=None)
-    parser.add_argument(
-        '--build-arg',
-        help='pass given args to all docker builds',
-        nargs="+")
-    args = parser.parse_args()
-
-    print('Building base image...')
-    subprocess.check_call(
-        'docker build \
-        --rm -t ann-benchmarks -f install/Dockerfile .', shell=True)
-
-    if args.algorithm:
-        tags = [args.algorithm]
-    elif os.getenv('LIBRARY'):
-        tags = [os.getenv('LIBRARY')]
-    else:
-        tags = [fn.split('.')[-1] for fn in os.listdir('install') if fn.startswith('Dockerfile.')]
-
-    print('Building algorithm images... with (%d) processes' % args.proc)
-
-    if args.proc == 1:
-        install_status = [build(tag, args.build_arg) for tag in tags]
-    else:
-        pool = Pool(processes=args.proc)
-        install_status = pool.map(build_multiprocess, [(tag, args.build_arg) for tag in tags])
-        pool.close()
-        pool.join()
-
-    print('\n\nInstall Status:\n' + '\n'.join(str(algo) for algo in install_status))

redisbench_admin/run/ann/pkg/logging.conf

@@ -1,34 +0,0 @@
-[loggers]
-keys=root,annb
-
-[handlers]
-keys=consoleHandler,fileHandler
-
-[formatters]
-keys=simpleFormatter
-
-[formatter_simpleFormatter]
-format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
-datefmt=
-
-[handler_consoleHandler]
-class=StreamHandler
-level=INFO
-formatter=simpleFormatter
-args=(sys.stdout,)
-
-[handler_fileHandler]
-class=FileHandler
-level=INFO
-formatter=simpleFormatter
-args=('annb.log','w')
-
-[logger_root]
-level=WARN
-handlers=consoleHandler
-
-[logger_annb]
-level=INFO
-handlers=consoleHandler,fileHandler
-qualname=annb
-propagate=0

redisbench_admin/run/ann/pkg/multirun.py

@@ -1,298 +0,0 @@
-from multiprocessing import Process
-import argparse
-import time
-import json
-from numpy import average
-import h5py
-import os
-from watchdog.observers import Observer
-from watchdog.events import PatternMatchingEventHandler
-import pathlib
-from ann_benchmarks.results import get_result_filename
-from ann_benchmarks.algorithms.definitions import get_run_groups
-
-
-def aggregate_outputs(files, clients):
-    different_attrs = set([f.split('client')[0] for f in files])
-    groups = [[f + f'client_{i}.hdf5' for i in range(1, clients + 1)] for f in different_attrs]
-
-    if len(different_attrs) * clients > len(files):
-        print(f'missing files! got {len(files)} but expected {len(different_attrs) * clients}')
-        print('got files:')
-        [print('\t' + f) for f in files]
-        print('probably missing files:')
-        [[print('\t' + f) for f in g if f not in files] for g in groups]
-        assert False
-    elif len(different_attrs) * clients < len(files):
-        print(f'too many files! got {len(files)} but expected {len(different_attrs) * clients}')
-        print('got files:')
-        [print('\t' + f) for f in files]
-        print('probably unnecessary files:')
-        [print('\t' + f) for f in files if len([g for g in groups if f in g]) == 0]
-        raise False
-
-    for group in groups:
-        fn = group[0].split('client')[0][:-1] + '.hdf5'
-        f = h5py.File(fn, 'w')
-
-        fs = [h5py.File(fi, 'r') for fi in group]
-        for k, v in fs[0].attrs.items():
-            f.attrs[k] = v
-        f.attrs["best_search_time"] = average([fi.attrs["best_search_time"] for fi in fs])
-        f.attrs["candidates"] = average([fi.attrs["candidates"] for fi in fs])
-
-        # As we split the test work between the clients, wee should concatenate their results
-        f['times'] = [t for fi in fs for t in fi['times']]
-        f['neighbors'] = [n for fi in fs for n in fi['neighbors']]
-        f['distances'] = [d for fi in fs for d in fi['distances']]
-
-        [fi.close() for fi in fs]
-        [os.remove(fi) for fi in group]
-        f.close()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument(
-        '--dataset',
-        metavar='NAME',
-        help='the dataset to load training points from',
-        default='glove-100-angular')
-    parser.add_argument(
-        '--json-output',
-        help='Path to the output file. If defined will store the results in json format.',
-        default=""
-    )
-    parser.add_argument(
-        "-k", "--count",
-        default="10",
-        type=str,
-        help="the number of near neighbours to search for")
-    parser.add_argument(
-        '--host',
-        type=str,
-        help='host name or IP',
-        default=None)
-    parser.add_argument(
-        '--port',
-        type=str,
-        help='the port "host" is listening on',
-        default=None)
-    parser.add_argument(
-        '--auth', '-a',
-        type=str,
-        metavar='PASS',
-        help='password for connection',
-        default=None)
-    parser.add_argument(
-        '--user',
-        type=str,
-        metavar='NAME',
-        help='user name for connection',
-        default=None)
-    parser.add_argument(
-        '--build-clients',
-        type=str,
-        metavar='NUM',
-        help='total number of clients running in parallel to build the index (could be 0)',
-        default="1")
-    parser.add_argument(
-        '--test-clients',
-        type=str,
-        metavar='NUM',
-        help='total number of clients running in parallel to test the index (could be 0)',
-        default="1")
-    parser.add_argument(
-        '--force',
-        help='re-run algorithms even if their results already exist',
-        action='store_true')
-    parser.add_argument(
-        '--algorithm',
-        metavar='ALGO',
-        help='run redisearch with this algorithm',
-        default="redisearch-hnsw")
-    parser.add_argument(
-        '--run-group',
-        type=str,
-        metavar='NAME',
-        help='run only the named run group',
-        default=None)
-    parser.add_argument(
-        '--runs',
-        type=str,
-        help='run each algorithm instance %(metavar)s times and use only'
-             ' the best result',
-        default="3")
-    parser.add_argument(
-        '--cluster',
-        action='store_true',
-        help='working with a cluster')
-    parser.add_argument(
-        '--shards',
-        type=str,
-        metavar='NUM',
-        default="1",
-        help='specify number of shards')
-
-    args = parser.parse_args()
-
-    # we should change to the proper workdir as soon we parse the args
-    # given some functions bellow require on relative path to the project
-    workdir = pathlib.Path(__file__).parent.absolute()
-    print("Changing the workdir to {}".format(workdir))
-    os.chdir(workdir)
-
-    # All supported algorithms that need spacial stuff
-    isredis = ismilvus = ispinecone = iselastic = False
-
-    if 'redisearch' in args.algorithm:
-        from redis import Redis
-        from redis.cluster import RedisCluster
-        isredis = True
-
-    elif 'milvus' in args.algorithm:
-        from pymilvus import utility, connections
-        ismilvus = True
-
-    elif 'pinecone' in args.algorithm:
-        import pinecone
-        ispinecone = True
-
-    elif 'elasticsearch' in args.algorithm:
-        from elasticsearch import Elasticsearch
-        from elastic_transport.client_utils import DEFAULT
-        iselastic = True
-
-    if args.host is None:
-        args.host = 'localhost'
-    if args.port is None:
-        if isredis: args.port = '6379'
-        elif ismilvus: args.port = '19530'
-        elif iselastic: args.port = '9200'
-
-    if isredis:
-        redis = RedisCluster if args.cluster else Redis
-        redis = redis(host=args.host, port=int(args.port), password=args.auth, username=args.user)
-    elif ismilvus:
-        connections.connect(host=args.host, port=args.port)
-    elif ispinecone:
-        pinecone.init(api_key=args.auth)
-    elif iselastic:
-        args.user = args.user if args.user is not None else 'elastic'
-        args.auth = args.auth if args.auth is not None else os.environ.get('ELASTIC_PASSWORD', '')
-        try:
-            es = Elasticsearch([f'http://{args.host}:{args.port}'],  request_timeout=3600, basic_auth=(args.user, args.auth))
-            es.info()
-        except Exception:
-            es = Elasticsearch([f'https://{args.host}:{args.port}'], request_timeout=3600, basic_auth=(args.user, args.auth), ca_certs=os.environ.get('ELASTIC_CA', DEFAULT))
-
-    if args.run_group is not None:
-        run_groups = [args.run_group]
-    else:
-        run_groups = get_run_groups('algos.yaml', args.algorithm)
-
-    base = 'python3 run.py --local --algorithm ' + args.algorithm + ' -k ' + args.count + ' --dataset ' + args.dataset
-
-    if args.host:       base += ' --host ' + args.host
-    if args.port:       base += ' --port ' + args.port
-    if args.user:       base += ' --user ' + args.user
-    if args.auth:       base += ' --auth ' + args.auth
-    if args.force:      base += ' --force'
-    if args.cluster:    base += ' --cluster'
-    if args.shards:     base += ' --shards ' + args.shards
-
-    base_build = base + ' --build-only --total-clients ' + args.build_clients
-    base_test = base + ' --test-only --runs {} --total-clients {}'.format(args.runs, args.test_clients)
-    outputsdir = "{}/{}".format(workdir, get_result_filename(args.dataset, args.count))
-    outputsdir = os.path.join(outputsdir, args.algorithm)
-    if not os.path.isdir(outputsdir):
-        os.makedirs(outputsdir)
-    results_dicts = []
-
-    # skipping aggregation if using one tester
-    if int(args.test_clients) > 1:
-        test_stats_files = set()
-        watcher = PatternMatchingEventHandler(["*.hdf5"], ignore_directories=True)
-
-
-        def on_created_or_modified(event):
-            test_stats_files.add(event.src_path)
-
-
-        watcher.on_created = on_created_or_modified
-        watcher.on_modified = on_created_or_modified
-        observer = Observer()
-        observer.schedule(watcher, outputsdir)
-        observer.start()
-
-    for run_group in run_groups:
-        results_dict = {}
-        curr_base_build = base_build + ' --run-group ' + run_group
-        curr_base_test = base_test + ' --run-group ' + run_group
-
-        if int(args.build_clients) > 0:
-            if isredis:
-                redis.flushall()
-            elif ismilvus:
-                if utility.has_collection('milvus'):
-                    utility.drop_collection('milvus')
-            elif ispinecone:
-                for idx in pinecone.list_indexes():
-                    pinecone.delete_index(idx)
-            elif iselastic:
-                for idx in es.indices.stats()['indices']:
-                    es.indices.delete(index=idx)
-
-            clients = [Process(target=os.system, args=(curr_base_build + ' --client-id ' + str(i),)) for i in
-                       range(1, int(args.build_clients) + 1)]
-
-            t0 = time.time()
-            for client in clients: client.start()
-            for client in clients: client.join()
-            total_time = time.time() - t0
-            print(f'total build time: {total_time}\n\n')
-
-            fn = os.path.join(outputsdir, 'build_stats')
-            f = h5py.File(fn, 'w')
-            f.attrs["build_time"] = total_time
-            print(fn)
-            index_size = -1
-            if isredis:
-                if not args.cluster:  # TODO: get total size from all the shards
-                    index_size = float(redis.ft('ann_benchmark').info()['vector_index_sz_mb']) * 1024
-                f.attrs["index_size"] = index_size
-            elif iselastic:
-                f.attrs["index_size"] = es.indices.stats(index='ann_benchmark')['indices']['ann_benchmark']['total']['store']['size_in_bytes']
-            f.close()
-            results_dict["build"] = {"total_clients": args.build_clients, "build_time": total_time,
-                                     "vector_index_sz_mb": index_size}
-
-        if int(args.test_clients) > 0:
-            queriers = [Process(target=os.system, args=(curr_base_test + ' --client-id ' + str(i),)) for i in
-                        range(1, int(args.test_clients) + 1)]
-            t0 = time.time()
-            for querier in queriers: querier.start()
-            for querier in queriers: querier.join()
-            query_time = time.time() - t0
-            print(f'total test time: {query_time}')
-            results_dict["query"] = {"total_clients": args.test_clients, "test_time": query_time}
-
-        results_dicts.append(results_dict)
-
-    # skipping aggregation if using one tester
-    if int(args.test_clients) > 1:
-        observer.stop()
-        observer.join()
-        print(
-            f'summarizing {int(args.test_clients)} clients data ({len(test_stats_files)} files into {len(test_stats_files) // int(args.test_clients)})...')
-        # ls = os.listdir(outputsdir)
-        # ls.remove('build_stats')
-        # aggregate_outputs(ls, int(args.test_clients))
-        aggregate_outputs(test_stats_files, int(args.test_clients))
-        print('done!')
-
-    if args.json_output != "":
-        with open(args.json_output, "w") as json_out_file:
-            print(f'storing json result into: {args.json_output}')
-            json.dump(results_dict, json_out_file)

redisbench_admin/run/ann/pkg/plot.py

@@ -1,159 +0,0 @@
-import os
-import matplotlib as mpl
-mpl.use('Agg')  # noqa
-import matplotlib.pyplot as plt
-import numpy as np
-import argparse
-
-from ann_benchmarks.datasets import get_dataset
-from ann_benchmarks.algorithms.definitions import get_definitions
-from ann_benchmarks.plotting.metrics import all_metrics as metrics
-from ann_benchmarks.plotting.utils import (get_plot_label, compute_metrics,
-                                           create_linestyles, create_pointset)
-from ann_benchmarks.results import (store_results, load_all_results,
-                                    get_unique_algorithms)
-
-
-def create_plot(all_data, raw, x_scale, y_scale, xn, yn, fn_out, linestyles,
-                batch):
-    xm, ym = (metrics[xn], metrics[yn])
-    # Now generate each plot
-    handles = []
-    labels = []
-    plt.figure(figsize=(12, 9))
-
-    # Sorting by mean y-value helps aligning plots with labels
-    def mean_y(algo):
-        xs, ys, ls, axs, ays, als = create_pointset(all_data[algo], xn, yn)
-        return -np.log(np.array(ys)).mean()
-    # Find range for logit x-scale
-    min_x, max_x = 1, 0
-    for algo in sorted(all_data.keys(), key=mean_y):
-        xs, ys, ls, axs, ays, als = create_pointset(all_data[algo], xn, yn)
-        min_x = min([min_x]+[x for x in xs if x > 0])
-        max_x = max([max_x]+[x for x in xs if x < 1])
-        color, faded, linestyle, marker = linestyles[algo]
-        handle, = plt.plot(xs, ys, '-', label=algo, color=color,
-                           ms=7, mew=3, lw=3, linestyle=linestyle,
-                           marker=marker)
-        handles.append(handle)
-        if raw:
-            handle2, = plt.plot(axs, ays, '-', label=algo, color=faded,
-                                ms=5, mew=2, lw=2, linestyle=linestyle,
-                                marker=marker)
-        labels.append(algo)
-
-    ax = plt.gca()
-    ax.set_ylabel(ym['description'])
-    ax.set_xlabel(xm['description'])
-    # Custom scales of the type --x-scale a3
-    if x_scale[0] == 'a':
-        alpha = float(x_scale[1:])
-        fun = lambda x: 1-(1-x)**(1/alpha)
-        inv_fun = lambda x: 1-(1-x)**alpha
-        ax.set_xscale('function', functions=(fun, inv_fun))
-        if alpha <= 3:
-            ticks = [inv_fun(x) for x in np.arange(0,1.2,.2)]
-            plt.xticks(ticks)
-        if alpha > 3:
-            from matplotlib import ticker
-            ax.xaxis.set_major_formatter(ticker.LogitFormatter())
-            #plt.xticks(ticker.LogitLocator().tick_values(min_x, max_x))
-            plt.xticks([0, 1/2, 1-1e-1, 1-1e-2, 1-1e-3, 1-1e-4, 1])
-    # Other x-scales
-    else:
-        ax.set_xscale(x_scale)
-    ax.set_yscale(y_scale)
-    ax.set_title(get_plot_label(xm, ym))
-    box = plt.gca().get_position()
-    # plt.gca().set_position([box.x0, box.y0, box.width * 0.8, box.height])
-    ax.legend(handles, labels, loc='center left',
-              bbox_to_anchor=(1, 0.5), prop={'size': 9})
-    plt.grid(b=True, which='major', color='0.65', linestyle='-')
-    plt.setp(ax.get_xminorticklabels(), visible=True)
-
-    # Logit scale has to be a subset of (0,1)
-    if 'lim' in xm and x_scale != 'logit':
-        x0, x1 = xm['lim']
-        plt.xlim(max(x0,0), min(x1,1))
-    elif x_scale == 'logit':
-        plt.xlim(min_x, max_x)
-    if 'lim' in ym:
-        plt.ylim(ym['lim'])
-
-    # Workaround for bug https://github.com/matplotlib/matplotlib/issues/6789
-    ax.spines['bottom']._adjust_location()
-
-    plt.savefig(fn_out, bbox_inches='tight')
-    plt.close()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        '--dataset',
-        metavar="DATASET",
-        default='glove-100-angular')
-    parser.add_argument(
-        '--count',
-        default=10)
-    parser.add_argument(
-        '--definitions',
-        metavar='FILE',
-        help='load algorithm definitions from FILE',
-        default='algos.yaml')
-    parser.add_argument(
-        '--limit',
-        default=-1)
-    parser.add_argument(
-        '-o', '--output')
-    parser.add_argument(
-        '-x', '--x-axis',
-        help='Which metric to use on the X-axis',
-        choices=metrics.keys(),
-        default="k-nn")
-    parser.add_argument(
-        '-y', '--y-axis',
-        help='Which metric to use on the Y-axis',
-        choices=metrics.keys(),
-        default="qps")
-    parser.add_argument(
-        '-X', '--x-scale',
-        help='Scale to use when drawing the X-axis. Typically linear, logit or a2',
-        default='linear')
-    parser.add_argument(
-        '-Y', '--y-scale',
-        help='Scale to use when drawing the Y-axis',
-        choices=["linear", "log", "symlog", "logit"],
-        default='linear')
-    parser.add_argument(
-        '--raw',
-        help='Show raw results (not just Pareto frontier) in faded colours',
-        action='store_true')
-    parser.add_argument(
-        '--batch',
-        help='Plot runs in batch mode',
-        action='store_true')
-    parser.add_argument(
-        '--recompute',
-        help='Clears the cache and recomputes the metrics',
-        action='store_true')
-    args = parser.parse_args()
-
-    if not args.output:
-        args.output = 'results/%s.png' % (args.dataset + ('-batch' if args.batch else ''))
-        print('writing output to %s' % args.output)
-
-    dataset, _ = get_dataset(args.dataset)
-    count = int(args.count)
-    unique_algorithms = get_unique_algorithms()
-    results = load_all_results(args.dataset, count, args.batch)
-    linestyles = create_linestyles(sorted(unique_algorithms))
-    runs = compute_metrics(np.array(dataset["distances"]),
-                           results, args.x_axis, args.y_axis, args.recompute)
-    if not runs:
-        raise Exception('Nothing to plot')
-
-    create_plot(runs, args.raw, args.x_scale,
-                args.y_scale, args.x_axis, args.y_axis, args.output,
-                linestyles, args.batch)

redisbench_admin/run/ann/pkg/protocol/bf-runner

@@ -1,10 +0,0 @@
-#!/bin/sh
-
-where="$(dirname "$0")"
-if [ "$1" = "2" -o "$1" = "-2" -o "$1" = "--2" ]; then
-	PYTHON=python2
-else
-	PYTHON=python3
-fi
-export PYTHONPATH="$where/..:$PYTHONPATH"
-exec $PYTHON "$where/bf-runner.py"