elasticsearch9 9.1.1__py3-none-any.whl → 9.1.3__py3-none-any.whl

elasticsearch9/_async/client/transform.py

@@ -85,6 +85,45 @@ class TransformClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters()
+    async def get_node_stats(
+        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 node stats.</p>
+          <p>Get per-node information about transform usage.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-get-node-stats>`_
+        """
+        __path_parts: t.Dict[str, str] = {}
+        __path = "/_transform/_node_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 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="transform.get_node_stats",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         parameter_aliases={"from": "from_"},
     )
@@ -104,8 +143,8 @@ class TransformClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Get transforms.
-          Get configuration information for transforms.</p>
+          <p>Get transforms.</p>
+          <p>Get configuration information for transforms.</p>
 
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-get-transform>`_
@@ -262,8 +301,8 @@ class TransformClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Preview a transform.
-          Generates a preview of the results that you will get when you create a transform with the same configuration.</p>
+          <p>Preview a transform.</p>
+          <p>Generates a preview of the results that you will get when you create a transform with the same configuration.</p>
           <p>It returns a maximum of 100 results. The calculations are based on all the current data in the source index. It also
           generates a list of mappings and settings for the destination index. These values are determined based on the field
           types of the source index and the transform aggregations.</p>
@@ -386,8 +425,8 @@ class TransformClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Create a transform.
-          Creates a transform.</p>
+          <p>Create a transform.</p>
+          <p>Creates a transform.</p>
           <p>A transform copies data from source indices, transforms it, and persists it into an entity-centric destination index. You can also think of the destination index as a two-dimensional tabular data structure (known as
           a data frame). The ID for each document in the data frame is generated from a hash of the entity, so there is a
           unique row per entity.</p>
@@ -616,8 +655,8 @@ class TransformClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Set upgrade_mode for transform indices.
-          Sets a cluster wide upgrade_mode setting that prepares transform
+          <p>Set upgrade_mode for transform indices.</p>
+          <p>Sets a cluster wide upgrade_mode setting that prepares transform
           indices for an upgrade.
           When upgrading your cluster, in some circumstances you must restart your
           nodes and reindex your transform indices. In those circumstances,
@@ -749,8 +788,8 @@ class TransformClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Stop transforms.
-          Stops one or more transforms.</p>
+          <p>Stop transforms.</p>
+          <p>Stops one or more transforms.</p>
 
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-stop-transform>`_
@@ -846,8 +885,8 @@ class TransformClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Update a transform.
-          Updates certain properties of a transform.</p>
+          <p>Update a transform.</p>
+          <p>Updates certain properties of a transform.</p>
           <p>All updated properties except <code>description</code> do not take effect until after the transform starts the next checkpoint,
           thus there is data consistency in each checkpoint. To use this API, you must have <code>read</code> and <code>view_index_metadata</code>
           privileges for the source indices. You must also have <code>index</code> and <code>read</code> privileges for the destination index. When

elasticsearch9/_async/client/utils.py

@@ -21,11 +21,12 @@ from ..._sync.client.utils import (
     CLIENT_META_SERVICE,
     SKIP_IN_PATH,
     Stability,
+    Visibility,
+    _availability_warning,
     _base64_auth_header,
     _quote,
     _quote_query,
     _rewrite_parameters,
-    _stability_warning,
     client_node_configs,
     is_requests_http_auth,
     is_requests_node_class,
@@ -40,9 +41,10 @@ __all__ = [
     "_TYPE_HOSTS",
     "SKIP_IN_PATH",
     "Stability",
+    "Visibility",
     "client_node_configs",
     "_rewrite_parameters",
-    "_stability_warning",
+    "_availability_warning",
     "is_requests_http_auth",
     "is_requests_node_class",
 ]

elasticsearch9/_async/client/watcher.py

@@ -39,8 +39,8 @@ class WatcherClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Acknowledge a watch.
-          Acknowledging a watch enables you to manually throttle the execution of the watch's actions.</p>
+          <p>Acknowledge a watch.</p>
+          <p>Acknowledging a watch enables you to manually throttle the execution of the watch's actions.</p>
           <p>The acknowledgement state of an action is stored in the <code>status.actions.&lt;id&gt;.ack.state</code> structure.</p>
           <p>IMPORTANT: If the specified watch is currently being executed, this API will return an error
           The reason for this behavior is to prevent overwriting the watch status from a watch execution.</p>
@@ -101,8 +101,8 @@ class WatcherClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Activate a watch.
-          A watch can be either active or inactive.</p>
+          <p>Activate a watch.</p>
+          <p>A watch can be either active or inactive.</p>
 
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-activate-watch>`_
@@ -145,8 +145,8 @@ class WatcherClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Deactivate a watch.
-          A watch can be either active or inactive.</p>
+          <p>Deactivate a watch.</p>
+          <p>A watch can be either active or inactive.</p>
 
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-deactivate-watch>`_
@@ -189,8 +189,8 @@ class WatcherClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Delete a watch.
-          When the watch is removed, the document representing the watch in the <code>.watches</code> index is gone and it will never be run again.</p>
+          <p>Delete a watch.</p>
+          <p>When the watch is removed, the document representing the watch in the <code>.watches</code> index is gone and it will never be run again.</p>
           <p>Deleting a watch does not delete any watch execution records related to this watch from the watch history.</p>
           <p>IMPORTANT: Deleting a watch must be done by using only this API.
           Do not delete the watch directly from the <code>.watches</code> index using the Elasticsearch delete document API
@@ -266,8 +266,8 @@ class WatcherClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Run a watch.
-          This API can be used to force execution of the watch outside of its triggering logic or to simulate the watch execution for debugging purposes.</p>
+          <p>Run a watch.</p>
+          <p>This API can be used to force execution of the watch outside of its triggering logic or to simulate the watch execution for debugging purposes.</p>
           <p>For testing and debugging purposes, you also have fine-grained control on how the watch runs.
           You can run the watch without running all of its actions or alternatively by simulating them.
           You can also force execution by ignoring the watch condition and control whether a watch record would be written to the watch history after it runs.</p>
@@ -362,8 +362,8 @@ class WatcherClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Get Watcher index settings.
-          Get settings for the Watcher internal index (<code>.watches</code>).
+          <p>Get Watcher index settings.</p>
+          <p>Get settings for the Watcher internal index (<code>.watches</code>).
           Only a subset of settings are shown, for example <code>index.auto_expand_replicas</code> and <code>index.number_of_replicas</code>.</p>
 
 
@@ -476,8 +476,8 @@ class WatcherClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Create or update a watch.
-          When a watch is registered, a new document that represents the watch is added to the <code>.watches</code> index and its trigger is immediately registered with the relevant trigger engine.
+          <p>Create or update a watch.</p>
+          <p>When a watch is registered, a new document that represents the watch is added to the <code>.watches</code> index and its trigger is immediately registered with the relevant trigger engine.
           Typically for the <code>schedule</code> trigger, the scheduler is the trigger engine.</p>
           <p>IMPORTANT: You must use Kibana or this API to create a watch.
           Do not add a watch directly to the <code>.watches</code> index by using the Elasticsearch index API.
@@ -494,9 +494,9 @@ class WatcherClient(NamespacedClient):
         :param active: The initial state of the watch. The default value is `true`, which
             means the watch is active by default.
         :param condition: The condition that defines if the actions should be run.
-        :param if_primary_term: only update the watch if the last operation that has
+        :param if_primary_term: Only update the watch if the last operation that has
             changed the watch has the specified primary term
-        :param if_seq_no: only update the watch if the last operation that has changed
+        :param if_seq_no: Only update the watch if the last operation that has changed
             the watch has the specified sequence number
         :param input: The input that defines the input that loads the data for the watch.
         :param metadata: Metadata JSON that will be copied into the history entries.
@@ -552,11 +552,7 @@ class WatcherClient(NamespacedClient):
                 __body["transform"] = transform
             if trigger is not None:
                 __body["trigger"] = trigger
-        if not __body:
-            __body = None  # type: ignore[assignment]
-        __headers = {"accept": "application/json"}
-        if __body is not None:
-            __headers["content-type"] = "application/json"
+        __headers = {"accept": "application/json", "content-type": "application/json"}
         return await self.perform_request(  # type: ignore[return-value]
             "PUT",
             __path,
@@ -595,8 +591,8 @@ class WatcherClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Query watches.
-          Get all registered watches in a paginated manner and optionally filter watches by a query.</p>
+          <p>Query watches.</p>
+          <p>Get all registered watches in a paginated manner and optionally filter watches by a query.</p>
           <p>Note that only the <code>_id</code> and <code>metadata.*</code> fields are queryable or sortable.</p>
 
 
@@ -671,8 +667,8 @@ class WatcherClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Start the watch service.
-          Start the Watcher service if it is not already running.</p>
+          <p>Start the watch service.</p>
+          <p>Start the Watcher service if it is not already running.</p>
 
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-start>`_
@@ -736,8 +732,8 @@ class WatcherClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Get Watcher statistics.
-          This API always returns basic metrics.
+          <p>Get Watcher statistics.</p>
+          <p>This API always returns basic metrics.
           You retrieve more metrics by using the metric parameter.</p>
 
 
@@ -788,8 +784,8 @@ class WatcherClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Stop the watch service.
-          Stop the Watcher service if it is running.</p>
+          <p>Stop the watch service.</p>
+          <p>Stop the Watcher service if it is running.</p>
 
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-watcher-stop>`_
@@ -844,8 +840,8 @@ class WatcherClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Update Watcher index settings.
-          Update settings for the Watcher internal index (<code>.watches</code>).
+          <p>Update Watcher index settings.</p>
+          <p>Update settings for the Watcher internal index (<code>.watches</code>).
           Only a subset of settings can be modified.
           This includes <code>index.auto_expand_replicas</code>, <code>index.number_of_replicas</code>, <code>index.routing.allocation.exclude.*</code>,
           <code>index.routing.allocation.include.*</code> and <code>index.routing.allocation.require.*</code>.

elasticsearch9/_async/client/xpack.py

@@ -45,8 +45,8 @@ class XPackClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Get information.
-          The information provided by the API includes:</p>
+          <p>Get information.</p>
+          <p>The information provided by the API includes:</p>
           <ul>
           <li>Build information including the build number and timestamp.</li>
           <li>License information about the currently installed license.</li>
@@ -56,7 +56,8 @@ class XPackClient(NamespacedClient):
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-info>`_
 
-        :param accept_enterprise: If this param is used it must be set to true
+        :param accept_enterprise: If used, this otherwise ignored parameter must be set
+            to true
         :param categories: A comma-separated list of the information categories to include
             in the response. For example, `build,license,features`.
         """
@@ -98,8 +99,8 @@ class XPackClient(NamespacedClient):
         """
         .. raw:: html
 
-          <p>Get usage information.
-          Get information about the features that are currently enabled and available under the current license.
+          <p>Get usage information.</p>
+          <p>Get information about the features that are currently enabled and available under the current license.
           The API also provides some usage statistics.</p>
 
 

elasticsearch9/_async/helpers.py

@@ -33,12 +33,16 @@ from typing import (
     Union,
 )
 
+from ..compat import safe_task
 from ..exceptions import ApiError, NotFoundError, TransportError
 from ..helpers.actions import (
     _TYPE_BULK_ACTION,
     _TYPE_BULK_ACTION_BODY,
     _TYPE_BULK_ACTION_HEADER,
     _TYPE_BULK_ACTION_HEADER_AND_BODY,
+    _TYPE_BULK_ACTION_HEADER_WITH_META_AND_BODY,
+    _TYPE_BULK_ACTION_WITH_META,
+    BulkMeta,
     _ActionChunker,
     _process_bulk_chunk_error,
     _process_bulk_chunk_success,
@@ -54,9 +58,10 @@ T = TypeVar("T")
 
 
 async def _chunk_actions(
-    actions: AsyncIterable[_TYPE_BULK_ACTION_HEADER_AND_BODY],
+    actions: AsyncIterable[_TYPE_BULK_ACTION_HEADER_WITH_META_AND_BODY],
     chunk_size: int,
     max_chunk_bytes: int,
+    flush_after_seconds: Optional[float],
     serializer: Serializer,
 ) -> AsyncIterable[
     Tuple[
@@ -76,10 +81,42 @@ async def _chunk_actions(
     chunker = _ActionChunker(
         chunk_size=chunk_size, max_chunk_bytes=max_chunk_bytes, serializer=serializer
     )
-    async for action, data in actions:
-        ret = chunker.feed(action, data)
-        if ret:
-            yield ret
+
+    if not flush_after_seconds:
+        async for action, data in actions:
+            ret = chunker.feed(action, data)
+            if ret:
+                yield ret
+    else:
+        item_queue: asyncio.Queue[_TYPE_BULK_ACTION_HEADER_WITH_META_AND_BODY] = (
+            asyncio.Queue()
+        )
+
+        async def get_items() -> None:
+            try:
+                async for item in actions:
+                    await item_queue.put(item)
+            finally:
+                await item_queue.put((BulkMeta.done, None))
+
+        async with safe_task(get_items()):
+            timeout: Optional[float] = flush_after_seconds
+            while True:
+                try:
+                    action, data = await asyncio.wait_for(
+                        item_queue.get(), timeout=timeout
+                    )
+                    timeout = flush_after_seconds
+                except asyncio.TimeoutError:
+                    action, data = BulkMeta.flush, None
+                    timeout = None
+
+                if action is BulkMeta.done:
+                    break
+                ret = chunker.feed(action, data)
+                if ret:
+                    yield ret
+
     ret = chunker.flush()
     if ret:
         yield ret
@@ -159,9 +196,13 @@ async def azip(
 
 async def async_streaming_bulk(
     client: AsyncElasticsearch,
-    actions: Union[Iterable[_TYPE_BULK_ACTION], AsyncIterable[_TYPE_BULK_ACTION]],
+    actions: Union[
+        Iterable[_TYPE_BULK_ACTION_WITH_META],
+        AsyncIterable[_TYPE_BULK_ACTION_WITH_META],
+    ],
     chunk_size: int = 500,
     max_chunk_bytes: int = 100 * 1024 * 1024,
+    flush_after_seconds: Optional[float] = None,
     raise_on_error: bool = True,
     expand_action_callback: Callable[
         [_TYPE_BULK_ACTION], _TYPE_BULK_ACTION_HEADER_AND_BODY
@@ -194,6 +235,9 @@ async def async_streaming_bulk(
     :arg actions: iterable or async iterable containing the actions to be executed
     :arg chunk_size: number of docs in one chunk sent to es (default: 500)
     :arg max_chunk_bytes: the maximum size of the request in bytes (default: 100MB)
+    :arg flush_after_seconds: time in seconds after which a chunk is written even
+        if hasn't reached `chunk_size` or `max_chunk_bytes`. Set to 0 to not use a
+        timeout-based flush. (default: 0)
     :arg raise_on_error: raise ``BulkIndexError`` containing errors (as `.errors`)
         from the execution of the last chunk when some occur. By default we raise.
     :arg raise_on_exception: if ``False`` then don't propagate exceptions from
@@ -220,9 +264,14 @@ async def async_streaming_bulk(
     if isinstance(retry_on_status, int):
         retry_on_status = (retry_on_status,)
 
-    async def map_actions() -> AsyncIterable[_TYPE_BULK_ACTION_HEADER_AND_BODY]:
+    async def map_actions() -> (
+        AsyncIterable[_TYPE_BULK_ACTION_HEADER_WITH_META_AND_BODY]
+    ):
         async for item in aiter(actions):
-            yield expand_action_callback(item)
+            if isinstance(item, BulkMeta):
+                yield item, None
+            else:
+                yield expand_action_callback(item)
 
     serializer = client.transport.serializers.get_serializer("application/json")
 
@@ -234,7 +283,7 @@ async def async_streaming_bulk(
     ]
     bulk_actions: List[bytes]
     async for bulk_data, bulk_actions in _chunk_actions(
-        map_actions(), chunk_size, max_chunk_bytes, serializer
+        map_actions(), chunk_size, max_chunk_bytes, flush_after_seconds, serializer
     ):
         for attempt in range(max_retries + 1):
             to_retry: List[bytes] = []