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

elasticsearch9/dsl/types.py

@@ -142,48 +142,6 @@ 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
@@ -371,9 +329,6 @@ 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[
@@ -392,9 +347,6 @@ 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,
@@ -415,9 +367,6 @@ 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:
@@ -428,29 +377,6 @@ 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)
 
 
@@ -945,7 +871,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
@@ -956,7 +882,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]
@@ -965,15 +891,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:
@@ -1799,6 +1725,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.
     """
 
@@ -1807,6 +1735,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__(
@@ -1817,6 +1747,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,
     ):
@@ -1830,6 +1762,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)
@@ -2050,6 +1986,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
@@ -2064,6 +2002,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]
@@ -2076,6 +2016,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,
@@ -2091,6 +2033,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:
@@ -2100,6 +2046,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.
@@ -4806,7 +4829,7 @@ class ErrorCause(AttrDict[Any]):
     """
 
     type: str
-    reason: str
+    reason: Union[str, None]
     stack_trace: str
     caused_by: "ErrorCause"
     root_cause: Sequence["ErrorCause"]
@@ -5022,9 +5045,11 @@ class FiltersAggregate(AttrDict[Any]):
 class FiltersBucket(AttrDict[Any]):
     """
     :arg doc_count: (required)
+    :arg key:
     """
 
     doc_count: int
+    key: str
 
 
 class FrequentItemSetsAggregate(AttrDict[Any]):

elasticsearch9/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:

elasticsearch9/{dsl/_sync/_sync_check → esql}/__init__.py

@@ -14,3 +14,5 @@
 #  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