elasticsearch9 9.0.0__py3-none-any.whl

elasticsearch9/_async/client/dangling_indices.py

@@ -0,0 +1,192 @@
+#  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.
+
+import typing as t
+
+from elastic_transport import ObjectApiResponse
+
+from ._base import NamespacedClient
+from .utils import SKIP_IN_PATH, _quote, _rewrite_parameters
+
+
+class DanglingIndicesClient(NamespacedClient):
+
+    @_rewrite_parameters()
+    async def delete_dangling_index(
+        self,
+        *,
+        index_uuid: str,
+        accept_data_loss: bool,
+        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,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Delete a dangling index.
+          If Elasticsearch encounters index data that is absent from the current cluster state, those indices are considered to be dangling.
+          For example, this can happen if you delete more than <code>cluster.indices.tombstones.size</code> indices while an Elasticsearch node is offline.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-dangling-indices-delete-dangling-index>`_
+
+        :param index_uuid: The UUID of the index to delete. Use the get dangling indices
+            API to find the UUID.
+        :param accept_data_loss: This parameter must be set to true to acknowledge that
+            it will no longer be possible to recove data from the dangling index.
+        :param master_timeout: Specify timeout for connection to master
+        :param timeout: Explicit operation timeout
+        """
+        if index_uuid in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'index_uuid'")
+        if accept_data_loss is None:
+            raise ValueError("Empty value passed for parameter 'accept_data_loss'")
+        __path_parts: t.Dict[str, str] = {"index_uuid": _quote(index_uuid)}
+        __path = f'/_dangling/{__path_parts["index_uuid"]}'
+        __query: t.Dict[str, t.Any] = {}
+        if accept_data_loss is not None:
+            __query["accept_data_loss"] = accept_data_loss
+        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 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,
+            endpoint_id="dangling_indices.delete_dangling_index",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters()
+    async def import_dangling_index(
+        self,
+        *,
+        index_uuid: str,
+        accept_data_loss: bool,
+        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,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Import a dangling index.</p>
+          <p>If Elasticsearch encounters index data that is absent from the current cluster state, those indices are considered to be dangling.
+          For example, this can happen if you delete more than <code>cluster.indices.tombstones.size</code> indices while an Elasticsearch node is offline.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-dangling-indices-import-dangling-index>`_
+
+        :param index_uuid: The UUID of the index to import. Use the get dangling indices
+            API to locate the UUID.
+        :param accept_data_loss: This parameter must be set to true to import a dangling
+            index. Because Elasticsearch cannot know where the dangling index data came
+            from or determine which shard copies are fresh and which are stale, it cannot
+            guarantee that the imported data represents the latest state of the index
+            when it was last in the cluster.
+        :param master_timeout: Specify timeout for connection to master
+        :param timeout: Explicit operation timeout
+        """
+        if index_uuid in SKIP_IN_PATH:
+            raise ValueError("Empty value passed for parameter 'index_uuid'")
+        if accept_data_loss is None:
+            raise ValueError("Empty value passed for parameter 'accept_data_loss'")
+        __path_parts: t.Dict[str, str] = {"index_uuid": _quote(index_uuid)}
+        __path = f'/_dangling/{__path_parts["index_uuid"]}'
+        __query: t.Dict[str, t.Any] = {}
+        if accept_data_loss is not None:
+            __query["accept_data_loss"] = accept_data_loss
+        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 timeout is not None:
+            __query["timeout"] = timeout
+        __headers = {"accept": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "POST",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="dangling_indices.import_dangling_index",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters()
+    async def list_dangling_indices(
+        self,
+        *,
+        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 the dangling indices.</p>
+          <p>If Elasticsearch encounters index data that is absent from the current cluster state, those indices are considered to be dangling.
+          For example, this can happen if you delete more than <code>cluster.indices.tombstones.size</code> indices while an Elasticsearch node is offline.</p>
+          <p>Use this API to list dangling indices, which you can then import or delete.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-dangling-indices-list-dangling-indices>`_
+        """
+        __path_parts: t.Dict[str, str] = {}
+        __path = "/_dangling"
+        __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="dangling_indices.list_dangling_indices",
+            path_parts=__path_parts,
+        )

elasticsearch9/_async/client/enrich.py

