Update API to 8.2

Author: miriam-eid

elasticsearch/_async/client/__init__.py

@@ -1149,7 +1149,7 @@ async def delete_by_query(
             t.Union["t.Literal['dfs_query_then_fetch', 'query_then_fetch']", str]
         ] = None,
         slice: t.Optional[t.Mapping[str, t.Any]] = None,
-        slices: t.Optional[int] = None,
+        slices: t.Optional[t.Union[int, t.Union["t.Literal['auto']", str]]] = None,
         sort: t.Optional[t.Union[t.List[str], t.Tuple[str, ...]]] = None,
         stats: t.Optional[t.Union[t.List[str], t.Tuple[str, ...]]] = None,
         terminate_after: t.Optional[int] = None,
@@ -2529,6 +2529,7 @@ async def msearch(
         pre_filter_shard_size: t.Optional[int] = None,
         pretty: t.Optional[bool] = None,
         rest_total_hits_as_int: t.Optional[bool] = None,
+        routing: t.Optional[str] = None,
         search_type: t.Optional[
             t.Union["t.Literal['dfs_query_then_fetch', 'query_then_fetch']", str]
         ] = None,
@@ -2568,6 +2569,8 @@ async def msearch(
             filters are mandatory to match but the shard bounds and the query are disjoint.
         :param rest_total_hits_as_int: If true, hits.total are returned as an integer
             in the response. Defaults to false, which returns an object.
+        :param routing: Custom routing value used to route search operations to a specific
+            shard.
         :param search_type: Indicates whether global term and document frequencies should
             be used when scoring returned documents.
         :param typed_keys: Specifies whether aggregation and suggester names should be
@@ -2606,6 +2609,8 @@ async def msearch(
             __query["pretty"] = pretty
         if rest_total_hits_as_int is not None:
             __query["rest_total_hits_as_int"] = rest_total_hits_as_int
+        if routing is not None:
+            __query["routing"] = routing
         if search_type is not None:
             __query["search_type"] = search_type
         if typed_keys is not None:
@@ -3036,7 +3041,7 @@ async def reindex(
         script: t.Optional[t.Mapping[str, t.Any]] = None,
         scroll: t.Optional[t.Union[int, str]] = None,
         size: t.Optional[int] = None,
-        slices: t.Optional[int] = None,
+        slices: t.Optional[t.Union[int, t.Union["t.Literal['auto']", str]]] = None,
         timeout: t.Optional[t.Union[int, str]] = None,
         wait_for_active_shards: t.Optional[
             t.Union[int, t.Union["t.Literal['all', 'index-setting']", str]]
@@ -4530,7 +4535,7 @@ async def update_by_query(
             t.Union["t.Literal['dfs_query_then_fetch', 'query_then_fetch']", str]
         ] = None,
         slice: t.Optional[t.Mapping[str, t.Any]] = None,
-        slices: t.Optional[int] = None,
+        slices: t.Optional[t.Union[int, t.Union["t.Literal['auto']", str]]] = None,
         sort: t.Optional[t.Union[t.List[str], t.Tuple[str, ...]]] = None,
         stats: t.Optional[t.Union[t.List[str], t.Tuple[str, ...]]] = None,
         terminate_after: t.Optional[int] = None,

elasticsearch/_async/client/cat.py

@@ -201,6 +201,78 @@ async def allocation(
             "GET", __path, params=__query, headers=__headers
         )
 
+    @_rewrite_parameters()
+    async def component_templates(
+        self,
+        *,
+        name: t.Optional[str] = None,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[
+            t.Union[str, t.Union[t.List[str], t.Tuple[str, ...]]]
+        ] = None,
+        format: t.Optional[str] = None,
+        h: t.Optional[t.Union[str, t.Union[t.List[str], t.Tuple[str, ...]]]] = None,
+        help: t.Optional[bool] = None,
+        human: t.Optional[bool] = None,
+        local: t.Optional[bool] = None,
+        master_timeout: t.Optional[t.Union[int, str]] = None,
+        pretty: t.Optional[bool] = None,
+        s: t.Optional[t.Union[str, t.Union[t.List[str], t.Tuple[str, ...]]]] = None,
+        v: t.Optional[bool] = None,
+    ) -> t.Union[ObjectApiResponse[t.Any], TextApiResponse]:
+        """
+        Returns information about existing component_templates templates.
+
+        `<https://www.elastic.co/guide/en/elasticsearch/reference/8.2/cat-compoentn-templates.html>`_
+
+        :param name: A pattern that returned component template names must match
+        :param format: Specifies the format to return the columnar data in, can be set
+            to `text`, `json`, `cbor`, `yaml`, or `smile`.
+        :param h: List of columns to appear in the response. Supports simple wildcards.
+        :param help: When set to `true` will output available columns. This option can't
+            be combined with any other query string option.
+        :param local: If `true`, the request computes the list of selected nodes from
+            the local cluster state. If `false` the list of selected nodes are computed
+            from the cluster state of the master node. In both cases the coordinating
+            node will send requests for further information to each selected node.
+        :param master_timeout: Period to wait for a connection to the master node.
+        :param s: List of columns that determine how the table should be sorted. Sorting
+            defaults to ascending and can be changed by setting `:asc` or `:desc` as
+            a suffix to the column name.
+        :param v: When set to `true` will enable verbose output.
+        """
+        if name not in SKIP_IN_PATH:
+            __path = f"/_cat/component_templates/{_quote(name)}"
+        else:
+            __path = "/_cat/component_templates"
+        __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 format is not None:
+            __query["format"] = format
+        if h is not None:
+            __query["h"] = h
+        if help is not None:
+            __query["help"] = help
+        if human is not None:
+            __query["human"] = human
+        if local is not None:
+            __query["local"] = local
+        if master_timeout is not None:
+            __query["master_timeout"] = master_timeout
+        if pretty is not None:
+            __query["pretty"] = pretty
+        if s is not None:
+            __query["s"] = s
+        if v is not None:
+            __query["v"] = v
+        __headers = {"accept": "text/plain,application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "GET", __path, params=__query, headers=__headers
+        )
+
     @_rewrite_parameters()
     async def count(
         self,

elasticsearch/_async/client/ingest.py

@@ -189,6 +189,7 @@ async def put_pipeline(
             t.Union[str, t.Union[t.List[str], t.Tuple[str, ...]]]
         ] = None,
         human: t.Optional[bool] = None,
+        if_version: t.Optional[int] = None,
         master_timeout: t.Optional[t.Union[int, str]] = None,
         meta: t.Optional[t.Mapping[str, t.Any]] = None,
         on_failure: t.Optional[
@@ -208,6 +209,8 @@ async def put_pipeline(
 
         :param id: ID of the ingest pipeline to create or update.
         :param description: Description of the ingest pipeline.
+        :param if_version: Required version for optimistic concurrency control for pipeline
+            updates
         :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.
@@ -240,6 +243,8 @@ async def put_pipeline(
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
+        if if_version is not None:
+            __query["if_version"] = if_version
         if master_timeout is not None:
             __query["master_timeout"] = master_timeout
         if meta is not None:

elasticsearch/_async/client/security.py

@@ -438,13 +438,16 @@ async def create_service_token(
         *,
         namespace: str,
         service: str,
-        name: str,
+        name: t.Optional[str] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[
             t.Union[str, t.Union[t.List[str], t.Tuple[str, ...]]]
         ] = None,
         human: t.Optional[bool] = None,
         pretty: t.Optional[bool] = None,
+        refresh: t.Optional[
+            t.Union["t.Literal['false', 'true', 'wait_for']", bool, str]
+        ] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         Creates a service account token for access without requiring basic authentication.
@@ -454,13 +457,14 @@ async def create_service_token(
         :param namespace: An identifier for the namespace
         :param service: An identifier for the service name
         :param name: An identifier for the token name
+        :param refresh: If `true` then refresh the affected shards to make this operation
+            visible to search, if `wait_for` (the default) then wait for a refresh to
+            make this operation visible to search, if `false` then do nothing with refreshes.
         """
         if namespace in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'namespace'")
         if service in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'service'")
-        if name in SKIP_IN_PATH:
-            raise ValueError("Empty value passed for parameter 'name'")
         if (
             namespace not in SKIP_IN_PATH
             and service not in SKIP_IN_PATH
@@ -482,6 +486,8 @@ async def create_service_token(
             __query["human"] = human
         if pretty is not None:
             __query["pretty"] = pretty
+        if refresh is not None:
+            __query["refresh"] = refresh
         __headers = {"accept": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             __method, __path, params=__query, headers=__headers
@@ -1508,7 +1514,7 @@ async def grant_api_key(
     async def has_privileges(
         self,
         *,
-        user: t.Optional[t.Union[None, str]] = None,
+        user: t.Optional[str] = None,
         application: t.Optional[
             t.Union[t.List[t.Mapping[str, t.Any]], t.Tuple[t.Mapping[str, t.Any], ...]]
         ] = None,

elasticsearch/_async/client/shutdown.py

@@ -34,7 +34,13 @@ async def delete_node(
             t.Union[str, t.Union[t.List[str], t.Tuple[str, ...]]]
         ] = None,
         human: t.Optional[bool] = None,
+        master_timeout: t.Optional[
+            t.Union["t.Literal['d', 'h', 'm', 'micros', 'ms', 'nanos', 's']", str]
+        ] = None,
         pretty: t.Optional[bool] = None,
+        timeout: t.Optional[
+            t.Union["t.Literal['d', 'h', 'm', 'micros', 'ms', 'nanos', 's']", str]
+        ] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         Removes a node from the shutdown list. Designed for indirect use by ECE/ESS and
@@ -43,6 +49,11 @@ async def delete_node(
         `<https://www.elastic.co/guide/en/elasticsearch/reference/current>`_
 
         :param node_id: The node id of node to be removed from the shutdown state
+        :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.
         """
         if node_id in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'node_id'")
@@ -54,8 +65,12 @@ async def delete_node(
             __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 timeout is not None:
+            __query["timeout"] = timeout
         __headers = {"accept": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             "DELETE", __path, params=__query, headers=__headers
@@ -73,7 +88,13 @@ async def get_node(
             t.Union[str, t.Union[t.List[str], t.Tuple[str, ...]]]
         ] = None,
         human: t.Optional[bool] = None,
+        master_timeout: t.Optional[
+            t.Union["t.Literal['d', 'h', 'm', 'micros', 'ms', 'nanos', 's']", str]
+        ] = None,
         pretty: t.Optional[bool] = None,
+        timeout: t.Optional[
+            t.Union["t.Literal['d', 'h', 'm', 'micros', 'ms', 'nanos', 's']", str]
+        ] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         Retrieve status of a node or nodes that are currently marked as shutting down.
@@ -82,6 +103,11 @@ async def get_node(
         `<https://www.elastic.co/guide/en/elasticsearch/reference/current>`_
 
         :param node_id: Which node for which to retrieve the shutdown status
+        :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.
         """
         if node_id not in SKIP_IN_PATH:
             __path = f"/_nodes/{_quote(node_id)}/shutdown"
@@ -94,24 +120,40 @@ async def get_node(
             __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 timeout is not None:
+            __query["timeout"] = timeout
         __headers = {"accept": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             "GET", __path, params=__query, headers=__headers
         )
 
-    @_rewrite_parameters()
+    @_rewrite_parameters(
+        body_fields=True,
+    )
     async def put_node(
         self,
         *,
         node_id: str,
+        reason: str,
+        type: t.Union["t.Literal['remove', 'replace', 'restart']", str],
+        allocation_delay: t.Optional[str] = None,
         error_trace: t.Optional[bool] = None,
         filter_path: t.Optional[
             t.Union[str, t.Union[t.List[str], t.Tuple[str, ...]]]
         ] = None,
         human: t.Optional[bool] = None,
+        master_timeout: t.Optional[
+            t.Union["t.Literal['d', 'h', 'm', 'micros', 'ms', 'nanos', 's']", str]
+        ] = None,
         pretty: t.Optional[bool] = None,
+        target_node_name: t.Optional[str] = None,
+        timeout: t.Optional[
+            t.Union["t.Literal['d', 'h', 'm', 'micros', 'ms', 'nanos', 's']", str]
+        ] = None,
     ) -> ObjectApiResponse[t.Any]:
         """
         Adds a node to be shut down. Designed for indirect use by ECE/ESS and ECK. Direct
@@ -120,20 +162,68 @@ async def put_node(
         `<https://www.elastic.co/guide/en/elasticsearch/reference/current>`_
 
         :param node_id: The node id of node to be shut down
+        :param reason: A human-readable reason that the node is being shut down. This
+            field provides information for other cluster operators; it does not affect
+            the shut down process.
+        :param type: Valid values are restart, remove, or replace. Use restart when you
+            need to temporarily shut down a node to perform an upgrade, make configuration
+            changes, or perform other maintenance. Because the node is expected to rejoin
+            the cluster, data is not migrated off of the node. Use remove when you need
+            to permanently remove a node from the cluster. The node is not marked ready
+            for shutdown until data is migrated off of the node Use replace to do a 1:1
+            replacement of a node with another node. Certain allocation decisions will
+            be ignored (such as disk watermarks) in the interest of true replacement
+            of the source node with the target node. During a replace-type shutdown,
+            rollover and index creation may result in unassigned shards, and shrink may
+            fail until the replacement is complete.
+        :param allocation_delay: Only valid if type is restart. Controls how long Elasticsearch
+            will wait for the node to restart and join the cluster before reassigning
+            its shards to other nodes. This works the same as delaying allocation with
+            the index.unassigned.node_left.delayed_timeout setting. If you specify both
+            a restart allocation delay and an index-level allocation delay, the longer
+            of the two is used.
+        :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 target_node_name: Only valid if type is replace. Specifies the name of
+            the node that is replacing the node being shut down. Shards from the shut
+            down node are only allowed to be allocated to the target node, and no other
+            data will be allocated to the target node. During relocation of data certain
+            allocation rules are ignored, such as disk watermarks or user attribute filtering
+            rules.
+        :param timeout: Period to wait for a response. If no response is received before
+            the timeout expires, the request fails and returns an error.
         """
         if node_id in SKIP_IN_PATH:
             raise ValueError("Empty value passed for parameter 'node_id'")
+        if reason is None:
+            raise ValueError("Empty value passed for parameter 'reason'")
+        if type is None:
+            raise ValueError("Empty value passed for parameter 'type'")
         __path = f"/_nodes/{_quote(node_id)}/shutdown"
+        __body: t.Dict[str, t.Any] = {}
         __query: t.Dict[str, t.Any] = {}
+        if reason is not None:
+            __body["reason"] = reason
+        if type is not None:
+            __body["type"] = type
+        if allocation_delay is not None:
+            __body["allocation_delay"] = allocation_delay
         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
-        __headers = {"accept": "application/json"}
+        if target_node_name is not None:
+            __body["target_node_name"] = target_node_name
+        if timeout is not None:
+            __query["timeout"] = timeout
+        __headers = {"accept": "application/json", "content-type": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
-            "PUT", __path, params=__query, headers=__headers
+            "PUT", __path, params=__query, headers=__headers, body=__body
         )