elasticsearch 8.15.0__py3-none-any.whl → 8.16.0__py3-none-any.whl

elasticsearch/helpers/actions.py

@@ -34,6 +34,8 @@ from typing import (
     Union,
 )
 
+from elastic_transport import OpenTelemetrySpan
+
 from .. import Elasticsearch
 from ..compat import to_bytes
 from ..exceptions import ApiError, NotFoundError, TransportError
@@ -322,6 +324,7 @@ def _process_bulk_chunk(
             Tuple[_TYPE_BULK_ACTION_HEADER, _TYPE_BULK_ACTION_BODY],
         ]
     ],
+    otel_span: OpenTelemetrySpan,
     raise_on_exception: bool = True,
     raise_on_error: bool = True,
     ignore_status: Union[int, Collection[int]] = (),
@@ -331,28 +334,29 @@ def _process_bulk_chunk(
     """
     Send a bulk request to elasticsearch and process the output.
     """
-    if isinstance(ignore_status, int):
-        ignore_status = (ignore_status,)
-
-    try:
-        # send the actual request
-        resp = client.bulk(*args, operations=bulk_actions, **kwargs)  # type: ignore[arg-type]
-    except ApiError as e:
-        gen = _process_bulk_chunk_error(
-            error=e,
-            bulk_data=bulk_data,
-            ignore_status=ignore_status,
-            raise_on_exception=raise_on_exception,
-            raise_on_error=raise_on_error,
-        )
-    else:
-        gen = _process_bulk_chunk_success(
-            resp=resp.body,
-            bulk_data=bulk_data,
-            ignore_status=ignore_status,
-            raise_on_error=raise_on_error,
-        )
-    yield from gen
+    with client._otel.use_span(otel_span):
+        if isinstance(ignore_status, int):
+            ignore_status = (ignore_status,)
+
+        try:
+            # send the actual request
+            resp = client.bulk(*args, operations=bulk_actions, **kwargs)  # type: ignore[arg-type]
+        except ApiError as e:
+            gen = _process_bulk_chunk_error(
+                error=e,
+                bulk_data=bulk_data,
+                ignore_status=ignore_status,
+                raise_on_exception=raise_on_exception,
+                raise_on_error=raise_on_error,
+            )
+        else:
+            gen = _process_bulk_chunk_success(
+                resp=resp.body,
+                bulk_data=bulk_data,
+                ignore_status=ignore_status,
+                raise_on_error=raise_on_error,
+            )
+        yield from gen
 
 
 def streaming_bulk(
@@ -370,6 +374,8 @@ def streaming_bulk(
     max_backoff: float = 600,
     yield_ok: bool = True,
     ignore_status: Union[int, Collection[int]] = (),
+    retry_on_status: Union[int, Collection[int]] = (429,),
+    span_name: str = "helpers.streaming_bulk",
     *args: Any,
     **kwargs: Any,
 ) -> Iterable[Tuple[bool, Dict[str, Any]]]:
@@ -381,10 +387,11 @@ def streaming_bulk(
     entire input is consumed and sent.
 
     If you specify ``max_retries`` it will also retry any documents that were
-    rejected with a ``429`` status code. To do this it will wait (**by calling
-    time.sleep which will block**) for ``initial_backoff`` seconds and then,
-    every subsequent rejection for the same chunk, for double the time every
-    time up to ``max_backoff`` seconds.
+    rejected with a ``429`` status code. Use ``retry_on_status`` to
+    configure which status codes will be retried. To do this it will wait
+    (**by calling time.sleep which will block**) for ``initial_backoff`` seconds
+    and then, every subsequent rejection for the same chunk, for double the time
+    every time up to ``max_backoff`` seconds.
 
     :arg client: instance of :class:`~elasticsearch.Elasticsearch` to use
     :arg actions: iterable containing the actions to be executed
@@ -397,8 +404,11 @@ def streaming_bulk(
     :arg expand_action_callback: callback executed on each action passed in,
         should return a tuple containing the action line and the data line
         (`None` if data line should be omitted).
+    :arg retry_on_status: HTTP status code that will trigger a retry.
+        (if `None` is specified only status 429 will retry).
     :arg max_retries: maximum number of times a document will be retried when
-        ``429`` is received, set to 0 (default) for no retries on ``429``
+        retry_on_status (defaulting to ``429``) is received,
+        set to 0 (default) for no retries
     :arg initial_backoff: number of seconds we should wait before the first
         retry. Any subsequent retries will be powers of ``initial_backoff *
         2**retry_number``
@@ -406,73 +416,82 @@ def streaming_bulk(
     :arg yield_ok: if set to False will skip successful documents in the output
     :arg ignore_status: list of HTTP status code that you want to ignore
     """
-    client = client.options()
-    client._client_meta = (("h", "bp"),)
+    with client._otel.helpers_span(span_name) as otel_span:
+        client = client.options()
+        client._client_meta = (("h", "bp"),)
 
-    serializer = client.transport.serializers.get_serializer("application/json")
+        if isinstance(retry_on_status, int):
+            retry_on_status = (retry_on_status,)
 
-    bulk_data: List[
-        Union[
-            Tuple[_TYPE_BULK_ACTION_HEADER],
-            Tuple[_TYPE_BULK_ACTION_HEADER, _TYPE_BULK_ACTION_BODY],
-        ]
-    ]
-    bulk_actions: List[bytes]
-    for bulk_data, bulk_actions in _chunk_actions(
-        map(expand_action_callback, actions), chunk_size, max_chunk_bytes, serializer
-    ):
-        for attempt in range(max_retries + 1):
-            to_retry: List[bytes] = []
-            to_retry_data: List[
-                Union[
-                    Tuple[_TYPE_BULK_ACTION_HEADER],
-                    Tuple[_TYPE_BULK_ACTION_HEADER, _TYPE_BULK_ACTION_BODY],
-                ]
-            ] = []
-            if attempt:
-                time.sleep(min(max_backoff, initial_backoff * 2 ** (attempt - 1)))
+        serializer = client.transport.serializers.get_serializer("application/json")
 
-            try:
-                for data, (ok, info) in zip(
-                    bulk_data,
-                    _process_bulk_chunk(
-                        client,
-                        bulk_actions,
+        bulk_data: List[
+            Union[
+                Tuple[_TYPE_BULK_ACTION_HEADER],
+                Tuple[_TYPE_BULK_ACTION_HEADER, _TYPE_BULK_ACTION_BODY],
+            ]
+        ]
+        bulk_actions: List[bytes]
+        for bulk_data, bulk_actions in _chunk_actions(
+            map(expand_action_callback, actions),
+            chunk_size,
+            max_chunk_bytes,
+            serializer,
+        ):
+            for attempt in range(max_retries + 1):
+                to_retry: List[bytes] = []
+                to_retry_data: List[
+                    Union[
+                        Tuple[_TYPE_BULK_ACTION_HEADER],
+                        Tuple[_TYPE_BULK_ACTION_HEADER, _TYPE_BULK_ACTION_BODY],
+                    ]
+                ] = []
+                if attempt:
+                    time.sleep(min(max_backoff, initial_backoff * 2 ** (attempt - 1)))
+
+                try:
+                    for data, (ok, info) in zip(
                         bulk_data,
-                        raise_on_exception,
-                        raise_on_error,
-                        ignore_status,
-                        *args,
-                        **kwargs,
-                    ),
-                ):
-                    if not ok:
-                        action, info = info.popitem()
-                        # retry if retries enabled, we get 429, and we are not
-                        # in the last attempt
-                        if (
-                            max_retries
-                            and info["status"] == 429
-                            and (attempt + 1) <= max_retries
-                        ):
-                            # _process_bulk_chunk expects bytes so we need to
-                            # re-serialize the data
-                            to_retry.extend(map(serializer.dumps, data))
-                            to_retry_data.append(data)
-                        else:
-                            yield ok, {action: info}
-                    elif yield_ok:
-                        yield ok, info
-
-            except ApiError as e:
-                # suppress 429 errors since we will retry them
-                if attempt == max_retries or e.status_code != 429:
-                    raise
-            else:
-                if not to_retry:
-                    break
-                # retry only subset of documents that didn't succeed
-                bulk_actions, bulk_data = to_retry, to_retry_data
+                        _process_bulk_chunk(
+                            client,
+                            bulk_actions,
+                            bulk_data,
+                            otel_span,
+                            raise_on_exception,
+                            raise_on_error,
+                            ignore_status,
+                            *args,
+                            **kwargs,
+                        ),
+                    ):
+                        if not ok:
+                            action, info = info.popitem()
+                            # retry if retries enabled, we are not in the last attempt,
+                            # and status in retry_on_status (defaulting to 429)
+                            if (
+                                max_retries
+                                and info["status"] in retry_on_status
+                                and (attempt + 1) <= max_retries
+                            ):
+                                # _process_bulk_chunk expects bytes so we need to
+                                # re-serialize the data
+                                to_retry.extend(map(serializer.dumps, data))
+                                to_retry_data.append(data)
+                            else:
+                                yield ok, {action: info}
+                        elif yield_ok:
+                            yield ok, info
+
+                except ApiError as e:
+                    # suppress any status in retry_on_status (429 by default)
+                    # since we will retry them
+                    if attempt == max_retries or e.status_code not in retry_on_status:
+                        raise
+                else:
+                    if not to_retry:
+                        break
+                    # retry only subset of documents that didn't succeed
+                    bulk_actions, bulk_data = to_retry, to_retry_data
 
 
 def bulk(
@@ -519,7 +538,7 @@ def bulk(
     # make streaming_bulk yield successful results so we can count them
     kwargs["yield_ok"] = True
     for ok, item in streaming_bulk(
-        client, actions, ignore_status=ignore_status, *args, **kwargs  # type: ignore[misc]
+        client, actions, ignore_status=ignore_status, span_name="helpers.bulk", *args, **kwargs  # type: ignore[misc]
     ):
         # go through request-response pairs and detect failures
         if not ok:
@@ -589,27 +608,31 @@ def parallel_bulk(
             ] = Queue(max(queue_size, thread_count))
             self._quick_put = self._inqueue.put
 
-    pool = BlockingPool(thread_count)
-
-    try:
-        for result in pool.imap(
-            lambda bulk_chunk: list(
-                _process_bulk_chunk(
-                    client,
-                    bulk_chunk[1],
-                    bulk_chunk[0],
-                    ignore_status=ignore_status,  # type: ignore[misc]
-                    *args,
-                    **kwargs,
-                )
-            ),
-            _chunk_actions(expanded_actions, chunk_size, max_chunk_bytes, serializer),
-        ):
-            yield from result
+    with client._otel.helpers_span("helpers.parallel_bulk") as otel_span:
+        pool = BlockingPool(thread_count)
 
-    finally:
-        pool.close()
-        pool.join()
+        try:
+            for result in pool.imap(
+                lambda bulk_chunk: list(
+                    _process_bulk_chunk(
+                        client,
+                        bulk_chunk[1],
+                        bulk_chunk[0],
+                        otel_span=otel_span,
+                        ignore_status=ignore_status,  # type: ignore[misc]
+                        *args,
+                        **kwargs,
+                    )
+                ),
+                _chunk_actions(
+                    expanded_actions, chunk_size, max_chunk_bytes, serializer
+                ),
+            ):
+                yield from result
+
+        finally:
+            pool.close()
+            pool.join()
 
 
 def scan(

elasticsearch/helpers/errors.py

@@ -15,18 +15,26 @@
 #  specific language governing permissions and limitations
 #  under the License.
 
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Tuple, Type
 
 
 class BulkIndexError(Exception):
-    def __init__(self, message: Any, errors: List[Dict[str, Any]]):
+    def __init__(self, message: str, errors: List[Dict[str, Any]]):
         super().__init__(message)
         self.errors: List[Dict[str, Any]] = errors
 
+    def __reduce__(
+        self,
+    ) -> Tuple[Type["BulkIndexError"], Tuple[str, List[Dict[str, Any]]]]:
+        return (self.__class__, (self.args[0], self.errors))
+
 
 class ScanError(Exception):
     scroll_id: str
 
-    def __init__(self, scroll_id: str, *args: Any, **kwargs: Any) -> None:
-        super().__init__(*args, **kwargs)
+    def __init__(self, scroll_id: str, *args: Any) -> None:
+        super().__init__(*args)
         self.scroll_id = scroll_id
+
+    def __reduce__(self) -> Tuple[Type["ScanError"], Tuple[str, str]]:
+        return (self.__class__, (self.scroll_id,) + self.args)

elasticsearch/helpers/vectorstore/_async/strategies.py

@@ -283,10 +283,9 @@ class AsyncDenseVectorStrategy(AsyncRetrievalStrategy):
     ) -> Dict[str, Any]:
         # Add a query to the knn query.
         # RRF is used to even the score from the knn query and text query
-        # RRF has two optional parameters: {'rank_constant':int, 'window_size':int}
+        # RRF has two optional parameters: {'rank_constant':int, 'rank_window_size':int}
         # https://www.elastic.co/guide/en/elasticsearch/reference/current/rrf.html
-        query_body = {
-            "knn": knn,
+        standard_query = {
             "query": {
                 "bool": {
                     "must": [
@@ -300,14 +299,36 @@ class AsyncDenseVectorStrategy(AsyncRetrievalStrategy):
                     ],
                     "filter": filter,
                 }
-            },
+            }
         }
 
-        if isinstance(self.rrf, Dict):
-            query_body["rank"] = {"rrf": self.rrf}
-        elif isinstance(self.rrf, bool) and self.rrf is True:
-            query_body["rank"] = {"rrf": {}}
-
+        if self.rrf is False:
+            query_body = {
+                "knn": knn,
+                **standard_query,
+            }
+        else:
+            rrf_options = {}
+            if isinstance(self.rrf, Dict):
+                if "rank_constant" in self.rrf:
+                    rrf_options["rank_constant"] = self.rrf["rank_constant"]
+                if "window_size" in self.rrf:
+                    # 'window_size' was renamed to 'rank_window_size', but we support
+                    # the older name for backwards compatibility
+                    rrf_options["rank_window_size"] = self.rrf["window_size"]
+                if "rank_window_size" in self.rrf:
+                    rrf_options["rank_window_size"] = self.rrf["rank_window_size"]
+            query_body = {
+                "retriever": {
+                    "rrf": {
+                        "retrievers": [
+                            {"standard": standard_query},
+                            {"knn": knn},
+                        ],
+                        **rrf_options,
+                    },
+                },
+            }
         return query_body
 
     def needs_inference(self) -> bool:

elasticsearch/helpers/vectorstore/_sync/strategies.py

@@ -283,10 +283,9 @@ class DenseVectorStrategy(RetrievalStrategy):
     ) -> Dict[str, Any]:
         # Add a query to the knn query.
         # RRF is used to even the score from the knn query and text query
-        # RRF has two optional parameters: {'rank_constant':int, 'window_size':int}
+        # RRF has two optional parameters: {'rank_constant':int, 'rank_window_size':int}
         # https://www.elastic.co/guide/en/elasticsearch/reference/current/rrf.html
-        query_body = {
-            "knn": knn,
+        standard_query = {
             "query": {
                 "bool": {
                     "must": [
@@ -300,14 +299,36 @@ class DenseVectorStrategy(RetrievalStrategy):
                     ],
                     "filter": filter,
                 }
-            },
+            }
         }
 
-        if isinstance(self.rrf, Dict):
-            query_body["rank"] = {"rrf": self.rrf}
-        elif isinstance(self.rrf, bool) and self.rrf is True:
-            query_body["rank"] = {"rrf": {}}
-
+        if self.rrf is False:
+            query_body = {
+                "knn": knn,
+                **standard_query,
+            }
+        else:
+            rrf_options = {}
+            if isinstance(self.rrf, Dict):
+                if "rank_constant" in self.rrf:
+                    rrf_options["rank_constant"] = self.rrf["rank_constant"]
+                if "window_size" in self.rrf:
+                    # 'window_size' was renamed to 'rank_window_size', but we support
+                    # the older name for backwards compatibility
+                    rrf_options["rank_window_size"] = self.rrf["window_size"]
+                if "rank_window_size" in self.rrf:
+                    rrf_options["rank_window_size"] = self.rrf["rank_window_size"]
+            query_body = {
+                "retriever": {
+                    "rrf": {
+                        "retrievers": [
+                            {"standard": standard_query},
+                            {"knn": knn},
+                        ],
+                        **rrf_options,
+                    },
+                },
+            }
         return query_body
 
     def needs_inference(self) -> bool:

{elasticsearch-8.15.0.dist-info → elasticsearch-8.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: elasticsearch
-Version: 8.15.0
+Version: 8.16.0
 Summary: Python client for Elasticsearch
 Project-URL: Documentation, https://elasticsearch-py.readthedocs.io/
 Project-URL: Homepage, https://github.com/elastic/elasticsearch-py
@@ -8,9 +8,7 @@ Project-URL: Issue Tracker, https://github.com/elastic/elasticsearch-py/issues
 Project-URL: Source Code, https://github.com/elastic/elasticsearch-py
 Author-email: Elastic Client Library Maintainers <client-libs@elastic.co>
 Maintainer-email: Elastic Client Library Maintainers <client-libs@elastic.co>
-License-Expression: Apache-2.0
-License-File: LICENSE
-License-File: NOTICE
+License: Apache-2.0
 Keywords: REST,client,elastic,elasticsearch,index,kibana,mapping,search
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -23,10 +21,11 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.8
-Requires-Dist: elastic-transport<9,>=8.13
+Requires-Dist: elastic-transport<9,>=8.15.1
 Provides-Extra: async
 Requires-Dist: aiohttp<4,>=3; extra == 'async'
 Provides-Extra: dev
@@ -48,13 +47,13 @@ Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: python-dateutil; extra == 'dev'
 Requires-Dist: pyyaml>=5.4; extra == 'dev'
 Requires-Dist: requests<3,>=2; extra == 'dev'
-Requires-Dist: simsimd; extra == 'dev'
+Requires-Dist: simsimd; (python_version < '3.13') and extra == 'dev'
 Requires-Dist: twine; extra == 'dev'
 Requires-Dist: unasync; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == 'docs'
 Requires-Dist: sphinx-autodoc-typehints; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme>=2.0; extra == 'docs'
 Provides-Extra: orjson
 Requires-Dist: orjson>=3; extra == 'orjson'
 Provides-Extra: pyarrow

elasticsearch-8.16.0.dist-info/RECORD

@@ -0,0 +1,117 @@
+elasticsearch/__init__.py,sha256=w5YnO16zjOi6loGJ8caUgSXsj3b-Y8OfF0BIddP2BiE,3289
+elasticsearch/_otel.py,sha256=Oidt86g9XzeVrwMsJeV7dGLsyquVMJWfhcRlz43RlGo,4188
+elasticsearch/_utils.py,sha256=Vr_aNG5ddxInE1PgDpCXMYpXBTNUFM9nYrgbw-cjeCc,1419
+elasticsearch/_version.py,sha256=cCncJ6G7egEMKO8B9tVa2tUhTcFqEnR8lddtJz7b2Ag,814
+elasticsearch/client.py,sha256=Zik8KKnpJBvbapk4BhZXC7PZiuZwWqtcmMARDNXMwlA,5213
+elasticsearch/compat.py,sha256=hL3mtqVxWwxeiFbNGADva5XruAwK-A6xcu-vrpnDXFs,2657
+elasticsearch/exceptions.py,sha256=ynpP0TLJxur7x7JQJD-CFtXov0bPImGt234gdlAyv6g,4142
+elasticsearch/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+elasticsearch/serializer.py,sha256=vLhhlU6fAjHXB-z2E5ieBe_XKWx4A0o-lbJY9Bknt70,8059
+elasticsearch/transport.py,sha256=CxKo2USPQ-6q4x8Ckfq_dUFWhA1s98p75ghXc3breJI,2248
+elasticsearch/_async/__init__.py,sha256=TZps9WjF-TaSNzBvW5wUCgXRcbHnvE_9xAynBHsMtSo,787
+elasticsearch/_async/helpers.py,sha256=E-nZfxH4qtEFSm33wy1sJ3kHM5aEwcxIFPiho7AeW5w,22802
+elasticsearch/_async/client/__init__.py,sha256=p9ZTGVSW8aoSntzAYCiXdCHDkUzm_8IXEGoEX2orVLQ,250098
+elasticsearch/_async/client/_base.py,sha256=wDJIs-4Z_fDBF0_XvfCmfSuyL6Oh8I2nSGDZyP91XCU,15531
+elasticsearch/_async/client/async_search.py,sha256=is7Y2c9hx10og5vhrK5vQHK6LYetY2LYhty1bpz1Nso,30504
+elasticsearch/_async/client/autoscaling.py,sha256=rOChE7GopR3lfuRgeygHPmHZ5ngMN-WXR45WEdBuYJM,8895
+elasticsearch/_async/client/cat.py,sha256=VYDAT38C0BjI2-EOXJUdNPXXKeSzjRyDX9zChvWs7CY,138917
+elasticsearch/_async/client/ccr.py,sha256=mEp7DA59ePYU1ufU6ESsfdZX-0IpS858mXtG1CwCLkg,36972
+elasticsearch/_async/client/cluster.py,sha256=FeblXwD7_8SeEnpLpFJzluj7acPlcOmr2qceYwTyW6U,50606
+elasticsearch/_async/client/connector.py,sha256=37-etm0MX5wwJPSAxPWBSp10pablnP_BAAioykh4xNs,61311
+elasticsearch/_async/client/dangling_indices.py,sha256=zDhhAeTUvPl3TVT1EuXMm4RFLXSjNJS5qccnjViQfyA,8354
+elasticsearch/_async/client/enrich.py,sha256=Gww5cfDzTTT-IJsuBRZPjp455ONCxC4oehWjCDGHbQ0,9750
+elasticsearch/_async/client/eql.py,sha256=5G8QvXsSR4dIlspyGFa9ha3dQIklUzjCfUCvSgVGSOk,13138
+elasticsearch/_async/client/esql.py,sha256=VK7y0yzko9iQJM1QTM1mCxnwmivjADVRJ6J9ly5qt_Q,6183
+elasticsearch/_async/client/features.py,sha256=LSLT_dp9K9IiEjhbHjLurdo1sXIxrlMkWbGgdDWxkxM,3629
+elasticsearch/_async/client/fleet.py,sha256=5VY0-h7LCmksa0fzXLFUX34EoNFkugUxNXZBJpa9md4,31300
+elasticsearch/_async/client/graph.py,sha256=4cseN8MymM6nsWuxA__PS-SE4VqAPteTWMI0u2zfZRY,4594
+elasticsearch/_async/client/ilm.py,sha256=xn8FYGihL4xzz0WqNUaTTynhJI3wN4eaKqBI36l6bco,24222
+elasticsearch/_async/client/indices.py,sha256=XpD4A6kIeg1hXxA3GvB84qUhG_TI0dntUE21aAQ8T6o,221453
+elasticsearch/_async/client/inference.py,sha256=_eBRxreOSD4Y39Jntdwqr9BQR8osY5ix1lkdtsCXLoQ,12508
+elasticsearch/_async/client/ingest.py,sha256=omwEgiLAt7obl9FJb8yHMcBtIDImkZJ440A_UIWdAAs,24051
+elasticsearch/_async/client/license.py,sha256=85L9YhnJpwWwXXK_EKnJrB4Jw3iif-dySSz504XF33Q,12956
+elasticsearch/_async/client/logstash.py,sha256=mhnvDiLp9lBQrmiK-5lpuAU3zkde94RwkaemZiCNvTc,6136
+elasticsearch/_async/client/migration.py,sha256=TmqOovsIqd2hgQsr7lPOT5yODY1I2kKotYzRugAZcDE,5331
+elasticsearch/_async/client/ml.py,sha256=gIb3w-GB_9h419m63KDJrtdOodUBwlHJ6X94fPUn1SM,258760
+elasticsearch/_async/client/monitoring.py,sha256=GtoD_JztiOf5s3d3TG4gp2MH67Hsg98GSDG8lK13VHU,3818
+elasticsearch/_async/client/nodes.py,sha256=5vhhl10VdUGeVpoHK2k-HNjtSJ4lZlYvLRfg1zvjF4E,24242
+elasticsearch/_async/client/query_rules.py,sha256=Tryx9Q2jVoLkT_FJ_s7KzLqzHUyvlhGbYV5cc41aENA,16947
+elasticsearch/_async/client/rollup.py,sha256=w2mRQskar9WQF8U2Cgt-GVjImOBc6v4Vde5pBH439Fs,21268
+elasticsearch/_async/client/search_application.py,sha256=wb-DrkJtCL4e1-W4mNggdY4DjWGF7EId93STmmbzvXM,16101
+elasticsearch/_async/client/searchable_snapshots.py,sha256=fvSKFUNQJvxCrevlvaBcznb9GB3L-mTWjfMfHmzuoL0,11788
+elasticsearch/_async/client/security.py,sha256=tawwwaqMFpvdQ3W_JHd2x2--nm-5YJtTEhpZ4kD_9Fg,162146
+elasticsearch/_async/client/shutdown.py,sha256=VLUD0VL065THNNuXB4lrA66aAPb_v2WW5oJfJNlfJcs,11350
+elasticsearch/_async/client/slm.py,sha256=jPHUwg17EMh6Gykll33sNiLK9xBW98kvlBh3xYtW-T4,16120
+elasticsearch/_async/client/snapshot.py,sha256=PCoTFnrs6l3fOGxO2_S79E2GSVfbfxT-Z0Oj9x3PkVk,41082
+elasticsearch/_async/client/sql.py,sha256=OEWS3TEuBYHMMaB5otAEa2ie-aljr-UKJ4ThGHa5_xI,17956
+elasticsearch/_async/client/ssl.py,sha256=52KlTmyJfeU2mqq7h7Ch7d14NdmrpSrL1_kanLaVEm4,3636
+elasticsearch/_async/client/synonyms.py,sha256=4vi7EKdQGM5DZizgf99wwmJJYokTUEkA9QdBiX5MTp0,13851
+elasticsearch/_async/client/tasks.py,sha256=KdJn7yVleLOCeVpuJZQPLEbPSF6nDvSG0J3mPo5jbmc,9315
+elasticsearch/_async/client/text_structure.py,sha256=IU5K1CFDcoed8kJLmJHSdjqfL7Pur9GBeZ5r6jozxHM,12046
+elasticsearch/_async/client/transform.py,sha256=G9sFSqNuh7yC3HYjLSQyoGGYJRHQJdIgZin0IwzSNK4,42542
+elasticsearch/_async/client/utils.py,sha256=h64qW1YcQZoJdEpDiYqkgnD3Q_0r2Y_ltUiNpNzpekI,1449
+elasticsearch/_async/client/watcher.py,sha256=HIBQ8dNRYrK1X52wBJJTSpqBNZyu8EADQmIJ7jjO9yc,26482
+elasticsearch/_async/client/xpack.py,sha256=lnTOOBYxQu8IzLR5OkJh1raEp2SRax_eXBiYcf5FsO4,4628
+elasticsearch/_sync/__init__.py,sha256=TZps9WjF-TaSNzBvW5wUCgXRcbHnvE_9xAynBHsMtSo,787
+elasticsearch/_sync/client/__init__.py,sha256=wVd4Aoy8GvrMcai1TDtEjxyFgvkoiTxgmVIpg7jjMi4,249467
+elasticsearch/_sync/client/_base.py,sha256=LesRKQzvgstEPn-hzoY7PBq_4hAyPCzjGiUggGn-fB8,15461
+elasticsearch/_sync/client/async_search.py,sha256=znGy_0Bh5nQl_y1tWE0UxsxYQlSZu0IuxPOx8hYm2PA,30456
+elasticsearch/_sync/client/autoscaling.py,sha256=MEaVghDLVN8Gv_LH1HoiNXdUAY7c2-Sxla4pCpxZAAU,8847
+elasticsearch/_sync/client/cat.py,sha256=-X9Xat5nTYMVMoUR_KHNK20seuD9enZqR1VX4LoDgGg,138605
+elasticsearch/_sync/client/ccr.py,sha256=vgHVO4OTcl24uEHbAFTAm8LQJuu65AtZwpIY0pOGQiU,36816
+elasticsearch/_sync/client/cluster.py,sha256=TGMf8eGKnqF7PiOvzaHl3hbvOu0e0rygSQ6qwvRfbZA,50414
+elasticsearch/_sync/client/connector.py,sha256=9yaeSJErNQRYukWFCWsauF3BjAi-_UZIge-PhBtEoXk,61011
+elasticsearch/_sync/client/dangling_indices.py,sha256=FmL09mX2gkcT_IkPCd7QXlm2YfyN42twwWIfq0tnQKw,8318
+elasticsearch/_sync/client/enrich.py,sha256=0dIcKN-QXa8zR52Z_wc0hmGR2DJw1UsY2fhaCKjRP1Q,9690
+elasticsearch/_sync/client/eql.py,sha256=9sy4NhvcQhKpahHtHM_mpFfLoQ1dClyywmh8RY6cHfs,13090
+elasticsearch/_sync/client/esql.py,sha256=_7ePOiPm__rGcQ-buZ41nS3ef8UGGdfsJIQe5XnYU4w,6171
+elasticsearch/_sync/client/features.py,sha256=XZT8skOz9qeLTVegheBUjDtwMy8Q2hklbgGULdXHLOY,3605
+elasticsearch/_sync/client/fleet.py,sha256=PGcQHK2IvRFHFMCqYDnIjqYyorTRAAmEvoMkOVDcSdE,31264
+elasticsearch/_sync/client/graph.py,sha256=hwsCdovvD6HCAqPSAq2o0mclhWQdDwVUHkyYekA0Pyo,4582
+elasticsearch/_sync/client/ilm.py,sha256=QUGI9nESYP-_k0RFW1EPyGtNcouwQRm9b7oUhvDcaKE,24090
+elasticsearch/_sync/client/indices.py,sha256=fr-dPEvQfT2YnIir6LUGl7RKBeuVJ4hlars-y74AgoU,220745
+elasticsearch/_sync/client/inference.py,sha256=4UjB1pRq2C0bJanZyHAFjt8UU7ldI9XgAg7TssZNLuQ,12460
+elasticsearch/_sync/client/ingest.py,sha256=QP3rwvi4nZGOzmZYbe-u00Pq3h_78U_tGwZFoc1Fi4o,23943
+elasticsearch/_sync/client/license.py,sha256=-Mq5H0MjmHtSYWZTUl-mGvFwMiuXyp9Rd_pHecfwdMQ,12872
+elasticsearch/_sync/client/logstash.py,sha256=F1m9DxPJRTlgYqIXE8iQmArMCZQZBvNxjsQOYCUKE48,6100
+elasticsearch/_sync/client/migration.py,sha256=wyk2Bp6xYEtDsq3WXZuDPwcHO6pPSPfJt0mRL7Rb0Fo,5295
+elasticsearch/_sync/client/ml.py,sha256=LL_9TH4w9wWx6W_g7E0P3jMDbrizxLf7EjvpFohqv44,257884
+elasticsearch/_sync/client/monitoring.py,sha256=gy9AbNYG9nNWVf4zDg40eybAcv3u8auhIkjC04nYWDI,3806
+elasticsearch/_sync/client/nodes.py,sha256=P6w5nOuyr-Rrilsch3WcPQavm-Bh8nCvdjW_b0M7lEg,24158
+elasticsearch/_sync/client/query_rules.py,sha256=UK3CvOro7WZFzJxlNR3qP5YCgZK3uagefzTQC0tUkc8,16851
+elasticsearch/_sync/client/rollup.py,sha256=-7HAIIfARW5cpKIqIyNSxbmEtJsFg6NJeTu-XX0gGwE,21172
+elasticsearch/_sync/client/search_application.py,sha256=bDzsaK84y7PpbcUkLHuJxfYVtJ-7C8qakTRaGb43VwU,16005
+elasticsearch/_sync/client/searchable_snapshots.py,sha256=Nx8z61FZhUCsM-coj8_LOTNL0cFpfpF9tddGVC07hwA,11740
+elasticsearch/_sync/client/security.py,sha256=EUjQhtayvu0sCZzKASTUnWCCGIHmeY6zXMvP8oUWkBc,161462
+elasticsearch/_sync/client/shutdown.py,sha256=XmHwRxJTaETA7w2kc4i98WcMYGaQU04h-kXhMmgeSK0,11314
+elasticsearch/_sync/client/slm.py,sha256=hMbs-DtrUm8CgzKdseyOhF1f2iPBf_EMaLzinBBWask,16012
+elasticsearch/_sync/client/snapshot.py,sha256=-NPYxpO0-x9VKWhDW8LXbutduCULXKNkAz4eGlVlo1U,40938
+elasticsearch/_sync/client/sql.py,sha256=-2DfSuoIDCLkE4SOKsBVMMqEhEE_HWbnRVzzh_YCgc4,17884
+elasticsearch/_sync/client/ssl.py,sha256=pd6JrsTEHmEqqM8S7txfsiqObdAy-kzY9YBXUHrgl3o,3624
+elasticsearch/_sync/client/synonyms.py,sha256=bVU13E-7CLor7jiYfH6_nZNtcULnO8Rwba7Sr9wad6o,13767
+elasticsearch/_sync/client/tasks.py,sha256=2ncovB_GIgjBJd7sdqtooxKSN8Nkb7ZR3dQ014r7WWA,9279
+elasticsearch/_sync/client/text_structure.py,sha256=N2ZrBw6Lah8zxDsonn9Rd64Oz-IEHlgzAi5Yrkvskxc,12022
+elasticsearch/_sync/client/transform.py,sha256=CVT0GdBGqBBC0dInHKM5VFkUx3UhNzaNiYIjZ5SMHnQ,42410
+elasticsearch/_sync/client/utils.py,sha256=aPAIUrofb5AXK5YLgHNqrc10csWnHMSdPWKQSUd-EwI,18714
+elasticsearch/_sync/client/watcher.py,sha256=dD81SjUmhT_4N9NPTG9PbHCCMwTQu9pXl4VhFUQJE6Q,26350
+elasticsearch/_sync/client/xpack.py,sha256=brTWkWurtXGHprcp-ZB77Sn4p7KQgq4y33kV9oEKYso,4604
+elasticsearch/helpers/__init__.py,sha256=7X10XwdP_fP1QTHGcOxGbCvl2oBevkz_DjhjXCh_59I,1470
+elasticsearch/helpers/actions.py,sha256=rSK-tfpYtgD8x72tm_Lyv_aDnyEZQXDrKNKKZm8VM2k,32372
+elasticsearch/helpers/errors.py,sha256=5khkK4zbXsk4ry8HDmGfyzlmZI9KSKP-MivCgcPoO5U,1506
+elasticsearch/helpers/vectorstore/__init__.py,sha256=znQOANiaSZOJco_dkBf06wpFMKwK0OoDcNkkS8NMWKE,2192
+elasticsearch/helpers/vectorstore/_utils.py,sha256=xJwCFq7sqUBeq143tfnfm3i4e-ta88s85wKZmPZwJWg,3985
+elasticsearch/helpers/vectorstore/_async/__init__.py,sha256=TZps9WjF-TaSNzBvW5wUCgXRcbHnvE_9xAynBHsMtSo,787
+elasticsearch/helpers/vectorstore/_async/_utils.py,sha256=wYlPKvAT4bflJjULLB2LMjJroAgX6tjoDGBPT6V1gj8,1608
+elasticsearch/helpers/vectorstore/_async/embedding_service.py,sha256=Qv4HsPC4k6J00K4ajhJPFlET6fOTV-l74iDCr4dpZgc,3655
+elasticsearch/helpers/vectorstore/_async/strategies.py,sha256=YpmCiz-skq2uvJhUY_nFpX_L6eRlAawZdA2jvGj30Hs,16210
+elasticsearch/helpers/vectorstore/_async/vectorstore.py,sha256=U9xOnjLjJmLeT8dltKWYvsDD4jkmyH0ybfxR0Bn6-_Y,16707
+elasticsearch/helpers/vectorstore/_sync/__init__.py,sha256=TZps9WjF-TaSNzBvW5wUCgXRcbHnvE_9xAynBHsMtSo,787
+elasticsearch/helpers/vectorstore/_sync/_utils.py,sha256=5pdvNS5XC3wqShjliW9Njl9tVuyI9WMy0cxc5-97K-c,1569
+elasticsearch/helpers/vectorstore/_sync/embedding_service.py,sha256=sAw_WKUcmyqOOJRqnNesZCzn7ZyA91v4NvvQszHIWJ8,3582
+elasticsearch/helpers/vectorstore/_sync/strategies.py,sha256=LfB2_uQMnPkWpe67hnPxeS1h5rLodnYOgk64hp9bs-s,16108
+elasticsearch/helpers/vectorstore/_sync/vectorstore.py,sha256=bTWLhdGkdXHS4SojSFHHAuBTUUC3OBdiyDqgQmHC_sI,16510
+elasticsearch-8.16.0.dist-info/METADATA,sha256=_xGsSZiHcAz5xzEfESCk9QDzOhXdApNOfiEqiZKxrJ0,8757
+elasticsearch-8.16.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+elasticsearch-8.16.0.dist-info/licenses/LICENSE,sha256=XfKg2H1sVi8OoRxoisUlMqoo10TKvHmU_wU39ks7MyA,10143
+elasticsearch-8.16.0.dist-info/licenses/NOTICE,sha256=t4IjKAJ_G-0hYaL4AH16CVS_xDel8UXrJVK6x7JDaGA,61
+elasticsearch-8.16.0.dist-info/RECORD,,

{elasticsearch-8.15.0.dist-info → elasticsearch-8.16.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.26.3
 Root-Is-Purelib: true
 Tag: py3-none-any