pyreindexer

Name	pyreindexer JSON
Version	0.5.600 JSON
	download
home_page	https://github.com/Restream/reindexer
Summary	A connector that allows to interact with Reindexer. Reindexer static library or reindexer-dev package must be installed
upload_time	2025-08-29 17:17:33
maintainer	Reindexer Team
docs_url	None
author	Igor Tulmentyev
requires_python	>=3.8
license	Apache License 2.0
keywords	reindexer reindexer-py in-memory-database database python connector
VCS
bugtrack_url
requirements	No requirements were recorded.
Travis-CI	No Travis.
coveralls test coverage	No coveralls.

            # The PyReindexer module provides a connector and its auxiliary tools for interaction with Reindexer. Reindexer static library or reindexer-dev package must be installed

* [pyreindexer.rx\_connector](#pyreindexer.rx_connector)
  * [RxConnector](#pyreindexer.rx_connector.RxConnector)
    * [close](#pyreindexer.rx_connector.RxConnector.close)
    * [namespace\_open](#pyreindexer.rx_connector.RxConnector.namespace_open)
    * [namespace\_close](#pyreindexer.rx_connector.RxConnector.namespace_close)
    * [namespace\_drop](#pyreindexer.rx_connector.RxConnector.namespace_drop)
    * [namespaces\_enum](#pyreindexer.rx_connector.RxConnector.namespaces_enum)
    * [index\_add](#pyreindexer.rx_connector.RxConnector.index_add)
    * [index\_update](#pyreindexer.rx_connector.RxConnector.index_update)
    * [index\_drop](#pyreindexer.rx_connector.RxConnector.index_drop)
    * [item\_insert](#pyreindexer.rx_connector.RxConnector.item_insert)
    * [item\_update](#pyreindexer.rx_connector.RxConnector.item_update)
    * [item\_upsert](#pyreindexer.rx_connector.RxConnector.item_upsert)
    * [item\_delete](#pyreindexer.rx_connector.RxConnector.item_delete)
    * [meta\_put](#pyreindexer.rx_connector.RxConnector.meta_put)
    * [meta\_get](#pyreindexer.rx_connector.RxConnector.meta_get)
    * [meta\_delete](#pyreindexer.rx_connector.RxConnector.meta_delete)
    * [meta\_enum](#pyreindexer.rx_connector.RxConnector.meta_enum)
    * [select](#pyreindexer.rx_connector.RxConnector.select)
    * [new\_transaction](#pyreindexer.rx_connector.RxConnector.new_transaction)
    * [new\_query](#pyreindexer.rx_connector.RxConnector.new_query)
* [pyreindexer.query\_results](#pyreindexer.query_results)
  * [QueryResults](#pyreindexer.query_results.QueryResults)
    * [status](#pyreindexer.query_results.QueryResults.status)
    * [count](#pyreindexer.query_results.QueryResults.count)
    * [total\_count](#pyreindexer.query_results.QueryResults.total_count)
    * [get\_agg\_results](#pyreindexer.query_results.QueryResults.get_agg_results)
    * [get\_explain\_results](#pyreindexer.query_results.QueryResults.get_explain_results)
* [pyreindexer.transaction](#pyreindexer.transaction)
  * [Transaction](#pyreindexer.transaction.Transaction)
    * [insert](#pyreindexer.transaction.Transaction.insert)
    * [update](#pyreindexer.transaction.Transaction.update)
    * [update\_query](#pyreindexer.transaction.Transaction.update_query)
    * [upsert](#pyreindexer.transaction.Transaction.upsert)
    * [delete](#pyreindexer.transaction.Transaction.delete)
    * [delete\_query](#pyreindexer.transaction.Transaction.delete_query)
    * [commit](#pyreindexer.transaction.Transaction.commit)
    * [commit\_with\_count](#pyreindexer.transaction.Transaction.commit_with_count)
    * [rollback](#pyreindexer.transaction.Transaction.rollback)
* [pyreindexer.point](#pyreindexer.point)
  * [Point](#pyreindexer.point.Point)
* [pyreindexer.query](#pyreindexer.query)
  * [Query](#pyreindexer.query.Query)
    * [where](#pyreindexer.query.Query.where)
    * [where\_query](#pyreindexer.query.Query.where_query)
    * [where\_subquery](#pyreindexer.query.Query.where_subquery)
    * [where\_composite](#pyreindexer.query.Query.where_composite)
    * [where\_uuid](#pyreindexer.query.Query.where_uuid)
    * [where\_between\_fields](#pyreindexer.query.Query.where_between_fields)
    * [where\_knn](#pyreindexer.query.Query.where_knn)
    * [where\_knn\_string](#pyreindexer.query.Query.where_knn_string)
    * [open\_bracket](#pyreindexer.query.Query.open_bracket)
    * [close\_bracket](#pyreindexer.query.Query.close_bracket)
    * [match](#pyreindexer.query.Query.match)
    * [dwithin](#pyreindexer.query.Query.dwithin)
    * [distinct](#pyreindexer.query.Query.distinct)
    * [aggregate\_sum](#pyreindexer.query.Query.aggregate_sum)
    * [aggregate\_avg](#pyreindexer.query.Query.aggregate_avg)
    * [aggregate\_min](#pyreindexer.query.Query.aggregate_min)
    * [aggregate\_max](#pyreindexer.query.Query.aggregate_max)
    * [aggregate\_facet](#pyreindexer.query.Query.aggregate_facet)
    * [sort](#pyreindexer.query.Query.sort)
    * [sort\_stpoint\_distance](#pyreindexer.query.Query.sort_stpoint_distance)
    * [sort\_stfield\_distance](#pyreindexer.query.Query.sort_stfield_distance)
    * [op\_and](#pyreindexer.query.Query.op_and)
    * [op\_or](#pyreindexer.query.Query.op_or)
    * [op\_not](#pyreindexer.query.Query.op_not)
    * [request\_total](#pyreindexer.query.Query.request_total)
    * [cached\_total](#pyreindexer.query.Query.cached_total)
    * [limit](#pyreindexer.query.Query.limit)
    * [offset](#pyreindexer.query.Query.offset)
    * [debug](#pyreindexer.query.Query.debug)
    * [strict](#pyreindexer.query.Query.strict)
    * [explain](#pyreindexer.query.Query.explain)
    * [with\_rank](#pyreindexer.query.Query.with_rank)
    * [execute](#pyreindexer.query.Query.execute)
    * [delete](#pyreindexer.query.Query.delete)
    * [set\_object](#pyreindexer.query.Query.set_object)
    * [set](#pyreindexer.query.Query.set)
    * [drop](#pyreindexer.query.Query.drop)
    * [expression](#pyreindexer.query.Query.expression)
    * [update](#pyreindexer.query.Query.update)
    * [must\_execute](#pyreindexer.query.Query.must_execute)
    * [get](#pyreindexer.query.Query.get)
    * [inner\_join](#pyreindexer.query.Query.inner_join)
    * [join](#pyreindexer.query.Query.join)
    * [left\_join](#pyreindexer.query.Query.left_join)
    * [merge](#pyreindexer.query.Query.merge)
    * [on](#pyreindexer.query.Query.on)
    * [select](#pyreindexer.query.Query.select)
    * [functions](#pyreindexer.query.Query.functions)
    * [equal\_position](#pyreindexer.query.Query.equal_position)
* [pyreindexer.index\_search\_params](#pyreindexer.index_search_params)
  * [IndexSearchParamBruteForce](#pyreindexer.index_search_params.IndexSearchParamBruteForce)
  * [IndexSearchParamHnsw](#pyreindexer.index_search_params.IndexSearchParamHnsw)
  * [IndexSearchParamIvf](#pyreindexer.index_search_params.IndexSearchParamIvf)
* [pyreindexer.index\_definition](#pyreindexer.index_definition)
  * [IndexDefinition](#pyreindexer.index_definition.IndexDefinition)

<a id="pyreindexer.rx_connector"></a>

# pyreindexer.rx\_connector

<a id="pyreindexer.rx_connector.RxConnector"></a>

## RxConnector Objects

```python
class RxConnector(RaiserMixin)
```

RxConnector provides a binding to Reindexer upon two shared libraries (hereinafter - APIs): 'rawpyreindexerb.so'
    and 'rawpyreindexerc.so'. The first one is aimed to a builtin way usage. That API embeds Reindexer, so it could
    be used right in-place as is. The second one acts as a lightweight client which establishes a connection to
    Reindexer server via RPC. The APIs interfaces are completely the same.

#### Arguments:
        dsn (string): The connection string which contains a protocol
            Examples: 'builtin:///tmp/pyrx', 'cproto://127.0.0.1:6534/pyrx'

        cproto options:
             fetch_amount (int): The number of items that will be fetched by one operation
             reconnect_attempts (int): Number of reconnection attempts when connection is lost
             net_timeout (`datetime.timedelta`): Connection and database login timeout value [milliseconds]
             enable_compression (bool): Flag enable/disable traffic compression
             start_special_thread (bool): Determines whether to request a special thread of execution
                on the server for this connection
             client_name (string): Proper name of the application (as a client for Reindexer-server)
             sync_rxcoro_count (int): Client concurrency per connection

        built-in options:
            max_replication_updates_size (int): Max pended replication updates size in bytes
            allocator_cache_limit (int): Recommended maximum free cache size of tcmalloc memory allocator in bytes
            allocator_cache_part (float): Recommended maximum free cache size of tcmalloc memory allocator in
                relation to total Reindexer allocated memory size, in units

#### Attributes:
    api (module): An API module loaded dynamically for Reindexer calls
    rx (int): A memory pointer to Reindexer instance
    err_code (int): The API error code
    err_msg (string): The API error message

<a id="pyreindexer.rx_connector.RxConnector.close"></a>

### RxConnector.close

```python
def close() -> None
```

Closes an API instance with Reindexer resources freeing

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet

<a id="pyreindexer.rx_connector.RxConnector.namespace_open"></a>

### RxConnector.namespace\_open

```python
def namespace_open(
    namespace: str, timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Opens a namespace specified or creates a namespace if it does not exist

#### Arguments:
    namespace (string): A name of a namespace
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.namespace_close"></a>

### RxConnector.namespace\_close

```python
def namespace_close(
    namespace: str, timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Closes a namespace specified

#### Arguments:
    namespace (string): A name of a namespace
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.namespace_drop"></a>

### RxConnector.namespace\_drop

```python
def namespace_drop(
    namespace: str, timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Drops a namespace specified

#### Arguments:
    namespace (string): A name of a namespace
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    Exception: Raises with an error message when Reindexer instance is not initialized yet
    Exception: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.namespaces_enum"></a>

### RxConnector.namespaces\_enum

```python
def namespaces_enum(
    enum_not_opened: bool = False,
    timeout: timedelta = timedelta(milliseconds=0)
) -> List[Dict[str, str]]
```

Gets a list of namespaces available

#### Arguments:
    enum_not_opened (bool, optional): An enumeration mode flag. If it is
        set then closed namespaces are in result list too. Defaults to False
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (:obj:`list` of :obj:`dict`): A list of dictionaries which describe each namespace

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.index_add"></a>

### RxConnector.index\_add

```python
def index_add(
    namespace: str,
    index_def: Dict,
    timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Adds an index to the namespace specified

#### Arguments:
    namespace (string): A name of a namespace
    index_def (dict): A dictionary of index definition
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.index_update"></a>

### RxConnector.index\_update

```python
def index_update(
    namespace: str,
    index_def: Dict,
    timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Updates an index in the namespace specified

#### Arguments:
    namespace (string): A name of a namespace
    index_def (dict): A dictionary of index definition
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.index_drop"></a>

### RxConnector.index\_drop

```python
def index_drop(
    namespace: str,
    index_name: str,
    timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Drops an index from the namespace specified

#### Arguments:
    namespace (string): A name of a namespace
    index_name (string): A name of an index
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.item_insert"></a>

### RxConnector.item\_insert

```python
def item_insert(
    namespace: str,
    item_def: Dict,
    precepts: List[str] = None,
    timeout: timedelta = timedelta(milliseconds=0)
) -> None
```

Inserts an item with its precepts to the namespace specified

#### Arguments:
    namespace (string): A name of a namespace
    item_def (dict): A dictionary of item definition
    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.item_update"></a>

### RxConnector.item\_update

```python
def item_update(
    namespace: str,
    item_def: Dict,
    precepts: List[str] = None,
    timeout: timedelta = timedelta(milliseconds=0)
) -> None
```

Updates an item with its precepts in the namespace specified

#### Arguments:
    namespace (string): A name of a namespace
    item_def (dict): A dictionary of item definition
    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.item_upsert"></a>

### RxConnector.item\_upsert

```python
def item_upsert(
    namespace: str,
    item_def: Dict,
    precepts: List[str] = None,
    timeout: timedelta = timedelta(milliseconds=0)
) -> None
```

Updates an item with its precepts in the namespace specified. Creates the item if it not exists

#### Arguments:
    namespace (string): A name of a namespace
    item_def (dict): A dictionary of item definition
    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.item_delete"></a>

### RxConnector.item\_delete

```python
def item_delete(
    namespace: str,
    item_def: Dict,
    timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Deletes an item from the namespace specified

#### Arguments:
    namespace (string): A name of a namespace
    item_def (dict): A dictionary of item definition
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.meta_put"></a>

### RxConnector.meta\_put

```python
def meta_put(
    namespace: str,
    key: str,
    value: str,
    timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Puts metadata to a storage of Reindexer by key

#### Arguments:
    namespace (string): A name of a namespace
    key (string): A key in a storage of Reindexer for metadata keeping
    value (string): A metadata for storage
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.meta_get"></a>

### RxConnector.meta\_get

```python
def meta_get(namespace: str,
             key: str,
             timeout: timedelta = timedelta(milliseconds=0)) -> str
```

Gets metadata from a storage of Reindexer by key specified

#### Arguments:
    namespace (string): A name of a namespace
    key (string): A key in a storage of Reindexer where metadata is kept
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    string: A metadata value

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.meta_delete"></a>

### RxConnector.meta\_delete

```python
def meta_delete(
    namespace: str, key: str,
    timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Deletes metadata from a storage of Reindexer by key specified

#### Arguments:
    namespace (string): A name of a namespace
    key (string): A key in a storage of Reindexer where metadata is kept
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.meta_enum"></a>

### RxConnector.meta\_enum

```python
def meta_enum(
    namespace: str,
    timeout: timedelta = timedelta(milliseconds=0)) -> List[str]
```

Gets a list of metadata keys from a storage of Reindexer

#### Arguments:
    namespace (string): A name of a namespace
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (:obj:`list` of :obj:`str`): A list of all metadata keys

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.select"></a>

### RxConnector.select

```python
def select(
    query: str,
    timeout: timedelta = timedelta(milliseconds=0)) -> QueryResults
```

Executes an SQL query and returns query results

#### Arguments:
    query (string): An SQL query
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (:obj:`QueryResults`): A QueryResults iterator

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.new_transaction"></a>

### RxConnector.new\_transaction

```python
def new_transaction(
    namespace: str,
    timeout: timedelta = timedelta(milliseconds=0)) -> Transaction
```

Starts a new transaction and return the transaction object to processing.
    Warning: once a timeout is set, it will apply to all subsequent steps in the transaction

#### Arguments:
    namespace (string): A name of a namespace
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (:obj:`Transaction`): A new transaction

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.new_query"></a>

### RxConnector.new\_query

```python
def new_query(namespace: str) -> Query
```

Creates a new query and return the query object to processing

#### Arguments:
    namespace (string): A name of a namespace

#### Returns:
    (:obj:`Query`): A new query

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet

<a id="pyreindexer.query_results"></a>

# pyreindexer.query\_results

<a id="pyreindexer.query_results.QueryResults"></a>

## QueryResults Objects

```python
class QueryResults()
```

QueryResults is a disposable iterator of Reindexer results for such queries as SELECT etc.
    When the results are fetched the iterator closes and frees a memory of results buffer of Reindexer

#### Attributes:
    api (module): An API module for Reindexer calls
    err_code (int): The API error code
    err_msg (string): The API error message
    qres_wrapper_ptr (int): A memory pointer to Reindexer iterator object
    qres_iter_count (int): A count of results for iterations
    pos (int): The current result position in iterator

<a id="pyreindexer.query_results.QueryResults.status"></a>

### QueryResults.status

```python
def status() -> None
```

Check status

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query_results.QueryResults.count"></a>

### QueryResults.count

```python
def count() -> int
```

Returns a count of results for iterations

#### Returns
    int: A count of results

<a id="pyreindexer.query_results.QueryResults.total_count"></a>

### QueryResults.total\_count

```python
def total_count() -> int
```

Returns a total or cached count of results

#### Returns
    int: A total or cached count of results

<a id="pyreindexer.query_results.QueryResults.get_agg_results"></a>

### QueryResults.get\_agg\_results

```python
def get_agg_results() -> dict
```

Returns aggregation results for the current query

#### Returns
    (:obj:`dict`): Dictionary with all results for the current query

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query_results.QueryResults.get_explain_results"></a>

### QueryResults.get\_explain\_results

```python
def get_explain_results() -> str
```

Returns explain results for the current query

#### Returns
    (string): Formatted string with explain of results for the current query

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction"></a>

# pyreindexer.transaction

<a id="pyreindexer.transaction.Transaction"></a>

## Transaction Objects

```python
class Transaction()
```

An object representing the context of a Reindexer transaction

#### Attributes:
    api (module): An API module for Reindexer calls
    transaction_wrapper_ptr (int): A memory pointer to Reindexer transaction object
    err_code (int): The API error code
    err_msg (string): The API error message

<a id="pyreindexer.transaction.Transaction.insert"></a>

### Transaction.insert

```python
def insert(item_def: Dict, precepts: List[str] = None) -> None
```

Inserts an item with its precepts to the transaction
    Warning: the timeout set when the transaction was created is used

#### Arguments:
    item_def (dict): A dictionary of item definition
    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.update"></a>

### Transaction.update

```python
def update(item_def: Dict, precepts: List[str] = None) -> None
```

Updates an item with its precepts to the transaction
    Warning: the timeout set when the transaction was created is used

#### Arguments:
    item_def (dict): A dictionary of item definition
    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.update_query"></a>

### Transaction.update\_query

```python
def update_query(query: Query) -> None
```

Updates items with the transaction
    Read-committed isolation is available for read operations.
    Changes made in active transaction is invisible to current and another transactions.

#### Arguments:
    query (:obj:`Query`): A query object to modify

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.upsert"></a>

### Transaction.upsert

```python
def upsert(item_def: Dict, precepts: List[str] = None) -> None
```

Updates an item with its precepts to the transaction. Creates the item if it not exists
    Warning: the timeout set when the transaction was created is used

#### Arguments:
    item_def (dict): A dictionary of item definition
    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.delete"></a>

### Transaction.delete

```python
def delete(item_def: Dict) -> None
```

Deletes an item from the transaction
    Warning: the timeout set when the transaction was created is used

#### Arguments:
    item_def (dict): A dictionary of item definition

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.delete_query"></a>

### Transaction.delete\_query

```python
def delete_query(query: Query)
```

Deletes items with the transaction
    Read-committed isolation is available for read operations.
    Changes made in active transaction is invisible to current and another transactions.

#### Arguments:
    query (:obj:`Query`): A query object to modify

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.commit"></a>

### Transaction.commit

```python
def commit(timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Applies changes

#### Arguments:
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.commit_with_count"></a>

### Transaction.commit\_with\_count

```python
def commit_with_count(timeout: timedelta = timedelta(milliseconds=0)) -> int
```

Applies changes and return the number of count of changed items

#### Arguments:
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.rollback"></a>

### Transaction.rollback

```python
def rollback(timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Rollbacks changes

#### Arguments:
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.point"></a>

# pyreindexer.point

<a id="pyreindexer.point.Point"></a>

## Point Objects

```python
class Point()
```

An object representing the context of a Reindexer 2D point

#### Attributes:
    x (float): x coordinate of the point
    y (float): y coordinate of the point

<a id="pyreindexer.query"></a>

# pyreindexer.query

<a id="pyreindexer.query.Query"></a>

## Query Objects

```python
class Query()
```

An object representing the context of a Reindexer query

#### Attributes:
    api (module): An API module for Reindexer calls
    query_wrapper_ptr (int): A memory pointer to Reindexer query object
    err_code (int): The API error code
    err_msg (string): The API error message
    root (:object: Optional[`Query`]): The root query of the Reindexer query
    join_queries (list[:object:`Query`]): The list of join Reindexer query objects
    merged_queries (list[:object:`Query`]): The list of merged Reindexer query objects

<a id="pyreindexer.query.Query.where"></a>

### Query.where

```python
def where(
        index: str,
        condition: CondType,
        keys: Union[simple_types, tuple[list[simple_types],
                                        ...]] = None) -> Query
```

Adds where condition to DB query with args

#### Arguments:
    index (string): Field name used in condition clause
    condition (:enum:`CondType`): Type of condition
    keys (union[simple_types, (list[simple_types], ...)]):
        Value of index to be compared with. For composite indexes keys must be list,
        with value of each sub-index

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.where_query"></a>

### Query.where\_query

```python
def where_query(
        sub_query: Query,
        condition: CondType,
        keys: Union[simple_types, tuple[list[simple_types],
                                        ...]] = None) -> Query
```

Adds sub-query where condition to DB query with args

#### Arguments:
    sub_query (:obj:`Query`): Field name used in condition clause
    condition (:enum:`CondType`): Type of condition
    keys (union[simple_types, (list[simple_types], ...)]):
        Value of index to be compared with. For composite indexes keys must be list,
        with value of each sub-index

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.where_subquery"></a>

### Query.where\_subquery

```python
def where_subquery(index: str, condition: CondType, sub_query: Query) -> Query
```

Adds sub-query where condition to DB query

#### Arguments:
    index (string): Field name used in condition clause
    condition (:enum:`CondType`): Type of condition
    sub_query (:obj:`Query`): Field name used in condition clause

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.where_composite"></a>

### Query.where\_composite

```python
def where_composite(index: str, condition: CondType,
                    keys: tuple[list[simple_types], ...]) -> Query
```

Adds where condition to DB query with interface args for composite indexes

#### Arguments:
    index (string): Field name used in condition clause
    condition (:enum:`CondType`): Type of condition
    keys (list[simple_types], ...): Values of composite index to be compared with (value of each sub-index).
        Supported variants:
            ([1, "test1"], [2, "test2"])
            [[1, "test1"], [2, "test2"]])
            ([1, "testval1"], )
            [[1, "testval1"]]
            (1, "testval1")

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.where_uuid"></a>

### Query.where\_uuid

```python
def where_uuid(index: str, condition: CondType, *uuids: UUID) -> Query
```

Adds where condition to DB query with UUID.
    `index` MUST be declared as uuid-string index in this case

#### Arguments:
    index (string): Field name used in condition clause
    condition (:enum:`CondType`): Type of condition
    uuids (*:obj:`UUID`): Value of index to be compared with. For composite indexes uuids must be list,
        with value of each sub-index

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.where_between_fields"></a>

### Query.where\_between\_fields

```python
def where_between_fields(first_field: str, condition: CondType,
                         second_field: str) -> Query
```

Adds comparing two fields where condition to DB query

#### Arguments:
    first_field (string): First field name used in condition clause
    condition (:enum:`CondType`): Type of condition
    second_field (string): Second field name used in condition clause

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.where_knn"></a>

### Query.where\_knn

```python
def where_knn(
    index: str, vec: List[float],
    param: Union[IndexSearchParamBruteForce | IndexSearchParamHnsw | IndexSearchParamIvf]
) -> Query
```

Adds where condition to DB query with float_vector as args.
    `index` MUST be declared as float_vector index in this case

#### Arguments:
    index (string): Field name used in condition clause (only float_vector)
    vec (list[float]): KNN value of index to be compared with
    param (:obj:`union[IndexSearchParamBruteForce|IndexSearchParamHnsw|IndexSearchParamIvf]`): KNN search parameters

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    QueryError: Raises with an error message if no vec are specified
    QueryError: Raises with an error message if no param are specified or have an invalid value
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.where_knn_string"></a>

### Query.where\_knn\_string

```python
def where_knn_string(
    index: str, value: str,
    param: Union[IndexSearchParamBruteForce | IndexSearchParamHnsw | IndexSearchParamIvf]
) -> Query
```

Adds where condition to DB query with string as args.
    `index` MUST be declared as float_vector index in this case.
    WARNING: Only relevant if automatic embedding is configured for this float_vector index

#### Arguments:
    index (string): Field name used in condition clause (only float_vector)
    value (string): value to be generated using automatic embedding of KNN index value to be compared to
    param (:obj:`union[IndexSearchParamBruteForce|IndexSearchParamHnsw|IndexSearchParamIvf]`): KNN search parameters

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    QueryError: Raises with an error message if no value are specified
    QueryError: Raises with an error message if no param are specified or have an invalid value
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.open_bracket"></a>

### Query.open\_bracket

```python
def open_bracket() -> Query
```

Opens bracket for where condition to DB query

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.close_bracket"></a>

### Query.close\_bracket

```python
def close_bracket() -> Query
```

Closes bracket for where condition to DB query

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.match"></a>

### Query.match

```python
def match(index: str, *keys: str) -> Query
```

Adds string EQ-condition to DB query with string args

#### Arguments:
    index (string): Field name used in condition clause
    keys (*string): Value of index to be compared with. For composite indexes keys must be list,
        with value of each sub-index

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.dwithin"></a>

### Query.dwithin

```python
def dwithin(index: str, point: Point, distance: float) -> Query
```

Adds DWithin condition to DB query

#### Arguments:
    index (string): Field name used in condition clause
    point (:obj:`Point`): Point object used in condition clause
    distance (float): Distance in meters between point

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.distinct"></a>

### Query.distinct

```python
def distinct(index: str) -> Query
```

Performs distinct for a certain index. Return only items with uniq value of field

#### Arguments:
    index (string): Field name for distinct operation

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.aggregate_sum"></a>

### Query.aggregate\_sum

```python
def aggregate_sum(index: str) -> Query
```

Performs a summation of values for a specified index

#### Arguments:
    index (string): Field name for sum operation

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.aggregate_avg"></a>

### Query.aggregate\_avg

```python
def aggregate_avg(index: str) -> Query
```

Finds for the average at the specified index

#### Arguments:
    index (string): Field name for sum operation

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.aggregate_min"></a>

### Query.aggregate\_min

```python
def aggregate_min(index: str) -> Query
```

Finds for the minimum at the specified index

#### Arguments:
    index (string): Field name for sum operation

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.aggregate_max"></a>

### Query.aggregate\_max

```python
def aggregate_max(index: str) -> Query
```

Finds for the maximum at the specified index

#### Arguments:
    index (string): Field name for sum operation

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.aggregate_facet"></a>

### Query.aggregate\_facet

```python
def aggregate_facet(*fields: str) -> Query._AggregateFacet
```

Gets fields facet value. Applicable to multiple data fields and the result of that could be sorted
    by any data column or `count` and cut off by offset and limit. In order to support this functionality
    this method returns AggregationFacetRequest which has methods sort, limit and offset

#### Arguments:
    fields (*string): Fields any data column name or `count`, fields should not be empty

#### Returns:
    (:obj:`_AggregateFacet`): Request object for further customizations

<a id="pyreindexer.query.Query.sort"></a>

### Query.sort

```python
def sort(
    index: str,
    desc: bool = False,
    forced_sort_values: Union[simple_types, tuple[list[simple_types],
                                                  ...]] = None
) -> Query
```

Applies sort order to return from query items. If forced_sort_values argument specified, then items equal to
    values, if found will be placed in the top positions. Forced sort is support for the first sorting field
    only

#### Arguments:
    index (string): The index name
    desc (bool): Sort in descending order
    forced_sort_values (union[simple_types, (list[simple_types], ...)]):
        Value of index to match. For composite indexes keys must be list, with value of each sub-index

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.sort_stpoint_distance"></a>

### Query.sort\_stpoint\_distance

```python
def sort_stpoint_distance(index: str, point: Point, desc: bool) -> Query
```

Applies geometry sort order to return from query items. Wrapper for geometry sorting by shortest distance
    between geometry field and point (ST_Distance)

#### Arguments:
    index (string): The index name
    point (:obj:`Point`): Point object used in sorting operation
    desc (bool): Sort in descending order

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.sort_stfield_distance"></a>

### Query.sort\_stfield\_distance

```python
def sort_stfield_distance(first_field: str, second_field: str,
                          desc: bool) -> Query
```

Applies geometry sort order to return from query items. Wrapper for geometry sorting by shortest distance
    between 2 geometry fields (ST_Distance)

#### Arguments:
    first_field (string): First field name used in condition
    second_field (string): Second field name used in condition
    desc (bool): Sort in descending order

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.op_and"></a>

### Query.op\_and

```python
def op_and() -> Query
```

Next condition will be added with AND.
    This is the default operation for WHERE statement. Do not have to be called explicitly in user's code.
    Used in DSL conversion

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.op_or"></a>

### Query.op\_or

```python
def op_or() -> Query
```

Next condition will be added with OR.
    Implements short-circuiting:
    if the previous condition is successful the next will not be evaluated, but except Join conditions

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.op_not"></a>

### Query.op\_not

```python
def op_not() -> Query
```

Next condition will be added with NOT AND.
    Implements short-circuiting: if the previous condition is failed the next will not be evaluated

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.request_total"></a>

### Query.request\_total

```python
def request_total() -> Query
```

Requests total items calculation

#### Arguments:
    total_name (string, optional): Name to be requested

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.cached_total"></a>

### Query.cached\_total

```python
def cached_total() -> Query
```

Requests cached total items calculation

#### Arguments:
    total_name (string, optional): Name to be requested

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.limit"></a>

### Query.limit

```python
def limit(limit_items: int) -> Query
```

Sets a limit (count) of returned items. Analog to sql LIMIT rowsNumber

#### Arguments:
    limit_items (int): Number of rows to get from result set

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.offset"></a>

### Query.offset

```python
def offset(start_offset: int) -> Query
```

Sets the number of the first selected row from result query

#### Arguments:
    limit_items (int): Index of the first row to get from result set

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.debug"></a>

### Query.debug

```python
def debug(level: LogLevel) -> Query
```

Changes debug log level on server

#### Arguments:
    level (:enum:`LogLevel`): Debug log level on server

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.strict"></a>

### Query.strict

```python
def strict(mode: StrictMode) -> Query
```

Changes strict mode

#### Arguments:
    mode (:enum:`StrictMode`): Strict mode

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.explain"></a>

### Query.explain

```python
def explain() -> Query
```

Enables explain query

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.with_rank"></a>

### Query.with\_rank

```python
def with_rank() -> Query
```

Outputs fulltext/float_vector rank. Allowed only with fulltext and KNN query

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.execute"></a>

### Query.execute

```python
def execute(timeout: timedelta = timedelta(milliseconds=0)) -> QueryResults
```

Executes a select query

#### Arguments:
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (:obj:`QueryResults`): A QueryResults iterator

#### Raises:
    ApiError: Raises with an error message when query is in an invalid state
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.delete"></a>

### Query.delete

```python
def delete(timeout: timedelta = timedelta(milliseconds=0)) -> int
```

Executes a query, and delete items, matches query

#### Arguments:
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (int): Number of deleted elements

#### Raises:
    QueryError: Raises with an error message when query is in an invalid state
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.set_object"></a>

### Query.set\_object

```python
def set_object(field: str, values: list[simple_types]) -> Query
```

Adds an update query to an object field for an update query

#### Arguments:
    field (string): Field name
    values (list[simple_types]): List of values to add

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    QueryError: Raises with an error message if no values are specified
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.set"></a>

### Query.set

```python
def set(field: str, values: list[simple_types]) -> Query
```

Adds a field update request to the update request

#### Arguments:
    field (string): Field name
    values (list[simple_types]): List of values to add

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.drop"></a>

### Query.drop

```python
def drop(index: str) -> Query
```

Drops a value for a field

#### Arguments:
    index (string): Field name for drop operation

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.expression"></a>

### Query.expression

```python
def expression(field: str, value: str) -> Query
```

Updates indexed field by arithmetical expression

#### Arguments:
    field (string): Field name
    value (string): New value expression for field

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.update"></a>

### Query.update

```python
def update(timeout: timedelta = timedelta(milliseconds=0)) -> QueryResults
```

Executes update query, and update fields in items, which matches query

#### Arguments:
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (:obj:`QueryResults`): A QueryResults iterator

#### Raises:
    QueryError: Raises with an error message when query is in an invalid state
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.must_execute"></a>

### Query.must\_execute

```python
def must_execute(timeout: timedelta = timedelta(
    milliseconds=0)) -> QueryResults
```

Executes a query, and update fields in items, which matches query, with status check

#### Arguments:
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (:obj:`QueryResults`): A QueryResults iterator

#### Raises:
    ApiError: Raises with an error message when query is in an invalid state
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.get"></a>

### Query.get

```python
def get(timeout: timedelta = timedelta(milliseconds=0)) -> (str, bool)
```

Executes a query, and return 1 JSON item

#### Arguments:
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (:tuple:string,bool): 1st string item and found flag

#### Raises:
    ApiError: Raises with an error message when query is in an invalid state
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.inner_join"></a>

### Query.inner\_join

```python
def inner_join(query: Query, field: str) -> Query
```

Joins 2 queries.
    Items from the 1-st query are filtered by and expanded with the data from the 2-nd query

#### Arguments:
    query (:obj:`Query`): Query object to left join
    field (string): Joined field name. As unique identifier for the join between this query and `join_query`.
        Parameter in order for InnerJoin to work: namespace of `query` contains `field` as one of its fields
        marked as `joined`

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.join"></a>

### Query.join

```python
def join(query: Query, field: str) -> Query
```

Join is an alias for LeftJoin. Joins 2 queries.
    Items from this query are expanded with the data from the `query`

#### Arguments:
    query (:obj:`Query`): Query object to left join
    field (string): Joined field name. As unique identifier for the join between this query and `join_query`

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.left_join"></a>

### Query.left\_join

```python
def left_join(join_query: Query, field: str) -> Query
```

Joins 2 queries.
    Items from this query are expanded with the data from the join_query.
    One of the conditions below must hold for `field` parameter in order for LeftJoin to work:
        namespace of `join_query` contains `field` as one of its fields marked as `joined`

#### Arguments:
    query (:obj:`Query`): Query object to left join
    field (string): Joined field name. As unique identifier for the join between this query and `join_query`

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.merge"></a>

### Query.merge

```python
def merge(query: Query) -> Query
```

Merges queries of the same type

#### Arguments:
    query (:obj:`Query`): Query object to merge

#### Returns:
    (:obj:`Query`): Query object for further customizations

<a id="pyreindexer.query.Query.on"></a>

### Query.on

```python
def on(index: str, condition: CondType, join_index: str) -> Query
```

On specifies join condition

#### Arguments:
    index (string): Field name from `Query` namespace should be used during join
    condition (:enum:`CondType`): Type of condition, specifies how `Query` will be joined with the latest join query issued on `Query` (e.g. `EQ`/`GT`/`SET`/...)
    join_index (string): Index-field name from namespace for the latest join query issued on `Query` should be used during join

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    QueryError: Raises with an error message when query is in an invalid state

<a id="pyreindexer.query.Query.select"></a>

### Query.select

```python
def select(*fields: str) -> Query
```

Sets list of columns in this namespace to be finally selected.
    The columns should be specified in the same case as the jsonpaths corresponding to them.
    Non-existent fields and fields in the wrong case are ignored.
    If there are no fields in this list that meet these conditions, then the filter works as "*"

#### Arguments:
    fields (*string): List of columns to be selected

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.functions"></a>

### Query.functions

```python
def functions(*functions: str) -> Query
```

Adds sql-functions to query

#### Arguments:
    functions (*string): Functions declaration

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.equal_position"></a>

### Query.equal\_position

```python
def equal_position(*equal_position: str) -> Query
```

Adds equal position fields to arrays queries

#### Arguments:
    equal_poses (*string): Equal position fields to arrays queries

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.index_search_params"></a>

# pyreindexer.index\_search\_params

<a id="pyreindexer.index_search_params.IndexSearchParamBruteForce"></a>

## IndexSearchParamBruteForce Objects

```python
class IndexSearchParamBruteForce()
```

Index search param for brute force index. Equal to basic parameters

#### Attributes:
    k (int): Expected size of KNN index results. Should not be less than 1
    radius (float): In addition to the parameter `k`, the query results can also be filtered by a `rank` -
      value using the parameter, witch called `radius`. It's named so because, under the `L2`-metric,
      it restricts vectors from query result to a sphere of the specified radius. [More about `radius`]
      (https://github.com/Restream/reindexer/blob/master/float_vector.md)

<a id="pyreindexer.index_search_params.IndexSearchParamHnsw"></a>

## IndexSearchParamHnsw Objects

```python
class IndexSearchParamHnsw()
```

Index search param for HNSW index.

#### Attributes:
    k (int): Expected size of KNN index results. Should not be less than 1
    ef (int): Size of nearest neighbor buffer that will be filled during fetching. Should not be less than 'k',
    good story when `ef` ~= 1.5 * `k`
    radius (float): In addition to the parameter `k`, the query results can also be filtered by a `rank` -
      value using the parameter, witch called `radius`. It's named so because, under the `L2`-metric,
      it restricts vectors from query result to a sphere of the specified radius. [More about `radius`]
      (https://github.com/Restream/reindexer/blob/master/float_vector.md)

<a id="pyreindexer.index_search_params.IndexSearchParamIvf"></a>

## IndexSearchParamIvf Objects

```python
class IndexSearchParamIvf()
```

Index search param for IVF index.

#### Attributes:
    k (int): Expected size of KNN index results. Should not be less than 1
    nprobe (int): Number of centroids that will be scanned in where. Should not be less than 1
    radius (float): In addition to the parameter `k`, the query results can also be filtered by a `rank` -
      value using the parameter, witch called `radius`. It's named so because, under the `L2`-metric,
      it restricts vectors from query result to a sphere of the specified radius. [More about `radius`]
      (https://github.com/Restream/reindexer/blob/master/float_vector.md)

<a id="pyreindexer.index_definition"></a>

# pyreindexer.index\_definition

<a id="pyreindexer.index_definition.IndexDefinition"></a>

## IndexDefinition Objects

```python
class IndexDefinition(dict)
```

IndexDefinition is a dictionary subclass which allows to construct and manage indexes more efficiently.
NOT IMPLEMENTED YET. USE FIELDS DESCRIPTION ONLY.

#### Arguments:
    name (str): An index name.
    json_paths (:obj:`list` of :obj:`str`): A name for mapping a value to a json field.
    field_type (str): A type of field. Possible values are: `int`, `int64`, `double`, `string`, `bool`,
    `composite`, `float_vector`.
    index_type (str): An index type. Possible values are: `hash`, `tree`, `text`, `-`, `hnsw`, `vec_bf`, `ivf`.
    is_pk (bool): True if a field is a primary key.
    is_array (bool): True if an index is an array.
    is_dense (bool): True if an index is dense. Reduce the index size. Saves 8 bytes per unique key value for 'hash'
        and 'tree' index types. For '-' index type saves 4-8 bytes per each element. Useful for indexes with
        high selectivity, but for tree and hash indexes with low selectivity can seriously decrease update
        performance.
    is_no_column (bool): True if allows to disable column subindex. Reduces the index size.
        Allows to save ~(`stored_type_size` * `namespace_items_count`) bytes, where `stored_type_size` is the size
        of the type stored in the index, and `namespace_items_count` is the number of items in the namespace.
        May reduce performance.
    is_sparse (bool): True if a value of an index may be not presented.
    collate_mode (str): Sets an order of values by collate mode. Possible values are:
        `none`, `ascii`, `utf8`, `numeric`, `custom`.
    sort_order_letters (str): Order for a sort sequence for a custom collate mode.
    config (dict): A config for a fulltext and float_vector engine.
    [More about `fulltext`](https://github.com/Restream/reindexer/blob/master/fulltext.md) or
    [More about `float_vector`](https://github.com/Restream/reindexer/blob/master/float_vector.md).


            

Raw data

            {
    "_id": null,
    "home_page": "https://github.com/Restream/reindexer",
    "name": "pyreindexer",
    "maintainer": "Reindexer Team",
    "docs_url": null,
    "requires_python": ">=3.8",
    "maintainer_email": "contactus@reindexer.io",
    "keywords": "reindexer, reindexer-py, in-memory-database, database, python, connector",
    "author": "Igor Tulmentyev",
    "author_email": "contactus@reindexer.io",
    "download_url": "https://files.pythonhosted.org/packages/9b/b3/5b200caead15bcbb1413b159e19bc2a878a62db31a0363c0ddd1c4bd1331/pyreindexer-0.5.600.tar.gz",
    "platform": "ALT Linux",
    "description": "# The PyReindexer module provides a connector and its auxiliary tools for interaction with Reindexer. Reindexer static library or reindexer-dev package must be installed\n\n* [pyreindexer.rx\\_connector](#pyreindexer.rx_connector)\n  * [RxConnector](#pyreindexer.rx_connector.RxConnector)\n    * [close](#pyreindexer.rx_connector.RxConnector.close)\n    * [namespace\\_open](#pyreindexer.rx_connector.RxConnector.namespace_open)\n    * [namespace\\_close](#pyreindexer.rx_connector.RxConnector.namespace_close)\n    * [namespace\\_drop](#pyreindexer.rx_connector.RxConnector.namespace_drop)\n    * [namespaces\\_enum](#pyreindexer.rx_connector.RxConnector.namespaces_enum)\n    * [index\\_add](#pyreindexer.rx_connector.RxConnector.index_add)\n    * [index\\_update](#pyreindexer.rx_connector.RxConnector.index_update)\n    * [index\\_drop](#pyreindexer.rx_connector.RxConnector.index_drop)\n    * [item\\_insert](#pyreindexer.rx_connector.RxConnector.item_insert)\n    * [item\\_update](#pyreindexer.rx_connector.RxConnector.item_update)\n    * [item\\_upsert](#pyreindexer.rx_connector.RxConnector.item_upsert)\n    * [item\\_delete](#pyreindexer.rx_connector.RxConnector.item_delete)\n    * [meta\\_put](#pyreindexer.rx_connector.RxConnector.meta_put)\n    * [meta\\_get](#pyreindexer.rx_connector.RxConnector.meta_get)\n    * [meta\\_delete](#pyreindexer.rx_connector.RxConnector.meta_delete)\n    * [meta\\_enum](#pyreindexer.rx_connector.RxConnector.meta_enum)\n    * [select](#pyreindexer.rx_connector.RxConnector.select)\n    * [new\\_transaction](#pyreindexer.rx_connector.RxConnector.new_transaction)\n    * [new\\_query](#pyreindexer.rx_connector.RxConnector.new_query)\n* [pyreindexer.query\\_results](#pyreindexer.query_results)\n  * [QueryResults](#pyreindexer.query_results.QueryResults)\n    * [status](#pyreindexer.query_results.QueryResults.status)\n    * [count](#pyreindexer.query_results.QueryResults.count)\n    * [total\\_count](#pyreindexer.query_results.QueryResults.total_count)\n    * [get\\_agg\\_results](#pyreindexer.query_results.QueryResults.get_agg_results)\n    * [get\\_explain\\_results](#pyreindexer.query_results.QueryResults.get_explain_results)\n* [pyreindexer.transaction](#pyreindexer.transaction)\n  * [Transaction](#pyreindexer.transaction.Transaction)\n    * [insert](#pyreindexer.transaction.Transaction.insert)\n    * [update](#pyreindexer.transaction.Transaction.update)\n    * [update\\_query](#pyreindexer.transaction.Transaction.update_query)\n    * [upsert](#pyreindexer.transaction.Transaction.upsert)\n    * [delete](#pyreindexer.transaction.Transaction.delete)\n    * [delete\\_query](#pyreindexer.transaction.Transaction.delete_query)\n    * [commit](#pyreindexer.transaction.Transaction.commit)\n    * [commit\\_with\\_count](#pyreindexer.transaction.Transaction.commit_with_count)\n    * [rollback](#pyreindexer.transaction.Transaction.rollback)\n* [pyreindexer.point](#pyreindexer.point)\n  * [Point](#pyreindexer.point.Point)\n* [pyreindexer.query](#pyreindexer.query)\n  * [Query](#pyreindexer.query.Query)\n    * [where](#pyreindexer.query.Query.where)\n    * [where\\_query](#pyreindexer.query.Query.where_query)\n    * [where\\_subquery](#pyreindexer.query.Query.where_subquery)\n    * [where\\_composite](#pyreindexer.query.Query.where_composite)\n    * [where\\_uuid](#pyreindexer.query.Query.where_uuid)\n    * [where\\_between\\_fields](#pyreindexer.query.Query.where_between_fields)\n    * [where\\_knn](#pyreindexer.query.Query.where_knn)\n    * [where\\_knn\\_string](#pyreindexer.query.Query.where_knn_string)\n    * [open\\_bracket](#pyreindexer.query.Query.open_bracket)\n    * [close\\_bracket](#pyreindexer.query.Query.close_bracket)\n    * [match](#pyreindexer.query.Query.match)\n    * [dwithin](#pyreindexer.query.Query.dwithin)\n    * [distinct](#pyreindexer.query.Query.distinct)\n    * [aggregate\\_sum](#pyreindexer.query.Query.aggregate_sum)\n    * [aggregate\\_avg](#pyreindexer.query.Query.aggregate_avg)\n    * [aggregate\\_min](#pyreindexer.query.Query.aggregate_min)\n    * [aggregate\\_max](#pyreindexer.query.Query.aggregate_max)\n    * [aggregate\\_facet](#pyreindexer.query.Query.aggregate_facet)\n    * [sort](#pyreindexer.query.Query.sort)\n    * [sort\\_stpoint\\_distance](#pyreindexer.query.Query.sort_stpoint_distance)\n    * [sort\\_stfield\\_distance](#pyreindexer.query.Query.sort_stfield_distance)\n    * [op\\_and](#pyreindexer.query.Query.op_and)\n    * [op\\_or](#pyreindexer.query.Query.op_or)\n    * [op\\_not](#pyreindexer.query.Query.op_not)\n    * [request\\_total](#pyreindexer.query.Query.request_total)\n    * [cached\\_total](#pyreindexer.query.Query.cached_total)\n    * [limit](#pyreindexer.query.Query.limit)\n    * [offset](#pyreindexer.query.Query.offset)\n    * [debug](#pyreindexer.query.Query.debug)\n    * [strict](#pyreindexer.query.Query.strict)\n    * [explain](#pyreindexer.query.Query.explain)\n    * [with\\_rank](#pyreindexer.query.Query.with_rank)\n    * [execute](#pyreindexer.query.Query.execute)\n    * [delete](#pyreindexer.query.Query.delete)\n    * [set\\_object](#pyreindexer.query.Query.set_object)\n    * [set](#pyreindexer.query.Query.set)\n    * [drop](#pyreindexer.query.Query.drop)\n    * [expression](#pyreindexer.query.Query.expression)\n    * [update](#pyreindexer.query.Query.update)\n    * [must\\_execute](#pyreindexer.query.Query.must_execute)\n    * [get](#pyreindexer.query.Query.get)\n    * [inner\\_join](#pyreindexer.query.Query.inner_join)\n    * [join](#pyreindexer.query.Query.join)\n    * [left\\_join](#pyreindexer.query.Query.left_join)\n    * [merge](#pyreindexer.query.Query.merge)\n    * [on](#pyreindexer.query.Query.on)\n    * [select](#pyreindexer.query.Query.select)\n    * [functions](#pyreindexer.query.Query.functions)\n    * [equal\\_position](#pyreindexer.query.Query.equal_position)\n* [pyreindexer.index\\_search\\_params](#pyreindexer.index_search_params)\n  * [IndexSearchParamBruteForce](#pyreindexer.index_search_params.IndexSearchParamBruteForce)\n  * [IndexSearchParamHnsw](#pyreindexer.index_search_params.IndexSearchParamHnsw)\n  * [IndexSearchParamIvf](#pyreindexer.index_search_params.IndexSearchParamIvf)\n* [pyreindexer.index\\_definition](#pyreindexer.index_definition)\n  * [IndexDefinition](#pyreindexer.index_definition.IndexDefinition)\n\n<a id=\"pyreindexer.rx_connector\"></a>\n\n# pyreindexer.rx\\_connector\n\n<a id=\"pyreindexer.rx_connector.RxConnector\"></a>\n\n## RxConnector Objects\n\n```python\nclass RxConnector(RaiserMixin)\n```\n\nRxConnector provides a binding to Reindexer upon two shared libraries (hereinafter - APIs): 'rawpyreindexerb.so'\n    and 'rawpyreindexerc.so'. The first one is aimed to a builtin way usage. That API embeds Reindexer, so it could\n    be used right in-place as is. The second one acts as a lightweight client which establishes a connection to\n    Reindexer server via RPC. The APIs interfaces are completely the same.\n\n#### Arguments:\n        dsn (string): The connection string which contains a protocol\n            Examples: 'builtin:///tmp/pyrx', 'cproto://127.0.0.1:6534/pyrx'\n\n        cproto options:\n             fetch_amount (int): The number of items that will be fetched by one operation\n             reconnect_attempts (int): Number of reconnection attempts when connection is lost\n             net_timeout (`datetime.timedelta`): Connection and database login timeout value [milliseconds]\n             enable_compression (bool): Flag enable/disable traffic compression\n             start_special_thread (bool): Determines whether to request a special thread of execution\n                on the server for this connection\n             client_name (string): Proper name of the application (as a client for Reindexer-server)\n             sync_rxcoro_count (int): Client concurrency per connection\n\n        built-in options:\n            max_replication_updates_size (int): Max pended replication updates size in bytes\n            allocator_cache_limit (int): Recommended maximum free cache size of tcmalloc memory allocator in bytes\n            allocator_cache_part (float): Recommended maximum free cache size of tcmalloc memory allocator in\n                relation to total Reindexer allocated memory size, in units\n\n#### Attributes:\n    api (module): An API module loaded dynamically for Reindexer calls\n    rx (int): A memory pointer to Reindexer instance\n    err_code (int): The API error code\n    err_msg (string): The API error message\n\n<a id=\"pyreindexer.rx_connector.RxConnector.close\"></a>\n\n### RxConnector.close\n\n```python\ndef close() -> None\n```\n\nCloses an API instance with Reindexer resources freeing\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n\n<a id=\"pyreindexer.rx_connector.RxConnector.namespace_open\"></a>\n\n### RxConnector.namespace\\_open\n\n```python\ndef namespace_open(\n    namespace: str, timeout: timedelta = timedelta(milliseconds=0)) -> None\n```\n\nOpens a namespace specified or creates a namespace if it does not exist\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.namespace_close\"></a>\n\n### RxConnector.namespace\\_close\n\n```python\ndef namespace_close(\n    namespace: str, timeout: timedelta = timedelta(milliseconds=0)) -> None\n```\n\nCloses a namespace specified\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.namespace_drop\"></a>\n\n### RxConnector.namespace\\_drop\n\n```python\ndef namespace_drop(\n    namespace: str, timeout: timedelta = timedelta(milliseconds=0)) -> None\n```\n\nDrops a namespace specified\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    Exception: Raises with an error message when Reindexer instance is not initialized yet\n    Exception: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.namespaces_enum\"></a>\n\n### RxConnector.namespaces\\_enum\n\n```python\ndef namespaces_enum(\n    enum_not_opened: bool = False,\n    timeout: timedelta = timedelta(milliseconds=0)\n) -> List[Dict[str, str]]\n```\n\nGets a list of namespaces available\n\n#### Arguments:\n    enum_not_opened (bool, optional): An enumeration mode flag. If it is\n        set then closed namespaces are in result list too. Defaults to False\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Returns:\n    (:obj:`list` of :obj:`dict`): A list of dictionaries which describe each namespace\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.index_add\"></a>\n\n### RxConnector.index\\_add\n\n```python\ndef index_add(\n    namespace: str,\n    index_def: Dict,\n    timeout: timedelta = timedelta(milliseconds=0)) -> None\n```\n\nAdds an index to the namespace specified\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    index_def (dict): A dictionary of index definition\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.index_update\"></a>\n\n### RxConnector.index\\_update\n\n```python\ndef index_update(\n    namespace: str,\n    index_def: Dict,\n    timeout: timedelta = timedelta(milliseconds=0)) -> None\n```\n\nUpdates an index in the namespace specified\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    index_def (dict): A dictionary of index definition\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.index_drop\"></a>\n\n### RxConnector.index\\_drop\n\n```python\ndef index_drop(\n    namespace: str,\n    index_name: str,\n    timeout: timedelta = timedelta(milliseconds=0)) -> None\n```\n\nDrops an index from the namespace specified\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    index_name (string): A name of an index\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.item_insert\"></a>\n\n### RxConnector.item\\_insert\n\n```python\ndef item_insert(\n    namespace: str,\n    item_def: Dict,\n    precepts: List[str] = None,\n    timeout: timedelta = timedelta(milliseconds=0)\n) -> None\n```\n\nInserts an item with its precepts to the namespace specified\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    item_def (dict): A dictionary of item definition\n    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.item_update\"></a>\n\n### RxConnector.item\\_update\n\n```python\ndef item_update(\n    namespace: str,\n    item_def: Dict,\n    precepts: List[str] = None,\n    timeout: timedelta = timedelta(milliseconds=0)\n) -> None\n```\n\nUpdates an item with its precepts in the namespace specified\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    item_def (dict): A dictionary of item definition\n    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.item_upsert\"></a>\n\n### RxConnector.item\\_upsert\n\n```python\ndef item_upsert(\n    namespace: str,\n    item_def: Dict,\n    precepts: List[str] = None,\n    timeout: timedelta = timedelta(milliseconds=0)\n) -> None\n```\n\nUpdates an item with its precepts in the namespace specified. Creates the item if it not exists\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    item_def (dict): A dictionary of item definition\n    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.item_delete\"></a>\n\n### RxConnector.item\\_delete\n\n```python\ndef item_delete(\n    namespace: str,\n    item_def: Dict,\n    timeout: timedelta = timedelta(milliseconds=0)) -> None\n```\n\nDeletes an item from the namespace specified\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    item_def (dict): A dictionary of item definition\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.meta_put\"></a>\n\n### RxConnector.meta\\_put\n\n```python\ndef meta_put(\n    namespace: str,\n    key: str,\n    value: str,\n    timeout: timedelta = timedelta(milliseconds=0)) -> None\n```\n\nPuts metadata to a storage of Reindexer by key\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    key (string): A key in a storage of Reindexer for metadata keeping\n    value (string): A metadata for storage\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.meta_get\"></a>\n\n### RxConnector.meta\\_get\n\n```python\ndef meta_get(namespace: str,\n             key: str,\n             timeout: timedelta = timedelta(milliseconds=0)) -> str\n```\n\nGets metadata from a storage of Reindexer by key specified\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    key (string): A key in a storage of Reindexer where metadata is kept\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Returns:\n    string: A metadata value\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.meta_delete\"></a>\n\n### RxConnector.meta\\_delete\n\n```python\ndef meta_delete(\n    namespace: str, key: str,\n    timeout: timedelta = timedelta(milliseconds=0)) -> None\n```\n\nDeletes metadata from a storage of Reindexer by key specified\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    key (string): A key in a storage of Reindexer where metadata is kept\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.meta_enum\"></a>\n\n### RxConnector.meta\\_enum\n\n```python\ndef meta_enum(\n    namespace: str,\n    timeout: timedelta = timedelta(milliseconds=0)) -> List[str]\n```\n\nGets a list of metadata keys from a storage of Reindexer\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Returns:\n    (:obj:`list` of :obj:`str`): A list of all metadata keys\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.select\"></a>\n\n### RxConnector.select\n\n```python\ndef select(\n    query: str,\n    timeout: timedelta = timedelta(milliseconds=0)) -> QueryResults\n```\n\nExecutes an SQL query and returns query results\n\n#### Arguments:\n    query (string): An SQL query\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Returns:\n    (:obj:`QueryResults`): A QueryResults iterator\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.new_transaction\"></a>\n\n### RxConnector.new\\_transaction\n\n```python\ndef new_transaction(\n    namespace: str,\n    timeout: timedelta = timedelta(milliseconds=0)) -> Transaction\n```\n\nStarts a new transaction and return the transaction object to processing.\n    Warning: once a timeout is set, it will apply to all subsequent steps in the transaction\n\n#### Arguments:\n    namespace (string): A name of a namespace\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Returns:\n    (:obj:`Transaction`): A new transaction\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.rx_connector.RxConnector.new_query\"></a>\n\n### RxConnector.new\\_query\n\n```python\ndef new_query(namespace: str) -> Query\n```\n\nCreates a new query and return the query object to processing\n\n#### Arguments:\n    namespace (string): A name of a namespace\n\n#### Returns:\n    (:obj:`Query`): A new query\n\n#### Raises:\n    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet\n\n<a id=\"pyreindexer.query_results\"></a>\n\n# pyreindexer.query\\_results\n\n<a id=\"pyreindexer.query_results.QueryResults\"></a>\n\n## QueryResults Objects\n\n```python\nclass QueryResults()\n```\n\nQueryResults is a disposable iterator of Reindexer results for such queries as SELECT etc.\n    When the results are fetched the iterator closes and frees a memory of results buffer of Reindexer\n\n#### Attributes:\n    api (module): An API module for Reindexer calls\n    err_code (int): The API error code\n    err_msg (string): The API error message\n    qres_wrapper_ptr (int): A memory pointer to Reindexer iterator object\n    qres_iter_count (int): A count of results for iterations\n    pos (int): The current result position in iterator\n\n<a id=\"pyreindexer.query_results.QueryResults.status\"></a>\n\n### QueryResults.status\n\n```python\ndef status() -> None\n```\n\nCheck status\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query_results.QueryResults.count\"></a>\n\n### QueryResults.count\n\n```python\ndef count() -> int\n```\n\nReturns a count of results for iterations\n\n#### Returns\n    int: A count of results\n\n<a id=\"pyreindexer.query_results.QueryResults.total_count\"></a>\n\n### QueryResults.total\\_count\n\n```python\ndef total_count() -> int\n```\n\nReturns a total or cached count of results\n\n#### Returns\n    int: A total or cached count of results\n\n<a id=\"pyreindexer.query_results.QueryResults.get_agg_results\"></a>\n\n### QueryResults.get\\_agg\\_results\n\n```python\ndef get_agg_results() -> dict\n```\n\nReturns aggregation results for the current query\n\n#### Returns\n    (:obj:`dict`): Dictionary with all results for the current query\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query_results.QueryResults.get_explain_results\"></a>\n\n### QueryResults.get\\_explain\\_results\n\n```python\ndef get_explain_results() -> str\n```\n\nReturns explain results for the current query\n\n#### Returns\n    (string): Formatted string with explain of results for the current query\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.transaction\"></a>\n\n# pyreindexer.transaction\n\n<a id=\"pyreindexer.transaction.Transaction\"></a>\n\n## Transaction Objects\n\n```python\nclass Transaction()\n```\n\nAn object representing the context of a Reindexer transaction\n\n#### Attributes:\n    api (module): An API module for Reindexer calls\n    transaction_wrapper_ptr (int): A memory pointer to Reindexer transaction object\n    err_code (int): The API error code\n    err_msg (string): The API error message\n\n<a id=\"pyreindexer.transaction.Transaction.insert\"></a>\n\n### Transaction.insert\n\n```python\ndef insert(item_def: Dict, precepts: List[str] = None) -> None\n```\n\nInserts an item with its precepts to the transaction\n    Warning: the timeout set when the transaction was created is used\n\n#### Arguments:\n    item_def (dict): A dictionary of item definition\n    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition\n\n#### Raises:\n    TransactionError: Raises with an error message of API return if Transaction is over\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.transaction.Transaction.update\"></a>\n\n### Transaction.update\n\n```python\ndef update(item_def: Dict, precepts: List[str] = None) -> None\n```\n\nUpdates an item with its precepts to the transaction\n    Warning: the timeout set when the transaction was created is used\n\n#### Arguments:\n    item_def (dict): A dictionary of item definition\n    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition\n\n#### Raises:\n    TransactionError: Raises with an error message of API return if Transaction is over\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.transaction.Transaction.update_query\"></a>\n\n### Transaction.update\\_query\n\n```python\ndef update_query(query: Query) -> None\n```\n\nUpdates items with the transaction\n    Read-committed isolation is available for read operations.\n    Changes made in active transaction is invisible to current and another transactions.\n\n#### Arguments:\n    query (:obj:`Query`): A query object to modify\n\n#### Raises:\n    TransactionError: Raises with an error message of API return if Transaction is over\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.transaction.Transaction.upsert\"></a>\n\n### Transaction.upsert\n\n```python\ndef upsert(item_def: Dict, precepts: List[str] = None) -> None\n```\n\nUpdates an item with its precepts to the transaction. Creates the item if it not exists\n    Warning: the timeout set when the transaction was created is used\n\n#### Arguments:\n    item_def (dict): A dictionary of item definition\n    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition\n\n#### Raises:\n    TransactionError: Raises with an error message of API return if Transaction is over\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.transaction.Transaction.delete\"></a>\n\n### Transaction.delete\n\n```python\ndef delete(item_def: Dict) -> None\n```\n\nDeletes an item from the transaction\n    Warning: the timeout set when the transaction was created is used\n\n#### Arguments:\n    item_def (dict): A dictionary of item definition\n\n#### Raises:\n    TransactionError: Raises with an error message of API return if Transaction is over\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.transaction.Transaction.delete_query\"></a>\n\n### Transaction.delete\\_query\n\n```python\ndef delete_query(query: Query)\n```\n\nDeletes items with the transaction\n    Read-committed isolation is available for read operations.\n    Changes made in active transaction is invisible to current and another transactions.\n\n#### Arguments:\n    query (:obj:`Query`): A query object to modify\n\n#### Raises:\n    TransactionError: Raises with an error message of API return if Transaction is over\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.transaction.Transaction.commit\"></a>\n\n### Transaction.commit\n\n```python\ndef commit(timeout: timedelta = timedelta(milliseconds=0)) -> None\n```\n\nApplies changes\n\n#### Arguments:\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    TransactionError: Raises with an error message of API return if Transaction is over\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.transaction.Transaction.commit_with_count\"></a>\n\n### Transaction.commit\\_with\\_count\n\n```python\ndef commit_with_count(timeout: timedelta = timedelta(milliseconds=0)) -> int\n```\n\nApplies changes and return the number of count of changed items\n\n#### Arguments:\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    TransactionError: Raises with an error message of API return if Transaction is over\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.transaction.Transaction.rollback\"></a>\n\n### Transaction.rollback\n\n```python\ndef rollback(timeout: timedelta = timedelta(milliseconds=0)) -> None\n```\n\nRollbacks changes\n\n#### Arguments:\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Raises:\n    TransactionError: Raises with an error message of API return if Transaction is over\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.point\"></a>\n\n# pyreindexer.point\n\n<a id=\"pyreindexer.point.Point\"></a>\n\n## Point Objects\n\n```python\nclass Point()\n```\n\nAn object representing the context of a Reindexer 2D point\n\n#### Attributes:\n    x (float): x coordinate of the point\n    y (float): y coordinate of the point\n\n<a id=\"pyreindexer.query\"></a>\n\n# pyreindexer.query\n\n<a id=\"pyreindexer.query.Query\"></a>\n\n## Query Objects\n\n```python\nclass Query()\n```\n\nAn object representing the context of a Reindexer query\n\n#### Attributes:\n    api (module): An API module for Reindexer calls\n    query_wrapper_ptr (int): A memory pointer to Reindexer query object\n    err_code (int): The API error code\n    err_msg (string): The API error message\n    root (:object: Optional[`Query`]): The root query of the Reindexer query\n    join_queries (list[:object:`Query`]): The list of join Reindexer query objects\n    merged_queries (list[:object:`Query`]): The list of merged Reindexer query objects\n\n<a id=\"pyreindexer.query.Query.where\"></a>\n\n### Query.where\n\n```python\ndef where(\n        index: str,\n        condition: CondType,\n        keys: Union[simple_types, tuple[list[simple_types],\n                                        ...]] = None) -> Query\n```\n\nAdds where condition to DB query with args\n\n#### Arguments:\n    index (string): Field name used in condition clause\n    condition (:enum:`CondType`): Type of condition\n    keys (union[simple_types, (list[simple_types], ...)]):\n        Value of index to be compared with. For composite indexes keys must be list,\n        with value of each sub-index\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.where_query\"></a>\n\n### Query.where\\_query\n\n```python\ndef where_query(\n        sub_query: Query,\n        condition: CondType,\n        keys: Union[simple_types, tuple[list[simple_types],\n                                        ...]] = None) -> Query\n```\n\nAdds sub-query where condition to DB query with args\n\n#### Arguments:\n    sub_query (:obj:`Query`): Field name used in condition clause\n    condition (:enum:`CondType`): Type of condition\n    keys (union[simple_types, (list[simple_types], ...)]):\n        Value of index to be compared with. For composite indexes keys must be list,\n        with value of each sub-index\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.where_subquery\"></a>\n\n### Query.where\\_subquery\n\n```python\ndef where_subquery(index: str, condition: CondType, sub_query: Query) -> Query\n```\n\nAdds sub-query where condition to DB query\n\n#### Arguments:\n    index (string): Field name used in condition clause\n    condition (:enum:`CondType`): Type of condition\n    sub_query (:obj:`Query`): Field name used in condition clause\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.where_composite\"></a>\n\n### Query.where\\_composite\n\n```python\ndef where_composite(index: str, condition: CondType,\n                    keys: tuple[list[simple_types], ...]) -> Query\n```\n\nAdds where condition to DB query with interface args for composite indexes\n\n#### Arguments:\n    index (string): Field name used in condition clause\n    condition (:enum:`CondType`): Type of condition\n    keys (list[simple_types], ...): Values of composite index to be compared with (value of each sub-index).\n        Supported variants:\n            ([1, \"test1\"], [2, \"test2\"])\n            [[1, \"test1\"], [2, \"test2\"]])\n            ([1, \"testval1\"], )\n            [[1, \"testval1\"]]\n            (1, \"testval1\")\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.where_uuid\"></a>\n\n### Query.where\\_uuid\n\n```python\ndef where_uuid(index: str, condition: CondType, *uuids: UUID) -> Query\n```\n\nAdds where condition to DB query with UUID.\n    `index` MUST be declared as uuid-string index in this case\n\n#### Arguments:\n    index (string): Field name used in condition clause\n    condition (:enum:`CondType`): Type of condition\n    uuids (*:obj:`UUID`): Value of index to be compared with. For composite indexes uuids must be list,\n        with value of each sub-index\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.where_between_fields\"></a>\n\n### Query.where\\_between\\_fields\n\n```python\ndef where_between_fields(first_field: str, condition: CondType,\n                         second_field: str) -> Query\n```\n\nAdds comparing two fields where condition to DB query\n\n#### Arguments:\n    first_field (string): First field name used in condition clause\n    condition (:enum:`CondType`): Type of condition\n    second_field (string): Second field name used in condition clause\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.where_knn\"></a>\n\n### Query.where\\_knn\n\n```python\ndef where_knn(\n    index: str, vec: List[float],\n    param: Union[IndexSearchParamBruteForce | IndexSearchParamHnsw | IndexSearchParamIvf]\n) -> Query\n```\n\nAdds where condition to DB query with float_vector as args.\n    `index` MUST be declared as float_vector index in this case\n\n#### Arguments:\n    index (string): Field name used in condition clause (only float_vector)\n    vec (list[float]): KNN value of index to be compared with\n    param (:obj:`union[IndexSearchParamBruteForce|IndexSearchParamHnsw|IndexSearchParamIvf]`): KNN search parameters\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    QueryError: Raises with an error message if no vec are specified\n    QueryError: Raises with an error message if no param are specified or have an invalid value\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.where_knn_string\"></a>\n\n### Query.where\\_knn\\_string\n\n```python\ndef where_knn_string(\n    index: str, value: str,\n    param: Union[IndexSearchParamBruteForce | IndexSearchParamHnsw | IndexSearchParamIvf]\n) -> Query\n```\n\nAdds where condition to DB query with string as args.\n    `index` MUST be declared as float_vector index in this case.\n    WARNING: Only relevant if automatic embedding is configured for this float_vector index\n\n#### Arguments:\n    index (string): Field name used in condition clause (only float_vector)\n    value (string): value to be generated using automatic embedding of KNN index value to be compared to\n    param (:obj:`union[IndexSearchParamBruteForce|IndexSearchParamHnsw|IndexSearchParamIvf]`): KNN search parameters\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    QueryError: Raises with an error message if no value are specified\n    QueryError: Raises with an error message if no param are specified or have an invalid value\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.open_bracket\"></a>\n\n### Query.open\\_bracket\n\n```python\ndef open_bracket() -> Query\n```\n\nOpens bracket for where condition to DB query\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.close_bracket\"></a>\n\n### Query.close\\_bracket\n\n```python\ndef close_bracket() -> Query\n```\n\nCloses bracket for where condition to DB query\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.match\"></a>\n\n### Query.match\n\n```python\ndef match(index: str, *keys: str) -> Query\n```\n\nAdds string EQ-condition to DB query with string args\n\n#### Arguments:\n    index (string): Field name used in condition clause\n    keys (*string): Value of index to be compared with. For composite indexes keys must be list,\n        with value of each sub-index\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.dwithin\"></a>\n\n### Query.dwithin\n\n```python\ndef dwithin(index: str, point: Point, distance: float) -> Query\n```\n\nAdds DWithin condition to DB query\n\n#### Arguments:\n    index (string): Field name used in condition clause\n    point (:obj:`Point`): Point object used in condition clause\n    distance (float): Distance in meters between point\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.distinct\"></a>\n\n### Query.distinct\n\n```python\ndef distinct(index: str) -> Query\n```\n\nPerforms distinct for a certain index. Return only items with uniq value of field\n\n#### Arguments:\n    index (string): Field name for distinct operation\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.aggregate_sum\"></a>\n\n### Query.aggregate\\_sum\n\n```python\ndef aggregate_sum(index: str) -> Query\n```\n\nPerforms a summation of values for a specified index\n\n#### Arguments:\n    index (string): Field name for sum operation\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.aggregate_avg\"></a>\n\n### Query.aggregate\\_avg\n\n```python\ndef aggregate_avg(index: str) -> Query\n```\n\nFinds for the average at the specified index\n\n#### Arguments:\n    index (string): Field name for sum operation\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.aggregate_min\"></a>\n\n### Query.aggregate\\_min\n\n```python\ndef aggregate_min(index: str) -> Query\n```\n\nFinds for the minimum at the specified index\n\n#### Arguments:\n    index (string): Field name for sum operation\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.aggregate_max\"></a>\n\n### Query.aggregate\\_max\n\n```python\ndef aggregate_max(index: str) -> Query\n```\n\nFinds for the maximum at the specified index\n\n#### Arguments:\n    index (string): Field name for sum operation\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.aggregate_facet\"></a>\n\n### Query.aggregate\\_facet\n\n```python\ndef aggregate_facet(*fields: str) -> Query._AggregateFacet\n```\n\nGets fields facet value. Applicable to multiple data fields and the result of that could be sorted\n    by any data column or `count` and cut off by offset and limit. In order to support this functionality\n    this method returns AggregationFacetRequest which has methods sort, limit and offset\n\n#### Arguments:\n    fields (*string): Fields any data column name or `count`, fields should not be empty\n\n#### Returns:\n    (:obj:`_AggregateFacet`): Request object for further customizations\n\n<a id=\"pyreindexer.query.Query.sort\"></a>\n\n### Query.sort\n\n```python\ndef sort(\n    index: str,\n    desc: bool = False,\n    forced_sort_values: Union[simple_types, tuple[list[simple_types],\n                                                  ...]] = None\n) -> Query\n```\n\nApplies sort order to return from query items. If forced_sort_values argument specified, then items equal to\n    values, if found will be placed in the top positions. Forced sort is support for the first sorting field\n    only\n\n#### Arguments:\n    index (string): The index name\n    desc (bool): Sort in descending order\n    forced_sort_values (union[simple_types, (list[simple_types], ...)]):\n        Value of index to match. For composite indexes keys must be list, with value of each sub-index\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.sort_stpoint_distance\"></a>\n\n### Query.sort\\_stpoint\\_distance\n\n```python\ndef sort_stpoint_distance(index: str, point: Point, desc: bool) -> Query\n```\n\nApplies geometry sort order to return from query items. Wrapper for geometry sorting by shortest distance\n    between geometry field and point (ST_Distance)\n\n#### Arguments:\n    index (string): The index name\n    point (:obj:`Point`): Point object used in sorting operation\n    desc (bool): Sort in descending order\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.sort_stfield_distance\"></a>\n\n### Query.sort\\_stfield\\_distance\n\n```python\ndef sort_stfield_distance(first_field: str, second_field: str,\n                          desc: bool) -> Query\n```\n\nApplies geometry sort order to return from query items. Wrapper for geometry sorting by shortest distance\n    between 2 geometry fields (ST_Distance)\n\n#### Arguments:\n    first_field (string): First field name used in condition\n    second_field (string): Second field name used in condition\n    desc (bool): Sort in descending order\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.op_and\"></a>\n\n### Query.op\\_and\n\n```python\ndef op_and() -> Query\n```\n\nNext condition will be added with AND.\n    This is the default operation for WHERE statement. Do not have to be called explicitly in user's code.\n    Used in DSL conversion\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.op_or\"></a>\n\n### Query.op\\_or\n\n```python\ndef op_or() -> Query\n```\n\nNext condition will be added with OR.\n    Implements short-circuiting:\n    if the previous condition is successful the next will not be evaluated, but except Join conditions\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.op_not\"></a>\n\n### Query.op\\_not\n\n```python\ndef op_not() -> Query\n```\n\nNext condition will be added with NOT AND.\n    Implements short-circuiting: if the previous condition is failed the next will not be evaluated\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.request_total\"></a>\n\n### Query.request\\_total\n\n```python\ndef request_total() -> Query\n```\n\nRequests total items calculation\n\n#### Arguments:\n    total_name (string, optional): Name to be requested\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.cached_total\"></a>\n\n### Query.cached\\_total\n\n```python\ndef cached_total() -> Query\n```\n\nRequests cached total items calculation\n\n#### Arguments:\n    total_name (string, optional): Name to be requested\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.limit\"></a>\n\n### Query.limit\n\n```python\ndef limit(limit_items: int) -> Query\n```\n\nSets a limit (count) of returned items. Analog to sql LIMIT rowsNumber\n\n#### Arguments:\n    limit_items (int): Number of rows to get from result set\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.offset\"></a>\n\n### Query.offset\n\n```python\ndef offset(start_offset: int) -> Query\n```\n\nSets the number of the first selected row from result query\n\n#### Arguments:\n    limit_items (int): Index of the first row to get from result set\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.debug\"></a>\n\n### Query.debug\n\n```python\ndef debug(level: LogLevel) -> Query\n```\n\nChanges debug log level on server\n\n#### Arguments:\n    level (:enum:`LogLevel`): Debug log level on server\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.strict\"></a>\n\n### Query.strict\n\n```python\ndef strict(mode: StrictMode) -> Query\n```\n\nChanges strict mode\n\n#### Arguments:\n    mode (:enum:`StrictMode`): Strict mode\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.explain\"></a>\n\n### Query.explain\n\n```python\ndef explain() -> Query\n```\n\nEnables explain query\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.with_rank\"></a>\n\n### Query.with\\_rank\n\n```python\ndef with_rank() -> Query\n```\n\nOutputs fulltext/float_vector rank. Allowed only with fulltext and KNN query\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.execute\"></a>\n\n### Query.execute\n\n```python\ndef execute(timeout: timedelta = timedelta(milliseconds=0)) -> QueryResults\n```\n\nExecutes a select query\n\n#### Arguments:\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Returns:\n    (:obj:`QueryResults`): A QueryResults iterator\n\n#### Raises:\n    ApiError: Raises with an error message when query is in an invalid state\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.delete\"></a>\n\n### Query.delete\n\n```python\ndef delete(timeout: timedelta = timedelta(milliseconds=0)) -> int\n```\n\nExecutes a query, and delete items, matches query\n\n#### Arguments:\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Returns:\n    (int): Number of deleted elements\n\n#### Raises:\n    QueryError: Raises with an error message when query is in an invalid state\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.set_object\"></a>\n\n### Query.set\\_object\n\n```python\ndef set_object(field: str, values: list[simple_types]) -> Query\n```\n\nAdds an update query to an object field for an update query\n\n#### Arguments:\n    field (string): Field name\n    values (list[simple_types]): List of values to add\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    QueryError: Raises with an error message if no values are specified\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.set\"></a>\n\n### Query.set\n\n```python\ndef set(field: str, values: list[simple_types]) -> Query\n```\n\nAdds a field update request to the update request\n\n#### Arguments:\n    field (string): Field name\n    values (list[simple_types]): List of values to add\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.drop\"></a>\n\n### Query.drop\n\n```python\ndef drop(index: str) -> Query\n```\n\nDrops a value for a field\n\n#### Arguments:\n    index (string): Field name for drop operation\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.expression\"></a>\n\n### Query.expression\n\n```python\ndef expression(field: str, value: str) -> Query\n```\n\nUpdates indexed field by arithmetical expression\n\n#### Arguments:\n    field (string): Field name\n    value (string): New value expression for field\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.update\"></a>\n\n### Query.update\n\n```python\ndef update(timeout: timedelta = timedelta(milliseconds=0)) -> QueryResults\n```\n\nExecutes update query, and update fields in items, which matches query\n\n#### Arguments:\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Returns:\n    (:obj:`QueryResults`): A QueryResults iterator\n\n#### Raises:\n    QueryError: Raises with an error message when query is in an invalid state\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.must_execute\"></a>\n\n### Query.must\\_execute\n\n```python\ndef must_execute(timeout: timedelta = timedelta(\n    milliseconds=0)) -> QueryResults\n```\n\nExecutes a query, and update fields in items, which matches query, with status check\n\n#### Arguments:\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Returns:\n    (:obj:`QueryResults`): A QueryResults iterator\n\n#### Raises:\n    ApiError: Raises with an error message when query is in an invalid state\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.get\"></a>\n\n### Query.get\n\n```python\ndef get(timeout: timedelta = timedelta(milliseconds=0)) -> (str, bool)\n```\n\nExecutes a query, and return 1 JSON item\n\n#### Arguments:\n    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.\n        Minimum 1 millisecond, if set to a value less, it corresponds to disabling the timeout.\n        A value of 0 disables the timeout (default value)\n\n#### Returns:\n    (:tuple:string,bool): 1st string item and found flag\n\n#### Raises:\n    ApiError: Raises with an error message when query is in an invalid state\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.inner_join\"></a>\n\n### Query.inner\\_join\n\n```python\ndef inner_join(query: Query, field: str) -> Query\n```\n\nJoins 2 queries.\n    Items from the 1-st query are filtered by and expanded with the data from the 2-nd query\n\n#### Arguments:\n    query (:obj:`Query`): Query object to left join\n    field (string): Joined field name. As unique identifier for the join between this query and `join_query`.\n        Parameter in order for InnerJoin to work: namespace of `query` contains `field` as one of its fields\n        marked as `joined`\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.join\"></a>\n\n### Query.join\n\n```python\ndef join(query: Query, field: str) -> Query\n```\n\nJoin is an alias for LeftJoin. Joins 2 queries.\n    Items from this query are expanded with the data from the `query`\n\n#### Arguments:\n    query (:obj:`Query`): Query object to left join\n    field (string): Joined field name. As unique identifier for the join between this query and `join_query`\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.left_join\"></a>\n\n### Query.left\\_join\n\n```python\ndef left_join(join_query: Query, field: str) -> Query\n```\n\nJoins 2 queries.\n    Items from this query are expanded with the data from the join_query.\n    One of the conditions below must hold for `field` parameter in order for LeftJoin to work:\n        namespace of `join_query` contains `field` as one of its fields marked as `joined`\n\n#### Arguments:\n    query (:obj:`Query`): Query object to left join\n    field (string): Joined field name. As unique identifier for the join between this query and `join_query`\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.merge\"></a>\n\n### Query.merge\n\n```python\ndef merge(query: Query) -> Query\n```\n\nMerges queries of the same type\n\n#### Arguments:\n    query (:obj:`Query`): Query object to merge\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n<a id=\"pyreindexer.query.Query.on\"></a>\n\n### Query.on\n\n```python\ndef on(index: str, condition: CondType, join_index: str) -> Query\n```\n\nOn specifies join condition\n\n#### Arguments:\n    index (string): Field name from `Query` namespace should be used during join\n    condition (:enum:`CondType`): Type of condition, specifies how `Query` will be joined with the latest join query issued on `Query` (e.g. `EQ`/`GT`/`SET`/...)\n    join_index (string): Index-field name from namespace for the latest join query issued on `Query` should be used during join\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    QueryError: Raises with an error message when query is in an invalid state\n\n<a id=\"pyreindexer.query.Query.select\"></a>\n\n### Query.select\n\n```python\ndef select(*fields: str) -> Query\n```\n\nSets list of columns in this namespace to be finally selected.\n    The columns should be specified in the same case as the jsonpaths corresponding to them.\n    Non-existent fields and fields in the wrong case are ignored.\n    If there are no fields in this list that meet these conditions, then the filter works as \"*\"\n\n#### Arguments:\n    fields (*string): List of columns to be selected\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.functions\"></a>\n\n### Query.functions\n\n```python\ndef functions(*functions: str) -> Query\n```\n\nAdds sql-functions to query\n\n#### Arguments:\n    functions (*string): Functions declaration\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.query.Query.equal_position\"></a>\n\n### Query.equal\\_position\n\n```python\ndef equal_position(*equal_position: str) -> Query\n```\n\nAdds equal position fields to arrays queries\n\n#### Arguments:\n    equal_poses (*string): Equal position fields to arrays queries\n\n#### Returns:\n    (:obj:`Query`): Query object for further customizations\n\n#### Raises:\n    ApiError: Raises with an error message of API return on non-zero error code\n\n<a id=\"pyreindexer.index_search_params\"></a>\n\n# pyreindexer.index\\_search\\_params\n\n<a id=\"pyreindexer.index_search_params.IndexSearchParamBruteForce\"></a>\n\n## IndexSearchParamBruteForce Objects\n\n```python\nclass IndexSearchParamBruteForce()\n```\n\nIndex search param for brute force index. Equal to basic parameters\n\n#### Attributes:\n    k (int): Expected size of KNN index results. Should not be less than 1\n    radius (float): In addition to the parameter `k`, the query results can also be filtered by a `rank` -\n      value using the parameter, witch called `radius`. It's named so because, under the `L2`-metric,\n      it restricts vectors from query result to a sphere of the specified radius. [More about `radius`]\n      (https://github.com/Restream/reindexer/blob/master/float_vector.md)\n\n<a id=\"pyreindexer.index_search_params.IndexSearchParamHnsw\"></a>\n\n## IndexSearchParamHnsw Objects\n\n```python\nclass IndexSearchParamHnsw()\n```\n\nIndex search param for HNSW index.\n\n#### Attributes:\n    k (int): Expected size of KNN index results. Should not be less than 1\n    ef (int): Size of nearest neighbor buffer that will be filled during fetching. Should not be less than 'k',\n    good story when `ef` ~= 1.5 * `k`\n    radius (float): In addition to the parameter `k`, the query results can also be filtered by a `rank` -\n      value using the parameter, witch called `radius`. It's named so because, under the `L2`-metric,\n      it restricts vectors from query result to a sphere of the specified radius. [More about `radius`]\n      (https://github.com/Restream/reindexer/blob/master/float_vector.md)\n\n<a id=\"pyreindexer.index_search_params.IndexSearchParamIvf\"></a>\n\n## IndexSearchParamIvf Objects\n\n```python\nclass IndexSearchParamIvf()\n```\n\nIndex search param for IVF index.\n\n#### Attributes:\n    k (int): Expected size of KNN index results. Should not be less than 1\n    nprobe (int): Number of centroids that will be scanned in where. Should not be less than 1\n    radius (float): In addition to the parameter `k`, the query results can also be filtered by a `rank` -\n      value using the parameter, witch called `radius`. It's named so because, under the `L2`-metric,\n      it restricts vectors from query result to a sphere of the specified radius. [More about `radius`]\n      (https://github.com/Restream/reindexer/blob/master/float_vector.md)\n\n<a id=\"pyreindexer.index_definition\"></a>\n\n# pyreindexer.index\\_definition\n\n<a id=\"pyreindexer.index_definition.IndexDefinition\"></a>\n\n## IndexDefinition Objects\n\n```python\nclass IndexDefinition(dict)\n```\n\nIndexDefinition is a dictionary subclass which allows to construct and manage indexes more efficiently.\nNOT IMPLEMENTED YET. USE FIELDS DESCRIPTION ONLY.\n\n#### Arguments:\n    name (str): An index name.\n    json_paths (:obj:`list` of :obj:`str`): A name for mapping a value to a json field.\n    field_type (str): A type of field. Possible values are: `int`, `int64`, `double`, `string`, `bool`,\n    `composite`, `float_vector`.\n    index_type (str): An index type. Possible values are: `hash`, `tree`, `text`, `-`, `hnsw`, `vec_bf`, `ivf`.\n    is_pk (bool): True if a field is a primary key.\n    is_array (bool): True if an index is an array.\n    is_dense (bool): True if an index is dense. Reduce the index size. Saves 8 bytes per unique key value for 'hash'\n        and 'tree' index types. For '-' index type saves 4-8 bytes per each element. Useful for indexes with\n        high selectivity, but for tree and hash indexes with low selectivity can seriously decrease update\n        performance.\n    is_no_column (bool): True if allows to disable column subindex. Reduces the index size.\n        Allows to save ~(`stored_type_size` * `namespace_items_count`) bytes, where `stored_type_size` is the size\n        of the type stored in the index, and `namespace_items_count` is the number of items in the namespace.\n        May reduce performance.\n    is_sparse (bool): True if a value of an index may be not presented.\n    collate_mode (str): Sets an order of values by collate mode. Possible values are:\n        `none`, `ascii`, `utf8`, `numeric`, `custom`.\n    sort_order_letters (str): Order for a sort sequence for a custom collate mode.\n    config (dict): A config for a fulltext and float_vector engine.\n    [More about `fulltext`](https://github.com/Restream/reindexer/blob/master/fulltext.md) or\n    [More about `float_vector`](https://github.com/Restream/reindexer/blob/master/float_vector.md).\n\n",
    "bugtrack_url": null,
    "license": "Apache License 2.0",
    "summary": "A connector that allows to interact with Reindexer. Reindexer static library or reindexer-dev package must be installed",
    "version": "0.5.600",
    "project_urls": {
        "Documentation": "https://reindexer.io/",
        "Download": "https://github.com/Restream/reindexer-py",
        "Homepage": "https://github.com/Restream/reindexer",
        "Telegram chat": "https://t.me/reindexer"
    },
    "split_keywords": [
        "reindexer",
        " reindexer-py",
        " in-memory-database",
        " database",
        " python",
        " connector"
    ],
    "urls": [
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "f89e25b88f78de1c8403bf1058340010741e60214e0ecacf91f88bc5e59935e2",
                "md5": "cc8cbae9d81cd8caf226fc6ce24abf44",
                "sha256": "2dc52c9dfe33beca661c1bca6c1663a6a67b49e479809cfcb7f8220c26e1b832"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-cp310-cp310-macosx_14_0_arm64.whl",
            "has_sig": false,
            "md5_digest": "cc8cbae9d81cd8caf226fc6ce24abf44",
            "packagetype": "bdist_wheel",
            "python_version": "cp310",
            "requires_python": ">=3.8",
            "size": 18284504,
            "upload_time": "2025-08-29T17:16:41",
            "upload_time_iso_8601": "2025-08-29T17:16:41.376908Z",
            "url": "https://files.pythonhosted.org/packages/f8/9e/25b88f78de1c8403bf1058340010741e60214e0ecacf91f88bc5e59935e2/pyreindexer-0.5.600-cp310-cp310-macosx_14_0_arm64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "7d6765561dad07f34ba7b65b9c0eda0442cec4cd9686be73066c540e91379652",
                "md5": "3a8e587d85d762515e6de1af0e8b3b16",
                "sha256": "4deeff63818a256b56dc227d3da42cae85e86113f70592438c465f5e3fc2448a"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "has_sig": false,
            "md5_digest": "3a8e587d85d762515e6de1af0e8b3b16",
            "packagetype": "bdist_wheel",
            "python_version": "cp310",
            "requires_python": ">=3.8",
            "size": 21459013,
            "upload_time": "2025-08-29T17:16:44",
            "upload_time_iso_8601": "2025-08-29T17:16:44.165433Z",
            "url": "https://files.pythonhosted.org/packages/7d/67/65561dad07f34ba7b65b9c0eda0442cec4cd9686be73066c540e91379652/pyreindexer-0.5.600-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "fc43bb2925b206b169396d34f57a1f4c487dacd4e07c0778e18c09c8e069fe3c",
                "md5": "14264d22b52ff908f478c615cae5f8aa",
                "sha256": "d1dc1f674e5290ba1b87d63c33b1f88548bd03888ee0f726eed04a386396d22a"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-cp311-cp311-macosx_14_0_arm64.whl",
            "has_sig": false,
            "md5_digest": "14264d22b52ff908f478c615cae5f8aa",
            "packagetype": "bdist_wheel",
            "python_version": "cp311",
            "requires_python": ">=3.8",
            "size": 18284505,
            "upload_time": "2025-08-29T17:16:46",
            "upload_time_iso_8601": "2025-08-29T17:16:46.671329Z",
            "url": "https://files.pythonhosted.org/packages/fc/43/bb2925b206b169396d34f57a1f4c487dacd4e07c0778e18c09c8e069fe3c/pyreindexer-0.5.600-cp311-cp311-macosx_14_0_arm64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "80e465d8e347b7f5ffdbd7b7daafc843edf19478ea03914f6baa24b5e9acbaef",
                "md5": "7010e32ab700871963135acf88bc0b82",
                "sha256": "b6cd6f4b00bd464bacaeed52e89f35b45f32978bc9fb936296a47053dcdb739d"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "has_sig": false,
            "md5_digest": "7010e32ab700871963135acf88bc0b82",
            "packagetype": "bdist_wheel",
            "python_version": "cp311",
            "requires_python": ">=3.8",
            "size": 21459014,
            "upload_time": "2025-08-29T17:16:49",
            "upload_time_iso_8601": "2025-08-29T17:16:49.148790Z",
            "url": "https://files.pythonhosted.org/packages/80/e4/65d8e347b7f5ffdbd7b7daafc843edf19478ea03914f6baa24b5e9acbaef/pyreindexer-0.5.600-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "e70666e1206581bfaae87c24e4fe38f145640c7d2f573cd28fd32655e0a10993",
                "md5": "c243d0b097aed8650c459020b003137b",
                "sha256": "5a21b622f4c15a57eab547c7906eb198768ca9e9f3836a6d33ecee9e5ac5f394"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-cp312-cp312-macosx_14_0_arm64.whl",
            "has_sig": false,
            "md5_digest": "c243d0b097aed8650c459020b003137b",
            "packagetype": "bdist_wheel",
            "python_version": "cp312",
            "requires_python": ">=3.8",
            "size": 18284507,
            "upload_time": "2025-08-29T17:16:51",
            "upload_time_iso_8601": "2025-08-29T17:16:51.590209Z",
            "url": "https://files.pythonhosted.org/packages/e7/06/66e1206581bfaae87c24e4fe38f145640c7d2f573cd28fd32655e0a10993/pyreindexer-0.5.600-cp312-cp312-macosx_14_0_arm64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "277ea9e609c70034020239b3fe035eadf63fc31d91fc64904ab5a1281dddfe8a",
                "md5": "33fb53c43744c1ecdc512dfc833e039e",
                "sha256": "6d65b11da83bab0d3d524ada82fbe8deab52574ad2bd9b310da555d0c38df6e8"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "has_sig": false,
            "md5_digest": "33fb53c43744c1ecdc512dfc833e039e",
            "packagetype": "bdist_wheel",
            "python_version": "cp312",
            "requires_python": ">=3.8",
            "size": 21459012,
            "upload_time": "2025-08-29T17:16:54",
            "upload_time_iso_8601": "2025-08-29T17:16:54.097435Z",
            "url": "https://files.pythonhosted.org/packages/27/7e/a9e609c70034020239b3fe035eadf63fc31d91fc64904ab5a1281dddfe8a/pyreindexer-0.5.600-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "2eeebe4c54344eb9430f314c4d8df27642270027c82abbf2f69258d4d20a85f5",
                "md5": "89891fcd563b5980f13279f3341440c7",
                "sha256": "81a7da929b036a3494a097530b2d425f13510c2efe896603a91de913ed017e82"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-cp313-cp313-macosx_14_0_arm64.whl",
            "has_sig": false,
            "md5_digest": "89891fcd563b5980f13279f3341440c7",
            "packagetype": "bdist_wheel",
            "python_version": "cp313",
            "requires_python": ">=3.8",
            "size": 18284505,
            "upload_time": "2025-08-29T17:16:56",
            "upload_time_iso_8601": "2025-08-29T17:16:56.580006Z",
            "url": "https://files.pythonhosted.org/packages/2e/ee/be4c54344eb9430f314c4d8df27642270027c82abbf2f69258d4d20a85f5/pyreindexer-0.5.600-cp313-cp313-macosx_14_0_arm64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "277d62c4c4f2f67dc82f3c517821c27cc362eb097d1a7643915ca8545b7fd1d1",
                "md5": "6989dcad0652446f7130cdf73489d851",
                "sha256": "57ddf9a27d2235426e9487e773b710b10657688b8f89dd84a496614b0de24abf"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "has_sig": false,
            "md5_digest": "6989dcad0652446f7130cdf73489d851",
            "packagetype": "bdist_wheel",
            "python_version": "cp313",
            "requires_python": ">=3.8",
            "size": 21459013,
            "upload_time": "2025-08-29T17:16:59",
            "upload_time_iso_8601": "2025-08-29T17:16:59.095377Z",
            "url": "https://files.pythonhosted.org/packages/27/7d/62c4c4f2f67dc82f3c517821c27cc362eb097d1a7643915ca8545b7fd1d1/pyreindexer-0.5.600-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "5235eedbbe3b9d14ce75ee35b1507e7abc2eb2fe3a68fb876b00ceb9375b6f60",
                "md5": "b8826ef81cbc39d044874b666e85b382",
                "sha256": "31cb579535e13732436308f1e93e85a845b4bc4b3c908062fdc9f502c60a0aaf"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-cp38-cp38-macosx_14_0_arm64.whl",
            "has_sig": false,
            "md5_digest": "b8826ef81cbc39d044874b666e85b382",
            "packagetype": "bdist_wheel",
            "python_version": "cp38",
            "requires_python": ">=3.8",
            "size": 18284228,
            "upload_time": "2025-08-29T17:17:01",
            "upload_time_iso_8601": "2025-08-29T17:17:01.640321Z",
            "url": "https://files.pythonhosted.org/packages/52/35/eedbbe3b9d14ce75ee35b1507e7abc2eb2fe3a68fb876b00ceb9375b6f60/pyreindexer-0.5.600-cp38-cp38-macosx_14_0_arm64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "627d36436f9a7ba0a48970a56511afbb6f9b56e708f2d95c1db9ea57cdca1501",
                "md5": "05a7bda92acac4345b6e16da3438a852",
                "sha256": "76f220e149af3ed30f03dc192a3980b008e37051b07010241575b42bb835a0bf"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "has_sig": false,
            "md5_digest": "05a7bda92acac4345b6e16da3438a852",
            "packagetype": "bdist_wheel",
            "python_version": "cp38",
            "requires_python": ">=3.8",
            "size": 21458748,
            "upload_time": "2025-08-29T17:17:04",
            "upload_time_iso_8601": "2025-08-29T17:17:04.238483Z",
            "url": "https://files.pythonhosted.org/packages/62/7d/36436f9a7ba0a48970a56511afbb6f9b56e708f2d95c1db9ea57cdca1501/pyreindexer-0.5.600-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "c9ffdcef1f97bb4cf9eb86ea182b6433a3312f777bf3fbf132e4dfaf6e5d2448",
                "md5": "829764647c8015350efa6d0ec4d5adc9",
                "sha256": "4897ebc4e764a4cbcd8fe0f13822915ffc9fc73ce15c1c1d16089a367a74389a"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-cp39-cp39-macosx_14_0_arm64.whl",
            "has_sig": false,
            "md5_digest": "829764647c8015350efa6d0ec4d5adc9",
            "packagetype": "bdist_wheel",
            "python_version": "cp39",
            "requires_python": ">=3.8",
            "size": 18284504,
            "upload_time": "2025-08-29T17:17:06",
            "upload_time_iso_8601": "2025-08-29T17:17:06.763123Z",
            "url": "https://files.pythonhosted.org/packages/c9/ff/dcef1f97bb4cf9eb86ea182b6433a3312f777bf3fbf132e4dfaf6e5d2448/pyreindexer-0.5.600-cp39-cp39-macosx_14_0_arm64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "0a229eaa7190a281db6c89785f6fa67e40aa526172fc237d6696db4d3ec63ce4",
                "md5": "8a1903105834b01bcb00e4f9e744669c",
                "sha256": "4f1680ad8dd0c6ba83ac40012ec5cc3a79605652ad097aa224b4d137868db84d"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "has_sig": false,
            "md5_digest": "8a1903105834b01bcb00e4f9e744669c",
            "packagetype": "bdist_wheel",
            "python_version": "cp39",
            "requires_python": ">=3.8",
            "size": 21459011,
            "upload_time": "2025-08-29T17:17:09",
            "upload_time_iso_8601": "2025-08-29T17:17:09.434304Z",
            "url": "https://files.pythonhosted.org/packages/0a/22/9eaa7190a281db6c89785f6fa67e40aa526172fc237d6696db4d3ec63ce4/pyreindexer-0.5.600-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "3b09a27b5017be3490011482a51a3f48446898fcb6d398a0b4b9204b5ef74db4",
                "md5": "2691f186b67470f5e58bfad4f27c4400",
                "sha256": "ac93047dcdb23ec5b6da497e2b985888d6d42715c76247d4b3f990dc2cec8ea2"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-pp310-pypy310_pp73-macosx_14_0_arm64.whl",
            "has_sig": false,
            "md5_digest": "2691f186b67470f5e58bfad4f27c4400",
            "packagetype": "bdist_wheel",
            "python_version": "pp310",
            "requires_python": ">=3.8",
            "size": 18284512,
            "upload_time": "2025-08-29T17:17:12",
            "upload_time_iso_8601": "2025-08-29T17:17:12.368283Z",
            "url": "https://files.pythonhosted.org/packages/3b/09/a27b5017be3490011482a51a3f48446898fcb6d398a0b4b9204b5ef74db4/pyreindexer-0.5.600-pp310-pypy310_pp73-macosx_14_0_arm64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "10554441bc01c8a3e87b21a0f973bfb67f1e39b341e6ca24103e55fcb899444e",
                "md5": "c0caf9de444e2d2ca533d7e8620637be",
                "sha256": "65bc3c8f9971f0cd75eaf312229e85e25cff8f65e3cc5b704bbe43943d2fdda7"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "has_sig": false,
            "md5_digest": "c0caf9de444e2d2ca533d7e8620637be",
            "packagetype": "bdist_wheel",
            "python_version": "pp310",
            "requires_python": ">=3.8",
            "size": 21459019,
            "upload_time": "2025-08-29T17:17:15",
            "upload_time_iso_8601": "2025-08-29T17:17:15.336374Z",
            "url": "https://files.pythonhosted.org/packages/10/55/4441bc01c8a3e87b21a0f973bfb67f1e39b341e6ca24103e55fcb899444e/pyreindexer-0.5.600-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "ea2359f9d8dd7ca050a487bb9b902e77efc35aa957d538ae9c44b5f8f19dc1b6",
                "md5": "c0c897e5587c5205f9bb0aed9a31c50a",
                "sha256": "528d82fa87575e3fb42d381aece568883b05b02a4d912c8773ebf050bc16b433"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-pp311-pypy311_pp73-macosx_14_0_arm64.whl",
            "has_sig": false,
            "md5_digest": "c0c897e5587c5205f9bb0aed9a31c50a",
            "packagetype": "bdist_wheel",
            "python_version": "pp311",
            "requires_python": ">=3.8",
            "size": 18284510,
            "upload_time": "2025-08-29T17:17:18",
            "upload_time_iso_8601": "2025-08-29T17:17:18.538967Z",
            "url": "https://files.pythonhosted.org/packages/ea/23/59f9d8dd7ca050a487bb9b902e77efc35aa957d538ae9c44b5f8f19dc1b6/pyreindexer-0.5.600-pp311-pypy311_pp73-macosx_14_0_arm64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "a010fd71fa3e0cbbe6a856f28b80e59f723334d7507bbbcdd916db6516a825d0",
                "md5": "30acd927a50cb5c624c3f19d8474a176",
                "sha256": "822f7e58a7006e9cda63f10a0217ffa24b9d5ce1b3f67d30d21470e3b3d0641b"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "has_sig": false,
            "md5_digest": "30acd927a50cb5c624c3f19d8474a176",
            "packagetype": "bdist_wheel",
            "python_version": "pp311",
            "requires_python": ">=3.8",
            "size": 21459021,
            "upload_time": "2025-08-29T17:17:20",
            "upload_time_iso_8601": "2025-08-29T17:17:20.962935Z",
            "url": "https://files.pythonhosted.org/packages/a0/10/fd71fa3e0cbbe6a856f28b80e59f723334d7507bbbcdd916db6516a825d0/pyreindexer-0.5.600-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "875ab68f758eabf487b60272eee2a931db8ed3edf5f4b911cb3eeee4324d03bb",
                "md5": "9dad3928ee2a72495ec252daa5cb1a65",
                "sha256": "16f4a2ea8580b7bb33d635970654a21c0f6b839c2114f2f41511804a90886f46"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-pp38-pypy38_pp73-macosx_14_0_arm64.whl",
            "has_sig": false,
            "md5_digest": "9dad3928ee2a72495ec252daa5cb1a65",
            "packagetype": "bdist_wheel",
            "python_version": "pp38",
            "requires_python": ">=3.8",
            "size": 18284234,
            "upload_time": "2025-08-29T17:17:23",
            "upload_time_iso_8601": "2025-08-29T17:17:23.877242Z",
            "url": "https://files.pythonhosted.org/packages/87/5a/b68f758eabf487b60272eee2a931db8ed3edf5f4b911cb3eeee4324d03bb/pyreindexer-0.5.600-pp38-pypy38_pp73-macosx_14_0_arm64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "f9ee88a40ab5ee6bd36393cbb6b79dd60e39536aff1e918b7bc69b6ff1f96aaa",
                "md5": "1f718e8cb9d47ffed929094055c26d2e",
                "sha256": "ee3687dcf1d76d068d6c0af84766a2525b04328b83bab272afad050527426f76"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "has_sig": false,
            "md5_digest": "1f718e8cb9d47ffed929094055c26d2e",
            "packagetype": "bdist_wheel",
            "python_version": "pp38",
            "requires_python": ">=3.8",
            "size": 21458753,
            "upload_time": "2025-08-29T17:17:26",
            "upload_time_iso_8601": "2025-08-29T17:17:26.799649Z",
            "url": "https://files.pythonhosted.org/packages/f9/ee/88a40ab5ee6bd36393cbb6b79dd60e39536aff1e918b7bc69b6ff1f96aaa/pyreindexer-0.5.600-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "bec9b2098dafcbaada563463500b536bb51185607c7b2470b0d7ae6d52c2aec9",
                "md5": "d79a16db6ccd3e5259b93ff7365cb45e",
                "sha256": "556a57e162247655f19b79b861d891c2294c71bdaa56704dd219328e063597c9"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-pp39-pypy39_pp73-macosx_14_0_arm64.whl",
            "has_sig": false,
            "md5_digest": "d79a16db6ccd3e5259b93ff7365cb45e",
            "packagetype": "bdist_wheel",
            "python_version": "pp39",
            "requires_python": ">=3.8",
            "size": 18284509,
            "upload_time": "2025-08-29T17:17:29",
            "upload_time_iso_8601": "2025-08-29T17:17:29.221414Z",
            "url": "https://files.pythonhosted.org/packages/be/c9/b2098dafcbaada563463500b536bb51185607c7b2470b0d7ae6d52c2aec9/pyreindexer-0.5.600-pp39-pypy39_pp73-macosx_14_0_arm64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "dac2d0775aa4758e9b597caf7427206728be7c7c48e3a80a399aea909628758c",
                "md5": "2e866411e1699c193d5f24a88afacedc",
                "sha256": "77bba2810b8e92d89e04c9b5388a5e588cde2d44314af29bfab9775f47ac1496"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "has_sig": false,
            "md5_digest": "2e866411e1699c193d5f24a88afacedc",
            "packagetype": "bdist_wheel",
            "python_version": "pp39",
            "requires_python": ">=3.8",
            "size": 21459017,
            "upload_time": "2025-08-29T17:17:31",
            "upload_time_iso_8601": "2025-08-29T17:17:31.842353Z",
            "url": "https://files.pythonhosted.org/packages/da/c2/d0775aa4758e9b597caf7427206728be7c7c48e3a80a399aea909628758c/pyreindexer-0.5.600-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "9bb35b200caead15bcbb1413b159e19bc2a878a62db31a0363c0ddd1c4bd1331",
                "md5": "f9b490fd26ed5c5615dc8ff022a5c1f3",
                "sha256": "a19ea1b316bae5be9adfac8c4e151f5acf582a6ed97ee30774032674e9f6c607"
            },
            "downloads": -1,
            "filename": "pyreindexer-0.5.600.tar.gz",
            "has_sig": false,
            "md5_digest": "f9b490fd26ed5c5615dc8ff022a5c1f3",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": ">=3.8",
            "size": 87330,
            "upload_time": "2025-08-29T17:17:33",
            "upload_time_iso_8601": "2025-08-29T17:17:33.696756Z",
            "url": "https://files.pythonhosted.org/packages/9b/b3/5b200caead15bcbb1413b159e19bc2a878a62db31a0363c0ddd1c4bd1331/pyreindexer-0.5.600.tar.gz",
            "yanked": false,
            "yanked_reason": null
        }
    ],
    "upload_time": "2025-08-29 17:17:33",
    "github": true,
    "gitlab": false,
    "bitbucket": false,
    "codeberg": false,
    "github_user": "Restream",
    "github_project": "reindexer",
    "travis_ci": false,
    "coveralls": false,
    "github_actions": true,
    "lcname": "pyreindexer"
}