elasticsearch 9.0.1__py3-none-any.whl → 9.1.0__py3-none-any.whl

elasticsearch/dsl/query.py

@@ -1084,7 +1084,7 @@ class Knn(Query):
     :arg similarity: The minimum similarity for a vector to be considered
         a match
     :arg rescore_vector: Apply oversampling and rescoring to quantized
-        vectors *
+        vectors
     :arg boost: Floating point number used to decrease or increase the
         relevance scores of the query. Boost values are relative to the
         default value of 1.0. A boost value between 0 and 1.0 decreases
@@ -1382,7 +1382,49 @@ class MoreLikeThis(Query):
         min_term_freq: Union[int, "DefaultType"] = DEFAULT,
         min_word_length: Union[int, "DefaultType"] = DEFAULT,
         routing: Union[str, "DefaultType"] = DEFAULT,
-        stop_words: Union[str, Sequence[str], "DefaultType"] = DEFAULT,
+        stop_words: Union[
+            Literal[
+                "_arabic_",
+                "_armenian_",
+                "_basque_",
+                "_bengali_",
+                "_brazilian_",
+                "_bulgarian_",
+                "_catalan_",
+                "_cjk_",
+                "_czech_",
+                "_danish_",
+                "_dutch_",
+                "_english_",
+                "_estonian_",
+                "_finnish_",
+                "_french_",
+                "_galician_",
+                "_german_",
+                "_greek_",
+                "_hindi_",
+                "_hungarian_",
+                "_indonesian_",
+                "_irish_",
+                "_italian_",
+                "_latvian_",
+                "_lithuanian_",
+                "_norwegian_",
+                "_persian_",
+                "_portuguese_",
+                "_romanian_",
+                "_russian_",
+                "_serbian_",
+                "_sorani_",
+                "_spanish_",
+                "_swedish_",
+                "_thai_",
+                "_turkish_",
+                "_none_",
+            ],
+            Sequence[str],
+            "DefaultType",
+        ] = DEFAULT,
         unlike: Union[
             Union[str, "types.LikeDocument"],
             Sequence[Union[str, "types.LikeDocument"]],
@@ -1992,8 +2034,9 @@ class Regexp(Query):
 class Rule(Query):
     """
     :arg organic: (required)
-    :arg ruleset_ids: (required)
     :arg match_criteria: (required)
+    :arg ruleset_ids:
+    :arg ruleset_id:
     :arg boost: Floating point number used to decrease or increase the
         relevance scores of the query. Boost values are relative to the
         default value of 1.0. A boost value between 0 and 1.0 decreases
@@ -2011,16 +2054,18 @@ class Rule(Query):
         self,
         *,
         organic: Union[Query, "DefaultType"] = DEFAULT,
-        ruleset_ids: Union[Sequence[str], "DefaultType"] = DEFAULT,
         match_criteria: Any = DEFAULT,
+        ruleset_ids: Union[str, Sequence[str], "DefaultType"] = DEFAULT,
+        ruleset_id: Union[str, "DefaultType"] = DEFAULT,
         boost: Union[float, "DefaultType"] = DEFAULT,
         _name: Union[str, "DefaultType"] = DEFAULT,
         **kwargs: Any,
     ):
         super().__init__(
             organic=organic,
-            ruleset_ids=ruleset_ids,
             match_criteria=match_criteria,
+            ruleset_ids=ruleset_ids,
+            ruleset_id=ruleset_id,
             boost=boost,
             _name=_name,
             **kwargs,

elasticsearch/dsl/response/__init__.py

@@ -363,7 +363,7 @@ class UpdateByQueryResponse(AttrDict[Any], Generic[_R]):
     deleted: int
     requests_per_second: float
     retries: "types.Retries"
-    task: Union[str, int]
+    task: str
     timed_out: bool
     took: Any
     total: int

elasticsearch/dsl/types.py

@@ -142,6 +142,48 @@ class ChiSquareHeuristic(AttrDict[Any]):
         super().__init__(kwargs)
 
 
+class ChunkingSettings(AttrDict[Any]):
+    """
+    :arg strategy: (required) The chunking strategy: `sentence` or `word`.
+        Defaults to `sentence` if omitted.
+    :arg max_chunk_size: (required) The maximum size of a chunk in words.
+        This value cannot be higher than `300` or lower than `20` (for
+        `sentence` strategy) or `10` (for `word` strategy). Defaults to
+        `250` if omitted.
+    :arg overlap: The number of overlapping words for chunks. It is
+        applicable only to a `word` chunking strategy. This value cannot
+        be higher than half the `max_chunk_size` value. Defaults to `100`
+        if omitted.
+    :arg sentence_overlap: The number of overlapping sentences for chunks.
+        It is applicable only for a `sentence` chunking strategy. It can
+        be either `1` or `0`. Defaults to `1` if omitted.
+    """
+
+    strategy: Union[str, DefaultType]
+    max_chunk_size: Union[int, DefaultType]
+    overlap: Union[int, DefaultType]
+    sentence_overlap: Union[int, DefaultType]
+
+    def __init__(
+        self,
+        *,
+        strategy: Union[str, DefaultType] = DEFAULT,
+        max_chunk_size: Union[int, DefaultType] = DEFAULT,
+        overlap: Union[int, DefaultType] = DEFAULT,
+        sentence_overlap: Union[int, DefaultType] = DEFAULT,
+        **kwargs: Any,
+    ):
+        if strategy is not DEFAULT:
+            kwargs["strategy"] = strategy
+        if max_chunk_size is not DEFAULT:
+            kwargs["max_chunk_size"] = max_chunk_size
+        if overlap is not DEFAULT:
+            kwargs["overlap"] = overlap
+        if sentence_overlap is not DEFAULT:
+            kwargs["sentence_overlap"] = sentence_overlap
+        super().__init__(kwargs)
+
+
 class ClassificationInferenceOptions(AttrDict[Any]):
     """
     :arg num_top_classes: Specifies the number of top class predictions to
@@ -329,6 +371,9 @@ class DenseVectorIndexOptions(AttrDict[Any]):
     :arg m: The number of neighbors each node will be connected to in the
         HNSW graph.  Only applicable to `hnsw`, `int8_hnsw`, `bbq_hnsw`,
         and `int4_hnsw` index types. Defaults to `16` if omitted.
+    :arg rescore_vector: The rescore vector options. This is only
+        applicable to `bbq_hnsw`, `int4_hnsw`, `int8_hnsw`, `bbq_flat`,
+        `int4_flat`, and `int8_flat` index types.
     """
 
     type: Union[
@@ -347,6 +392,9 @@ class DenseVectorIndexOptions(AttrDict[Any]):
     confidence_interval: Union[float, DefaultType]
     ef_construction: Union[int, DefaultType]
     m: Union[int, DefaultType]
+    rescore_vector: Union[
+        "DenseVectorIndexOptionsRescoreVector", Dict[str, Any], DefaultType
+    ]
 
     def __init__(
         self,
@@ -367,6 +415,9 @@ class DenseVectorIndexOptions(AttrDict[Any]):
         confidence_interval: Union[float, DefaultType] = DEFAULT,
         ef_construction: Union[int, DefaultType] = DEFAULT,
         m: Union[int, DefaultType] = DEFAULT,
+        rescore_vector: Union[
+            "DenseVectorIndexOptionsRescoreVector", Dict[str, Any], DefaultType
+        ] = DEFAULT,
         **kwargs: Any,
     ):
         if type is not DEFAULT:
@@ -377,6 +428,29 @@ class DenseVectorIndexOptions(AttrDict[Any]):
             kwargs["ef_construction"] = ef_construction
         if m is not DEFAULT:
             kwargs["m"] = m
+        if rescore_vector is not DEFAULT:
+            kwargs["rescore_vector"] = rescore_vector
+        super().__init__(kwargs)
+
+
+class DenseVectorIndexOptionsRescoreVector(AttrDict[Any]):
+    """
+    :arg oversample: (required) The oversampling factor to use when
+        searching for the nearest neighbor. This is only applicable to the
+        quantized formats: `bbq_*`, `int4_*`, and `int8_*`. When provided,
+        `oversample * k` vectors will be gathered and then their scores
+        will be re-computed with the original vectors.  valid values are
+        between `1.0` and `10.0` (inclusive), or `0` exactly to disable
+        oversampling.
+    """
+
+    oversample: Union[float, DefaultType]
+
+    def __init__(
+        self, *, oversample: Union[float, DefaultType] = DEFAULT, **kwargs: Any
+    ):
+        if oversample is not DEFAULT:
+            kwargs["oversample"] = oversample
         super().__init__(kwargs)
 
 
@@ -871,7 +945,7 @@ class GeoDistanceSort(AttrDict[Any]):
 
 class GeoGridQuery(AttrDict[Any]):
     """
-    :arg geogrid:
+    :arg geotile:
     :arg geohash:
     :arg geohex:
     :arg boost: Floating point number used to decrease or increase the
@@ -882,7 +956,7 @@ class GeoGridQuery(AttrDict[Any]):
     :arg _name:
     """
 
-    geogrid: Union[str, DefaultType]
+    geotile: Union[str, DefaultType]
     geohash: Union[str, DefaultType]
     geohex: Union[str, DefaultType]
     boost: Union[float, DefaultType]
@@ -891,15 +965,15 @@ class GeoGridQuery(AttrDict[Any]):
     def __init__(
         self,
         *,
-        geogrid: Union[str, DefaultType] = DEFAULT,
+        geotile: Union[str, DefaultType] = DEFAULT,
         geohash: Union[str, DefaultType] = DEFAULT,
         geohex: Union[str, DefaultType] = DEFAULT,
         boost: Union[float, DefaultType] = DEFAULT,
         _name: Union[str, DefaultType] = DEFAULT,
         **kwargs: Any,
     ):
-        if geogrid is not DEFAULT:
-            kwargs["geogrid"] = geogrid
+        if geotile is not DEFAULT:
+            kwargs["geotile"] = geotile
         if geohash is not DEFAULT:
             kwargs["geohash"] = geohash
         if geohex is not DEFAULT:
@@ -1137,6 +1211,7 @@ class Highlight(AttrDict[Any]):
 
     fields: Union[
         Mapping[Union[str, InstrumentedField], "HighlightField"],
+        Sequence[Mapping[Union[str, InstrumentedField], "HighlightField"]],
         Dict[str, Any],
         DefaultType,
     ]
@@ -1168,6 +1243,7 @@ class Highlight(AttrDict[Any]):
         *,
         fields: Union[
             Mapping[Union[str, InstrumentedField], "HighlightField"],
+            Sequence[Mapping[Union[str, InstrumentedField], "HighlightField"]],
             Dict[str, Any],
             DefaultType,
         ] = DEFAULT,
@@ -1561,11 +1637,7 @@ class InnerHits(AttrDict[Any]):
         DefaultType,
     ]
     seq_no_primary_term: Union[bool, DefaultType]
-    fields: Union[
-        Union[str, InstrumentedField],
-        Sequence[Union[str, InstrumentedField]],
-        DefaultType,
-    ]
+    fields: Union[Sequence[Union[str, InstrumentedField]], DefaultType]
     sort: Union[
         Union[Union[str, InstrumentedField], "SortOptions"],
         Sequence[Union[Union[str, InstrumentedField], "SortOptions"]],
@@ -1600,11 +1672,7 @@ class InnerHits(AttrDict[Any]):
             DefaultType,
         ] = DEFAULT,
         seq_no_primary_term: Union[bool, DefaultType] = DEFAULT,
-        fields: Union[
-            Union[str, InstrumentedField],
-            Sequence[Union[str, InstrumentedField]],
-            DefaultType,
-        ] = DEFAULT,
+        fields: Union[Sequence[Union[str, InstrumentedField]], DefaultType] = DEFAULT,
         sort: Union[
             Union[Union[str, InstrumentedField], "SortOptions"],
             Sequence[Union[Union[str, InstrumentedField], "SortOptions"]],
@@ -1733,6 +1801,8 @@ class IntervalsContainer(AttrDict[Any]):
     :arg match: Matches analyzed text.
     :arg prefix: Matches terms that start with a specified set of
         characters.
+    :arg range:
+    :arg regexp:
     :arg wildcard: Matches terms using a wildcard pattern.
     """
 
@@ -1741,6 +1811,8 @@ class IntervalsContainer(AttrDict[Any]):
     fuzzy: Union["IntervalsFuzzy", Dict[str, Any], DefaultType]
     match: Union["IntervalsMatch", Dict[str, Any], DefaultType]
     prefix: Union["IntervalsPrefix", Dict[str, Any], DefaultType]
+    range: Union["IntervalsRange", Dict[str, Any], DefaultType]
+    regexp: Union["IntervalsRegexp", Dict[str, Any], DefaultType]
     wildcard: Union["IntervalsWildcard", Dict[str, Any], DefaultType]
 
     def __init__(
@@ -1751,6 +1823,8 @@ class IntervalsContainer(AttrDict[Any]):
         fuzzy: Union["IntervalsFuzzy", Dict[str, Any], DefaultType] = DEFAULT,
         match: Union["IntervalsMatch", Dict[str, Any], DefaultType] = DEFAULT,
         prefix: Union["IntervalsPrefix", Dict[str, Any], DefaultType] = DEFAULT,
+        range: Union["IntervalsRange", Dict[str, Any], DefaultType] = DEFAULT,
+        regexp: Union["IntervalsRegexp", Dict[str, Any], DefaultType] = DEFAULT,
         wildcard: Union["IntervalsWildcard", Dict[str, Any], DefaultType] = DEFAULT,
         **kwargs: Any,
     ):
@@ -1764,6 +1838,10 @@ class IntervalsContainer(AttrDict[Any]):
             kwargs["match"] = match
         if prefix is not DEFAULT:
             kwargs["prefix"] = prefix
+        if range is not DEFAULT:
+            kwargs["range"] = range
+        if regexp is not DEFAULT:
+            kwargs["regexp"] = regexp
         if wildcard is not DEFAULT:
             kwargs["wildcard"] = wildcard
         super().__init__(kwargs)
@@ -1984,6 +2062,8 @@ class IntervalsQuery(AttrDict[Any]):
     :arg match: Matches analyzed text.
     :arg prefix: Matches terms that start with a specified set of
         characters.
+    :arg range:
+    :arg regexp:
     :arg wildcard: Matches terms using a wildcard pattern.
     :arg boost: Floating point number used to decrease or increase the
         relevance scores of the query. Boost values are relative to the
@@ -1998,6 +2078,8 @@ class IntervalsQuery(AttrDict[Any]):
     fuzzy: Union["IntervalsFuzzy", Dict[str, Any], DefaultType]
     match: Union["IntervalsMatch", Dict[str, Any], DefaultType]
     prefix: Union["IntervalsPrefix", Dict[str, Any], DefaultType]
+    range: Union["IntervalsRange", Dict[str, Any], DefaultType]
+    regexp: Union["IntervalsRegexp", Dict[str, Any], DefaultType]
     wildcard: Union["IntervalsWildcard", Dict[str, Any], DefaultType]
     boost: Union[float, DefaultType]
     _name: Union[str, DefaultType]
@@ -2010,6 +2092,8 @@ class IntervalsQuery(AttrDict[Any]):
         fuzzy: Union["IntervalsFuzzy", Dict[str, Any], DefaultType] = DEFAULT,
         match: Union["IntervalsMatch", Dict[str, Any], DefaultType] = DEFAULT,
         prefix: Union["IntervalsPrefix", Dict[str, Any], DefaultType] = DEFAULT,
+        range: Union["IntervalsRange", Dict[str, Any], DefaultType] = DEFAULT,
+        regexp: Union["IntervalsRegexp", Dict[str, Any], DefaultType] = DEFAULT,
         wildcard: Union["IntervalsWildcard", Dict[str, Any], DefaultType] = DEFAULT,
         boost: Union[float, DefaultType] = DEFAULT,
         _name: Union[str, DefaultType] = DEFAULT,
@@ -2025,6 +2109,10 @@ class IntervalsQuery(AttrDict[Any]):
             kwargs["match"] = match
         if prefix is not DEFAULT:
             kwargs["prefix"] = prefix
+        if range is not DEFAULT:
+            kwargs["range"] = range
+        if regexp is not DEFAULT:
+            kwargs["regexp"] = regexp
         if wildcard is not DEFAULT:
             kwargs["wildcard"] = wildcard
         if boost is not DEFAULT:
@@ -2034,6 +2122,83 @@ class IntervalsQuery(AttrDict[Any]):
         super().__init__(kwargs)
 
 
+class IntervalsRange(AttrDict[Any]):
+    """
+    :arg analyzer: Analyzer used to analyze the `prefix`.
+    :arg gte: Lower term, either gte or gt must be provided.
+    :arg gt: Lower term, either gte or gt must be provided.
+    :arg lte: Upper term, either lte or lt must be provided.
+    :arg lt: Upper term, either lte or lt must be provided.
+    :arg use_field: If specified, match intervals from this field rather
+        than the top-level field. The `prefix` is normalized using the
+        search analyzer from this field, unless `analyzer` is specified
+        separately.
+    """
+
+    analyzer: Union[str, DefaultType]
+    gte: Union[str, DefaultType]
+    gt: Union[str, DefaultType]
+    lte: Union[str, DefaultType]
+    lt: Union[str, DefaultType]
+    use_field: Union[str, InstrumentedField, DefaultType]
+
+    def __init__(
+        self,
+        *,
+        analyzer: Union[str, DefaultType] = DEFAULT,
+        gte: Union[str, DefaultType] = DEFAULT,
+        gt: Union[str, DefaultType] = DEFAULT,
+        lte: Union[str, DefaultType] = DEFAULT,
+        lt: Union[str, DefaultType] = DEFAULT,
+        use_field: Union[str, InstrumentedField, DefaultType] = DEFAULT,
+        **kwargs: Any,
+    ):
+        if analyzer is not DEFAULT:
+            kwargs["analyzer"] = analyzer
+        if gte is not DEFAULT:
+            kwargs["gte"] = gte
+        if gt is not DEFAULT:
+            kwargs["gt"] = gt
+        if lte is not DEFAULT:
+            kwargs["lte"] = lte
+        if lt is not DEFAULT:
+            kwargs["lt"] = lt
+        if use_field is not DEFAULT:
+            kwargs["use_field"] = str(use_field)
+        super().__init__(kwargs)
+
+
+class IntervalsRegexp(AttrDict[Any]):
+    """
+    :arg pattern: (required) Regex pattern.
+    :arg analyzer: Analyzer used to analyze the `prefix`.
+    :arg use_field: If specified, match intervals from this field rather
+        than the top-level field. The `prefix` is normalized using the
+        search analyzer from this field, unless `analyzer` is specified
+        separately.
+    """
+
+    pattern: Union[str, DefaultType]
+    analyzer: Union[str, DefaultType]
+    use_field: Union[str, InstrumentedField, DefaultType]
+
+    def __init__(
+        self,
+        *,
+        pattern: Union[str, DefaultType] = DEFAULT,
+        analyzer: Union[str, DefaultType] = DEFAULT,
+        use_field: Union[str, InstrumentedField, DefaultType] = DEFAULT,
+        **kwargs: Any,
+    ):
+        if pattern is not DEFAULT:
+            kwargs["pattern"] = pattern
+        if analyzer is not DEFAULT:
+            kwargs["analyzer"] = analyzer
+        if use_field is not DEFAULT:
+            kwargs["use_field"] = str(use_field)
+        super().__init__(kwargs)
+
+
 class IntervalsWildcard(AttrDict[Any]):
     """
     :arg pattern: (required) Wildcard pattern used to find matching terms.
@@ -3051,10 +3216,15 @@ class SortOptions(AttrDict[Any]):
 
 class SourceFilter(AttrDict[Any]):
     """
-    :arg excludes:
-    :arg includes:
+    :arg exclude_vectors: If `true`, vector fields are excluded from the
+        returned source.  This option takes precedence over `includes`:
+        any vector field will remain excluded even if it matches an
+        `includes` rule.
+    :arg excludes: A list of fields to exclude from the returned source.
+    :arg includes: A list of fields to include in the returned source.
     """
 
+    exclude_vectors: Union[bool, DefaultType]
     excludes: Union[
         Union[str, InstrumentedField],
         Sequence[Union[str, InstrumentedField]],
@@ -3069,6 +3239,7 @@ class SourceFilter(AttrDict[Any]):
     def __init__(
         self,
         *,
+        exclude_vectors: Union[bool, DefaultType] = DEFAULT,
         excludes: Union[
             Union[str, InstrumentedField],
             Sequence[Union[str, InstrumentedField]],
@@ -3081,6 +3252,8 @@ class SourceFilter(AttrDict[Any]):
         ] = DEFAULT,
         **kwargs: Any,
     ):
+        if exclude_vectors is not DEFAULT:
+            kwargs["exclude_vectors"] = exclude_vectors
         if excludes is not DEFAULT:
             kwargs["excludes"] = str(excludes)
         if includes is not DEFAULT:
@@ -3530,6 +3703,38 @@ class SpanWithinQuery(AttrDict[Any]):
         super().__init__(kwargs)
 
 
+class SparseVectorIndexOptions(AttrDict[Any]):
+    """
+    :arg prune: Whether to perform pruning, omitting the non-significant
+        tokens from the query to improve query performance. If prune is
+        true but the pruning_config is not specified, pruning will occur
+        but default values will be used. Default: false
+    :arg pruning_config: Optional pruning configuration. If enabled, this
+        will omit non-significant tokens from the query in order to
+        improve query performance. This is only used if prune is set to
+        true. If prune is set to true but pruning_config is not specified,
+        default values will be used.
+    """
+
+    prune: Union[bool, DefaultType]
+    pruning_config: Union["TokenPruningConfig", Dict[str, Any], DefaultType]
+
+    def __init__(
+        self,
+        *,
+        prune: Union[bool, DefaultType] = DEFAULT,
+        pruning_config: Union[
+            "TokenPruningConfig", Dict[str, Any], DefaultType
+        ] = DEFAULT,
+        **kwargs: Any,
+    ):
+        if prune is not DEFAULT:
+            kwargs["prune"] = prune
+        if pruning_config is not DEFAULT:
+            kwargs["pruning_config"] = pruning_config
+        super().__init__(kwargs)
+
+
 class SuggestContext(AttrDict[Any]):
     """
     :arg name: (required)
@@ -3568,15 +3773,30 @@ class TDigest(AttrDict[Any]):
     :arg compression: Limits the maximum number of nodes used by the
         underlying TDigest algorithm to `20 * compression`, enabling
         control of memory usage and approximation error.
+    :arg execution_hint: The default implementation of TDigest is
+        optimized for performance, scaling to millions or even billions of
+        sample values while maintaining acceptable accuracy levels (close
+        to 1% relative error for millions of samples in some cases). To
+        use an implementation optimized for accuracy, set this parameter
+        to high_accuracy instead. Defaults to `default` if omitted.
     """
 
     compression: Union[int, DefaultType]
+    execution_hint: Union[Literal["default", "high_accuracy"], DefaultType]
 
     def __init__(
-        self, *, compression: Union[int, DefaultType] = DEFAULT, **kwargs: Any
+        self,
+        *,
+        compression: Union[int, DefaultType] = DEFAULT,
+        execution_hint: Union[
+            Literal["default", "high_accuracy"], DefaultType
+        ] = DEFAULT,
+        **kwargs: Any,
     ):
         if compression is not DEFAULT:
             kwargs["compression"] = compression
+        if execution_hint is not DEFAULT:
+            kwargs["execution_hint"] = execution_hint
         super().__init__(kwargs)
 
 
@@ -4046,7 +4266,7 @@ class WeightedTokensQuery(AttrDict[Any]):
     :arg _name:
     """
 
-    tokens: Union[Mapping[str, float], DefaultType]
+    tokens: Union[Mapping[str, float], Sequence[Mapping[str, float]], DefaultType]
     pruning_config: Union["TokenPruningConfig", Dict[str, Any], DefaultType]
     boost: Union[float, DefaultType]
     _name: Union[str, DefaultType]
@@ -4054,7 +4274,9 @@ class WeightedTokensQuery(AttrDict[Any]):
     def __init__(
         self,
         *,
-        tokens: Union[Mapping[str, float], DefaultType] = DEFAULT,
+        tokens: Union[
+            Mapping[str, float], Sequence[Mapping[str, float]], DefaultType
+        ] = DEFAULT,
         pruning_config: Union[
             "TokenPruningConfig", Dict[str, Any], DefaultType
         ] = DEFAULT,
@@ -4740,7 +4962,7 @@ class ErrorCause(AttrDict[Any]):
     """
 
     type: str
-    reason: str
+    reason: Union[str, None]
     stack_trace: str
     caused_by: "ErrorCause"
     root_cause: Sequence["ErrorCause"]
@@ -4956,9 +5178,11 @@ class FiltersAggregate(AttrDict[Any]):
 class FiltersBucket(AttrDict[Any]):
     """
     :arg doc_count: (required)
+    :arg key:
     """
 
     doc_count: int
+    key: str
 
 
 class FrequentItemSetsAggregate(AttrDict[Any]):

elasticsearch/dsl/utils.py

@@ -333,7 +333,7 @@ class DslBase(metaclass=DslMeta):
             _expand__to_dot = EXPAND__TO_DOT
         self._params: Dict[str, Any] = {}
         for pname, pvalue in params.items():
-            if pvalue == DEFAULT:
+            if pvalue is DEFAULT:
                 continue
             # expand "__" to dots
             if "__" in pname and _expand__to_dot:

elasticsearch/esql/__init__.py

@@ -0,0 +1,18 @@
+#  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.
+
+from .esql import ESQL, and_, not_, or_  # noqa: F401