Update APIs to 8.3.0-SNAPSHOT

Author: miriam-eid

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/master/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/ml.py

@@ -3620,10 +3620,10 @@ async def start_trained_model_deployment(
             t.Union[str, t.Union[t.List[str], t.Tuple[str, ...]]]
         ] = None,
         human: t.Optional[bool] = None,
-        inference_threads: t.Optional[int] = None,
-        model_threads: t.Optional[int] = None,
+        number_of_allocations: t.Optional[int] = None,
         pretty: t.Optional[bool] = None,
         queue_capacity: t.Optional[int] = None,
+        threads_per_allocation: t.Optional[int] = None,
         timeout: t.Optional[t.Union[int, str]] = None,
         wait_for: t.Optional[
             t.Union["t.Literal['fully_allocated', 'started', 'starting']", str]
@@ -3636,16 +3636,22 @@ async def start_trained_model_deployment(
 
         :param model_id: The unique identifier of the trained model. Currently, only
             PyTorch models are supported.
-        :param inference_threads: Specifies the number of threads that are used by the
-            inference process. If you increase this value, inference speed generally
-            increases. However, the actual number of threads is limited by the number
-            of available CPU cores.
-        :param model_threads: Specifies the number of threads that are used when sending
-            inference requests to the model. If you increase this value, throughput generally
-            increases.
+        :param number_of_allocations: The number of model allocations on each node where
+            the model is deployed. All allocations on a node share the same copy of the
+            model in memory but use a separate set of threads to evaluate the model.
+            Increasing this value generally increases the throughput. If this setting
+            is greater than the number of hardware threads it will automatically be changed
+            to a value less than the number of hardware threads.
         :param queue_capacity: Specifies the number of inference requests that are allowed
             in the queue. After the number of requests exceeds this value, new requests
             are rejected with a 429 error.
+        :param threads_per_allocation: Sets the number of threads used by each model
+            allocation during inference. This generally increases the inference speed.
+            The inference process is a compute-bound process; any number greater than
+            the number of available hardware threads on the machine does not increase
+            the inference speed. If this setting is greater than the number of hardware
+            threads it will automatically be changed to a value less than the number
+            of hardware threads.
         :param timeout: Specifies the amount of time to wait for the model to deploy.
         :param wait_for: Specifies the allocation status to wait for before returning.
         """
@@ -3659,14 +3665,14 @@ async def start_trained_model_deployment(
             __query["filter_path"] = filter_path
         if human is not None:
             __query["human"] = human
-        if inference_threads is not None:
-            __query["inference_threads"] = inference_threads
-        if model_threads is not None:
-            __query["model_threads"] = model_threads
+        if number_of_allocations is not None:
+            __query["number_of_allocations"] = number_of_allocations
         if pretty is not None:
             __query["pretty"] = pretty
         if queue_capacity is not None:
             __query["queue_capacity"] = queue_capacity
+        if threads_per_allocation is not None:
+            __query["threads_per_allocation"] = threads_per_allocation
         if timeout is not None:
             __query["timeout"] = timeout
         if wait_for is not None:

elasticsearch/_async/client/security.py

@@ -1508,7 +1508,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
         )