actions/opensearch-pyd
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
6e3f1a11945a568dec5e1ed71c4e80f383984fe7
opensearch-pyd/opensearchpy/_async/client/__init__.py
T
Hugo van Kemenade 6e3f1a1194 Remove redundant mock backport dependency and upgrade syntax for Python 3.8+ (#785) 
* Upgrade syntax with pyupgrade --py38-plus

Signed-off-by: Hugo van Kemenade <1324225+hugovk@users.noreply.github.com>

* Convert to f-strings with flynt

Signed-off-by: Hugo van Kemenade <1324225+hugovk@users.noreply.github.com>

* Format with Black

Signed-off-by: Hugo van Kemenade <1324225+hugovk@users.noreply.github.com>

* Remove redundant mock backport dependency

Signed-off-by: Hugo van Kemenade <1324225+hugovk@users.noreply.github.com>

* isort imports

Signed-off-by: Hugo van Kemenade <1324225+hugovk@users.noreply.github.com>

* Add changelog entry

Signed-off-by: Hugo van Kemenade <1324225+hugovk@users.noreply.github.com>

---------

Signed-off-by: Hugo van Kemenade <1324225+hugovk@users.noreply.github.com>
2024-07-20 16:19:20 -04:00

3070 lines
126 KiB
Python
Raw Blame History

# SPDX-License-Identifier: Apache-2.0
#
# The OpenSearch Contributors require contributions made to
# this file be licensed under the Apache-2.0 license or a
# compatible open source license.
#
# Modifications Copyright OpenSearch Contributors. See
# GitHub history for details.
#
# Licensed to Elasticsearch B.V. under one or more contributor
# license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright
# ownership. Elasticsearch B.V. licenses this file to you under
# the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# ------------------------------------------------------------------------------------------
# THIS CODE IS AUTOMATICALLY GENERATED AND MANUAL EDITS WILL BE LOST
#
# To contribute, kindly make modifications in the opensearch-py client generator
# or in the OpenSearch API specification, and run `nox -rs generate`. See DEVELOPER_GUIDE.md
# and https://github.com/opensearch-project/opensearch-api-specification for details.
# -----------------------------------------------------------------------------------------+
import logging
from typing import Any, Type
from ..transport import AsyncTransport, TransportError
from .cat import CatClient
from .client import Client
from .cluster import ClusterClient
from .dangling_indices import DanglingIndicesClient
from .features import FeaturesClient
from .http import HttpClient
from .indices import IndicesClient
from .ingest import IngestClient
from .nodes import NodesClient
from .plugins import PluginsClient
from .remote import RemoteClient
from .remote_store import RemoteStoreClient
from .search_pipeline import SearchPipelineClient
from .security import SecurityClient
from .snapshot import SnapshotClient
from .tasks import TasksClient
from .utils import SKIP_IN_PATH, _bulk_body, _make_path, query_params
logger = logging.getLogger("opensearch")
class AsyncOpenSearch(Client):
"""
OpenSearch client. Provides a straightforward mapping from
Python to OpenSearch REST endpoints.
The instance has attributes ``cat``, ``cluster``, ``indices``, ``ingest``,
``nodes``, ``snapshot`` and ``tasks`` that provide access to instances of
:class:`~opensearchpy.client.CatClient`,
:class:`~opensearchpy.client.ClusterClient`,
:class:`~opensearchpy.client.IndicesClient`,
:class:`~opensearchpy.client.IngestClient`,
:class:`~opensearchpy.client.NodesClient`,
:class:`~opensearchpy.client.SnapshotClient` and
:class:`~opensearchpy.client.TasksClient` respectively. This is the
preferred (and only supported) way to get access to those classes and their
methods.
You can specify your own connection class which should be used by providing
the ``connection_class`` parameter::
# create connection to localhost using the ThriftConnection
client = OpenSearch(connection_class=ThriftConnection)
If you want to turn on sniffing you have several options (described
in :class:`~opensearchpy.Transport`)::
# create connection that will automatically inspect the cluster to get
# the list of active nodes. Start with nodes running on
# 'opensearchnode1' and 'opensearchnode2'
client = OpenSearch(
['opensearchnode1', 'opensearchnode2'],
# sniff before doing anything
sniff_on_start=True,
# refresh nodes after a node fails to respond
sniff_on_connection_fail=True,
# and also every 60 seconds
sniffer_timeout=60
)
Different hosts can have different parameters, use a dictionary per node to
specify those::
# connect to localhost directly and another node using SSL on port 443
# and an url_prefix. Note that ``port`` needs to be an int.
client = OpenSearch([
{'host': 'localhost'},
{'host': 'othernode', 'port': 443, 'url_prefix': 'opensearch', 'use_ssl': True},
])
If using SSL, there are several parameters that control how we deal with
certificates (see :class:`~opensearchpy.Urllib3HttpConnection` for
detailed description of the options)::
client = OpenSearch(
['localhost:443', 'other_host:443'],
# turn on SSL
use_ssl=True,
# make sure we verify SSL certificates
verify_certs=True,
# provide a path to CA certs on disk
ca_certs='/path/to/CA_certs'
)
If using SSL, but don't verify the certs, a warning message is showed
optionally (see :class:`~opensearchpy.Urllib3HttpConnection` for
detailed description of the options)::
client = OpenSearch(
['localhost:443', 'other_host:443'],
# turn on SSL
use_ssl=True,
# no verify SSL certificates
verify_certs=False,
# don't show warnings about ssl certs verification
ssl_show_warn=False
)
SSL client authentication is supported
(see :class:`~opensearchpy.Urllib3HttpConnection` for
detailed description of the options)::
client = OpenSearch(
['localhost:443', 'other_host:443'],
# turn on SSL
use_ssl=True,
# make sure we verify SSL certificates
verify_certs=True,
# provide a path to CA certs on disk
ca_certs='/path/to/CA_certs',
# PEM formatted SSL client certificate
client_cert='/path/to/clientcert.pem',
# PEM formatted SSL client key
client_key='/path/to/clientkey.pem'
)
Alternatively you can use RFC-1738 formatted URLs, as long as they are not
in conflict with other options::
client = OpenSearch(
[
'http://user:secret@localhost:9200/',
'https://user:secret@other_host:443/production'
],
verify_certs=True
)
By default, `JSONSerializer
<https://github.com/opensearch-project/opensearch-py/blob/master/opensearch/serializer.py#L24>`_
is used to encode all outgoing requests.
However, you can implement your own custom serializer::
from opensearchpy.serializer import JSONSerializer
class SetEncoder(JSONSerializer):
def default(self, obj):
if isinstance(obj, set):
return list(obj)
if isinstance(obj, Something):
return 'CustomSomethingRepresentation'
return JSONSerializer.default(self, obj)
client = OpenSearch(serializer=SetEncoder())
"""
# include PIT functions inside _patch.py
from ._patch import ( # type: ignore
create_point_in_time,
delete_point_in_time,
list_all_point_in_time,
)
def __init__(
self,
hosts: Any = None,
transport_class: Type[AsyncTransport] = AsyncTransport,
**kwargs: Any,
) -> None:
"""
:arg hosts: list of nodes, or a single node, we should connect to.
Node should be a dictionary ({"host": "localhost", "port": 9200}),
the entire dictionary will be passed to the :class:`~opensearchpy.Connection`
class as kwargs, or a string in the format of ``host[:port]`` which will be
translated to a dictionary automatically. If no value is given the
:class:`~opensearchpy.Connection` class defaults will be used.
:arg transport_class: :class:`~opensearchpy.Transport` subclass to use.
:arg kwargs: any additional arguments will be passed on to the
:class:`~opensearchpy.Transport` class and, subsequently, to the
:class:`~opensearchpy.Connection` instances.
"""
super().__init__(hosts, transport_class, **kwargs)
# namespaced clients for compatibility with API names
self.search_pipeline = SearchPipelineClient(self)
self.cat = CatClient(self)
self.cluster = ClusterClient(self)
self.dangling_indices = DanglingIndicesClient(self)
self.indices = IndicesClient(self)
self.ingest = IngestClient(self)
self.nodes = NodesClient(self)
self.remote = RemoteClient(self)
self.security = SecurityClient(self)
self.snapshot = SnapshotClient(self)
self.tasks = TasksClient(self)
self.remote_store = RemoteStoreClient(self)
self.features = FeaturesClient(self)
self.plugins = PluginsClient(self)
self.http = HttpClient(self)
def __repr__(self) -> Any:
try:
# get a list of all connections
cons: Any = self.transport.hosts
# truncate to 5 if there are too many
if len(cons) > 5:
cons = cons[:5] + ["..."]
return f"<{self.__class__.__name__}({cons})>"
except Exception:
# probably operating on custom transport and connection_pool, ignore
return super().__repr__()
async def __aenter__(self) -> Any:
if hasattr(self.transport, "_async_call"):
await self.transport._async_call()
return self
async def __aexit__(self, *_: Any) -> None:
await self.close()
async def close(self) -> None:
"""Closes the Transport and all internal connections"""
await self.transport.close()
# AUTO-GENERATED-API-DEFINITIONS #
@query_params("error_trace", "filter_path", "human", "pretty", "source")
async def ping(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns whether the cluster is running.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
try:
return await self.transport.perform_request(
"HEAD", "/", params=params, headers=headers
)
except TransportError:
return False
@query_params("error_trace", "filter_path", "human", "pretty", "source")
async def info(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns basic information about the cluster.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return await self.transport.perform_request(
"GET", "/", params=params, headers=headers
)
@query_params(
"error_trace",
"filter_path",
"human",
"pipeline",
"pretty",
"refresh",
"routing",
"source",
"timeout",
"version",
"version_type",
"wait_for_active_shards",
)
async def create(
self,
index: Any,
id: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates a new document in the index. Returns a 409 response when a document
with a same ID already exists in the index.
:arg index: Name of the data stream or index to target. If the
target doesn't exist and matches the name or wildcard (`*`) pattern of
an index template with a `data_stream` definition, this request creates
the data stream. If the target doesn't exist and doesn't match a data
stream template, this request creates the index.
:arg id: Unique identifier for the document.
:arg body: The document
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pipeline: ID of the pipeline to use to preprocess incoming
documents.If the index has a default ingest pipeline specified, then
setting the value to `_none` disables the default ingest pipeline for
this request.If a final pipeline is configured it will always run,
regardless of the value of this parameter.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg refresh: If `true`, OpenSearch refreshes the affected
shards to make this operation visible to search, if `wait_for` then wait
for a refresh to make this operation visible to search, if `false` do
nothing with refreshes.Valid values: `true`, `false`, `wait_for`.
:arg routing: Custom value used to route operations to a
specific shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg timeout: Period the request waits for the following
operations: automatic index creation, dynamic mapping updates, waiting
for active shards.
:arg version: Explicit version number for concurrency
control.The specified version must match the current version of the
document for the request to succeed.
:arg version_type: Specific version type: `external`,
`external_gte`. Valid choices are external, external_gte, force,
internal.
:arg wait_for_active_shards: The number of shard copies that
must be active before proceeding with the operation.Set to `all` or any
positive integer up to the total number of shards in the index
(`number_of_replicas+1`). Valid choices are all, index-setting.
"""
for param in (index, id, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
path = _make_path(index, "_create", id)
return await self.transport.perform_request(
"PUT", path, params=params, headers=headers, body=body
)
@query_params(
"error_trace",
"filter_path",
"human",
"if_primary_term",
"if_seq_no",
"op_type",
"pipeline",
"pretty",
"refresh",
"require_alias",
"routing",
"source",
"timeout",
"version",
"version_type",
"wait_for_active_shards",
)
async def index(
self,
index: Any,
body: Any,
id: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates or updates a document in an index.
:arg index: Name of the data stream or index to target.
:arg body: The document
:arg id: Unique identifier for the document.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg if_primary_term: Only perform the operation if the document
has this primary term.
:arg if_seq_no: Only perform the operation if the document has
this sequence number.
:arg op_type: Set to create to only index the document if it
does not already exist (put if absent).If a document with the specified
`_id` already exists, the indexing operation will fail.Same as using the
`<index>/_create` endpoint.Valid values: `index`, `create`.If document
id is specified, it defaults to `index`.Otherwise, it defaults to
`create`.
:arg pipeline: ID of the pipeline to use to preprocess incoming
documents.If the index has a default ingest pipeline specified, then
setting the value to `_none` disables the default ingest pipeline for
this request.If a final pipeline is configured it will always run,
regardless of the value of this parameter.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg refresh: If `true`, OpenSearch refreshes the affected
shards to make this operation visible to search, if `wait_for` then wait
for a refresh to make this operation visible to search, if `false` do
nothing with refreshes.Valid values: `true`, `false`, `wait_for`.
:arg require_alias: If `true`, the destination must be an index
alias. Default is false.
:arg routing: Custom value used to route operations to a
specific shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg timeout: Period the request waits for the following
operations: automatic index creation, dynamic mapping updates, waiting
for active shards.
:arg version: Explicit version number for concurrency
control.The specified version must match the current version of the
document for the request to succeed.
:arg version_type: Specific version type: `external`,
`external_gte`. Valid choices are external, external_gte, force,
internal.
:arg wait_for_active_shards: The number of shard copies that
must be active before proceeding with the operation.Set to all or any
positive integer up to the total number of shards in the index
(`number_of_replicas+1`). Valid choices are all, index-setting.
"""
for param in (index, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return await self.transport.perform_request(
"POST" if id in SKIP_IN_PATH else "PUT",
_make_path(index, "_doc", id),
params=params,
headers=headers,
body=body,
)
@query_params(
"_source",
"_source_excludes",
"_source_includes",
"error_trace",
"filter_path",
"human",
"pipeline",
"pretty",
"refresh",
"require_alias",
"routing",
"source",
"timeout",
"wait_for_active_shards",
)
async def bulk(
self,
body: Any,
index: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Allows to perform multiple index/update/delete operations in a single request.
:arg body: The operation definition and data (action-data
pairs), separated by newlines
:arg index: Name of the data stream, index, or index alias to
perform bulk actions on.
:arg _source: `true` or `false` to return the `_source` field or
not, or a list of fields to return.
:arg _source_excludes: A comma-separated list of source fields
to exclude from the response.
:arg _source_includes: A comma-separated list of source fields
to include in the response.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pipeline: ID of the pipeline to use to preprocess incoming
documents.If the index has a default ingest pipeline specified, then
setting the value to `_none` disables the default ingest pipeline for
this request.If a final pipeline is configured it will always run,
regardless of the value of this parameter.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg refresh: If `true`, OpenSearch refreshes the affected
shards to make this operation visible to search, if `wait_for` then wait
for a refresh to make this operation visible to search, if `false` do
nothing with refreshes.Valid values: `true`, `false`, `wait_for`.
:arg require_alias: If `true`, the request's actions must target
an index alias. Default is false.
:arg routing: Custom value used to route operations to a
specific shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg timeout: Period each action waits for the following
operations: automatic index creation, dynamic mapping updates, waiting
for active shards.
:arg wait_for_active_shards: The number of shard copies that
must be active before proceeding with the operation.Set to all or any
positive integer up to the total number of shards in the index
(`number_of_replicas+1`). Valid choices are all, index-setting.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
body = _bulk_body(self.transport.serializer, body)
return await self.transport.perform_request(
"POST",
_make_path(index, "_bulk"),
params=params,
headers=headers,
body=body,
)
@query_params("error_trace", "filter_path", "human", "pretty", "source")
async def clear_scroll(
self,
body: Any = None,
scroll_id: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Explicitly clears the search context for a scroll.
:arg body: Comma-separated list of scroll IDs to clear if none
was specified via the scroll_id parameter
:arg scroll_id: Comma-separated list of scroll IDs to clear. To
clear all scroll IDs, use `_all`.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if scroll_id in SKIP_IN_PATH and body in SKIP_IN_PATH:
raise ValueError("You need to supply scroll_id or body.")
elif scroll_id and not body:
body = {"scroll_id": [scroll_id]}
elif scroll_id:
params["scroll_id"] = scroll_id
return await self.transport.perform_request(
"DELETE", "/_search/scroll", params=params, headers=headers, body=body
)
@query_params(
"allow_no_indices",
"analyze_wildcard",
"analyzer",
"default_operator",
"df",
"error_trace",
"expand_wildcards",
"filter_path",
"human",
"ignore_throttled",
"ignore_unavailable",
"lenient",
"min_score",
"preference",
"pretty",
"q",
"routing",
"source",
"terminate_after",
)
async def count(
self,
body: Any = None,
index: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns number of documents matching a query.
:arg body: Query to restrict the results specified with the
Query DSL (optional)
:arg index: Comma-separated list of data streams, indices, and
aliases to search. Supports wildcards (`*`). To search all data streams
and indices, omit this parameter or use `*` or `_all`.
:arg allow_no_indices: If `false`, the request returns an error
if any wildcard expression, index alias, or `_all` value targets only
missing or closed indices.This behavior applies even if the request
targets other open indices.
:arg analyze_wildcard: If `true`, wildcard and prefix queries
are analyzed.This parameter can only be used when the `q` query string
parameter is specified. Default is false.
:arg analyzer: Analyzer to use for the query string.This
parameter can only be used when the `q` query string parameter is
specified.
:arg default_operator: The default operator for query string
query: `AND` or `OR`.This parameter can only be used when the `q` query
string parameter is specified. Valid choices are and, or.
:arg df: Field to use as default where no field prefix is given
in the query string.This parameter can only be used when the `q` query
string parameter is specified.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg expand_wildcards: Type of index that wildcard patterns can
match.If the request can target data streams, this argument determines
whether wildcard expressions match hidden data streams.Supports comma-
separated values, such as `open,hidden`. Valid choices are all, closed,
hidden, none, open.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg ignore_throttled: If `true`, concrete, expanded or aliased
indices are ignored when frozen.
:arg ignore_unavailable: If `false`, the request returns an
error if it targets a missing or closed index.
:arg lenient: If `true`, format-based query failures (such as
providing text to a numeric field) in the query string will be ignored.
:arg min_score: Sets the minimum `_score` value that documents
must have to be included in the result.
:arg preference: Specifies the node or shard the operation
should be performed on.Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg q: Query in the Lucene query string syntax.
:arg routing: Custom value used to route operations to a
specific shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg terminate_after: Maximum number of documents to collect for
each shard.If a query reaches this limit, OpenSearch terminates the
query early.OpenSearch collects documents before sorting.
"""
return await self.transport.perform_request(
"POST",
_make_path(index, "_count"),
params=params,
headers=headers,
body=body,
)
@query_params(
"error_trace",
"filter_path",
"human",
"if_primary_term",
"if_seq_no",
"pretty",
"refresh",
"routing",
"source",
"timeout",
"version",
"version_type",
"wait_for_active_shards",
)
async def delete(
self,
index: Any,
id: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Removes a document from the index.
:arg index: Name of the target index.
:arg id: Unique identifier for the document.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg if_primary_term: Only perform the operation if the document
has this primary term.
:arg if_seq_no: Only perform the operation if the document has
this sequence number.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg refresh: If `true`, OpenSearch refreshes the affected
shards to make this operation visible to search, if `wait_for` then wait
for a refresh to make this operation visible to search, if `false` do
nothing with refreshes.Valid values: `true`, `false`, `wait_for`.
:arg routing: Custom value used to route operations to a
specific shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg timeout: Period to wait for active shards.
:arg version: Explicit version number for concurrency
control.The specified version must match the current version of the
document for the request to succeed.
:arg version_type: Specific version type: `external`,
`external_gte`. Valid choices are external, external_gte, force,
internal.
:arg wait_for_active_shards: The number of shard copies that
must be active before proceeding with the operation.Set to `all` or any
positive integer up to the total number of shards in the index
(`number_of_replicas+1`). Valid choices are all, index-setting.
"""
for param in (index, id):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return await self.transport.perform_request(
"DELETE", _make_path(index, "_doc", id), params=params, headers=headers
)
@query_params(
"_source",
"_source_excludes",
"_source_includes",
"allow_no_indices",
"analyze_wildcard",
"analyzer",
"conflicts",
"default_operator",
"df",
"error_trace",
"expand_wildcards",
"filter_path",
"from_",
"human",
"ignore_unavailable",
"lenient",
"max_docs",
"preference",
"pretty",
"q",
"refresh",
"request_cache",
"requests_per_second",
"routing",
"scroll",
"scroll_size",
"search_timeout",
"search_type",
"size",
"slices",
"sort",
"source",
"stats",
"terminate_after",
"timeout",
"version",
"wait_for_active_shards",
"wait_for_completion",
)
async def delete_by_query(
self,
index: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Deletes documents matching the provided query.
:arg index: Comma-separated list of data streams, indices, and
aliases to search. Supports wildcards (`*`). To search all data streams
or indices, omit this parameter or use `*` or `_all`.
:arg body: The search definition using the Query DSL
:arg _source: True or false to return the _source field or not,
or a list of fields to return.
:arg _source_excludes: List of fields to exclude from the
returned _source field.
:arg _source_includes: List of fields to extract and return from
the _source field.
:arg allow_no_indices: If `false`, the request returns an error
if any wildcard expression, index alias, or `_all` value targets only
missing or closed indices.This behavior applies even if the request
targets other open indices.For example, a request targeting `foo*,bar*`
returns an error if an index starts with `foo` but no index starts with
`bar`.
:arg analyze_wildcard: If `true`, wildcard and prefix queries
are analyzed. Default is false.
:arg analyzer: Analyzer to use for the query string.
:arg conflicts: What to do if delete by query hits version
conflicts: `abort` or `proceed`. Valid choices are abort, proceed.
:arg default_operator: The default operator for query string
query: `AND` or `OR`. Valid choices are and, or.
:arg df: Field to use as default where no field prefix is given
in the query string.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg expand_wildcards: Type of index that wildcard patterns can
match.If the request can target data streams, this argument determines
whether wildcard expressions match hidden data streams.Supports comma-
separated values, such as `open,hidden`. Valid values are: `all`,
`open`, `closed`, `hidden`, `none`.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg from_: Starting offset. Default is 0.
:arg human: Whether to return human readable values for
statistics.
:arg ignore_unavailable: If `false`, the request returns an
error if it targets a missing or closed index.
:arg lenient: If `true`, format-based query failures (such as
providing text to a numeric field) in the query string will be ignored.
:arg max_docs: Maximum number of documents to process.Defaults
to all documents.
:arg preference: Specifies the node or shard the operation
should be performed on.Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg q: Query in the Lucene query string syntax.
:arg refresh: If `true`, OpenSearch refreshes all shards
involved in the delete by query after the request completes.
:arg request_cache: If `true`, the request cache is used for
this request.Defaults to the index-level setting.
:arg requests_per_second: The throttle for this request in sub-
requests per second. Default is 0.
:arg routing: Custom value used to route operations to a
specific shard.
:arg scroll: Period to retain the search context for scrolling.
:arg scroll_size: Size of the scroll request that powers the
operation. Default is 100.
:arg search_timeout: Explicit timeout for each search
request.Defaults to no timeout.
:arg search_type: The type of the search operation.Available
options: `query_then_fetch`, `dfs_query_then_fetch`. Valid choices are
dfs_query_then_fetch, query_then_fetch.
:arg size: Deprecated, please use `max_docs` instead.
:arg slices: The number of slices this task should be divided
into. Valid choices are auto.
:arg sort: A comma-separated list of <field>:<direction> pairs.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg stats: Specific `tag` of the request for logging and
statistical purposes.
:arg terminate_after: Maximum number of documents to collect for
each shard.If a query reaches this limit, OpenSearch terminates the
query early.OpenSearch collects documents before sorting.Use with
caution.OpenSearch applies this parameter to each shard handling the
request.When possible, let OpenSearch perform early termination
automatically.Avoid specifying this parameter for requests that target
data streams with backing indices across multiple data tiers.
:arg timeout: Period each deletion request waits for active
shards.
:arg version: If `true`, returns the document version as part of
a hit.
:arg wait_for_active_shards: The number of shard copies that
must be active before proceeding with the operation.Set to all or any
positive integer up to the total number of shards in the index
(`number_of_replicas+1`). Valid choices are all, index-setting.
:arg wait_for_completion: If `true`, the request blocks until
the operation is complete. Default is True.
"""
# from is a reserved word so it cannot be used, use from_ instead
if "from_" in params:
params["from"] = params.pop("from_")
for param in (index, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return await self.transport.perform_request(
"POST",
_make_path(index, "_delete_by_query"),
params=params,
headers=headers,
body=body,
)
@query_params(
"error_trace", "filter_path", "human", "pretty", "requests_per_second", "source"
)
async def delete_by_query_rethrottle(
self,
task_id: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Changes the number of requests per second for a particular Delete By Query
operation.
:arg task_id: The ID for the task.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg requests_per_second: The throttle for this request in sub-
requests per second.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if task_id in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'task_id'.")
return await self.transport.perform_request(
"POST",
_make_path("_delete_by_query", task_id, "_rethrottle"),
params=params,
headers=headers,
)
@query_params(
"cluster_manager_timeout",
"error_trace",
"filter_path",
"human",
"master_timeout",
"pretty",
"source",
"timeout",
)
async def delete_script(
self,
id: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Deletes a script.
:arg id: Identifier for the stored script or search template.
:arg cluster_manager_timeout: Operation timeout for connection
to cluster-manager node.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg master_timeout (Deprecated: To promote inclusive language,
use 'cluster_manager_timeout' instead.): Period to wait for a connection
to the master node.If no response is received before the timeout
expires, the request fails and returns an error.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg timeout: Period to wait for a response.If no response is
received before the timeout expires, the request fails and returns an
error.
"""
if id in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'id'.")
return await self.transport.perform_request(
"DELETE", _make_path("_scripts", id), params=params, headers=headers
)
@query_params(
"_source",
"_source_excludes",
"_source_includes",
"error_trace",
"filter_path",
"human",
"preference",
"pretty",
"realtime",
"refresh",
"routing",
"source",
"stored_fields",
"version",
"version_type",
)
async def exists(
self,
index: Any,
id: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns information about whether a document exists in an index.
:arg index: Comma-separated list of data streams, indices, and
aliases. Supports wildcards (`*`).
:arg id: Identifier of the document.
:arg _source: `true` or `false` to return the `_source` field or
not, or a list of fields to return.
:arg _source_excludes: A comma-separated list of source fields
to exclude in the response.
:arg _source_includes: A comma-separated list of source fields
to include in the response.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg preference: Specifies the node or shard the operation
should be performed on.Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg realtime: If `true`, the request is real-time as opposed to
near-real-time.
:arg refresh: If `true`, OpenSearch refreshes all shards
involved in the delete by query after the request completes.
:arg routing: Target the specified primary shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg stored_fields: List of stored fields to return as part of a
hit.If no fields are specified, no stored fields are included in the
response.If this field is specified, the `_source` parameter defaults to
false.
:arg version: Explicit version number for concurrency
control.The specified version must match the current version of the
document for the request to succeed.
:arg version_type: Specific version type: `external`,
`external_gte`. Valid choices are external, external_gte, force,
internal.
"""
for param in (index, id):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return await self.transport.perform_request(
"HEAD", _make_path(index, "_doc", id), params=params, headers=headers
)
@query_params(
"_source",
"_source_excludes",
"_source_includes",
"error_trace",
"filter_path",
"human",
"preference",
"pretty",
"realtime",
"refresh",
"routing",
"source",
"version",
"version_type",
)
async def exists_source(
self,
index: Any,
id: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns information about whether a document source exists in an index.
:arg index: Comma-separated list of data streams, indices, and
aliases. Supports wildcards (`*`).
:arg id: Identifier of the document.
:arg _source: `true` or `false` to return the `_source` field or
not, or a list of fields to return.
:arg _source_excludes: A comma-separated list of source fields
to exclude in the response.
:arg _source_includes: A comma-separated list of source fields
to include in the response.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg preference: Specifies the node or shard the operation
should be performed on.Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg realtime: If true, the request is real-time as opposed to
near-real-time.
:arg refresh: If `true`, OpenSearch refreshes all shards
involved in the delete by query after the request completes.
:arg routing: Target the specified primary shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg version: Explicit version number for concurrency
control.The specified version must match the current version of the
document for the request to succeed.
:arg version_type: Specific version type: `external`,
`external_gte`. Valid choices are external, external_gte, force,
internal.
"""
for param in (index, id):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
path = _make_path(index, "_source", id)
return await self.transport.perform_request(
"HEAD", path, params=params, headers=headers
)
@query_params(
"_source",
"_source_excludes",
"_source_includes",
"analyze_wildcard",
"analyzer",
"default_operator",
"df",
"error_trace",
"filter_path",
"human",
"lenient",
"preference",
"pretty",
"q",
"routing",
"source",
"stored_fields",
)
async def explain(
self,
index: Any,
id: Any,
body: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns information about why a specific matches (or doesn't match) a query.
:arg index: Index names used to limit the request. Only a single
index name can be provided to this parameter.
:arg id: Defines the document ID.
:arg body: The query definition using the Query DSL
:arg _source: True or false to return the `_source` field or
not, or a list of fields to return.
:arg _source_excludes: A comma-separated list of source fields
to exclude from the response.
:arg _source_includes: A comma-separated list of source fields
to include in the response.
:arg analyze_wildcard: If `true`, wildcard and prefix queries
are analyzed. Default is false.
:arg analyzer: Analyzer to use for the query string.This
parameter can only be used when the `q` query string parameter is
specified.
:arg default_operator: The default operator for query string
query: `AND` or `OR`. Valid choices are and, or.
:arg df: Field to use as default where no field prefix is given
in the query string. Default is _all.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg lenient: If `true`, format-based query failures (such as
providing text to a numeric field) in the query string will be ignored.
:arg preference: Specifies the node or shard the operation
should be performed on.Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg q: Query in the Lucene query string syntax.
:arg routing: Custom value used to route operations to a
specific shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg stored_fields: A comma-separated list of stored fields to
return in the response.
"""
for param in (index, id):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
path = _make_path(index, "_explain", id)
return await self.transport.perform_request(
"POST", path, params=params, headers=headers, body=body
)
@query_params(
"allow_no_indices",
"error_trace",
"expand_wildcards",
"fields",
"filter_path",
"human",
"ignore_unavailable",
"include_unmapped",
"pretty",
"source",
)
async def field_caps(
self,
body: Any = None,
index: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns the information about the capabilities of fields among multiple
indices.
:arg body: An index filter specified with the Query DSL
:arg index: Comma-separated list of data streams, indices, and
aliases used to limit the request. Supports wildcards (*). To target all
data streams and indices, omit this parameter or use * or _all.
:arg allow_no_indices: If false, the request returns an error if
any wildcard expression, index alias,or `_all` value targets only
missing or closed indices. This behavior applies even if the request
targets other open indices. For example, a requesttargeting `foo*,bar*`
returns an error if an index starts with foo but no index starts with
bar.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg expand_wildcards: Type of index that wildcard patterns can
match. If the request can target data streams, this argument determines
whether wildcard expressions match hidden data streams. Supports comma-
separated values, such as `open,hidden`. Valid choices are all, closed,
hidden, none, open.
:arg fields: Comma-separated list of fields to retrieve
capabilities for. Wildcard (`*`) expressions are supported.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg ignore_unavailable: If `true`, missing or closed indices
are not included in the response.
:arg include_unmapped: If true, unmapped fields are included in
the response. Default is false.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return await self.transport.perform_request(
"POST",
_make_path(index, "_field_caps"),
params=params,
headers=headers,
body=body,
)
@query_params(
"_source",
"_source_excludes",
"_source_includes",
"error_trace",
"filter_path",
"human",
"preference",
"pretty",
"realtime",
"refresh",
"routing",
"source",
"stored_fields",
"version",
"version_type",
)
async def get(
self,
index: Any,
id: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns a document.
:arg index: Name of the index that contains the document.
:arg id: Unique identifier of the document.
:arg _source: True or false to return the _source field or not,
or a list of fields to return.
:arg _source_excludes: A comma-separated list of source fields
to exclude in the response.
:arg _source_includes: A comma-separated list of source fields
to include in the response.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg preference: Specifies the node or shard the operation
should be performed on. Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg realtime: If `true`, the request is real-time as opposed to
near-real-time.
:arg refresh: If true, OpenSearch refreshes the affected shards
to make this operation visible to search. If false, do nothing with
refreshes.
:arg routing: Target the specified primary shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg stored_fields: List of stored fields to return as part of a
hit.If no fields are specified, no stored fields are included in the
response.If this field is specified, the `_source` parameter defaults to
false.
:arg version: Explicit version number for concurrency control.
The specified version must match the current version of the document for
the request to succeed.
:arg version_type: Specific version type: internal, external,
external_gte. Valid choices are external, external_gte, force, internal.
"""
for param in (index, id):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return await self.transport.perform_request(
"GET", _make_path(index, "_doc", id), params=params, headers=headers
)
@query_params(
"cluster_manager_timeout",
"error_trace",
"filter_path",
"human",
"master_timeout",
"pretty",
"source",
)
async def get_script(
self,
id: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns a script.
:arg id: Identifier for the stored script or search template.
:arg cluster_manager_timeout: Operation timeout for connection
to cluster-manager node.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg master_timeout (Deprecated: To promote inclusive language,
use 'cluster_manager_timeout' instead.): Specify timeout for connection
to master
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if id in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'id'.")
return await self.transport.perform_request(
"GET", _make_path("_scripts", id), params=params, headers=headers
)
@query_params(
"_source",
"_source_excludes",
"_source_includes",
"error_trace",
"filter_path",
"human",
"preference",
"pretty",
"realtime",
"refresh",
"routing",
"source",
"version",
"version_type",
)
async def get_source(
self,
index: Any,
id: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns the source of a document.
:arg index: Name of the index that contains the document.
:arg id: Unique identifier of the document.
:arg _source: True or false to return the _source field or not,
or a list of fields to return.
:arg _source_excludes: A comma-separated list of source fields
to exclude in the response.
:arg _source_includes: A comma-separated list of source fields
to include in the response.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg preference: Specifies the node or shard the operation
should be performed on. Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg realtime: Boolean) If true, the request is real-time as
opposed to near-real-time.
:arg refresh: If true, OpenSearch refreshes the affected shards
to make this operation visible to search. If false, do nothing with
refreshes.
:arg routing: Target the specified primary shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg version: Explicit version number for concurrency control.
The specified version must match the current version of the document for
the request to succeed.
:arg version_type: Specific version type: internal, external,
external_gte. Valid choices are external, external_gte, force, internal.
"""
for param in (index, id):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
path = _make_path(index, "_source", id)
return await self.transport.perform_request(
"GET", path, params=params, headers=headers
)
@query_params(
"_source",
"_source_excludes",
"_source_includes",
"error_trace",
"filter_path",
"human",
"preference",
"pretty",
"realtime",
"refresh",
"routing",
"source",
"stored_fields",
)
async def mget(
self,
body: Any,
index: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Allows to get multiple documents in one request.
:arg body: Document identifiers; can be either `docs`
(containing full document information) or `ids` (when index is provided
in the URL.
:arg index: Name of the index to retrieve documents from when
`ids` are specified, or when a document in the `docs` array does not
specify an index.
:arg _source: True or false to return the `_source` field or
not, or a list of fields to return.
:arg _source_excludes: A comma-separated list of source fields
to exclude from the response.You can also use this parameter to exclude
fields from the subset specified in `_source_includes` query parameter.
:arg _source_includes: A comma-separated list of source fields
to include in the response.If this parameter is specified, only these
source fields are returned. You can exclude fields from this subset
using the `_source_excludes` query parameter.If the `_source` parameter
is `false`, this parameter is ignored.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg preference: Specifies the node or shard the operation
should be performed on. Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg realtime: If `true`, the request is real-time as opposed to
near-real-time.
:arg refresh: If `true`, the request refreshes relevant shards
before retrieving documents.
:arg routing: Custom value used to route operations to a
specific shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg stored_fields: If `true`, retrieves the document fields
stored in the index rather than the document `_source`.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return await self.transport.perform_request(
"POST",
_make_path(index, "_mget"),
params=params,
headers=headers,
body=body,
)
@query_params(
"ccs_minimize_roundtrips",
"error_trace",
"filter_path",
"human",
"max_concurrent_searches",
"max_concurrent_shard_requests",
"pre_filter_shard_size",
"pretty",
"rest_total_hits_as_int",
"search_type",
"source",
"typed_keys",
)
async def msearch(
self,
body: Any,
index: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Allows to execute several search operations in one request.
:arg body: The request definitions (metadata-search request
definition pairs), separated by newlines
:arg index: Comma-separated list of data streams, indices, and
index aliases to search.
:arg ccs_minimize_roundtrips: If true, network roundtrips
between the coordinating node and remote clusters are minimized for
cross-cluster search requests. Default is True.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg max_concurrent_searches: Maximum number of concurrent
searches the multi search API can execute.
:arg max_concurrent_shard_requests: Maximum number of concurrent
shard requests that each sub-search request executes per node. Default
is 5.
:arg pre_filter_shard_size: Defines a threshold that enforces a
pre-filter roundtrip to prefilter search shards based on query rewriting
if the number of shards the search request expands to exceeds the
threshold. This filter roundtrip can limit the number of shards
significantly if for instance a shard can not match any documents based
on its rewrite method i.e., if date filters are mandatory to match but
the shard bounds and the query are disjoint.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg rest_total_hits_as_int: If true, hits.total are returned as
an integer in the response. Defaults to false, which returns an object.
Default is false.
:arg search_type: Indicates whether global term and document
frequencies should be used when scoring returned documents. Valid
choices are dfs_query_then_fetch, query_then_fetch.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg typed_keys: Specifies whether aggregation and suggester
names should be prefixed by their respective types in the response.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
body = _bulk_body(self.transport.serializer, body)
return await self.transport.perform_request(
"POST",
_make_path(index, "_msearch"),
params=params,
headers=headers,
body=body,
)
@query_params(
"ccs_minimize_roundtrips",
"error_trace",
"filter_path",
"human",
"max_concurrent_searches",
"pretty",
"rest_total_hits_as_int",
"search_type",
"source",
"typed_keys",
)
async def msearch_template(
self,
body: Any,
index: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Allows to execute several search template operations in one request.
:arg body: The request definitions (metadata-search request
definition pairs), separated by newlines
:arg index: Comma-separated list of data streams, indices, and
aliases to search. Supports wildcards (`*`). To search all data streams
and indices, omit this parameter or use `*`.
:arg ccs_minimize_roundtrips: If `true`, network round-trips are
minimized for cross-cluster search requests. Default is True.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg max_concurrent_searches: Maximum number of concurrent
searches the API can run.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg rest_total_hits_as_int: If `true`, the response returns
`hits.total` as an integer.If `false`, it returns `hits.total` as an
object. Default is false.
:arg search_type: The type of the search operation.Available
options: `query_then_fetch`, `dfs_query_then_fetch`. Valid choices are
dfs_query_then_fetch, query_then_fetch.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg typed_keys: If `true`, the response prefixes aggregation
and suggester names with their respective types.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
body = _bulk_body(self.transport.serializer, body)
return await self.transport.perform_request(
"POST",
_make_path(index, "_msearch", "template"),
params=params,
headers=headers,
body=body,
)
@query_params(
"error_trace",
"field_statistics",
"fields",
"filter_path",
"human",
"ids",
"offsets",
"payloads",
"positions",
"preference",
"pretty",
"realtime",
"routing",
"source",
"term_statistics",
"version",
"version_type",
)
async def mtermvectors(
self,
body: Any = None,
index: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns multiple termvectors in one request.
:arg body: Define ids, documents, parameters or a list of
parameters per document here. You must at least provide a list of
document ids. See documentation.
:arg index: Name of the index that contains the documents.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg field_statistics: If `true`, the response includes the
document count, sum of document frequencies, and sum of total term
frequencies. Default is True.
:arg fields: Comma-separated list or wildcard expressions of
fields to include in the statistics.Used as the default list unless a
specific field list is provided in the `completion_fields` or
`fielddata_fields` parameters.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg ids: A comma-separated list of documents ids. You must
define ids as parameter or set "ids" or "docs" in the request body
:arg offsets: If `true`, the response includes term offsets.
Default is True.
:arg payloads: If `true`, the response includes term payloads.
Default is True.
:arg positions: If `true`, the response includes term positions.
Default is True.
:arg preference: Specifies the node or shard the operation
should be performed on.Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg realtime: If true, the request is real-time as opposed to
near-real-time. Default is True.
:arg routing: Custom value used to route operations to a
specific shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg term_statistics: If true, the response includes term
frequency and document frequency. Default is false.
:arg version: If `true`, returns the document version as part of
a hit.
:arg version_type: Specific version type. Valid choices are
external, external_gte, force, internal.
"""
path = _make_path(index, "_mtermvectors")
return await self.transport.perform_request(
"POST", path, params=params, headers=headers, body=body
)
@query_params(
"cluster_manager_timeout",
"error_trace",
"filter_path",
"human",
"master_timeout",
"pretty",
"source",
"timeout",
)
async def put_script(
self,
id: Any,
body: Any,
context: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates or updates a script.
:arg id: Identifier for the stored script or search template.
Must be unique within the cluster.
:arg body: The document
:arg context: Context in which the script or search template
should run. To prevent errors, the API immediately compiles the script
or template in this context.
:arg cluster_manager_timeout: Operation timeout for connection
to cluster-manager node.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg master_timeout (Deprecated: To promote inclusive language,
use 'cluster_manager_timeout' instead.): Period to wait for a connection
to the master node.If no response is received before the timeout
expires, the request fails and returns an error.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg timeout: Period to wait for a response.If no response is
received before the timeout expires, the request fails and returns an
error.
"""
for param in (id, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
return await self.transport.perform_request(
"PUT",
_make_path("_scripts", id, context),
params=params,
headers=headers,
body=body,
)
@query_params(
"allow_no_indices",
"error_trace",
"expand_wildcards",
"filter_path",
"human",
"ignore_unavailable",
"pretty",
"search_type",
"source",
)
async def rank_eval(
self,
body: Any,
index: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Allows to evaluate the quality of ranked search results over a set of typical
search queries.
:arg body: The ranking evaluation search definition, including
search requests, document ratings and ranking metric definition.
:arg index: Comma-separated list of data streams, indices, and
index aliases used to limit the request. Wildcard (`*`) expressions are
supported. To target all data streams and indices in a cluster, omit
this parameter or use `_all` or `*`.
:arg allow_no_indices: If `false`, the request returns an error
if any wildcard expression, index alias, or `_all` value targets only
missing or closed indices. This behavior applies even if the request
targets other open indices. For example, a request targeting `foo*,bar*`
returns an error if an index starts with `foo` but no index starts with
`bar`.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg expand_wildcards: Whether to expand wildcard expression to
concrete indices that are open, closed or both. Valid choices are all,
closed, hidden, none, open.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg ignore_unavailable: If `true`, missing or closed indices
are not included in the response.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg search_type: Search operation type
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return await self.transport.perform_request(
"POST",
_make_path(index, "_rank_eval"),
params=params,
headers=headers,
body=body,
)
@query_params(
"error_trace",
"filter_path",
"human",
"max_docs",
"pretty",
"refresh",
"requests_per_second",
"scroll",
"slices",
"source",
"timeout",
"wait_for_active_shards",
"wait_for_completion",
)
async def reindex(
self,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Allows to copy documents from one index to another, optionally filtering the
source documents by a query, changing the destination index settings, or
fetching the documents from a remote cluster.
:arg body: The search definition using the Query DSL and the
prototype for the index request.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg max_docs: Maximum number of documents to process. By
default, all documents.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg refresh: If `true`, the request refreshes affected shards
to make this operation visible to search.
:arg requests_per_second: The throttle for this request in sub-
requests per second.Defaults to no throttle. Default is 0.
:arg scroll: Specifies how long a consistent view of the index
should be maintained for scrolled search.
:arg slices: The number of slices this task should be divided
into.Defaults to 1 slice, meaning the task isn't sliced into subtasks.
Valid choices are auto.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg timeout: Period each indexing waits for automatic index
creation, dynamic mapping updates, and waiting for active shards.
:arg wait_for_active_shards: The number of shard copies that
must be active before proceeding with the operation.Set to `all` or any
positive integer up to the total number of shards in the index
(`number_of_replicas+1`). Valid choices are all, index-setting.
:arg wait_for_completion: If `true`, the request blocks until
the operation is complete. Default is True.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return await self.transport.perform_request(
"POST", "/_reindex", params=params, headers=headers, body=body
)
@query_params(
"error_trace", "filter_path", "human", "pretty", "requests_per_second", "source"
)
async def reindex_rethrottle(
self,
task_id: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Changes the number of requests per second for a particular Reindex operation.
:arg task_id: Identifier for the task.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg requests_per_second: The throttle for this request in sub-
requests per second.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if task_id in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'task_id'.")
return await self.transport.perform_request(
"POST",
_make_path("_reindex", task_id, "_rethrottle"),
params=params,
headers=headers,
)
@query_params("error_trace", "filter_path", "human", "pretty", "source")
async def render_search_template(
self,
body: Any = None,
id: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Allows to use the Mustache language to pre-render a search definition.
:arg body: The search definition template and its params
:arg id: ID of the search template to render. If no `source` is
specified, this or the `id` request body parameter is required.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return await self.transport.perform_request(
"POST",
_make_path("_render", "template", id),
params=params,
headers=headers,
body=body,
)
@query_params("error_trace", "filter_path", "human", "pretty", "source")
async def scripts_painless_execute(
self,
body: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Allows an arbitrary script to be executed and a result to be returned.
:arg body: The script to execute
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return await self.transport.perform_request(
"POST",
"/_scripts/painless/_execute",
params=params,
headers=headers,
body=body,
)
@query_params(
"error_trace",
"filter_path",
"human",
"pretty",
"rest_total_hits_as_int",
"scroll",
"source",
)
async def scroll(
self,
body: Any = None,
scroll_id: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Allows to retrieve a large numbers of results from a single search request.
:arg body: The scroll ID if not passed by URL or query
parameter.
:arg scroll_id: The scroll ID for scrolled search
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg rest_total_hits_as_int: If true, the API response's
hit.total property is returned as an integer. If false, the API
response's hit.total property is returned as an object. Default is
false.
:arg scroll: Period to retain the search context for scrolling.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if scroll_id in SKIP_IN_PATH and body in SKIP_IN_PATH:
raise ValueError("You need to supply scroll_id or body.")
elif scroll_id and not body:
body = {"scroll_id": scroll_id}
elif scroll_id:
params["scroll_id"] = scroll_id
return await self.transport.perform_request(
"POST", "/_search/scroll", params=params, headers=headers, body=body
)
@query_params(
"_source",
"_source_excludes",
"_source_includes",
"allow_no_indices",
"allow_partial_search_results",
"analyze_wildcard",
"analyzer",
"batched_reduce_size",
"cancel_after_time_interval",
"ccs_minimize_roundtrips",
"default_operator",
"df",
"docvalue_fields",
"error_trace",
"expand_wildcards",
"explain",
"filter_path",
"from_",
"human",
"ignore_throttled",
"ignore_unavailable",
"include_named_queries_score",
"lenient",
"max_concurrent_shard_requests",
"phase_took",
"pre_filter_shard_size",
"preference",
"pretty",
"q",
"request_cache",
"rest_total_hits_as_int",
"routing",
"scroll",
"search_pipeline",
"search_type",
"seq_no_primary_term",
"size",
"sort",
"source",
"stats",
"stored_fields",
"suggest_field",
"suggest_mode",
"suggest_size",
"suggest_text",
"terminate_after",
"timeout",
"track_scores",
"track_total_hits",
"typed_keys",
"version",
)
async def search(
self,
body: Any = None,
index: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns results matching a query.
:arg body: The search definition using the Query DSL
:arg index: Comma-separated list of data streams, indices, and
aliases to search. Supports wildcards (`*`). To search all data streams
and indices, omit this parameter or use `*` or `_all`.
:arg _source: Indicates which source fields are returned for
matching documents.These fields are returned in the `hits._source`
property of the search response.Valid values are:`true` to return the
entire document source;`false` to not return the document
source;`<string>` to return the source fields that are specified as a
comma-separated list (supports wildcard (`*`) patterns).
:arg _source_excludes: A comma-separated list of source fields
to exclude from the response.You can also use this parameter to exclude
fields from the subset specified in `_source_includes` query
parameter.If the `_source` parameter is `false`, this parameter is
ignored.
:arg _source_includes: A comma-separated list of source fields
to include in the response.If this parameter is specified, only these
source fields are returned.You can exclude fields from this subset using
the `_source_excludes` query parameter.If the `_source` parameter is
`false`, this parameter is ignored.
:arg allow_no_indices: If `false`, the request returns an error
if any wildcard expression, index alias, or `_all` value targets only
missing or closed indices.This behavior applies even if the request
targets other open indices.For example, a request targeting `foo*,bar*`
returns an error if an index starts with `foo` but no index starts with
`bar`.
:arg allow_partial_search_results: If true, returns partial
results if there are shard request timeouts or shard failures. If false,
returns an error with no partial results. Default is True.
:arg analyze_wildcard: If true, wildcard and prefix queries are
analyzed.This parameter can only be used when the q query string
parameter is specified. Default is false.
:arg analyzer: Analyzer to use for the query string.This
parameter can only be used when the q query string parameter is
specified.
:arg batched_reduce_size: The number of shard results that
should be reduced at once on the coordinating node.This value should be
used as a protection mechanism to reduce the memory overhead per search
request if the potential number of shards in the request can be large.
Default is 512.
:arg cancel_after_time_interval: The time after which the search
request will be canceled.Request-level parameter takes precedence over
`cancel_after_time_interval` cluster setting.
:arg ccs_minimize_roundtrips: If true, network round-trips
between the coordinating node and the remote clusters are minimized when
executing cross-cluster search (CCS) requests. Default is True.
:arg default_operator: The default operator for query string
query: AND or OR.This parameter can only be used when the `q` query
string parameter is specified. Valid choices are and, or.
:arg df: Field to use as default where no field prefix is given
in the query string.This parameter can only be used when the q query
string parameter is specified.
:arg docvalue_fields: A comma-separated list of fields to return
as the docvalue representation for each hit.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg expand_wildcards: Type of index that wildcard patterns can
match.If the request can target data streams, this argument determines
whether wildcard expressions match hidden data streams.Supports comma-
separated values, such as `open,hidden`. Valid choices are all, closed,
hidden, none, open.
:arg explain: If `true`, returns detailed information about
score computation as part of a hit.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg from_: Starting document offset.Needs to be non-negative.By
default, you cannot page through more than 10,000 hits using the `from`
and `size` parameters.To page through more hits, use the `search_after`
parameter. Default is 0.
:arg human: Whether to return human readable values for
statistics.
:arg ignore_throttled: If `true`, concrete, expanded or aliased
indices will be ignored when frozen.
:arg ignore_unavailable: If `false`, the request returns an
error if it targets a missing or closed index.
:arg include_named_queries_score: Indicates whether
hit.matched_queries should be rendered as a map that includes the name
of the matched query associated with its score (true) or as an array
containing the name of the matched queries (false) Default is false.
:arg lenient: If `true`, format-based query failures (such as
providing text to a numeric field) in the query string will be
ignored.This parameter can only be used when the `q` query string
parameter is specified.
:arg max_concurrent_shard_requests: Defines the number of
concurrent shard requests per node this search executes
concurrently.This value should be used to limit the impact of the search
on the cluster in order to limit the number of concurrent shard
requests. Default is 5.
:arg phase_took: Indicates whether to return phase-level `took`
time values in the response. Default is false.
:arg pre_filter_shard_size: Defines a threshold that enforces a
pre-filter roundtrip to prefilter search shards based on query rewriting
if the number of shards the search request expands to exceeds the
threshold.This filter roundtrip can limit the number of shards
significantly if for instance a shard can not match any documents based
on its rewrite method (if date filters are mandatory to match but the
shard bounds and the query are disjoint).When unspecified, the pre-
filter phase is executed if any of these conditions is met:the request
targets more than 128 shards;the request targets one or more read-only
index;the primary sort of the query targets an indexed field.
:arg preference: Nodes and shards used for the search.By
default, OpenSearch selects from eligible nodes and shards using
adaptive replica selection, accounting for allocation awareness. Valid
values are:`_only_local` to run the search only on shards on the local
node;`_local` to, if possible, run the search on shards on the local
node, or if not, select shards using the default
method;`_only_nodes:<node-id>,<node-id>` to run the search on only the
specified nodes IDs, where, if suitable shards exist on more than one
selected node, use shards on those nodes using the default method, or if
none of the specified nodes are available, select shards from any
available node using the default method;`_prefer_nodes:<node-id>,<node-
id>` to if possible, run the search on the specified nodes IDs, or if
not, select shards using the default method;`_shards:<shard>,<shard>` to
run the search only on the specified shards;`<custom-string>` (any
string that does not start with `_`) to route searches with the same
`<custom-string>` to the same shards in the same order. Default is
random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg q: Query in the Lucene query string syntax using query
parameter search.Query parameter searches do not support the full
OpenSearch Query DSL but are handy for testing.
:arg request_cache: If `true`, the caching of search results is
enabled for requests where `size` is `0`.Defaults to index level
settings.
:arg rest_total_hits_as_int: Indicates whether `hits.total`
should be rendered as an integer or an object in the rest search
response. Default is false.
:arg routing: Custom value used to route operations to a
specific shard.
:arg scroll: Period to retain the search context for scrolling.
See Scroll search results.By default, this value cannot exceed `1d` (24
hours).You can change this limit using the `search.max_keep_alive`
cluster-level setting.
:arg search_pipeline: Customizable sequence of processing stages
applied to search queries.
:arg search_type: How distributed term frequencies are
calculated for relevance scoring. Valid choices are
dfs_query_then_fetch, query_then_fetch.
:arg seq_no_primary_term: If `true`, returns sequence number and
primary term of the last modification of each hit.
:arg size: Defines the number of hits to return.By default, you
cannot page through more than 10,000 hits using the `from` and `size`
parameters.To page through more hits, use the `search_after` parameter.
Default is 10.
:arg sort: A comma-separated list of <field>:<direction> pairs.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg stats: Specific `tag` of the request for logging and
statistical purposes.
:arg stored_fields: A comma-separated list of stored fields to
return as part of a hit.If no fields are specified, no stored fields are
included in the response.If this field is specified, the `_source`
parameter defaults to `false`.You can pass `_source: true` to return
both source fields and stored fields in the search response.
:arg suggest_field: Specifies which field to use for
suggestions.
:arg suggest_mode: Specifies the suggest mode.This parameter can
only be used when the `suggest_field` and `suggest_text` query string
parameters are specified. Valid choices are always, missing, popular.
:arg suggest_size: Number of suggestions to return.This
parameter can only be used when the `suggest_field` and `suggest_text`
query string parameters are specified.
:arg suggest_text: The source text for which the suggestions
should be returned.This parameter can only be used when the
`suggest_field` and `suggest_text` query string parameters are
specified.
:arg terminate_after: Maximum number of documents to collect for
each shard.If a query reaches this limit, OpenSearch terminates the
query early.OpenSearch collects documents before sorting.Use with
caution.OpenSearch applies this parameter to each shard handling the
request.When possible, let OpenSearch perform early termination
automatically.Avoid specifying this parameter for requests that target
data streams with backing indices across multiple data tiers.If set to
`0` (default), the query does not terminate early.
:arg timeout: Specifies the period of time to wait for a
response from each shard.If no response is received before the timeout
expires, the request fails and returns an error.
:arg track_scores: If `true`, calculate and return document
scores, even if the scores are not used for sorting.
:arg track_total_hits: Number of hits matching the query to
count accurately.If `true`, the exact number of hits is returned at the
cost of some performance.If `false`, the response does not include the
total number of hits matching the query.
:arg typed_keys: If `true`, aggregation and suggester names are
be prefixed by their respective types in the response.
:arg version: If `true`, returns document version as part of a
hit.
"""
# from is a reserved word so it cannot be used, use from_ instead
if "from_" in params:
params["from"] = params.pop("from_")
return await self.transport.perform_request(
"POST",
_make_path(index, "_search"),
params=params,
headers=headers,
body=body,
)
@query_params(
"allow_no_indices",
"error_trace",
"expand_wildcards",
"filter_path",
"human",
"ignore_unavailable",
"local",
"preference",
"pretty",
"routing",
"source",
)
async def search_shards(
self,
index: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns information about the indices and shards that a search request would be
executed against.
:arg index: Returns the indices and shards that a search request
would be executed against.
:arg allow_no_indices: If `false`, the request returns an error
if any wildcard expression, index alias, or `_all` value targets only
missing or closed indices.This behavior applies even if the request
targets other open indices.For example, a request targeting `foo*,bar*`
returns an error if an index starts with `foo` but no index starts with
`bar`.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg expand_wildcards: Type of index that wildcard patterns can
match.If the request can target data streams, this argument determines
whether wildcard expressions match hidden data streams.Supports comma-
separated values, such as `open,hidden`.Valid values are: `all`, `open`,
`closed`, `hidden`, `none`.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg ignore_unavailable: If `false`, the request returns an
error if it targets a missing or closed index.
:arg local: If `true`, the request retrieves information from
the local node only. Default is false.
:arg preference: Specifies the node or shard the operation
should be performed on.Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg routing: Custom value used to route operations to a
specific shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return await self.transport.perform_request(
"GET", _make_path(index, "_search_shards"), params=params, headers=headers
)
@query_params(
"allow_no_indices",
"ccs_minimize_roundtrips",
"error_trace",
"expand_wildcards",
"explain",
"filter_path",
"human",
"ignore_throttled",
"ignore_unavailable",
"preference",
"pretty",
"profile",
"rest_total_hits_as_int",
"routing",
"scroll",
"search_type",
"source",
"typed_keys",
)
async def search_template(
self,
body: Any,
index: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Allows to use the Mustache language to pre-render a search definition.
:arg body: The search definition template and its params
:arg index: Comma-separated list of data streams, indices, and
aliases to search. Supports wildcards (*).
:arg allow_no_indices: If `false`, the request returns an error
if any wildcard expression, index alias, or `_all` value targets only
missing or closed indices.This behavior applies even if the request
targets other open indices.For example, a request targeting `foo*,bar*`
returns an error if an index starts with `foo` but no index starts with
`bar`.
:arg ccs_minimize_roundtrips: If `true`, network round-trips are
minimized for cross-cluster search requests. Default is True.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg expand_wildcards: Type of index that wildcard patterns can
match.If the request can target data streams, this argument determines
whether wildcard expressions match hidden data streams.Supports comma-
separated values, such as `open,hidden`.Valid values are: `all`, `open`,
`closed`, `hidden`, `none`.
:arg explain: If `true`, the response includes additional
details about score computation as part of a hit.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg ignore_throttled: If `true`, specified concrete, expanded,
or aliased indices are not included in the response when throttled.
:arg ignore_unavailable: If `false`, the request returns an
error if it targets a missing or closed index.
:arg preference: Specifies the node or shard the operation
should be performed on.Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg profile: If `true`, the query execution is profiled.
:arg rest_total_hits_as_int: If true, hits.total are rendered as
an integer in the response. Default is false.
:arg routing: Custom value used to route operations to a
specific shard.
:arg scroll: Specifies how long a consistent view of the
indexshould be maintained for scrolled search.
:arg search_type: The type of the search operation. Valid
choices are dfs_query_then_fetch, query_then_fetch.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg typed_keys: If `true`, the response prefixes aggregation
and suggester names with their respective types.
"""
if body in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'body'.")
return await self.transport.perform_request(
"POST",
_make_path(index, "_search", "template"),
params=params,
headers=headers,
body=body,
)
@query_params(
"error_trace",
"field_statistics",
"fields",
"filter_path",
"human",
"offsets",
"payloads",
"positions",
"preference",
"pretty",
"realtime",
"routing",
"source",
"term_statistics",
"version",
"version_type",
)
async def termvectors(
self,
index: Any,
body: Any = None,
id: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns information and statistics about terms in the fields of a particular
document.
:arg index: Name of the index that contains the document.
:arg body: Define parameters and or supply a document to get
termvectors for. See documentation.
:arg id: Unique identifier of the document.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg field_statistics: If `true`, the response includes the
document count, sum of document frequencies, and sum of total term
frequencies. Default is True.
:arg fields: Comma-separated list or wildcard expressions of
fields to include in the statistics.Used as the default list unless a
specific field list is provided in the `completion_fields` or
`fielddata_fields` parameters.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg offsets: If `true`, the response includes term offsets.
Default is True.
:arg payloads: If `true`, the response includes term payloads.
Default is True.
:arg positions: If `true`, the response includes term positions.
Default is True.
:arg preference: Specifies the node or shard the operation
should be performed on.Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg realtime: If true, the request is real-time as opposed to
near-real-time. Default is True.
:arg routing: Custom value used to route operations to a
specific shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg term_statistics: If `true`, the response includes term
frequency and document frequency. Default is false.
:arg version: If `true`, returns the document version as part of
a hit.
:arg version_type: Specific version type. Valid choices are
external, external_gte, force, internal.
"""
if index in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'index'.")
path = _make_path(index, "_termvectors", id)
return await self.transport.perform_request(
"POST", path, params=params, headers=headers, body=body
)
@query_params(
"_source",
"_source_excludes",
"_source_includes",
"error_trace",
"filter_path",
"human",
"if_primary_term",
"if_seq_no",
"lang",
"pretty",
"refresh",
"require_alias",
"retry_on_conflict",
"routing",
"source",
"timeout",
"wait_for_active_shards",
)
async def update(
self,
index: Any,
id: Any,
body: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Updates a document with a script or partial document.
:arg index: The name of the index
:arg id: Document ID
:arg body: The request definition requires either `script` or
partial `doc`
:arg _source: Set to false to disable source retrieval. You can
also specify a comma-separatedlist of the fields you want to retrieve.
:arg _source_excludes: Specify the source fields you want to
exclude.
:arg _source_includes: Specify the source fields you want to
retrieve.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg if_primary_term: Only perform the operation if the document
has this primary term.
:arg if_seq_no: Only perform the operation if the document has
this sequence number.
:arg lang: The script language. Default is painless.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg refresh: If 'true', OpenSearch refreshes the affected
shards to make this operationvisible to search, if 'wait_for' then wait
for a refresh to make this operationvisible to search, if 'false' do
nothing with refreshes. Valid choices are false, true, wait_for.
:arg require_alias: If true, the destination must be an index
alias. Default is false.
:arg retry_on_conflict: Specify how many times should the
operation be retried when a conflict occurs. Default is 0.
:arg routing: Custom value used to route operations to a
specific shard.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg timeout: Period to wait for dynamic mapping updates and
active shards.This guarantees OpenSearch waits for at least the timeout
before failing.The actual wait time could be longer, particularly when
multiple waits occur.
:arg wait_for_active_shards: The number of shard copies that
must be active before proceeding with the operations.Set to 'all' or any
positive integer up to the total number of shards in the
index(number_of_replicas+1). Defaults to 1 meaning the primary shard.
Valid choices are all, index-setting.
"""
for param in (index, id, body):
if param in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument.")
path = _make_path(index, "_update", id)
return await self.transport.perform_request(
"POST", path, params=params, headers=headers, body=body
)
@query_params(
"_source",
"_source_excludes",
"_source_includes",
"allow_no_indices",
"analyze_wildcard",
"analyzer",
"conflicts",
"default_operator",
"df",
"error_trace",
"expand_wildcards",
"filter_path",
"from_",
"human",
"ignore_unavailable",
"lenient",
"max_docs",
"pipeline",
"preference",
"pretty",
"q",
"refresh",
"request_cache",
"requests_per_second",
"routing",
"scroll",
"scroll_size",
"search_timeout",
"search_type",
"size",
"slices",
"sort",
"source",
"stats",
"terminate_after",
"timeout",
"version",
"wait_for_active_shards",
"wait_for_completion",
)
async def update_by_query(
self,
index: Any,
body: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Performs an update on every document in the index without changing the source,
for example to pick up a mapping change.
:arg index: Comma-separated list of data streams, indices, and
aliases to search. Supports wildcards (`*`). To search all data streams
or indices, omit this parameter or use `*` or `_all`.
:arg body: The search definition using the Query DSL
:arg _source: True or false to return the _source field or not,
or a list of fields to return.
:arg _source_excludes: List of fields to exclude from the
returned _source field.
:arg _source_includes: List of fields to extract and return from
the _source field.
:arg allow_no_indices: If `false`, the request returns an error
if any wildcard expression, index alias, or `_all` value targets only
missing or closed indices.This behavior applies even if the request
targets other open indices.For example, a request targeting `foo*,bar*`
returns an error if an index starts with `foo` but no index starts with
`bar`.
:arg analyze_wildcard: If `true`, wildcard and prefix queries
are analyzed. Default is false.
:arg analyzer: Analyzer to use for the query string.
:arg conflicts: What to do if update by query hits version
conflicts: `abort` or `proceed`. Valid choices are abort, proceed.
:arg default_operator: The default operator for query string
query: `AND` or `OR`. Valid choices are and, or.
:arg df: Field to use as default where no field prefix is given
in the query string.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg expand_wildcards: Type of index that wildcard patterns can
match.If the request can target data streams, this argument determines
whether wildcard expressions match hidden data streams.Supports comma-
separated values, such as `open,hidden`.Valid values are: `all`, `open`,
`closed`, `hidden`, `none`.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg from_: Starting offset. Default is 0.
:arg human: Whether to return human readable values for
statistics.
:arg ignore_unavailable: If `false`, the request returns an
error if it targets a missing or closed index.
:arg lenient: If `true`, format-based query failures (such as
providing text to a numeric field) in the query string will be ignored.
:arg max_docs: Maximum number of documents to process.Defaults
to all documents.
:arg pipeline: ID of the pipeline to use to preprocess incoming
documents.If the index has a default ingest pipeline specified, then
setting the value to `_none` disables the default ingest pipeline for
this request.If a final pipeline is configured it will always run,
regardless of the value of this parameter.
:arg preference: Specifies the node or shard the operation
should be performed on.Random by default. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg q: Query in the Lucene query string syntax.
:arg refresh: If `true`, OpenSearch refreshes affected shards to
make the operation visible to search.
:arg request_cache: If `true`, the request cache is used for
this request.
:arg requests_per_second: The throttle for this request in sub-
requests per second. Default is 0.
:arg routing: Custom value used to route operations to a
specific shard.
:arg scroll: Period to retain the search context for scrolling.
:arg scroll_size: Size of the scroll request that powers the
operation. Default is 100.
:arg search_timeout: Explicit timeout for each search request.
:arg search_type: The type of the search operation. Available
options: `query_then_fetch`, `dfs_query_then_fetch`. Valid choices are
dfs_query_then_fetch, query_then_fetch.
:arg size: Deprecated, please use `max_docs` instead.
:arg slices: The number of slices this task should be divided
into. Valid choices are auto.
:arg sort: A comma-separated list of <field>:<direction> pairs.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
:arg stats: Specific `tag` of the request for logging and
statistical purposes.
:arg terminate_after: Maximum number of documents to collect for
each shard.If a query reaches this limit, OpenSearch terminates the
query early.OpenSearch collects documents before sorting.Use with
caution.OpenSearch applies this parameter to each shard handling the
request.When possible, let OpenSearch perform early termination
automatically.Avoid specifying this parameter for requests that target
data streams with backing indices across multiple data tiers.
:arg timeout: Period each update request waits for the following
operations: dynamic mapping updates, waiting for active shards.
:arg version: If `true`, returns the document version as part of
a hit.
:arg wait_for_active_shards: The number of shard copies that
must be active before proceeding with the operation.Set to `all` or any
positive integer up to the total number of shards in the index
(`number_of_replicas+1`). Valid choices are all, index-setting.
:arg wait_for_completion: If `true`, the request blocks until
the operation is complete. Default is True.
"""
# from is a reserved word so it cannot be used, use from_ instead
if "from_" in params:
params["from"] = params.pop("from_")
if index in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'index'.")
return await self.transport.perform_request(
"POST",
_make_path(index, "_update_by_query"),
params=params,
headers=headers,
body=body,
)
@query_params(
"error_trace", "filter_path", "human", "pretty", "requests_per_second", "source"
)
async def update_by_query_rethrottle(
self,
task_id: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Changes the number of requests per second for a particular Update By Query
operation.
:arg task_id: The ID for the task.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg requests_per_second: The throttle for this request in sub-
requests per second.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if task_id in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'task_id'.")
return await self.transport.perform_request(
"POST",
_make_path("_update_by_query", task_id, "_rethrottle"),
params=params,
headers=headers,
)
@query_params("error_trace", "filter_path", "human", "pretty", "source")
async def get_script_context(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns all script contexts.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return await self.transport.perform_request(
"GET", "/_script_context", params=params, headers=headers
)
@query_params("error_trace", "filter_path", "human", "pretty", "source")
async def get_script_languages(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Returns available script types, languages and contexts.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return await self.transport.perform_request(
"GET", "/_script_language", params=params, headers=headers
)
@query_params(
"allow_partial_pit_creation",
"error_trace",
"expand_wildcards",
"filter_path",
"human",
"keep_alive",
"preference",
"pretty",
"routing",
"source",
)
async def create_pit(
self,
index: Any,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Creates point in time context.
:arg index: Comma-separated list of indices; use `_all` or empty
string to perform the operation on all indices.
:arg allow_partial_pit_creation: Allow if point in time can be
created with partial failures.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg expand_wildcards: Whether to expand wildcard expression to
concrete indices that are open, closed or both. Valid choices are all,
closed, hidden, none, open.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg keep_alive: Specify the keep alive for point in time.
:arg preference: Specify the node or shard the operation should
be performed on. Default is random.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg routing: Comma-separated list of specific routing values.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
if index in SKIP_IN_PATH:
raise ValueError("Empty value passed for a required argument 'index'.")
return await self.transport.perform_request(
"POST",
_make_path(index, "_search", "point_in_time"),
params=params,
headers=headers,
)
@query_params("error_trace", "filter_path", "human", "pretty", "source")
async def delete_all_pits(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Deletes all active point in time searches.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return await self.transport.perform_request(
"DELETE", "/_search/point_in_time/_all", params=params, headers=headers
)
@query_params("error_trace", "filter_path", "human", "pretty", "source")
async def delete_pit(
self,
body: Any = None,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Deletes one or more point in time searches based on the IDs passed.
:arg body: The point-in-time ids to be deleted
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return await self.transport.perform_request(
"DELETE",
"/_search/point_in_time",
params=params,
headers=headers,
body=body,
)
@query_params("error_trace", "filter_path", "human", "pretty", "source")
async def get_all_pits(
self,
params: Any = None,
headers: Any = None,
) -> Any:
"""
Lists all active point in time searches.
:arg error_trace: Whether to include the stack trace of returned
errors.
:arg filter_path: Comma-separated list of filters used to reduce
the response.
:arg human: Whether to return human readable values for
statistics.
:arg pretty: Whether to pretty format the returned JSON
response.
:arg source: The URL-encoded request definition. Useful for
libraries that do not accept a request body for non-POST requests.
"""
return await self.transport.perform_request(
"GET", "/_search/point_in_time/_all", params=params, headers=headers
)
Reference in New Issue View Git Blame Copy Permalink