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

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

@@ -1,204 +0,0 @@
-from __future__ import print_function
-
-import sys
-from enum import Enum
-from shlex import split
-
-from ann_benchmarks.data import type_info
-from ann_benchmarks.distance import metrics
-from ann_benchmarks.algorithms.bruteforce import BruteForce, BruteForceBLAS
-
-
-class QueryMode(Enum):
-    NORMAL = 0,
-    PREPARED = 1,
-    BATCH = 2
-
-
-__true_print = print
-
-
-def print(*args, **kwargs):
-    __true_print(*args, **kwargs)
-    sys.stdout.flush()
-
-
-def next_line():
-    for line in iter(sys.stdin.readline, ''):
-        yield split(line.strip())
-
-
-if __name__ == '__main__':
-    point_type = None
-    distance = None
-    query_mode = QueryMode.NORMAL
-    fast = False
-    query_parameters = False
-    # Configuration mode
-    for line in next_line():
-        if not line:
-            break
-        elif len(line) == 2:
-            var, val = line[0], line[1]
-            if var == "point-type":
-                if val in type_info:
-                    point_type = type_info[val]
-                    print("epbprtv0 ok")
-                else:
-                    print("epbprtv0 fail")
-            elif var == "distance":
-                if val in metrics:
-                    distance = val
-                    print("epbprtv0 ok")
-                else:
-                    print("epbprtv0 fail")
-            elif var == "fast":
-                fast = (val == "1")
-                print("epbprtv0 ok")
-            else:
-                print("epbprtv0 fail")
-        elif len(line) == 3 and line[0] == "frontend":
-            var, val = line[1], line[2]
-            if var == "prepared-queries":
-                query_mode = \
-                    QueryMode.PREPARED if val == "1" else QueryMode.NORMAL
-                print("epbprtv0 ok")
-            elif var == "batch-queries":
-                query_mode = \
-                    QueryMode.BATCH if val == "1" else QueryMode.NORMAL
-                print("epbprtv0 ok")
-            elif var == "query-parameters":
-                query_parameters = (val == "1")
-                print("epbprtv0 ok")
-            else:
-                print("epbprtv0 fail")
-        else:
-            print("epbprtv0 fail")
-    if point_type and distance:
-        print("epbprtv0 ok")
-    else:
-        print("epbprtv0 fail")
-        sys.exit(1)
-
-    obj = None
-    if not fast:
-        obj = BruteForce(distance)
-    else:
-        obj = BruteForceBLAS(distance)
-
-    parser = point_type["parse_entry"]
-    # Training mode
-    points = []
-    for line in next_line():
-        if not line:
-            break
-        elif len(line) == 1:
-            point = line[0]
-            try:
-                parsed = parser(point)
-                print("epbprtv0 ok %d" % len(points))
-                points.append(parsed)
-            except ValueError:
-                print("epbprtv0 fail")
-        else:
-            print("epbprtv0 fail len %d" % len(line))
-    if "finish_entries" in point_type:
-        points = point_type["finish_entries"](points)
-    obj.fit(points)
-    print("epbprtv0 ok %d" % len(points))
-
-    def _query_parameters(line):
-        if hasattr(obj, "set_query_arguments"):
-            try:
-                obj.set_query_arguments(*line[1:-1])
-                print("epbprtv0 ok")
-            except TypeError:
-                print("epbprtv0 fail")
-        else:
-            print("epbprtv0 fail")
-
-    if query_mode == QueryMode.NORMAL:
-        # Query mode
-        for line in next_line():
-            if not line:
-                break
-            elif query_parameters and line[0] == "query-params" \
-                    and line[-1] == "set":
-                _query_parameters(line)
-            elif len(line) == 2:
-                try:
-                    query_point, k = line[0], int(line[1])
-                    parsed = parser(query_point)
-                    results = obj.query(parsed, k)
-                    if results:
-                        print("epbprtv0 ok %d" % len(results))
-                        for index in results:
-                            print("epbprtv0 %d" % index)
-                    else:
-                        print("epbprtv0 fail")
-                except ValueError:
-                    print("epbprtv0 fail")
-            else:
-                print("epbprtv0 fail")
-    elif query_mode == QueryMode.PREPARED:
-        # Prepared query mode
-        parsed = None
-        k = None
-        for line in next_line():
-            if not line:
-                break
-            elif query_parameters and line[0] == "query-params" \
-                    and line[-1] == "set":
-                _query_parameters(line)
-            elif line == ["query"]:
-                if parsed and k:
-                    results = obj.query(parsed, k)
-                    if results:
-                        print("epbprtv0 ok %d" % len(results))
-                        for index in results:
-                            print("epbprtv0 %d" % index)
-                    else:
-                        print("epbprtv0 fail")
-                else:
-                    print("epbprtv0 fail")
-            elif len(line) == 2:
-                try:
-                    parsed, k = parser(line[0]), int(line[1])
-                    print("epbprtv0 ok prepared true")
-                except ValueError:
-                    print("epbprtv0 fail")
-            else:
-                print("epbprtv0 fail")
-    elif query_mode == QueryMode.BATCH:
-        # Batch query mode
-        parsed = None
-        k = None
-        for line in next_line():
-            if not line:
-                break
-            elif query_parameters and line[0] == "query-params" \
-                    and line[-1] == "set":
-                _query_parameters(line)
-            elif line == ["query"]:
-                if parsed and k:
-                    results = obj.batch_query(parsed, k)
-                    print("epbprtv0 ok")
-                    for result in obj.get_batch_results():
-                        if result:
-                            print("epbprtv0 ok %d" % len(result))
-                            for index in result:
-                                print("epbprtv0 %d" % index)
-                        else:
-                            print("epbprtv0 fail")
-                else:
-                    print("epbprtv0 fail")
-            elif len(line) > 1:
-                try:
-                    parsed, k = map(parser, line[0:-1]), int(line[-1])
-                    print("epbprtv0 ok")
-                except ValueError as e:
-                    print("epbprtv0 fail" % e)
-            else:
-                print("epbprtv0 fail")
-        pass
-    print("epbprtv0 ok")

