Auto-generated API code

Author: elasticmachine

elasticsearch/_async/client/cat.py

@@ -3204,6 +3204,7 @@ async def recovery(
                     t.Union[
                         str,
                         t.Literal[
+                            "blocked_for_millis",
                             "bytes",
                             "bytes_percent",
                             "bytes_recovered",
@@ -3212,6 +3213,7 @@ async def recovery(
                             "files_percent",
                             "files_recovered",
                             "files_total",
+                            "gate",
                             "index",
                             "local_retries",
                             "priority",
@@ -3238,6 +3240,7 @@ async def recovery(
                 t.Union[
                     str,
                     t.Literal[
+                        "blocked_for_millis",
                         "bytes",
                         "bytes_percent",
                         "bytes_recovered",
@@ -3246,6 +3249,7 @@ async def recovery(
                         "files_percent",
                         "files_recovered",
                         "files_total",
+                        "gate",
                         "index",
                         "local_retries",
                         "priority",

elasticsearch/_async/client/data_recovery.py

@@ -0,0 +1,77 @@
+#  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.
+
+class C:
+
+    @_rewrite_parameters()
+    @_availability_warning(Stability.STABLE, Visibility.PRIVATE)
+    async def get_recovery_points(
+        self,
+        *,
+        end_time_before: t.Optional[t.Union[str, t.Any]] = None,
+        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[-1], t.Literal[0]]] = None,
+        pretty: t.Optional[bool] = None,
+        size: t.Optional[int] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Get recovery points.</p>
+          <p>Get recovery points from the platform-managed data recovery repository.
+          This API is intended for internal operator use.
+          Recovery points are returned in descending order by end time. Repository,
+          snapshot, and policy identifiers are not exposed.</p>
+
+
+        :param end_time_before: Return only recovery points whose end time is earlier
+            than this value. The boundary is exclusive and can be set to the last recovery
+            point's end time to retrieve the next page.
+        :param master_timeout: The 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.
+        :param size: The maximum number of recovery points to return. The value must
+            be between 1 and 1000.
+        """
+        __path_parts: t.Dict[str, str] = {}
+        __path = "/_data_recovery/points"
+        __query: t.Dict[str, t.Any] = {}
+        if end_time_before is not None:
+            __query["end_time_before"] = end_time_before
+        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 master_timeout is not None:
+            __query["master_timeout"] = master_timeout
+        if pretty is not None:
+            __query["pretty"] = pretty
+        if size is not None:
+            __query["size"] = size
+        __headers = {"accept": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "GET",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="data_recovery.get_recovery_points",
+            path_parts=__path_parts,
+        )

elasticsearch/_async/client/inference.py

@@ -506,6 +506,90 @@ async def inference(
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters(
+        body_name="chat_completion_request",
+    )
+    async def non_streaming_chat_completion(
+        self,
+        *,
+        inference_id: str,
+        chat_completion_request: t.Optional[t.Mapping[str, t.Any]] = None,
+        body: t.Optional[t.Mapping[str, t.Any]] = None,
+        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,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Perform non-streaming chat completion inference on the service.</p>
+          <p>The chat completion inference API enables rich responses for chat completion tasks.
+          It only works with the <code>chat_completion</code> task type.</p>
+          <p>NOTE: The <code>chat_completion</code> task type supports both streaming and non-streaming.
+          The Chat completion inference API provides more comprehensive customization options through more fields and function calling support.
+          To determine whether a given inference service supports this task type, please see the page for that service.</p>
+          <p>These services support non-streaming chat completion inference:</p>
+          <ul>
+          <li>AI21</li>
+          <li>Azure OpenAI</li>
+          <li>Deepseek</li>
+          <li>Elastic</li>
+          <li>FireworksAI</li>
+          <li>Groq</li>
+          <li>Huggingface</li>
+          <li>IBMWatsonX</li>
+          <li>Llama</li>
+          <li>Mistral</li>
+          <li>NVIDIA</li>
+          <li>OpenAI</li>
+          <li>OpenShiftAI</li>
+          </ul>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-non-streaming-chat-completion>`_
+
+        :param inference_id: The inference Id
+        :param chat_completion_request:
+        :param timeout: Specifies the amount of time to wait for the inference request
+            to complete.
+        """
+        if inference_id in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'inference_id'")
+        if chat_completion_request is None and body is None:
+            raise ValueError(
+                "Empty value passed for parameters 'chat_completion_request' and 'body', one of them should be set."
+            )
+        elif chat_completion_request is not None and body is not None:
+            raise ValueError("Cannot set both 'chat_completion_request' and 'body'")
+        __path_parts: t.Dict[str, str] = {"inference_id": _quote(inference_id)}
+        __path = f'/_inference/chat_completion/{__path_parts["inference_id"]}'
+        __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
+        if timeout is not None:
+            __query["timeout"] = timeout
+        __body = (
+            chat_completion_request if chat_completion_request is not None else body
+        )
+        __headers = {"accept": "application/json", "content-type": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "POST",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="inference.non_streaming_chat_completion",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         body_name="inference_config",
     )
@@ -3186,13 +3270,17 @@ async def rerank(
             example: ``` "input": { "type": "image", "format": "base64", "value": "data:image/jpeg;base64,..."
             } ``` object array example: ``` "input": [ { "type": "text", "format": "text",
             "value": "some document text" }, { "type": "image", "format": "base64", "value":
-            "data:image/jpeg;base64,..." } ] ```
+            "data:image/jpeg;base64,..." } ] ``` object array example using the `url`
+            format (available in Elasticsearch 9.6.0 and later): ``` "input": [ { "type":
+            "image", "format": "url", "value": "https://example.com/image.jpg" } ] ```
         :param query: Query input. The query can be specified as a single string, or
             as an object. The object form additionally allows specifying non-text inputs,
             such as images. > info > Only the `elastic` service currently supports non-text
             queries for the `rerank` task. For all other services, the query must be
             a string. string example: ``` "query": "some query text" ``` object example:
             ``` "query": { "type": "image", "format": "base64", "value": "data:image/jpeg;base64,..."
+            } ``` object example using the `url` format (available in Elasticsearch 9.6.0
+            and later): ``` "query": { "type": "image", "format": "url", "value": "https://example.com/image.jpg"
             } ```
         :param return_documents: Include the document text in the response.
         :param task_settings: Task settings for the individual inference request. These

elasticsearch/_async/client/ml.py

@@ -3468,6 +3468,7 @@ async def put_data_frame_analytics(
             "indices",
             "indices_options",
             "job_id",
+            "max_consecutive_extraction_failures",
             "max_empty_searches",
             "project_routing",
             "query",
@@ -3506,6 +3507,7 @@ async def put_datafeed(
         indices: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         indices_options: t.Optional[t.Mapping[str, t.Any]] = None,
         job_id: t.Optional[str] = None,
+        max_consecutive_extraction_failures: t.Optional[int] = None,
         max_empty_searches: t.Optional[int] = None,
         pretty: t.Optional[bool] = None,
         project_routing: t.Optional[str] = None,
@@ -3586,6 +3588,13 @@ async def put_datafeed(
         :param indices_options: Specifies index expansion options that are used during
             search
         :param job_id: Identifier for the anomaly detection job.
+        :param max_consecutive_extraction_failures: The maximum number of consecutive
+            real-time data extraction failures the datafeed tolerates before it automatically
+            stops itself, leaving the associated job open. The consecutive-failure counter
+            resets on any cycle that extracts successfully, including empty-data cycles.
+            If not set, the threshold defaults to roughly one day's worth of searches
+            based on the datafeed `frequency` (floored at 1). Set to `-1` to disable
+            auto-stop and retry indefinitely. Values of `0` or less than `-1` are rejected.
         :param max_empty_searches: If a real-time datafeed has never seen any data (including
             during any initial training period), it automatically stops and closes the
             associated job after this many real-time searches return no documents. In
@@ -3656,6 +3665,10 @@ async def put_datafeed(
                 __body["indices_options"] = indices_options
             if job_id is not None:
                 __body["job_id"] = job_id
+            if max_consecutive_extraction_failures is not None:
+                __body["max_consecutive_extraction_failures"] = (
+                    max_consecutive_extraction_failures
+                )
             if max_empty_searches is not None:
                 __body["max_empty_searches"] = max_empty_searches
             if project_routing is not None:
@@ -5069,6 +5082,7 @@ async def update_data_frame_analytics(
             "indices",
             "indices_options",
             "job_id",
+            "max_consecutive_extraction_failures",
             "max_empty_searches",
             "project_routing",
             "query",
@@ -5106,6 +5120,7 @@ async def update_datafeed(
         indices: t.Optional[t.Sequence[str]] = None,
         indices_options: t.Optional[t.Mapping[str, t.Any]] = None,
         job_id: t.Optional[str] = None,
+        max_consecutive_extraction_failures: t.Optional[int] = None,
         max_empty_searches: t.Optional[int] = None,
         pretty: t.Optional[bool] = None,
         project_routing: t.Optional[str] = None,
@@ -5183,6 +5198,13 @@ async def update_datafeed(
         :param indices_options: Specifies index expansion options that are used during
             search.
         :param job_id:
+        :param max_consecutive_extraction_failures: The maximum number of consecutive
+            real-time data extraction failures the datafeed tolerates before it automatically
+            stops itself, leaving the associated job open. The consecutive-failure counter
+            resets on any cycle that extracts successfully, including empty-data cycles.
+            If not set, the threshold defaults to roughly one day's worth of searches
+            based on the datafeed `frequency` (floored at 1). Set to `-1` to disable
+            auto-stop and retry indefinitely. Values of `0` or less than `-1` are rejected.
         :param max_empty_searches: If a real-time datafeed has never seen any data (including
             during any initial training period), it automatically stops and closes the
             associated job after this many real-time searches return no documents. In
@@ -5257,6 +5279,10 @@ async def update_datafeed(
                 __body["indices_options"] = indices_options
             if job_id is not None:
                 __body["job_id"] = job_id
+            if max_consecutive_extraction_failures is not None:
+                __body["max_consecutive_extraction_failures"] = (
+                    max_consecutive_extraction_failures
+                )
             if max_empty_searches is not None:
                 __body["max_empty_searches"] = max_empty_searches
             if project_routing is not None: