elasticsearch9 9.0.0__py3-none-any.whl

elasticsearch9/dsl/wrappers.py

@@ -0,0 +1,144 @@
+#  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.
+
+import operator
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    Literal,
+    Mapping,
+    Optional,
+    Tuple,
+    TypeVar,
+    Union,
+    cast,
+)
+
+if TYPE_CHECKING:
+    from _operator import _SupportsComparison
+
+from typing_extensions import TypeAlias
+
+from .utils import AttrDict
+
+ComparisonOperators: TypeAlias = Literal["lt", "lte", "gt", "gte"]
+RangeValT = TypeVar("RangeValT", bound="_SupportsComparison")
+
+__all__ = ["Range"]
+
+
+class Range(AttrDict[RangeValT]):
+    OPS: ClassVar[
+        Mapping[
+            ComparisonOperators,
+            Callable[["_SupportsComparison", "_SupportsComparison"], bool],
+        ]
+    ] = {
+        "lt": operator.lt,
+        "lte": operator.le,
+        "gt": operator.gt,
+        "gte": operator.ge,
+    }
+
+    def __init__(
+        self,
+        d: Optional[Dict[str, RangeValT]] = None,
+        /,
+        **kwargs: RangeValT,
+    ):
+        if d is not None and (kwargs or not isinstance(d, dict)):
+            raise ValueError(
+                "Range accepts a single dictionary or a set of keyword arguments."
+            )
+
+        if d is None:
+            data = kwargs
+        else:
+            data = d
+
+        for k in data:
+            if k not in self.OPS:
+                raise ValueError(f"Range received an unknown operator {k!r}")
+
+        if "gt" in data and "gte" in data:
+            raise ValueError("You cannot specify both gt and gte for Range.")
+
+        if "lt" in data and "lte" in data:
+            raise ValueError("You cannot specify both lt and lte for Range.")
+
+        super().__init__(data)
+
+    def __repr__(self) -> str:
+        return "Range(%s)" % ", ".join("%s=%r" % op for op in self._d_.items())
+
+    def __contains__(self, item: object) -> bool:
+        if isinstance(item, str):
+            return super().__contains__(item)
+
+        item_supports_comp = any(hasattr(item, f"__{op}__") for op in self.OPS)
+        if not item_supports_comp:
+            return False
+
+        for op in self.OPS:
+            if op in self._d_ and not self.OPS[op](
+                cast("_SupportsComparison", item), self._d_[op]
+            ):
+                return False
+        return True
+
+    @property
+    def upper(self) -> Union[Tuple[RangeValT, bool], Tuple[None, Literal[False]]]:
+        if "lt" in self._d_:
+            return self._d_["lt"], False
+        if "lte" in self._d_:
+            return self._d_["lte"], True
+        return None, False
+
+    @property
+    def lower(self) -> Union[Tuple[RangeValT, bool], Tuple[None, Literal[False]]]:
+        if "gt" in self._d_:
+            return self._d_["gt"], False
+        if "gte" in self._d_:
+            return self._d_["gte"], True
+        return None, False
+
+
+class AggregationRange(AttrDict[Any]):
+    """
+    :arg from: Start of the range (inclusive).
+    :arg key: Custom key to return the range with.
+    :arg to: End of the range (exclusive).
+    """
+
+    def __init__(
+        self,
+        *,
+        from_: Any = None,
+        key: Optional[str] = None,
+        to: Any = None,
+        **kwargs: Any,
+    ):
+        if from_ is not None:
+            kwargs["from_"] = from_
+        if key is not None:
+            kwargs["key"] = key
+        if to is not None:
+            kwargs["to"] = to
+        super().__init__(kwargs)

elasticsearch9/exceptions.py