@@ -0,0 +1,291 @@
+#  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.
+
+import typing as t
+
+from elastic_transport import ObjectApiResponse
+
+from ._base import NamespacedClient
+from .utils import SKIP_IN_PATH, _quote, _rewrite_parameters
+
+
+class EnrichClient(NamespacedClient):
+
+    @_rewrite_parameters()
+    async def delete_policy(
+        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,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+        pretty: t.Optional[bool] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Delete an enrich policy.
+          Deletes an existing enrich policy and its enrich index.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-delete-policy>`_
+
+        :param name: Enrich policy to delete.
+        :param master_timeout: Period to wait for a connection to the master node.
+        """
+        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'/_enrich/policy/{__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 master_timeout is not None:
+            __query["master_timeout"] = master_timeout
+        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="enrich.delete_policy",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters()
+    async def execute_policy(
+        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,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+        pretty: t.Optional[bool] = None,
+        wait_for_completion: t.Optional[bool] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Run an enrich policy.
+          Create the enrich index for an existing enrich policy.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-execute-policy>`_
+
+        :param name: Enrich policy to execute.
+        :param master_timeout: Period to wait for a connection to the master node.
+        :param wait_for_completion: If `true`, the request blocks other enrich policy
+            execution requests until complete.
+        """
+        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'/_enrich/policy/{__path_parts["name"]}/_execute'
+        __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 master_timeout is not None:
+            __query["master_timeout"] = master_timeout
+        if pretty is not None:
+            __query["pretty"] = pretty
+        if wait_for_completion is not None:
+            __query["wait_for_completion"] = wait_for_completion
+        __headers = {"accept": "application/json"}
+        return await self.perform_request(  # type: ignore[return-value]
+            "PUT",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="enrich.execute_policy",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters()
+    async def get_policy(
+        self,
+        *,
+        name: t.Optional[t.Union[str, t.Sequence[str]]] = 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,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Get an enrich policy.
+          Returns information about an enrich policy.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-get-policy>`_
+
+        :param name: Comma-separated list of enrich policy names used to limit the request.
+            To return information for all enrich policies, omit this parameter.
+        :param master_timeout: Period to wait for a connection to the master node.
+        """
+        __path_parts: t.Dict[str, str]
+        if name not in SKIP_IN_PATH:
+            __path_parts = {"name": _quote(name)}
+            __path = f'/_enrich/policy/{__path_parts["name"]}'
+        else:
+            __path_parts = {}
+            __path = "/_enrich/policy"
+        __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 master_timeout is not None:
+            __query["master_timeout"] = master_timeout
+        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="enrich.get_policy",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters(
+        body_fields=("geo_match", "match", "range"),
+    )
+    async def put_policy(
+        self,
+        *,
+        name: str,
+        error_trace: t.Optional[bool] = None,
+        filter_path: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        geo_match: t.Optional[t.Mapping[str, t.Any]] = None,
+        human: t.Optional[bool] = None,
+        master_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+        match: t.Optional[t.Mapping[str, t.Any]] = None,
+        pretty: t.Optional[bool] = None,
+        range: t.Optional[t.Mapping[str, t.Any]] = None,
+        body: t.Optional[t.Dict[str, t.Any]] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Create an enrich policy.
+          Creates an enrich policy.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-put-policy>`_
+
+        :param name: Name of the enrich policy to create or update.
+        :param geo_match: Matches enrich data to incoming documents based on a `geo_shape`
+            query.
+        :param master_timeout: Period to wait for a connection to the master node.
+        :param match: Matches enrich data to incoming documents based on a `term` query.
+        :param range: Matches a number, date, or IP address in incoming documents to
+            a range in the enrich index based on a `term` query.
+        """
+        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'/_enrich/policy/{__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 master_timeout is not None:
+            __query["master_timeout"] = master_timeout
+        if pretty is not None:
+            __query["pretty"] = pretty
+        if not __body:
+            if geo_match is not None:
+                __body["geo_match"] = geo_match
+            if match is not None:
+                __body["match"] = match
+            if range is not None:
+                __body["range"] = range
+        __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="enrich.put_policy",
+            path_parts=__path_parts,
+        )
+
+    @_rewrite_parameters()
+    async def stats(
+        self,
+        *,
+        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,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Get enrich stats.
+          Returns enrich coordinator statistics and information about enrich policies that are currently executing.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-enrich-stats>`_
+
+        :param master_timeout: Period to wait for a connection to the master node.
+        """
+        __path_parts: t.Dict[str, str] = {}
+        __path = "/_enrich/_stats"
+        __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 master_timeout is not None:
+            __query["master_timeout"] = master_timeout
+        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="enrich.stats",
+            path_parts=__path_parts,
+        )