elasticsearch 9.1.3__py3-none-any.whl → 9.2.1__py3-none-any.whl

elasticsearch/_async/client/license.py

@@ -104,8 +104,10 @@ class LicenseClient(NamespacedClient):
             license types. If `false`, this parameter returns platinum for both platinum
             and enterprise license types. This behavior is maintained for backwards compatibility.
             This parameter is deprecated and will always be set to true in 8.x.
-        :param local: Specifies whether to retrieve local information. The default value
-            is `false`, which means the information is retrieved from the master node.
+        :param local: Specifies whether to retrieve local information. From 9.2 onwards
+            the default value is `true`, which means the information is retrieved from
+            the responding node. In earlier versions the default is `false`, which means
+            the information is retrieved from the elected master node.
         """
         __path_parts: t.Dict[str, str] = {}
         __path = "/_license"

elasticsearch/_async/client/ml.py

@@ -2397,7 +2397,7 @@ class MlClient(NamespacedClient):
         exclude_interim: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
-        overall_score: t.Optional[t.Union[float, str]] = None,
+        overall_score: t.Optional[float] = None,
         pretty: t.Optional[bool] = None,
         start: t.Optional[t.Union[str, t.Any]] = None,
         top_n: t.Optional[int] = None,
@@ -5755,7 +5755,7 @@ class MlClient(NamespacedClient):
           <p>Validate an anomaly detection job.</p>
 
 
-        `<https://www.elastic.co/guide/en/machine-learning/9.1/ml-jobs.html>`_
+        `<https://www.elastic.co/guide/en/machine-learning/9.2/ml-jobs.html>`_
 
         :param analysis_config:
         :param analysis_limits:

elasticsearch/_async/client/nodes.py

@@ -368,9 +368,7 @@ class NodesClient(NamespacedClient):
         human: t.Optional[bool] = None,
         include_segment_file_sizes: t.Optional[bool] = None,
         include_unloaded_segments: t.Optional[bool] = None,
-        level: t.Optional[
-            t.Union[str, t.Literal["cluster", "indices", "shards"]]
-        ] = None,
+        level: t.Optional[t.Union[str, t.Literal["indices", "node", "shards"]]] = None,
         pretty: t.Optional[bool] = None,
         timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         types: t.Optional[t.Sequence[str]] = None,
@@ -387,7 +385,7 @@ class NodesClient(NamespacedClient):
 
         :param node_id: Comma-separated list of node IDs or names used to limit returned
             information.
-        :param metric:
+        :param metric: Limits the information returned to the specific metrics.
         :param index_metric: Limit the information returned for indices metric to the
             specific index metrics. It can be used only if indices (or all) metric is
             specified.

elasticsearch/_async/client/project.py

@@ -0,0 +1,68 @@
+#  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.
+
+import typing as t
+
+from elastic_transport import ObjectApiResponse
+
+from ._base import NamespacedClient
+from .utils import (
+    Stability,
+    _availability_warning,
+    _rewrite_parameters,
+)
+
+
+class ProjectClient(NamespacedClient):
+
+    @_rewrite_parameters()
+    @_availability_warning(Stability.EXPERIMENTAL)
+    async def tags(
+        self,
+        *,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Get tags.</p>
+          <p>Get the tags that are defined for the project.</p>
+
+        """
+        __path_parts: t.Dict[str, str] = {}
+        __path = "/_project/tags"
+        __query: t.Dict[str, t.Any] = {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        __headers = {"accept": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "GET",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="project.tags",
+            path_parts=__path_parts,
+        )

elasticsearch/_async/client/security.py

@@ -2052,6 +2052,45 @@ class SecurityClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters()
+    async def get_stats(
+        self,
+        *,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        human: t.Optional[bool] = None,
+        pretty: t.Optional[bool] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Get security stats.</p>
+          <p>Gather security usage statistics from all node(s) within the cluster.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-security-get-stats>`_
+        """
+        __path_parts: t.Dict[str, str] = {}
+        __path = "/_security/stats"
+        __query: t.Dict[str, t.Any] = {}
+        if error_trace is not None:
+            __query["error_trace"] = error_trace
+        if filter_path is not None:
+            __query["filter_path"] = filter_path
+        if human is not None:
+            __query["human"] = human
+        if pretty is not None:
+            __query["pretty"] = pretty
+        __headers = {"accept": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "GET",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="security.get_stats",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         body_fields=(
             "grant_type",

elasticsearch/_async/client/shutdown.py

@@ -22,6 +22,9 @@ from elastic_transport import ObjectApiResponse
 from ._base import NamespacedClient
 from .utils import (
     SKIP_IN_PATH,
+    Stability,
+    Visibility,
+    _availability_warning,
     _quote,
     _rewrite_parameters,
 )
@@ -30,6 +33,7 @@ from .utils import (
 class ShutdownClient(NamespacedClient):
 
     @_rewrite_parameters()
+    @_availability_warning(Stability.STABLE, Visibility.PRIVATE)
     async def delete_node(
         self,
         *,
@@ -90,6 +94,7 @@ class ShutdownClient(NamespacedClient):
         )
 
     @_rewrite_parameters()
+    @_availability_warning(Stability.STABLE, Visibility.PRIVATE)
     async def get_node(
         self,
         *,
@@ -149,6 +154,7 @@ class ShutdownClient(NamespacedClient):
     @_rewrite_parameters(
         body_fields=("reason", "type", "allocation_delay", "target_node_name"),
     )
+    @_availability_warning(Stability.STABLE, Visibility.PRIVATE)
     async def put_node(
         self,
         *,

elasticsearch/_async/client/simulate.py

@@ -56,6 +56,7 @@ class SimulateClient(NamespacedClient):
             t.Mapping[str, t.Mapping[str, t.Any]]
         ] = None,
         mapping_addition: t.Optional[t.Mapping[str, t.Any]] = None,
+        merge_type: t.Optional[t.Union[str, t.Literal["index", "template"]]] = None,
         pipeline: t.Optional[str] = None,
         pipeline_substitutions: t.Optional[
             t.Mapping[str, t.Mapping[str, t.Any]]
@@ -93,6 +94,11 @@ class SimulateClient(NamespacedClient):
         :param index_template_substitutions: A map of index template names to substitute
             index template definition objects.
         :param mapping_addition:
+        :param merge_type: The mapping merge type if mapping overrides are being provided
+            in mapping_addition. The allowed values are one of index or template. The
+            index option merges mappings the way they would be merged into an existing
+            index. The template option merges mappings the way they would be merged into
+            a template.
         :param pipeline: The pipeline to use as the default pipeline. This value can
             be used to override the default pipeline of the index.
         :param pipeline_substitutions: Pipelines to test. If you don’t specify the `pipeline`
@@ -116,6 +122,8 @@ class SimulateClient(NamespacedClient):
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
+        if merge_type is not None:
+            __query["merge_type"] = merge_type
         if pipeline is not None:
             __query["pipeline"] = pipeline
         if pretty is not None:

elasticsearch/_async/client/snapshot.py

@@ -872,35 +872,40 @@ class SnapshotClient(NamespacedClient):
 
         :param name: The name of the repository.
         :param blob_count: The total number of blobs to write to the repository during
-            the test. For realistic experiments, you should set it to at least `2000`.
+            the test. For realistic experiments, set this parameter to at least `2000`.
         :param concurrency: The number of operations to run concurrently during the test.
+            For realistic experiments, leave this parameter unset.
         :param detailed: Indicates whether to return detailed results, including timing
             information for every operation performed during the analysis. If false,
             it returns only a summary of the analysis.
         :param early_read_node_count: The number of nodes on which to perform an early
             read operation while writing each blob. Early read operations are only rarely
-            performed.
+            performed. For realistic experiments, leave this parameter unset.
         :param max_blob_size: The maximum size of a blob to be written during the test.
-            For realistic experiments, you should set it to at least `2gb`.
+            For realistic experiments, set this parameter to at least `2gb`.
         :param max_total_data_size: An upper limit on the total size of all the blobs
-            written during the test. For realistic experiments, you should set it to
+            written during the test. For realistic experiments, set this parameter to
             at least `1tb`.
         :param rare_action_probability: The probability of performing a rare action such
-            as an early read, an overwrite, or an aborted write on each blob.
+            as an early read, an overwrite, or an aborted write on each blob. For realistic
+            experiments, leave this parameter unset.
         :param rarely_abort_writes: Indicates whether to rarely cancel writes before
-            they complete.
+            they complete. For realistic experiments, leave this parameter unset.
         :param read_node_count: The number of nodes on which to read a blob after writing.
+            For realistic experiments, leave this parameter unset.
         :param register_operation_count: The minimum number of linearizable register
-            operations to perform in total. For realistic experiments, you should set
-            it to at least `100`.
+            operations to perform in total. For realistic experiments, set this parameter
+            to at least `100`.
         :param seed: The seed for the pseudo-random number generator used to generate
             the list of operations performed during the test. To repeat the same set
             of operations in multiple experiments, use the same seed in each experiment.
             Note that the operations are performed concurrently so might not always happen
-            in the same order on each run.
+            in the same order on each run. For realistic experiments, leave this parameter
+            unset.
         :param timeout: The period of time to wait for the test to complete. If no response
             is received before the timeout expires, the test is cancelled and returns
-            an error.
+            an error. For realistic experiments, set this parameter sufficiently long
+            to allow the test to complete.
         """
         if name in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'name'")
@@ -1266,6 +1271,11 @@ class SnapshotClient(NamespacedClient):
           <p>If you omit the <code>&lt;snapshot&gt;</code> request path parameter, the request retrieves information only for currently running snapshots.
           This usage is preferred.
           If needed, you can specify <code>&lt;repository&gt;</code> and <code>&lt;snapshot&gt;</code> to retrieve information for specific snapshots, even if they're not currently running.</p>
+          <p>Note that the stats will not be available for any shard snapshots in an ongoing snapshot completed by a node that (even momentarily) left the cluster.
+          Loading the stats from the repository is an expensive operation (see the WARNING below).
+          Therefore the stats values for such shards will be -1 even though the &quot;stage&quot; value will be &quot;DONE&quot;, in order to minimize latency.
+          A &quot;description&quot; field will be present for a shard snapshot completed by a departed node explaining why the shard snapshot's stats results are invalid.
+          Consequently, the total stats for the index will be less than expected due to the missing values from these shards.</p>
           <p>WARNING: Using the API to return the status of any snapshots other than currently running snapshots can be expensive.
           The API requires a read from the repository for each shard in each snapshot.
           For example, if you have 100 snapshots with 1,000 shards each, an API request that includes all snapshots will require 100,000 reads (100 snapshots x 1,000 shards).</p>

elasticsearch/_async/client/sql.py

@@ -285,6 +285,7 @@ class SqlClient(NamespacedClient):
         page_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         params: t.Optional[t.Sequence[t.Any]] = None,
         pretty: t.Optional[bool] = None,
+        project_routing: t.Optional[str] = None,
         query: t.Optional[str] = None,
         request_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         runtime_mappings: t.Optional[t.Mapping[str, t.Mapping[str, t.Any]]] = None,
@@ -332,6 +333,10 @@ class SqlClient(NamespacedClient):
             is no longer available. Subsequent scroll requests prolong the lifetime of
             the scroll cursor by the duration of `page_timeout` in the scroll request.
         :param params: The values for parameters in the query.
+        :param project_routing: Specifies a subset of projects to target for the search
+            using project metadata tags in a subset of Lucene query syntax. Allowed Lucene
+            queries: the _alias tag and a single value (possibly wildcarded). Examples:
+            _alias:my-project _alias:_origin _alias:*pr* Supported in serverless only.
         :param query: The SQL query to run.
         :param request_timeout: The timeout before the request fails.
         :param runtime_mappings: One or more runtime fields for the search request. These
@@ -357,6 +362,8 @@ class SqlClient(NamespacedClient):
             __query["human"] = human
         if pretty is not None:
             __query["pretty"] = pretty
+        if project_routing is not None:
+            __query["project_routing"] = project_routing
         if not __body:
             if allow_partial_search_results is not None:
                 __body["allow_partial_search_results"] = allow_partial_search_results

elasticsearch/_async/client/streams.py

@@ -15,6 +15,7 @@
 #  specific language governing permissions and limitations
 #  under the License.
 
+
 import typing as t
 
 from elastic_transport import ObjectApiResponse, TextApiResponse
@@ -144,9 +145,7 @@ class StreamsClient(NamespacedClient):
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         human: t.Optional[bool] = None,
-        master_timeout: t.Optional[
-            t.Union[str, t.Literal["d", "h", "m", "micros", "ms", "nanos", "s"]]
-        ] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         pretty: t.Optional[bool] = None,
     ) -> ObjectApiResponse[t.Any]:
         """

elasticsearch/_async/helpers.py

@@ -33,7 +33,9 @@ from typing import (
     Union,
 )
 
-from ..compat import safe_task
+import sniffio
+from anyio import create_memory_object_stream, create_task_group, move_on_after
+
 from ..exceptions import ApiError, NotFoundError, TransportError
 from ..helpers.actions import (
     _TYPE_BULK_ACTION,
@@ -57,6 +59,15 @@ logger = logging.getLogger("elasticsearch.helpers")
 T = TypeVar("T")
 
 
+async def _sleep(seconds: float) -> None:
+    if sniffio.current_async_library() == "trio":
+        import trio
+
+        await trio.sleep(seconds)
+    else:
+        await asyncio.sleep(seconds)
+
+
 async def _chunk_actions(
     actions: AsyncIterable[_TYPE_BULK_ACTION_HEADER_WITH_META_AND_BODY],
     chunk_size: int,
@@ -82,32 +93,36 @@ async def _chunk_actions(
         chunk_size=chunk_size, max_chunk_bytes=max_chunk_bytes, serializer=serializer
     )
 
+    action: _TYPE_BULK_ACTION_WITH_META
+    data: _TYPE_BULK_ACTION_BODY
     if not flush_after_seconds:
         async for action, data in actions:
             ret = chunker.feed(action, data)
             if ret:
                 yield ret
     else:
-        item_queue: asyncio.Queue[_TYPE_BULK_ACTION_HEADER_WITH_META_AND_BODY] = (
-            asyncio.Queue()
-        )
+        sender, receiver = create_memory_object_stream[
+            _TYPE_BULK_ACTION_HEADER_WITH_META_AND_BODY
+        ]()
 
         async def get_items() -> None:
             try:
                 async for item in actions:
-                    await item_queue.put(item)
+                    await sender.send(item)
             finally:
-                await item_queue.put((BulkMeta.done, None))
+                await sender.send((BulkMeta.done, None))
+
+        async with create_task_group() as tg:
+            tg.start_soon(get_items)
 
-        async with safe_task(get_items()):
             timeout: Optional[float] = flush_after_seconds
             while True:
-                try:
-                    action, data = await asyncio.wait_for(
-                        item_queue.get(), timeout=timeout
-                    )
+                action = {}
+                data = None
+                with move_on_after(timeout) as scope:
+                    action, data = await receiver.receive()
                     timeout = flush_after_seconds
-                except asyncio.TimeoutError:
+                if scope.cancelled_caught:
                     action, data = BulkMeta.flush, None
                     timeout = None
 
@@ -294,9 +309,7 @@ async def async_streaming_bulk(
                 ]
             ] = []
             if attempt:
-                await asyncio.sleep(
-                    min(max_backoff, initial_backoff * 2 ** (attempt - 1))
-                )
+                await _sleep(min(max_backoff, initial_backoff * 2 ** (attempt - 1)))
 
             try:
                 data: Union[