@@ -0,0 +1,133 @@
+#  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 typing import Any, Dict, Type
+
+from elastic_transport import ApiError as _ApiError
+from elastic_transport import ConnectionError as ConnectionError
+from elastic_transport import ConnectionTimeout as ConnectionTimeout
+from elastic_transport import SerializationError as SerializationError
+from elastic_transport import TlsError as SSLError
+from elastic_transport import TransportError as TransportError
+from elastic_transport import TransportWarning
+
+__all__ = [
+    "SerializationError",
+    "TransportError",
+    "ConnectionError",
+    "SSLError",
+    "ConnectionTimeout",
+    "AuthorizationException",
+    "AuthenticationException",
+    "NotFoundError",
+    "ConflictError",
+    "BadRequestError",
+]
+
+
+class ApiError(_ApiError):
+    @property
+    def status_code(self) -> int:
+        """Backwards-compatible way to access ``self.meta.status``"""
+        return self.meta.status
+
+    @property
+    def error(self) -> str:
+        """Backwards-compatible way to access ``self.message``"""
+        return self.message
+
+    @property
+    def info(self) -> Any:
+        """Backwards-compatible way to access ``self.body``"""
+        return self.body
+
+    def __str__(self) -> str:
+        cause = ""
+        try:
+            if self.body and isinstance(self.body, dict) and "error" in self.body:
+                if isinstance(self.body["error"], dict):
+                    root_cause = self.body["error"]["root_cause"][0]
+                    cause = ", ".join(
+                        filter(
+                            None,
+                            [
+                                repr(root_cause["reason"]),
+                                root_cause.get("resource.id"),
+                                root_cause.get("resource.type"),
+                            ],
+                        )
+                    )
+
+                else:
+                    cause = repr(self.body["error"])
+        except LookupError:
+            pass
+        msg = ", ".join(filter(None, [str(self.status_code), repr(self.error), cause]))
+        return f"{self.__class__.__name__}({msg})"
+
+
+class UnsupportedProductError(ApiError):
+    """Error which is raised when the client detects
+    it's not connected to a supported product.
+    """
+
+    def __str__(self) -> str:
+        return self.message
+
+
+class NotFoundError(ApiError):
+    """Exception representing a 404 status code."""
+
+
+class ConflictError(ApiError):
+    """Exception representing a 409 status code."""
+
+
+class BadRequestError(ApiError):
+    """Exception representing a 400 status code."""
+
+
+class AuthenticationException(ApiError):
+    """Exception representing a 401 status code."""
+
+
+class AuthorizationException(ApiError):
+    """Exception representing a 403 status code."""
+
+
+class ElasticsearchWarning(TransportWarning):
+    """Warning that is raised when a deprecated option
+    or incorrect usage is flagged via the 'Warning' HTTP header.
+    """
+
+
+class GeneralAvailabilityWarning(TransportWarning):
+    """Warning that is raised when a feature is not yet GA."""
+
+
+# Aliases for backwards compatibility
+ElasticsearchDeprecationWarning = ElasticsearchWarning
+RequestError = BadRequestError
+
+
+HTTP_EXCEPTIONS: Dict[int, Type[ApiError]] = {
+    400: BadRequestError,
+    401: AuthenticationException,
+    403: AuthorizationException,
+    404: NotFoundError,
+    409: ConflictError,
+}

elasticsearch9/helpers/__init__.py

@@ -0,0 +1,41 @@
+#  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 .._async.helpers import async_bulk, async_reindex, async_scan, async_streaming_bulk
+from .._utils import fixup_module_metadata
+from .actions import _chunk_actions  # noqa: F401
+from .actions import _process_bulk_chunk  # noqa: F401
+from .actions import bulk, expand_action, parallel_bulk, reindex, scan, streaming_bulk
+from .errors import BulkIndexError, ScanError
+
+__all__ = [
+    "BulkIndexError",
+    "ScanError",
+    "expand_action",
+    "streaming_bulk",
+    "bulk",
+    "parallel_bulk",
+    "scan",
+    "reindex",
+    "async_scan",
+    "async_bulk",
+    "async_reindex",
+    "async_streaming_bulk",
+]
+
+fixup_module_metadata(__name__, globals())
+del fixup_module_metadata