redisbench_admin/run/ann/pkg/protocol/ext-add-query-metric.md

@@ -1,51 +0,0 @@
-(This document describes an extension that front-ends aren't required to implement. In fact, no front-end is *known* to implement it; this document serves as an example of how to extend the protocol. Front-ends that don't implement this extension should reject attempts to set the `add-query-metric` configuration option.)
-
-When the configuration option `add-query-metric` is set to a value other than `all`, if that value identifies a query metric known to the front-end, then the value for this metric will be appended to each query response. This option may be set several times; each one will (try to) add another query metric.
-
-Setting this option to the value `all` will cause *all* metrics known to the front-end to be included.
-
-## Commands
-
-### Configuration mode
-
-#### `add-query-metric METRIC` (two tokens)
-
-Request that query responses also include the value of the query metric `METRIC`, if that's recognised by the front-end.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  The metric `METRIC` was recognised, and query responses will include a value for it.
-
-* `epbprtv0 fail`
-
-  The metric `METRIC` was not recognised; query responses will not include a value for it.
-
-#### `add-query-metric all` (two tokens)
-
-Request that query responses also include the values of all query metrics recognised by the front-end.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  Query responses will include the values of all metrics known to the front-end. (This may not actually change the output; the front-end could, in principle, support this extension but not recognise any query metrics.)
-
-* `epbprtv0 fail`
-
-  Front-ends may choose to emit this response if they do not recognise *any* query metrics, but they may also emit `epbprtv0 ok` in these circumstances (to indicate that all zero metrics will be included in the output).
-
-### Query mode
-
-#### `ENTRY N` (two tokens)
-
-This extension changes the behaviour of one response:
-
-* `epbprtv0 ok R [NAME0 VALUE0 ...]`
-
-  `R` (greater than zero and less than or equal to `N`) close matches were found. Each of the next `R` lines, when tokenised, will consist of the token `epbprtv0` followed by a token specifying the index of a close match. (The first line should identify the *closest* close match, and the `R`-th should identify the furthest away.)
-
-  If additional query metrics were specified and recognised during configuration mode, then their names and values will be provided as a number of pairs of tokens after `R`. For example, a response including the hypothetical `buckets_searched` and `candidates_checked` metrics might look like this:
-  
-  `epbprtv0 ok 10 buckets_searched 8 candidates_checked 507`

