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

elasticsearch/_async/client/cluster.py

@@ -302,8 +302,8 @@ class ClusterClient(NamespacedClient):
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-put-component-template>`_
 
-        :param name: Comma-separated list of component template names used to limit the
-            request. Wildcard (`*`) expressions are supported.
+        :param name: Name of component template to retrieve. Wildcard (`*`) expressions
+            are supported.
         :param flat_settings: If `true`, returns settings in flat format.
         :param include_defaults: Return all default configurations for the component
             template
@@ -470,39 +470,38 @@ class ClusterClient(NamespacedClient):
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-cluster-health>`_
 
-        :param index: Comma-separated list of data streams, indices, and index aliases
-            used to limit the request. Wildcard expressions (`*`) are supported. To target
+        :param index: A comma-separated list of data streams, indices, and index aliases
+            that limit the request. Wildcard expressions (`*`) are supported. To target
             all data streams and indices in a cluster, omit this parameter or use _all
             or `*`.
-        :param expand_wildcards: Whether to expand wildcard expression to concrete indices
-            that are open, closed or both.
-        :param level: Can be one of cluster, indices or shards. Controls the details
-            level of the health information returned.
-        :param local: If true, the request retrieves information from the local node
-            only. Defaults to false, which means information is retrieved from the master
-            node.
-        :param master_timeout: 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 timeout: Period to wait for a response. If no response is received before
-            the timeout expires, the request fails and returns an error.
-        :param wait_for_active_shards: A number controlling to how many active shards
-            to wait for, all to wait for all shards in the cluster to be active, or 0
-            to not wait.
-        :param wait_for_events: Can be one of immediate, urgent, high, normal, low, languid.
-            Wait until all currently queued events with the given priority are processed.
-        :param wait_for_no_initializing_shards: A boolean value which controls whether
-            to wait (until the timeout provided) for the cluster to have no shard initializations.
-            Defaults to false, which means it will not wait for initializing shards.
-        :param wait_for_no_relocating_shards: A boolean value which controls whether
-            to wait (until the timeout provided) for the cluster to have no shard relocations.
-            Defaults to false, which means it will not wait for relocating shards.
-        :param wait_for_nodes: The request waits until the specified number N of nodes
-            is available. It also accepts >=N, <=N, >N and <N. Alternatively, it is possible
-            to use ge(N), le(N), gt(N) and lt(N) notation.
-        :param wait_for_status: One of green, yellow or red. Will wait (until the timeout
-            provided) until the status of the cluster changes to the one provided or
-            better, i.e. green > yellow > red. By default, will not wait for any status.
+        :param expand_wildcards: Expand wildcard expression to concrete indices that
+            are open, closed or both.
+        :param level: Return health information at a specific level of detail.
+        :param local: If true, retrieve information from the local node only. If false,
+            retrieve information from the master node.
+        :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 timeout: The period to wait for a response. If no response is received
+            before the timeout expires, the request fails and returns an error.
+        :param wait_for_active_shards: Wait for the specified number of active shards.
+            Use `all` to wait for all shards in the cluster to be active. Use `0` to
+            not wait.
+        :param wait_for_events: Wait until all currently queued events with the given
+            priority are processed.
+        :param wait_for_no_initializing_shards: Wait (until the timeout expires) for
+            the cluster to have no shard initializations. If false, the request does
+            not wait for initializing shards.
+        :param wait_for_no_relocating_shards: Wait (until the timeout expires) for the
+            cluster to have no shard relocations. If false, the request not wait for
+            relocating shards.
+        :param wait_for_nodes: Wait until the specified number (N) of nodes is available.
+            It also accepts `>=N`, `<=N`, `>N` and `<N`. Alternatively, use the notations
+            `ge(N)`, `le(N)`, `gt(N)`, and `lt(N)`.
+        :param wait_for_status: Wait (until the timeout expires) for the cluster to reach
+            a specific health status (or a better status). A green status is better than
+            yellow and yellow is better than red. By default, the request does not wait
+            for a particular status.
         """
         __path_parts: t.Dict[str, str]
         if index not in SKIP_IN_PATH:
@@ -1068,7 +1067,40 @@ class ClusterClient(NamespacedClient):
     async def state(
         self,
         *,
-        metric: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        metric: t.Optional[
+            t.Union[
+                t.Sequence[
+                    t.Union[
+                        str,
+                        t.Literal[
+                            "_all",
+                            "blocks",
+                            "customs",
+                            "master_node",
+                            "metadata",
+                            "nodes",
+                            "routing_nodes",
+                            "routing_table",
+                            "version",
+                        ],
+                    ]
+                ],
+                t.Union[
+                    str,
+                    t.Literal[
+                        "_all",
+                        "blocks",
+                        "customs",
+                        "master_node",
+                        "metadata",
+                        "nodes",
+                        "routing_nodes",
+                        "routing_table",
+                        "version",
+                    ],
+                ],
+            ]
+        ] = None,
         index: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         allow_no_indices: t.Optional[bool] = None,
         error_trace: t.Optional[bool] = None,

elasticsearch/_async/client/eql.py

@@ -187,6 +187,7 @@ class EqlClient(NamespacedClient):
             "keep_alive",
             "keep_on_completion",
             "max_samples_per_key",
+            "project_routing",
             "result_position",
             "runtime_mappings",
             "size",
@@ -286,10 +287,10 @@ class EqlClient(NamespacedClient):
             `size` parameter to get a smaller or larger set of samples. To retrieve more
             than one sample per set of join keys, use the `max_samples_per_key` parameter.
             Pipes are not supported for sample queries.
-        :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 project_routing: Specifies a subset of projects to target 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 result_position:
         :param runtime_mappings:
         :param size: For basic queries, the maximum number of matching events to return.
@@ -323,8 +324,6 @@ class EqlClient(NamespacedClient):
             __query["ignore_unavailable"] = ignore_unavailable
         if pretty is not None:
             __query["pretty"] = pretty
-        if project_routing is not None:
-            __query["project_routing"] = project_routing
         if not __body:
             if query is not None:
                 __body["query"] = query
@@ -350,6 +349,8 @@ class EqlClient(NamespacedClient):
                 __body["keep_on_completion"] = keep_on_completion
             if max_samples_per_key is not None:
                 __body["max_samples_per_key"] = max_samples_per_key
+            if project_routing is not None:
+                __body["project_routing"] = project_routing
             if result_position is not None:
                 __body["result_position"] = result_position
             if runtime_mappings is not None:

elasticsearch/_async/client/esql.py

@@ -126,10 +126,10 @@ class EsqlClient(NamespacedClient):
             query, the response will include an extra `_clusters` object with information
             about the clusters that participated in the search along with info such as
             shards count.
-        :param include_execution_metadata: When set to `true` and performing a cross-cluster/cross-project
-            query, the response will include an extra `_clusters` object with information
-            about the clusters that participated in the search along with info such as
-            shards count.
+        :param include_execution_metadata: When set to `true`, the response will include
+            an extra `_clusters` object with information about the clusters that participated
+            in the search along with info such as shards count. This is similar to `include_ccs_metadata`,
+            but it also returns metadata when the query is not CCS/CPS
         :param keep_alive: The period for which the query and its results are stored
             in the cluster. The default period is five days. When this period expires,
             the query and its results are deleted, even if the query is still ongoing.
@@ -403,6 +403,51 @@ class EsqlClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters()
+    @_availability_warning(Stability.EXPERIMENTAL)
+    async def delete_view(
+        self,
+        *,
+        name: str,
+        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>Delete an ES|QL view.</p>
+          <p>Deletes a stored ES|QL view.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch#TODO>`_
+
+        :param name: The view name to remove.
+        """
+        if name in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'name'")
+        __path_parts: t.Dict[str, str] = {"name": _quote(name)}
+        __path = f'/_query/view/{__path_parts["name"]}'
+        __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]
+            "DELETE",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="esql.delete_view",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters()
     @_availability_warning(Stability.EXPERIMENTAL)
     async def get_query(
@@ -448,6 +493,54 @@ class EsqlClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters()
+    @_availability_warning(Stability.EXPERIMENTAL)
+    async def get_view(
+        self,
+        *,
+        name: t.Optional[str] = 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>Get an ES|QL view.</p>
+          <p>Returns a stored ES|QL view.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch#TODO>`_
+
+        :param name: The comma-separated view names to retrieve.
+        """
+        __path_parts: t.Dict[str, str]
+        if name not in SKIP_IN_PATH:
+            __path_parts = {"name": _quote(name)}
+            __path = f'/_query/view/{__path_parts["name"]}'
+        else:
+            __path_parts = {}
+            __path = "/_query/view"
+        __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="esql.get_view",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters()
     @_availability_warning(Stability.EXPERIMENTAL)
     async def list_queries(
@@ -488,6 +581,62 @@ class EsqlClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters(
+        body_fields=("query",),
+    )
+    @_availability_warning(Stability.EXPERIMENTAL)
+    async def put_view(
+        self,
+        *,
+        name: str,
+        query: t.Optional[t.Union[str, "ESQLBase"]] = 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 or update an ES|QL view.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch#TODO>`_
+
+        :param name: The view name to create or update.
+        :param query: The ES|QL query string from which to create a view.
+        """
+        if name in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'name'")
+        if query is None and body is None:
+            raise ValueError("Empty value passed for parameter 'query'")
+        __path_parts: t.Dict[str, str] = {"name": _quote(name)}
+        __path = f'/_query/view/{__path_parts["name"]}'
+        __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 query is not None:
+                __body["query"] = str(query)
+        __headers = {"accept": "application/json", "content-type": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            body=__body,
+            endpoint_id="esql.put_view",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         body_fields=(
             "query",
@@ -575,10 +724,10 @@ class EsqlClient(NamespacedClient):
             query, the response will include an extra `_clusters` object with information
             about the clusters that participated in the search along with info such as
             shards count.
-        :param include_execution_metadata: When set to `true` and performing a cross-cluster/cross-project
-            query, the response will include an extra `_clusters` object with information
-            about the clusters that participated in the search along with info such as
-            shards count.
+        :param include_execution_metadata: When set to `true`, the response will include
+            an extra `_clusters` object with information about the clusters that participated
+            in the search along with info such as shards count. This is similar to `include_ccs_metadata`,
+            but it also returns metadata when the query is not CCS/CPS
         :param locale:
         :param params: To avoid any attempts of hacking or code injection, extract the
             values in a separate list of parameters. Use question mark placeholders (?)

elasticsearch/_async/client/fleet.py

@@ -345,7 +345,7 @@ class FleetClient(NamespacedClient):
             t.Union[t.Mapping[str, t.Any], t.Sequence[t.Mapping[str, t.Any]]]
         ] = None,
         rest_total_hits_as_int: t.Optional[bool] = None,
-        routing: t.Optional[str] = None,
+        routing: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         runtime_mappings: t.Optional[t.Mapping[str, t.Mapping[str, t.Any]]] = None,
         script_fields: t.Optional[t.Mapping[str, t.Mapping[str, t.Any]]] = None,
         scroll: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,

elasticsearch/_async/client/graph.py

@@ -39,7 +39,7 @@ class GraphClient(NamespacedClient):
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
         query: t.Optional[t.Mapping[str, t.Any]] = None,
-        routing: t.Optional[str] = None,
+        routing: t.Optional[t.Union[str, t.Sequence[str]]] = None,
         timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         vertices: t.Optional[t.Sequence[t.Mapping[str, t.Any]]] = None,
         body: t.Optional[t.Dict[str, t.Any]] = None,