Merge branch 'main' into dont-wipe-xpack

Author: miguelgrinberg

docs/reference/esql-pandas.md

@@ -355,7 +355,7 @@ You can now analyze the data with Pandas or you can also continue transforming t
 
 ## Analyze the data with Pandas [analyze-data]
 
-In the next example, the [STATS …​ BY](elasticsearch://reference/query-languages/esql/esql-commands.md#esql-stats-by) command is utilized to count how many employees are speaking a given language. The results are sorted with the `languages` column using [SORT](elasticsearch://reference/query-languages/esql/esql-commands.md#esql-sort):
+In the next example, the [STATS …​ BY](elasticsearch://reference/query-languages/esql/commands/processing-commands.md#esql-stats-by) command is utilized to count how many employees are speaking a given language. The results are sorted with the `languages` column using [SORT](elasticsearch://reference/query-languages/esql/commands/processing-commands.md#esql-sort):
 
 ```python
 response = client.esql.query(

docs/reference/opentelemetry.md

@@ -5,7 +5,7 @@ mapped_pages:
 
 # Using OpenTelemetry [opentelemetry]
 
-You can use [OpenTelemetry](https://opentelemetry.io/) to monitor the performance and behavior of your {{es}} requests through the Elasticsearch Python client. The Python client comes with built-in OpenTelemetry instrumentation that emits [distributed tracing spans](docs-content://solutions/observability/apps/traces-2.md) by default. With that, applications using [manual OpenTelemetry instrumentation](https://www.elastic.co/blog/manual-instrumentation-of-python-applications-opentelemetry) or [automatic OpenTelemetry instrumentation](https://www.elastic.co/blog/auto-instrumentation-of-python-applications-opentelemetry) are enriched with additional spans that contain insightful information about the execution of the {{es}} requests.
+You can use [OpenTelemetry](https://opentelemetry.io/) to monitor the performance and behavior of your {{es}} requests through the Elasticsearch Python client. The Python client comes with built-in OpenTelemetry instrumentation that emits [distributed tracing spans](docs-content://solutions/observability/apm/traces-ui.md) by default. With that, applications using [manual OpenTelemetry instrumentation](https://www.elastic.co/blog/manual-instrumentation-of-python-applications-opentelemetry) or [automatic OpenTelemetry instrumentation](https://www.elastic.co/blog/auto-instrumentation-of-python-applications-opentelemetry) are enriched with additional spans that contain insightful information about the execution of the {{es}} requests.
 
 The native instrumentation in the Python client follows the [OpenTelemetry Semantic Conventions for {{es}}](https://opentelemetry.io/docs/specs/semconv/database/elasticsearch/). In particular, the instrumentation in the client covers the logical layer of {{es}} requests. A single span per request is created that is processed by the service through the Python client. The following image shows a trace that records the handling of two different {{es}} requests: an `info` request and a `search` request.
 

elasticsearch/_async/client/inference.py

@@ -20,13 +20,7 @@
 from elastic_transport import ObjectApiResponse
 
 from ._base import NamespacedClient
-from .utils import (
-    SKIP_IN_PATH,
-    Stability,
-    _quote,
-    _rewrite_parameters,
-    _stability_warning,
-)
+from .utils import SKIP_IN_PATH, _quote, _rewrite_parameters
 
 
 class InferenceClient(NamespacedClient):
@@ -240,178 +234,6 @@ async def get(
             path_parts=__path_parts,
         )
 
-    @_rewrite_parameters(
-        body_fields=("input", "query", "task_settings"),
-    )
-    @_stability_warning(
-        Stability.DEPRECATED,
-        version="8.18.0",
-        message="inference.inference() is deprecated in favor of provider-specific APIs such as inference.put_elasticsearch() or inference.put_hugging_face()",
-    )
-    async def inference(
-        self,
-        *,
-        inference_id: str,
-        input: t.Optional[t.Union[str, t.Sequence[str]]] = None,
-        task_type: t.Optional[
-            t.Union[
-                str,
-                t.Literal[
-                    "chat_completion",
-                    "completion",
-                    "rerank",
-                    "sparse_embedding",
-                    "text_embedding",
-                ],
-            ]
-        ] = 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,
-        query: t.Optional[str] = None,
-        task_settings: t.Optional[t.Any] = None,
-        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
-        body: t.Optional[t.Dict[str, t.Any]] = None,
-    ) -> ObjectApiResponse[t.Any]:
-        """
-        .. raw:: html
-
-          <p>Perform inference on the service.</p>
-          <p>This API enables you to use machine learning models to perform specific tasks on data that you provide as an input.
-          It returns a response with the results of the tasks.
-          The inference endpoint you use can perform one specific task that has been defined when the endpoint was created with the create inference API.</p>
-          <blockquote>
-          <p>info
-          The inference APIs enable you to use certain services, such as built-in machine learning models (ELSER, E5), models uploaded through Eland, Cohere, OpenAI, Azure, Google AI Studio, Google Vertex AI, Anthropic, Watsonx.ai, or Hugging Face. For built-in models and models uploaded through Eland, the inference APIs offer an alternative way to use and manage trained models. However, if you do not plan to use the inference APIs to use these models or if you want to use non-NLP models, use the machine learning trained model APIs.</p>
-          </blockquote>
-
-
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-inference>`_
-
-        :param inference_id: The unique identifier for the inference endpoint.
-        :param input: The text on which you want to perform the inference task. It can
-            be a single string or an array. > info > Inference endpoints for the `completion`
-            task type currently only support a single string as input.
-        :param task_type: The type of inference task that the model performs.
-        :param query: The query input, which is required only for the `rerank` task.
-            It is not required for other tasks.
-        :param task_settings: Task settings for the individual inference request. These
-            settings are specific to the task type you specified and override the task
-            settings specified when initializing the service.
-        :param timeout: 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 input is None and body is None:
-            raise ValueError("Empty value passed for parameter 'input'")
-        __path_parts: t.Dict[str, str]
-        if task_type not in SKIP_IN_PATH and inference_id not in SKIP_IN_PATH:
-            __path_parts = {
-                "task_type": _quote(task_type),
-                "inference_id": _quote(inference_id),
-            }
-            __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["inference_id"]}'
-        elif inference_id not in SKIP_IN_PATH:
-            __path_parts = {"inference_id": _quote(inference_id)}
-            __path = f'/_inference/{__path_parts["inference_id"]}'
-        else:
-            raise ValueError("Couldn't find a path for the given parameters")
-        __query: t.Dict[str, t.Any] = {}
-        __body: t.Dict[str, t.Any] = body if body is not None else {}
-        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
-        if not __body:
-            if input is not None:
-                __body["input"] = input
-            if query is not None:
-                __body["query"] = query
-            if task_settings is not None:
-                __body["task_settings"] = task_settings
-        if not __body:
-            __body = None  # type: ignore[assignment]
-        __headers = {"accept": "application/json"}
-        if __body is not None:
-            __headers["content-type"] = "application/json"
-        return await self.perform_request(  # type: ignore[return-value]
-            "POST",
-            __path,
-            params=__query,
-            headers=__headers,
-            body=__body,
-            endpoint_id="inference.inference",
-            path_parts=__path_parts,
-        )
-
-    @_rewrite_parameters(
-        body_name="chat_completion_request",
-    )
-    async def post_eis_chat_completion(
-        self,
-        *,
-        eis_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,
-    ) -> ObjectApiResponse[t.Any]:
-        """
-        .. raw:: html
-
-          <p>Perform a chat completion task through the Elastic Inference Service (EIS).</p>
-          <p>Perform a chat completion inference task with the <code>elastic</code> service.</p>
-
-
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-post-eis-chat-completion>`_
-
-        :param eis_inference_id: The unique identifier of the inference endpoint.
-        :param chat_completion_request:
-        """
-        if eis_inference_id in SKIP_IN_PATH:
-            raise ValueError("Empty value passed for parameter 'eis_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] = {"eis_inference_id": _quote(eis_inference_id)}
-        __path = (
-            f'/_inference/chat_completion/{__path_parts["eis_inference_id"]}/_stream'
-        )
-        __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
-        __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.post_eis_chat_completion",
-            path_parts=__path_parts,
-        )
-
     @_rewrite_parameters(
         body_name="inference_config",
     )
@@ -1088,83 +910,6 @@ async def put_cohere(
             path_parts=__path_parts,
         )
 
-    @_rewrite_parameters(
-        body_fields=("service", "service_settings"),
-    )
-    async def put_eis(
-        self,
-        *,
-        task_type: t.Union[str, t.Literal["chat_completion"]],
-        eis_inference_id: str,
-        service: t.Optional[t.Union[str, t.Literal["elastic"]]] = None,
-        service_settings: 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,
-        body: t.Optional[t.Dict[str, t.Any]] = None,
-    ) -> ObjectApiResponse[t.Any]:
-        """
-        .. raw:: html
-
-          <p>Create an Elastic Inference Service (EIS) inference endpoint.</p>
-          <p>Create an inference endpoint to perform an inference task through the Elastic Inference Service (EIS).</p>
-
-
-        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-inference-put-eis>`_
-
-        :param task_type: The type of the inference task that the model will perform.
-            NOTE: The `chat_completion` task type only supports streaming and only through
-            the _stream API.
-        :param eis_inference_id: The unique identifier of the inference endpoint.
-        :param service: The type of service supported for the specified task type. In
-            this case, `elastic`.
-        :param service_settings: Settings used to install the inference model. These
-            settings are specific to the `elastic` service.
-        """
-        if task_type in SKIP_IN_PATH:
-            raise ValueError("Empty value passed for parameter 'task_type'")
-        if eis_inference_id in SKIP_IN_PATH:
-            raise ValueError("Empty value passed for parameter 'eis_inference_id'")
-        if service is None and body is None:
-            raise ValueError("Empty value passed for parameter 'service'")
-        if service_settings is None and body is None:
-            raise ValueError("Empty value passed for parameter 'service_settings'")
-        __path_parts: t.Dict[str, str] = {
-            "task_type": _quote(task_type),
-            "eis_inference_id": _quote(eis_inference_id),
-        }
-        __path = f'/_inference/{__path_parts["task_type"]}/{__path_parts["eis_inference_id"]}'
-        __query: t.Dict[str, t.Any] = {}
-        __body: t.Dict[str, t.Any] = body if body is not None else {}
-        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 not __body:
-            if service is not None:
-                __body["service"] = service
-            if service_settings is not None:
-                __body["service_settings"] = service_settings
-        if not __body:
-            __body = None  # type: ignore[assignment]
-        __headers = {"accept": "application/json"}
-        if __body is not None:
-            __headers["content-type"] = "application/json"
-        return await self.perform_request(  # type: ignore[return-value]
-            "PUT",
-            __path,
-            params=__query,
-            headers=__headers,
-            body=__body,
-            endpoint_id="inference.put_eis",
-            path_parts=__path_parts,
-        )
-
     @_rewrite_parameters(
         body_fields=(
             "service",