redisbench_admin/run/ann/pkg/protocol/ext-batch-queries.md

@@ -1,77 +0,0 @@
-(This document describes an extension that front-ends aren't required to implement. Front-ends that don't implement this extension should reject attempts to set the `batch-queries` front-end configuration option.)
-
-When the front-end configuration option `batch-queries` is set to `1`, after finishing training mode, the front-end will transition to batch query mode instead of query mode. In batch query mode, all queries are submitted at once, and the front-end will indicate when the queries have finished before any results are returned.
-
-## Commands
-
-### Configuration mode
-
-#### `frontend batch-queries V` (three tokens)
-
-If `V` is `1`, then request that the front-end transition into batch query mode, and not query mode, after training mode has finished. If `V` is anything else, then request that it transition into query mode as usual.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  The front-end will transition into the requested query mode after the training mode has finished.
-
-* `epbprtv0 fail`
-
-  This command has had no effect on the query mode transition.
-
-### Training mode
-
-This extension changes the behaviour of one command in training mode:
-
-#### *empty line* (zero tokens)
-
-Finish training mode and enter batch query mode.
-
-Responses:
-
-* `epbprtv0 ok COUNT1 [fail COUNT2]`
-
-  `COUNT1` (potentially zero) entries were successfully interpreted and added to the data structure. (`COUNT2` entries couldn't be interpreted or couldn't be added for other reasons.):
-
-### Batch query mode
-
-In batch query mode, front-ends should respond to three different kinds of command:
-
-#### `ENTRY0 [..., ENTRYk] N` (two or more tokens)
-
-Prepare to run a query to find at most `N` (greater than or equal to 1) close matches for each of the `k` query points from `ENTRY0` to `ENTRYk`.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  Preparation is complete, and the `query` command can now be used.
-
-* `epbprtv0 fail`
-
-  Preparation has failed, and the `query` command should not be used. This may occur if one of the `k` query points could not be parsed.
-
-#### `query` (one token)
-
-Run the last prepared query.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  The query was executed successfully. `k` sets of results will appear after this line, each of them of the same form as in the normal query mode.
-
-* `epbprtv0 fail`
-
-  No query has been prepared.
-
-#### *empty line* (zero tokens)
-
-Finish prepared query mode and terminate the front-end.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  The front-end has terminated.

redisbench_admin/run/ann/pkg/protocol/ext-prepared-queries.md

@@ -1,77 +0,0 @@
-(This document describes an extension that front-ends aren't required to implement. Front-ends that don't implement this extension should reject attempts to set the `prepared-queries` front-end configuration option.)
-
-When the front-end configuration option `prepared-queries` is set to `1`, after finishing training mode, the front-end will transition to prepared query mode instead of query mode. In prepared query mode, parsing a query point -- a potentially expensive operation -- and actually running a query are two different commands; this makes the query timings more representative of the underlying algorithm's behaviour without the overhead of this protocol.
-
-## Commands
-
-### Configuration mode
-
-#### `frontend prepared-queries V` (three tokens)
-
-If `V` is `1`, then request that the front-end transition into prepared query mode, and not query mode, after training mode has finished. If `V` is anything else, then request that it transition into query mode as usual.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  The front-end will transition into the requested query mode after the training mode has finished.
-
-* `epbprtv0 fail`
-
-  This command has had no effect on the query mode transition.
-
-### Training mode
-
-This extension changes the behaviour of one command in training mode:
-
-#### *empty line* (zero tokens)
-
-Finish training mode and enter prepared query mode.
-
-Responses:
-
-* `epbprtv0 ok COUNT1 [fail COUNT2]`
-
-  `COUNT1` (potentially zero) entries were successfully interpreted and added to the data structure. (`COUNT2` entries couldn't be interpreted or couldn't be added for other reasons.):
-
-### Prepared query mode
-
-In prepared query mode, front-ends should respond to three different kinds of command:
-
-#### `ENTRY N` (two tokens)
-
-Prepare to run a query to find at most `N` (greater than or equal to 1) close matches for `ENTRY`.
-
-Responses:
-
-* `epbprtv0 ok prepared true`
-
-  Preparation is complete, the `query` command can now be used, and the underlying library wrapper has special support for prepared queries.
-
-* `epbprtv0 ok prepared false`
-
-  The `query` command can now be used, but the underlying library wrapper doesn't have support for prepared queries, so the `query` command will perform the parsing of `ENTRY` as it would in normal query mode.
-
-#### `query` (one token)
-
-Run the last prepared query.
-
-Responses:
-
-* `epbprtv0 ok R`
-
-  `R` (greater than zero and less than or equal to the value of `N` that was specified when the query was prepared) close matches were found. The next `R` lines, when tokenised, will consist of the token `epbprtv0` followed by a token specifying the index of a close match. (The first line should identify the *closest* close match, and the `R`-th should identify the furthest away.)
-
-* `epbprtv0 fail`
-
-  Either no close matches were found, or no query has been prepared.
-
-#### *empty line* (zero tokens)
-
-Finish prepared query mode and terminate the front-end.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  The front-end has terminated.

redisbench_admin/run/ann/pkg/protocol/ext-query-parameters.md

@@ -1,47 +0,0 @@
-(This document describes an extension that front-ends aren't required to implement. Front-ends that don't implement this extension should reject attempts to set the `query-parameters` front-end configuration option.)
-
-Many algorithms expose parameters that can be changed to adjust their search strategies without requiring that training data be resubmitted. When the front-end configuration option `query-parameters` is set to `1`, a new command will be added to query mode allowing these query configuration parameters to be changed.
-
-(Front-ends that support other optional query modes, such as prepared or batch queries, should also add this command to those modes.)
-
-## Commands
-
-### Configuration mode
-
-#### `frontend query-parameters V` (three tokens)
-
-If `V` is `1`, then request that query mode expose the `query-params` command. If `V` is anything else, then withdraw this request.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  The availability of the `query-params` command has been changed accordingly.
-
-* `epbprtv0 fail`
-
-  This command has had no effect on the availability of the `query-params` command.
-
-### Training mode
-
-This extension makes no changes to training mode.
-
-### Query mode
-
-When the `query-parameters` front-end configuration option has been set to `1`, this extension adds one new command to query mode:
-
-#### `query-params [VALUE0, ..., VALUEk] set` (two or more tokens)
-
-Change the values of the query parameters.
-
-(The final token `set` is required. It exists for the sake of compatibility with the `batch-queries` extension, which also uses variable-length commands but which requires that the last token specify a number.)
-
-Responses:
-
-* `epbprtv0 ok`
-
-  The query parameters were changed to the given values.
-
-* `epbprtv0 fail`
-
-  The query parameters were not changed to the given values, perhaps because one of them was invalid.

redisbench_admin/run/ann/pkg/protocol/specification.md

