elasticsearch9 9.0.3__py3-none-any.whl → 9.0.5__py3-none-any.whl

elasticsearch9/_sync/client/esql.py

@@ -22,6 +22,9 @@ from elastic_transport import ObjectApiResponse
 from ._base import NamespacedClient
 from .utils import SKIP_IN_PATH, _quote, _rewrite_parameters
 
+if t.TYPE_CHECKING:
+    from elasticsearch.esql import ESQLBase
+
 
 class EsqlClient(NamespacedClient):
 
@@ -44,7 +47,7 @@ class EsqlClient(NamespacedClient):
     def async_query(
         self,
         *,
-        query: t.Optional[str] = None,
+        query: t.Optional[t.Union[str, "ESQLBase"]] = None,
         columnar: t.Optional[bool] = None,
         delimiter: t.Optional[str] = None,
         drop_null_columns: t.Optional[bool] = None,
@@ -99,7 +102,12 @@ class EsqlClient(NamespacedClient):
             which has the name of all the columns.
         :param filter: Specify a Query DSL query in the filter parameter to filter the
             set of documents that an ES|QL query runs on.
-        :param format: A short version of the Accept header, for example `json` or `yaml`.
+        :param format: A short version of the Accept header, e.g. json, yaml. `csv`,
+            `tsv`, and `txt` formats will return results in a tabular format, excluding
+            other metadata fields from the response. For async requests, nothing will
+            be returned if the async query doesn't finish within the timeout. The query
+            ID and running status are available in the `X-Elasticsearch-Async-Id` and
+            `X-Elasticsearch-Async-Is-Running` HTTP headers of the response, respectively.
         :param include_ccs_metadata: When set to `true` and performing a cross-cluster
             query, the response will include an extra `_clusters` object with information
             about the clusters that participated in the search along with info such as
@@ -151,7 +159,7 @@ class EsqlClient(NamespacedClient):
             __query["pretty"] = pretty
         if not __body:
             if query is not None:
-                __body["query"] = query
+                __body["query"] = str(query)
             if columnar is not None:
                 __body["columnar"] = columnar
             if filter is not None:
@@ -389,7 +397,7 @@ class EsqlClient(NamespacedClient):
     def query(
         self,
         *,
-        query: t.Optional[str] = None,
+        query: t.Optional[t.Union[str, "ESQLBase"]] = None,
         columnar: t.Optional[bool] = None,
         delimiter: t.Optional[str] = None,
         drop_null_columns: t.Optional[bool] = None,
@@ -438,7 +446,9 @@ class EsqlClient(NamespacedClient):
             `all_columns` which has the name of all columns.
         :param filter: Specify a Query DSL query in the filter parameter to filter the
             set of documents that an ES|QL query runs on.
-        :param format: A short version of the Accept header, e.g. json, yaml.
+        :param format: A short version of the Accept header, e.g. json, yaml. `csv`,
+            `tsv`, and `txt` formats will return results in a tabular format, excluding
+            other metadata fields from the response.
         :param include_ccs_metadata: When set to `true` and performing a cross-cluster
             query, the response will include an extra `_clusters` object with information
             about the clusters that participated in the search along with info such as
@@ -476,7 +486,7 @@ class EsqlClient(NamespacedClient):
             __query["pretty"] = pretty
         if not __body:
             if query is not None:
-                __body["query"] = query
+                __body["query"] = str(query)
             if columnar is not None:
                 __body["columnar"] = columnar
             if filter is not None:

elasticsearch9/_sync/client/indices.py

@@ -3715,7 +3715,7 @@ class IndicesClient(NamespacedClient):
           <li>Change a field's mapping using reindexing</li>
           <li>Rename a field using a field alias</li>
           </ul>
-          <p>Learn how to use the update mapping API with practical examples in the <a href="https://www.elastic.co/docs//manage-data/data-store/mapping/update-mappings-examples">Update mapping API examples</a> guide.</p>
+          <p>Learn how to use the update mapping API with practical examples in the <a href="https://www.elastic.co/docs/manage-data/data-store/mapping/update-mappings-examples">Update mapping API examples</a> guide.</p>
 
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-indices-put-mapping>`_
@@ -4587,7 +4587,7 @@ class IndicesClient(NamespacedClient):
         .. raw:: html
 
           <p>Roll over to a new index.
-          TIP: It is recommended to use the index lifecycle rollover action to automate rollovers.</p>
+          TIP: We recommend using the index lifecycle rollover action to automate rollovers. However, Serverless does not support Index Lifecycle Management (ILM), so don't use this approach in the Serverless context.</p>
           <p>The rollover API creates a new index for a data stream or index alias.
           The API behavior depends on the rollover target.</p>
           <p><strong>Roll over a data stream</strong></p>

elasticsearch9/_sync/client/logstash.py

@@ -141,7 +141,9 @@ class LogstashClient(NamespacedClient):
 
         `<https://www.elastic.co/docs/api/doc/elasticsearch/v9/operation/operation-logstash-put-pipeline>`_
 
-        :param id: An identifier for the pipeline.
+        :param id: An identifier for the pipeline. Pipeline IDs must begin with a letter
+            or underscore and contain only letters, underscores, dashes, hyphens and
+            numbers.
         :param pipeline:
         """
         if id in SKIP_IN_PATH:

elasticsearch9/_sync/client/sql.py

@@ -283,7 +283,7 @@ class SqlClient(NamespacedClient):
         keep_alive: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
         keep_on_completion: t.Optional[bool] = None,
         page_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
-        params: t.Optional[t.Mapping[str, t.Any]] = None,
+        params: t.Optional[t.Sequence[t.Any]] = None,
         pretty: t.Optional[bool] = None,
         query: t.Optional[str] = None,
         request_timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,

elasticsearch9/_sync/client/transform.py

@@ -602,6 +602,66 @@ class TransformClient(NamespacedClient):
             path_parts=__path_parts,
         )
 
+    @_rewrite_parameters()
+    def set_upgrade_mode(
+        self,
+        *,
+        enabled: t.Optional[bool] = None,
+        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,
+        timeout: t.Optional[t.Union[str, t.Literal[-1], t.Literal[0]]] = None,
+    ) -> ObjectApiResponse[t.Any]:
+        """
+        .. raw:: html
+
+          <p>Set upgrade_mode for transform indices.
+          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,
+          there must be no transforms running. You can close the transforms,
+          do the upgrade, then open all the transforms again. Alternatively,
+          you can use this API to temporarily halt tasks associated with the transforms
+          and prevent new transforms from opening. You can also use this API
+          during upgrades that do not require you to reindex your transform
+          indices, though stopping transforms is not a requirement in that case.
+          You can see the current value for the upgrade_mode setting by using the get
+          transform info API.</p>
+
+
+        `<https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-transform-set-upgrade-mode>`_
+
+        :param enabled: When `true`, it enables `upgrade_mode` which temporarily halts
+            all transform tasks and prohibits new transform tasks from starting.
+        :param timeout: The time to wait for the request to be completed.
+        """
+        __path_parts: t.Dict[str, str] = {}
+        __path = "/_transform/set_upgrade_mode"
+        __query: t.Dict[str, t.Any] = {}
+        if enabled is not None:
+            __query["enabled"] = enabled
+        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
+        if timeout is not None:
+            __query["timeout"] = timeout
+        __headers = {"accept": "application/json"}
+        return self.perform_request(  # type: ignore[return-value]
+            "POST",
+            __path,
+            params=__query,
+            headers=__headers,
+            endpoint_id="transform.set_upgrade_mode",
+            path_parts=__path_parts,
+        )
+
     @_rewrite_parameters(
         parameter_aliases={"from": "from_"},
     )

elasticsearch9/_version.py

@@ -15,4 +15,4 @@
 #  specific language governing permissions and limitations
 #  under the License.
 
-__versionstr__ = "9.0.3"
+__versionstr__ = "9.0.5"

elasticsearch9/dsl/__init__.py

@@ -38,23 +38,30 @@ from .faceted_search import (
     TermsFacet,
 )
 from .field import (
+    AggregateMetricDouble,
+    Alias,
     Binary,
     Boolean,
     Byte,
     Completion,
     ConstantKeyword,
+    CountedKeyword,
     CustomField,
     Date,
+    DateNanos,
     DateRange,
     DenseVector,
     Double,
     DoubleRange,
     Field,
+    Flattened,
     Float,
     FloatRange,
     GeoPoint,
     GeoShape,
     HalfFloat,
+    Histogram,
+    IcuCollationKeyword,
     Integer,
     IntegerRange,
     Ip,
@@ -63,21 +70,28 @@ from .field import (
     Keyword,
     Long,
     LongRange,
+    MatchOnlyText,
     Murmur3,
     Nested,
     Object,
+    Passthrough,
     Percolator,
     Point,
     RangeField,
     RankFeature,
     RankFeatures,
+    RankVectors,
     ScaledFloat,
     SearchAsYouType,
+    SemanticText,
     Shape,
     Short,
     SparseVector,
     Text,
     TokenCount,
+    UnsignedLong,
+    Version,
+    Wildcard,
     construct_field,
 )
 from .function import SF
@@ -108,6 +122,8 @@ __all__ = [
     "A",
     "Agg",
     "AggResponse",
+    "AggregateMetricDouble",
+    "Alias",
     "AsyncComposableIndexTemplate",
     "AsyncDocument",
     "AsyncEmptySearch",
@@ -126,9 +142,11 @@ __all__ = [
     "Completion",
     "ComposableIndexTemplate",
     "ConstantKeyword",
+    "CountedKeyword",
     "CustomField",
     "Date",
     "DateHistogramFacet",
+    "DateNanos",
     "DateRange",
     "DenseVector",
     "Document",
@@ -142,12 +160,15 @@ __all__ = [
     "FacetedResponse",
     "FacetedSearch",
     "Field",
+    "Flattened",
     "Float",
     "FloatRange",
     "GeoPoint",
     "GeoShape",
     "HalfFloat",
+    "Histogram",
     "HistogramFacet",
+    "IcuCollationKeyword",
     "IllegalOperation",
     "Index",
     "IndexTemplate",
@@ -162,12 +183,14 @@ __all__ = [
     "LongRange",
     "M",
     "Mapping",
+    "MatchOnlyText",
     "MetaField",
     "MultiSearch",
     "Murmur3",
     "Nested",
     "NestedFacet",
     "Object",
+    "Passthrough",
     "Percolator",
     "Point",
     "Q",
@@ -177,11 +200,13 @@ __all__ = [
     "RangeField",
     "RankFeature",
     "RankFeatures",
+    "RankVectors",
     "Response",
     "SF",
     "ScaledFloat",
     "Search",
     "SearchAsYouType",
+    "SemanticText",
     "Shape",
     "Short",
     "SparseVector",
@@ -189,9 +214,12 @@ __all__ = [
     "Text",
     "TokenCount",
     "UnknownDslObject",
+    "UnsignedLong",
     "UpdateByQuery",
     "UpdateByQueryResponse",
     "ValidationException",
+    "Version",
+    "Wildcard",
     "analyzer",
     "async_connections",
     "char_filter",

elasticsearch9/dsl/_async/document.py

@@ -20,6 +20,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     AsyncIterable,
+    AsyncIterator,
     Dict,
     List,
     Optional,
@@ -42,6 +43,7 @@ from .search import AsyncSearch
 
 if TYPE_CHECKING:
     from elasticsearch import AsyncElasticsearch
+    from elasticsearch.esql.esql import ESQLBase
 
 
 class AsyncIndexMeta(DocumentMeta):
@@ -520,3 +522,85 @@ class AsyncDocument(DocumentBase, metaclass=AsyncIndexMeta):
                 return action
 
         return await async_bulk(es, Generate(actions), **kwargs)
+
+    @classmethod
+    async def esql_execute(
+        cls,
+        query: "ESQLBase",
+        return_additional: bool = False,
+        ignore_missing_fields: bool = False,
+        using: Optional[AsyncUsingType] = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[Union[Self, Tuple[Self, Dict[str, Any]]]]:
+        """
+        Execute the given ES|QL query and return an iterator of 2-element tuples,
+        where the first element is an instance of this ``Document`` and the
+        second a dictionary with any remaining columns requested in the query.
+
+        :arg query: an ES|QL query object created with the ``esql_from()`` method.
+        :arg return_additional: if ``False`` (the default), this method returns
+            document objects. If set to ``True``, the method returns tuples with
+            a document in the first element and a dictionary with any additional
+            columns returned by the query in the second element.
+        :arg ignore_missing_fields: if ``False`` (the default), all the fields of
+            the document must be present in the query, or else an exception is
+            raised. Set to ``True`` to allow missing fields, which will result in
+            partially initialized document objects.
+        :arg using: connection alias to use, defaults to ``'default'``
+        :arg kwargs: additional options for the ``client.esql.query()`` function.
+        """
+        es = cls._get_connection(using)
+        response = await es.esql.query(query=str(query), **kwargs)
+        query_columns = [col["name"] for col in response.body.get("columns", [])]
+
+        # Here we get the list of columns defined in the document, which are the
+        # columns that we will take from each result to assemble the document
+        # object.
+        # When `for_esql=False` is passed below by default, the list will include
+        # nested fields, which ES|QL does not return, causing an error. When passing
+        # `ignore_missing_fields=True` the list will be generated with
+        # `for_esql=True`, so the error will not occur, but the documents will
+        # not have any Nested objects in them.
+        doc_fields = set(cls._get_field_names(for_esql=ignore_missing_fields))
+        if not ignore_missing_fields and not doc_fields.issubset(set(query_columns)):
+            raise ValueError(
+                f"Not all fields of {cls.__name__} were returned by the query. "
+                "Make sure your document does not use Nested fields, which are "
+                "currently not supported in ES|QL. To force the query to be "
+                "evaluated in spite of the missing fields, pass set the "
+                "ignore_missing_fields=True option in the esql_execute() call."
+            )
+        non_doc_fields: set[str] = set(query_columns) - doc_fields - {"_id"}
+        index_id = query_columns.index("_id")
+
+        results = response.body.get("values", [])
+        for column_values in results:
+            # create a dictionary with all the document fields, expanding the
+            # dot notation returned by ES|QL into the recursive dictionaries
+            # used by Document.from_dict()
+            doc_dict: Dict[str, Any] = {}
+            for col, val in zip(query_columns, column_values):
+                if col in doc_fields:
+                    cols = col.split(".")
+                    d = doc_dict
+                    for c in cols[:-1]:
+                        if c not in d:
+                            d[c] = {}
+                        d = d[c]
+                    d[cols[-1]] = val
+
+            # create the document instance
+            obj = cls(meta={"_id": column_values[index_id]})
+            obj._from_dict(doc_dict)
+
+            if return_additional:
+                # build a dict with any other values included in the response
+                other = {
+                    col: val
+                    for col, val in zip(query_columns, column_values)
+                    if col in non_doc_fields
+                }
+
+                yield obj, other
+            else:
+                yield obj

elasticsearch9/dsl/_sync/document.py

@@ -21,6 +21,7 @@ from typing import (
     Any,
     Dict,
     Iterable,
+    Iterator,
     List,
     Optional,
     Tuple,
@@ -42,6 +43,7 @@ from .search import Search
 
 if TYPE_CHECKING:
     from elasticsearch import Elasticsearch
+    from elasticsearch.esql.esql import ESQLBase
 
 
 class IndexMeta(DocumentMeta):
@@ -512,3 +514,85 @@ class Document(DocumentBase, metaclass=IndexMeta):
                 return action
 
         return bulk(es, Generate(actions), **kwargs)
+
+    @classmethod
+    def esql_execute(
+        cls,
+        query: "ESQLBase",
+        return_additional: bool = False,
+        ignore_missing_fields: bool = False,
+        using: Optional[UsingType] = None,
+        **kwargs: Any,
+    ) -> Iterator[Union[Self, Tuple[Self, Dict[str, Any]]]]:
+        """
+        Execute the given ES|QL query and return an iterator of 2-element tuples,
+        where the first element is an instance of this ``Document`` and the
+        second a dictionary with any remaining columns requested in the query.
+
+        :arg query: an ES|QL query object created with the ``esql_from()`` method.
+        :arg return_additional: if ``False`` (the default), this method returns
+            document objects. If set to ``True``, the method returns tuples with
+            a document in the first element and a dictionary with any additional
+            columns returned by the query in the second element.
+        :arg ignore_missing_fields: if ``False`` (the default), all the fields of
+            the document must be present in the query, or else an exception is
+            raised. Set to ``True`` to allow missing fields, which will result in
+            partially initialized document objects.
+        :arg using: connection alias to use, defaults to ``'default'``
+        :arg kwargs: additional options for the ``client.esql.query()`` function.
+        """
+        es = cls._get_connection(using)
+        response = es.esql.query(query=str(query), **kwargs)
+        query_columns = [col["name"] for col in response.body.get("columns", [])]
+
+        # Here we get the list of columns defined in the document, which are the
+        # columns that we will take from each result to assemble the document
+        # object.
+        # When `for_esql=False` is passed below by default, the list will include
+        # nested fields, which ES|QL does not return, causing an error. When passing
+        # `ignore_missing_fields=True` the list will be generated with
+        # `for_esql=True`, so the error will not occur, but the documents will
+        # not have any Nested objects in them.
+        doc_fields = set(cls._get_field_names(for_esql=ignore_missing_fields))
+        if not ignore_missing_fields and not doc_fields.issubset(set(query_columns)):
+            raise ValueError(
+                f"Not all fields of {cls.__name__} were returned by the query. "
+                "Make sure your document does not use Nested fields, which are "
+                "currently not supported in ES|QL. To force the query to be "
+                "evaluated in spite of the missing fields, pass set the "
+                "ignore_missing_fields=True option in the esql_execute() call."
+            )
+        non_doc_fields: set[str] = set(query_columns) - doc_fields - {"_id"}
+        index_id = query_columns.index("_id")
+
+        results = response.body.get("values", [])
+        for column_values in results:
+            # create a dictionary with all the document fields, expanding the
+            # dot notation returned by ES|QL into the recursive dictionaries
+            # used by Document.from_dict()
+            doc_dict: Dict[str, Any] = {}
+            for col, val in zip(query_columns, column_values):
+                if col in doc_fields:
+                    cols = col.split(".")
+                    d = doc_dict
+                    for c in cols[:-1]:
+                        if c not in d:
+                            d[c] = {}
+                        d = d[c]
+                    d[cols[-1]] = val
+
+            # create the document instance
+            obj = cls(meta={"_id": column_values[index_id]})
+            obj._from_dict(doc_dict)
+
+            if return_additional:
+                # build a dict with any other values included in the response
+                other = {
+                    col: val
+                    for col, val in zip(query_columns, column_values)
+                    if col in non_doc_fields
+                }
+
+                yield obj, other
+            else:
+                yield obj

elasticsearch9/dsl/aggs.py

@@ -643,6 +643,54 @@ class Cardinality(Agg[_R]):
         )
 
 
+class CartesianBounds(Agg[_R]):
+    """
+    A metric aggregation that computes the spatial bounding box containing
+    all values for a Point or Shape field.
+
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "cartesian_bounds"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(field=field, missing=missing, script=script, **kwargs)
+
+
+class CartesianCentroid(Agg[_R]):
+    """
+    A metric aggregation that computes the weighted centroid from all
+    coordinate values for point and shape fields.
+
+    :arg field: The field on which to run the aggregation.
+    :arg missing: The value to apply to documents that do not have a
+        value. By default, documents without a value are ignored.
+    :arg script:
+    """
+
+    name = "cartesian_centroid"
+
+    def __init__(
+        self,
+        *,
+        field: Union[str, "InstrumentedField", "DefaultType"] = DEFAULT,
+        missing: Union[str, int, float, bool, "DefaultType"] = DEFAULT,
+        script: Union["types.Script", Dict[str, Any], "DefaultType"] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(field=field, missing=missing, script=script, **kwargs)
+
+
 class CategorizeText(Bucket[_R]):
     """
     A multi-bucket aggregation that groups semi-structured text into
@@ -725,6 +773,43 @@ class CategorizeText(Bucket[_R]):
         )
 
 
+class ChangePoint(Pipeline[_R]):
+    """
+    A sibling pipeline that detects, spikes, dips, and change points in a
+    metric. Given a distribution of values provided by the sibling multi-
+    bucket aggregation, this aggregation indicates the bucket of any spike
+    or dip and/or the bucket at which the largest change in the
+    distribution of values, if they are statistically significant. There
+    must be at least 22 bucketed values. Fewer than 1,000 is preferred.
+
+    :arg format: `DecimalFormat` pattern for the output value. If
+        specified, the formatted value is returned in the aggregation’s
+        `value_as_string` property.
+    :arg gap_policy: Policy to apply when gaps are found in the data.
+        Defaults to `skip` if omitted.
+    :arg buckets_path: Path to the buckets that contain one set of values
+        to correlate.
+    """
+
+    name = "change_point"
+
+    def __init__(
+        self,
+        *,
+        format: Union[str, "DefaultType"] = DEFAULT,
+        gap_policy: Union[
+            Literal["skip", "insert_zeros", "keep_values"], "DefaultType"
+        ] = DEFAULT,
+        buckets_path: Union[
+            str, Sequence[str], Mapping[str, str], "DefaultType"
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            format=format, gap_policy=gap_policy, buckets_path=buckets_path, **kwargs
+        )
+
+
 class Children(Bucket[_R]):
     """
     A single bucket aggregation that selects child documents that have the
@@ -2960,6 +3045,14 @@ class SignificantTerms(Bucket[_R]):
         the foreground sample with a term divided by the number of
         documents in the background with the term.
     :arg script_heuristic: Customized score, implemented via a script.
+    :arg p_value: Significant terms heuristic that calculates the p-value
+        between the term existing in foreground and background sets.  The
+        p-value is the probability of obtaining test results at least as
+        extreme as the results actually observed, under the assumption
+        that the null hypothesis is correct. The p-value is calculated
+        assuming that the foreground set and the background set are
+        independent https://en.wikipedia.org/wiki/Bernoulli_trial, with
+        the null hypothesis that the probabilities are the same.
     :arg shard_min_doc_count: Regulates the certainty a shard has if the
         term should actually be added to the candidate list or not with
         respect to the `min_doc_count`. Terms will only be considered if
@@ -3013,6 +3106,9 @@ class SignificantTerms(Bucket[_R]):
         script_heuristic: Union[
             "types.ScriptedHeuristic", Dict[str, Any], "DefaultType"
         ] = DEFAULT,
+        p_value: Union[
+            "types.PValueHeuristic", Dict[str, Any], "DefaultType"
+        ] = DEFAULT,
         shard_min_doc_count: Union[int, "DefaultType"] = DEFAULT,
         shard_size: Union[int, "DefaultType"] = DEFAULT,
         size: Union[int, "DefaultType"] = DEFAULT,
@@ -3031,6 +3127,7 @@ class SignificantTerms(Bucket[_R]):
             mutual_information=mutual_information,
             percentage=percentage,
             script_heuristic=script_heuristic,
+            p_value=p_value,
             shard_min_doc_count=shard_min_doc_count,
             shard_size=shard_size,
             size=size,