@@ -1,194 +0,0 @@
-This document specifies a simple text-based protocol that can be used to benchmark algorithms that don't have a Python wrapper. A program that implements the algorithm side of this specification will be referred to in the rest of this document as a "front-end".
-
-This protocol is line-oriented; both sides should configure their input and output streams to be line-buffered. Front-ends receive messages by reading lines from standard input and send messages by writing lines to standard output.
-
-## Modes
-
-A front-end begins in configuration mode. When configuration is complete, it transitions into training mode; when training data has been supplied, into query mode; and, when no more queries remain, it terminates. It isn't possible to return from one mode to an earlier mode without restarting the front-end.
-
-A front-end reads lines from standard input, tokenises them, and interprets them according to its current mode; responses are written as lines to standard output. To enable protocol responses to be distinguished from other messages that may appear on standard output, the first token of a line containing a response will always be `epbprtv0`; the second will be `ok` when a command succeeds, potentially followed by other tokens, and `fail` when it doesn't.
-
-(The obscure token `epbprtv0` is intended to uniquely identify this protocol, and is meant to suggest something like "**e**xternal **p**rogram **b**enchmarking **pr**o**t**ocol, **v**ersion **0**".)
-
-A front-end may choose to include extra tokens in its responses after the tokens required by this specification to communicate more information back to the caller.
-
-## Tokenisation
-
-Both the front-end and `ann-benchmarks` perform *tokenisation* on the lines of text they send and receive. The rules for tokenisation are as follows:
-
-* A token is a sequence of characters separated by one or more whitespace characters.
-
-  Input | Token 1 | Token 2 | Token 3
-  ----- | ------- | ------- | -------
-  abc | abc | |
-  a bc | a | bc |
-  a    bc | a | bc |
-  a b c | a | b | c
-
-* A sequence surrounded by single quote marks will be treated as part of a token, even if it contains whitespace or doesn't contain any other characters.
-
-  Input | Token 1 | Token 2 | Token 3
-  ----- | ------- | ------- | -------
-  'a b c' | a b c | |
-  'a b c'd | a b cd | |
-  a '' b | a | *empty string* | b
-
-* A sequence surrounded by double quote marks will be treated as part of a token, even if it contains whitespace or doesn't contain any other characters.
-
-  Input | Token 1 | Token 2 | Token 3
-  ----- | ------- | ------- | -------
-  "a b c" | a b c | |
-  "a b c"d | a b cd | |
-  a "" b | a | *empty string* | b
-
-* Outside of a quoted sequence, preceding a character with a backslash causes any special significance it may have to be ignored; the character is then said to have been "escaped".
-
-  Input | Token 1 | Token 2 | Token 3
-  ----- | ------- | ------- | -------
-  \a \b \c | a | b | c
-
-  An escaped whitespace character doesn't separate tokens:
-
-  Input | Token 1 | Token 2
-  ----- | ------- | -------
-  a b\ c | a | b c |
-  "a b c"\ d | a b c d |
-
-  An escaped quote mark doesn't begin a sequence:
-
-  Input | Token 1 | Token 2 | Token 3
-  ----- | ------- | ------- | -------
-  \'a b c\' | a | b | c |
-  \"a b c\" | a | b | c |
-
-  An escaped backslash doesn't escape the subsequent character:
-
-  Input | Token 1 | Token 2
-  ----- | ------- | -------
-  a\\\\"b c" d | a\b c | d
-
-* In sequences begun by a double quote mark, only double quote marks and backslashes (and, for compatibility reasons, dollar signs) may be escaped; the backslash otherwise has no special significance.
-
-  Input | Token 1 | Token 2 | Token 3
-  ----- | ------- | ------- | -------
-  "\a \b" \c | \a \b | c |
-  "\\\\ \\" \\$ a" "\b" c | \ " $ a | \b | c
-
-* In sequences begun by a single quote mark, a backslash has no special significance.
-
-  Input | Token 1 | Token 2
-  ----- | ------- | -------
-  'a b' c | a b | c
-  'a b\\' c | a b\ | c
-
-Apart from the fact that newline characters can't be escaped, these rules should match the tokenisation rules of the POSIX shell.
-
-## Commands
-
-Commands are sent to the front-end by `ann-benchmarks`. Each command consists of a single line of text; the front-end replies with one or more lines of text. Front-ends can't initiate communication; they can only reply to commands.
-
-This section specifies these commands, along with the possible responses a front-end might send.
-
-If a front-end receives a command that it doesn't understand in the current mode (or at all), it should respond with `epbprtv0 fail` and continue processing commands.
-
-### Configuration mode
-
-In configuration mode, front-ends should respond to three different kinds of command:
-
-#### `VAR VAL` (two tokens)
-
-Set the value of the algorithm configuration option `VAR` to `VAL`.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  The value specified for the algorithm configuration option `VAR` was acceptable, and the option has been set.
-
-* `epbprtv0 fail`
-
-  The value specified for the algorithm configuration option `VAR` wasn't acceptable. No change has been made to the value of this option.
-
-#### `frontend VAR VAL` (three tokens)
-
-Set the value of the front-end configuration option `VAR` to `VAL`. Front-end configuration options may cause the front-end to behave in a manner other than that described in this specification.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  The value specified for the front-end configuration option `VAR` was acceptable, and the option has been set.
-
-* `epbprtv0 fail`
-
-  The value specified for the front-end configuration option `VAR` wasn't acceptable. No change has been made to the value of this option.
-
-#### *empty line* (zero tokens)
-
-Finish configuration mode and enter training mode.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  Training mode has been entered.
-
-* `epbprtv0 fail`
-
-  One or more configuration options required by the algorithm weren't specified, and so the query process has terminated.
-
-### Training mode
-
-In training mode, front-ends should respond to two different kinds of command:
-
-#### `ENTRY` (one token)
-
-Interpret `ENTRY` as an item of training data.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  `ENTRY` was added as the next item of training data. The index values returned in query mode refer to the first item added as `0`, the second as `1`, and so on.
-
-* `epbprtv0 fail`
-
-  Either `ENTRY` couldn't be interpreted as an item of training data, or the training data wasn't accepted.
-
-#### *empty line* (zero tokens)
-
-Finish training mode and enter query mode.
-
-Responses:
-
-* `epbprtv0 ok COUNT1 [fail COUNT2]`
-
-  `COUNT1` (potentially zero) entries were successfully interpreted and added to the data structure. (`COUNT2` entries couldn't be interpreted or couldn't be added for other reasons.)
-
-### Query mode
-
-In query mode, front-ends should respond to two different kinds of command:
-
-#### `ENTRY N` (two tokens)
-
-Return the indices of at most `N` (greater than or equal to 1) close matches for `ENTRY`.
-
-Responses:
-
-* `epbprtv0 ok R`
-
-  `R` (greater than zero and less than or equal to `N`) close matches were found. Each of the next `R` lines, when tokenised, will consist of the token `epbprtv0` followed by a token specifying the index of a close match. (The first line should identify the *closest* close match, and the `R`-th should identify the furthest away.)
-
-* `epbprtv0 fail`
-
-  No close matches were found.
-
-#### *empty line* (zero tokens)
-
-Finish query mode and terminate the front-end.
-
-Responses:
-
-* `epbprtv0 ok`
-
-  The front-end has terminated.

redisbench_admin/run/ann/pkg/requirements.txt

@@ -1,14 +0,0 @@
-ansicolors==1.1.8
-docker==5.0.2
-h5py==2.10.0
-matplotlib==3.1.2
-numpy==1.17.4
-pyyaml==5.4
-psutil==5.6.6
-scipy==1.3.3
-scikit-learn==0.22.2
-jinja2==3.1.2
-pymilvus==2.0.2
-pinecone-client==2.0.11
-redis==4.3.2
-elasticsearch==8.3.1

redisbench_admin/run/ann/pkg/requirements_py38.txt

@@ -1,11 +0,0 @@
-ansicolors==1.1.8
-docker==5.0.2
-h5py==2.10.0
-matplotlib==3.3.4
-numpy==1.19.5
-pyyaml==5.4
-psutil==5.6.6
-scipy==1.5.4
-scikit-learn
-jinja2==2.10.1
-pandas==1.1.5