meilisearch-python-sdk 5.5.0__py3-none-any.whl

meilisearch_python_sdk/_http_requests.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import gzip
+from collections.abc import Callable
+from functools import lru_cache
+from typing import Any
+
+from httpx import (
+    AsyncClient,
+    Client,
+    ConnectError,
+    ConnectTimeout,
+    HTTPError,
+    RemoteProtocolError,
+    Response,
+)
+
+from meilisearch_python_sdk._version import VERSION
+from meilisearch_python_sdk.errors import (
+    MeilisearchApiError,
+    MeilisearchCommunicationError,
+    MeilisearchError,
+)
+from meilisearch_python_sdk.json_handler import BuiltinHandler, OrjsonHandler, UjsonHandler
+
+
+class AsyncHttpRequests:
+    def __init__(
+        self, http_client: AsyncClient, json_handler: BuiltinHandler | OrjsonHandler | UjsonHandler
+    ) -> None:
+        self.http_client = http_client
+        self.json_handler = json_handler
+
+    async def _send_request(
+        self,
+        http_method: Callable,
+        path: str,
+        body: Any | None = None,
+        content_type: str = "application/json",
+        compress: bool = False,
+    ) -> Response:
+        headers = build_headers(content_type, compress)
+
+        try:
+            if body is None:
+                response = await http_method(path)
+            elif content_type == "application/json" and not compress:
+                response = await http_method(
+                    path, content=self.json_handler.dumps(body), headers=headers
+                )
+            else:
+                if body and compress:
+                    if content_type == "application/json":
+                        body = gzip.compress(self.json_handler.dumps(body).encode("utf-8"))
+                    else:
+                        body = gzip.compress((body).encode("utf-8"))
+                response = await http_method(path, content=body, headers=headers)
+
+            response.raise_for_status()
+            return response
+
+        except (ConnectError, ConnectTimeout, RemoteProtocolError) as err:
+            raise MeilisearchCommunicationError(str(err)) from err
+        except HTTPError as err:
+            if "response" in locals():
+                if "application/json" in response.headers.get("content-type", ""):
+                    raise MeilisearchApiError(str(err), response) from err
+                else:
+                    raise
+            else:
+                # Fail safe just in case error happens before response is created
+                raise MeilisearchError(str(err)) from err  # pragma: no cover
+
+    async def get(self, path: str) -> Response:
+        return await self._send_request(self.http_client.get, path)
+
+    async def patch(
+        self,
+        path: str,
+        body: Any | None = None,
+        content_type: str = "application/json",
+        compress: bool = False,
+    ) -> Response:
+        return await self._send_request(self.http_client.patch, path, body, content_type, compress)
+
+    async def post(
+        self,
+        path: str,
+        body: Any | None = None,
+        content_type: str = "application/json",
+        compress: bool = False,
+    ) -> Response:
+        return await self._send_request(self.http_client.post, path, body, content_type, compress)
+
+    async def put(
+        self,
+        path: str,
+        body: Any | None = None,
+        content_type: str = "application/json",
+        compress: bool = False,
+    ) -> Response:
+        return await self._send_request(self.http_client.put, path, body, content_type, compress)
+
+    async def delete(self, path: str, body: dict | None = None) -> Response:
+        return await self._send_request(self.http_client.delete, path, body)
+
+
+class HttpRequests:
+    def __init__(
+        self, http_client: Client, json_handler: BuiltinHandler | OrjsonHandler | UjsonHandler
+    ) -> None:
+        self.http_client = http_client
+        self.json_handler = json_handler
+
+    def _send_request(
+        self,
+        http_method: Callable,
+        path: str,
+        body: Any | None = None,
+        content_type: str = "application/json",
+        compress: bool = False,
+    ) -> Response:
+        headers = build_headers(content_type, compress)
+        try:
+            if body is None:
+                response = http_method(path)
+            elif content_type == "application/json" and not compress:
+                response = http_method(path, content=self.json_handler.dumps(body), headers=headers)
+            else:
+                if body and compress:
+                    if content_type == "application/json":
+                        body = gzip.compress(self.json_handler.dumps(body).encode("utf-8"))
+                    else:
+                        body = gzip.compress((body).encode("utf-8"))
+                response = http_method(path, content=body, headers=headers)
+
+            response.raise_for_status()
+            return response
+
+        except (ConnectError, ConnectTimeout, RemoteProtocolError) as err:
+            raise MeilisearchCommunicationError(str(err)) from err
+        except HTTPError as err:
+            if "response" in locals():
+                if "application/json" in response.headers.get("content-type", ""):
+                    raise MeilisearchApiError(str(err), response) from err
+                else:
+                    raise
+            else:
+                # Fail safe just in case error happens before response is created
+                raise MeilisearchError(str(err)) from err  # pragma: no cover
+
+    def get(self, path: str) -> Response:
+        return self._send_request(self.http_client.get, path)
+
+    def patch(
+        self,
+        path: str,
+        body: Any | None = None,
+        content_type: str = "application/json",
+        compress: bool = False,
+    ) -> Response:
+        return self._send_request(self.http_client.patch, path, body, content_type, compress)
+
+    def post(
+        self,
+        path: str,
+        body: Any | None = None,
+        content_type: str = "application/json",
+        compress: bool = False,
+    ) -> Response:
+        return self._send_request(self.http_client.post, path, body, content_type, compress)
+
+    def put(
+        self,
+        path: str,
+        body: Any | None = None,
+        content_type: str = "application/json",
+        compress: bool = False,
+    ) -> Response:
+        return self._send_request(self.http_client.put, path, body, content_type, compress)
+
+    def delete(self, path: str, body: dict | None = None) -> Response:
+        return self._send_request(self.http_client.delete, path, body)
+
+
+def build_headers(content_type: str, compress: bool) -> dict[str, str]:
+    headers = {"user-agent": user_agent(), "Content-Type": content_type}
+
+    if compress:
+        headers["Content-Encoding"] = "gzip"
+
+    return headers
+
+
+@lru_cache(maxsize=1)
+def user_agent() -> str:
+    return f"Meilisearch Python SDK (v{VERSION})"

meilisearch_python_sdk/_task.py

@@ -0,0 +1,368 @@
+from __future__ import annotations
+
+import asyncio
+import time
+from datetime import datetime
+from typing import TYPE_CHECKING
+from urllib.parse import urlencode
+
+from httpx import AsyncClient as HttpxAsyncClient
+from httpx import Client as HttpxClient
+
+from meilisearch_python_sdk._http_requests import AsyncHttpRequests, HttpRequests
+from meilisearch_python_sdk._utils import get_async_client, get_client
+from meilisearch_python_sdk.errors import MeilisearchTaskFailedError, MeilisearchTimeoutError
+from meilisearch_python_sdk.json_handler import BuiltinHandler, OrjsonHandler, UjsonHandler
+from meilisearch_python_sdk.models.task import TaskInfo, TaskResult, TaskStatus
+
+if TYPE_CHECKING:
+    from meilisearch_python_sdk._client import AsyncClient, Client  # pragma: no cover
+
+
+async def async_cancel_tasks(
+    client: HttpxAsyncClient | AsyncClient,
+    *,
+    uids: list[int] | None = None,
+    index_uids: list[int] | None = None,
+    statuses: list[str] | None = None,
+    types: list[str] | None = None,
+    before_enqueued_at: datetime | None = None,
+    after_enqueued_at: datetime | None = None,
+    before_started_at: datetime | None = None,
+    after_finished_at: datetime | None = None,
+) -> TaskInfo:
+    """Cancel a list of enqueued or processing tasks.
+
+    Defaults to cancelling all tasks.
+
+    Args:
+        client: An httpx HttpxAsyncClient or meilisearch_python_sdk AsyncClient instance.
+        uids: A list of task UIDs to cancel.
+        index_uids: A list of index UIDs for which to cancel tasks.
+        statuses: A list of statuses to cancel.
+        types: A list of types to cancel.
+        before_enqueued_at: Cancel tasks that were enqueued before the specified date time.
+        after_enqueued_at: Cancel tasks that were enqueued after the specified date time.
+        before_started_at: Cancel tasks that were started before the specified date time.
+        after_finished_at: Cancel tasks that were finished after the specified date time.
+
+    Returns:
+        The details of the task
+
+    Raises:
+        MeilisearchCommunicationError: If there was an error communicating with the server.
+        MeilisearchApiError: If the Meilisearch API returned an error.
+        MeilisearchTimeoutError: If the connection times out.
+
+    Examples
+        >>> from meilisearch_python_sdk import AsyncClient
+        >>> from meilisearch_python_sdk.task import cancel_tasks
+        >>>
+        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
+        >>>     await cancel_tasks(client, uids=[1, 2])
+    """
+    parameters = _process_params(
+        uids,
+        index_uids,
+        statuses,
+        types,
+        before_enqueued_at,
+        after_enqueued_at,
+        before_started_at,
+        after_finished_at,
+    )
+
+    if not parameters:
+        # Cancel all tasks if no parameters provided
+        parameters["statuses"] = "enqueued,processing"
+
+    url = f"tasks/cancel?{urlencode(parameters)}"
+    client_ = get_async_client(client)
+    response = await client_.post(url)
+
+    return TaskInfo(**response.json())
+
+
+async def async_delete_tasks(
+    client: HttpxAsyncClient | AsyncClient,
+    *,
+    uids: list[int] | None = None,
+    index_uids: list[int] | None = None,
+    statuses: list[str] | None = None,
+    types: list[str] | None = None,
+    before_enqueued_at: datetime | None = None,
+    after_enqueued_at: datetime | None = None,
+    before_started_at: datetime | None = None,
+    after_finished_at: datetime | None = None,
+) -> TaskInfo:
+    parameters = _process_params(
+        uids,
+        index_uids,
+        statuses,
+        types,
+        before_enqueued_at,
+        after_enqueued_at,
+        before_started_at,
+        after_finished_at,
+    )
+
+    if not parameters:
+        # delete all tasks if no parameters provided
+        parameters["statuses"] = "canceled,enqueued,failed,processing,succeeded"
+
+    url = f"tasks?{urlencode(parameters)}"
+    client_ = get_async_client(client)
+    response = await client_.delete(url)
+
+    return TaskInfo(**response.json())
+
+
+async def async_get_task(
+    client: HttpxAsyncClient | AsyncClient,
+    task_id: int,
+) -> TaskResult:
+    client_ = get_async_client(client)
+    response = await client_.get(f"tasks/{task_id}")
+
+    return TaskResult(**response.json())
+
+
+async def async_get_tasks(
+    client: HttpxAsyncClient | AsyncClient,
+    *,
+    index_ids: list[str] | None = None,
+    types: str | list[str] | None = None,
+    reverse: bool | None = None,
+) -> TaskStatus:
+    url = f"tasks?indexUids={','.join(index_ids)}" if index_ids else "tasks"
+    if types:
+        formatted_types = ",".join(types) if isinstance(types, list) else types
+        url = f"{url}&types={formatted_types}" if "?" in url else f"{url}?types={formatted_types}"
+    if reverse:
+        url = (
+            f"{url}&reverse={str(reverse).lower()}"
+            if "?" in url
+            else f"{url}?reverse={str(reverse).lower()}"
+        )
+    client_ = get_async_client(client)
+    response = await client_.get(url)
+
+    return TaskStatus(**response.json())
+
+
+async def async_wait_for_task(
+    client: HttpxAsyncClient | AsyncClient,
+    task_id: int,
+    *,
+    timeout_in_ms: int | None = 5000,
+    interval_in_ms: int = 50,
+    raise_for_status: bool = False,
+) -> TaskResult:
+    client_ = get_async_client(client)
+    handler = _get_json_handler(client)
+    url = f"tasks/{task_id}"
+    http_requests = AsyncHttpRequests(client_, handler)
+    start_time = datetime.now()
+    elapsed_time = 0.0
+
+    if timeout_in_ms:
+        while elapsed_time < timeout_in_ms:
+            response = await http_requests.get(url)
+            status = TaskResult(**response.json())
+            if status.status in ("succeeded", "failed"):
+                if raise_for_status and status.status == "failed":
+                    raise MeilisearchTaskFailedError(f"Task {task_id} failed")
+                return status
+            await asyncio.sleep(interval_in_ms / 1000)
+            time_delta = datetime.now() - start_time
+            elapsed_time = time_delta.seconds * 1000 + time_delta.microseconds / 1000
+        raise MeilisearchTimeoutError(
+            f"timeout of {timeout_in_ms}ms has exceeded on process {task_id} when waiting for pending update to resolve."
+        )
+    else:
+        while True:
+            response = await http_requests.get(url)
+            status = TaskResult(**response.json())
+            if status.status in ("succeeded", "failed"):
+                if raise_for_status and status.status == "failed":
+                    raise MeilisearchTaskFailedError(f"Task {task_id} failed")
+                return status
+            await asyncio.sleep(interval_in_ms / 1000)
+
+
+def cancel_tasks(
+    client: HttpxClient | Client,
+    *,
+    uids: list[int] | None = None,
+    index_uids: list[int] | None = None,
+    statuses: list[str] | None = None,
+    types: list[str] | None = None,
+    before_enqueued_at: datetime | None = None,
+    after_enqueued_at: datetime | None = None,
+    before_started_at: datetime | None = None,
+    after_finished_at: datetime | None = None,
+) -> TaskInfo:
+    parameters = _process_params(
+        uids,
+        index_uids,
+        statuses,
+        types,
+        before_enqueued_at,
+        after_enqueued_at,
+        before_started_at,
+        after_finished_at,
+    )
+
+    if not parameters:
+        # Cancel all tasks if no parameters provided
+        parameters["statuses"] = "enqueued,processing"
+
+    url = f"tasks/cancel?{urlencode(parameters)}"
+    client_ = get_client(client)
+    response = client_.post(url)
+
+    return TaskInfo(**response.json())
+
+
+def delete_tasks(
+    client: HttpxClient | Client,
+    *,
+    uids: list[int] | None = None,
+    index_uids: list[int] | None = None,
+    statuses: list[str] | None = None,
+    types: list[str] | None = None,
+    before_enqueued_at: datetime | None = None,
+    after_enqueued_at: datetime | None = None,
+    before_started_at: datetime | None = None,
+    after_finished_at: datetime | None = None,
+) -> TaskInfo:
+    parameters = _process_params(
+        uids,
+        index_uids,
+        statuses,
+        types,
+        before_enqueued_at,
+        after_enqueued_at,
+        before_started_at,
+        after_finished_at,
+    )
+
+    if not parameters:
+        # delete all tasks if no parameters provided
+        parameters["statuses"] = "canceled,enqueued,failed,processing,succeeded"
+
+    url = f"tasks?{urlencode(parameters)}"
+    client_ = get_client(client)
+    response = client_.delete(url)
+
+    return TaskInfo(**response.json())
+
+
+def get_task(client: HttpxClient | Client, task_id: int) -> TaskResult:
+    client_ = get_client(client)
+    response = client_.get(f"tasks/{task_id}")
+
+    return TaskResult(**response.json())
+
+
+def get_tasks(
+    client: HttpxClient | Client,
+    *,
+    index_ids: list[str] | None = None,
+    types: str | list[str] | None = None,
+    reverse: bool | None = None,
+) -> TaskStatus:
+    url = f"tasks?indexUids={','.join(index_ids)}" if index_ids else "tasks"
+    if types:
+        formatted_types = ",".join(types) if isinstance(types, list) else types
+        url = f"{url}&types={formatted_types}" if "?" in url else f"{url}?types={formatted_types}"
+    if reverse:
+        url = (
+            f"{url}&reverse={str(reverse).lower()}"
+            if "?" in url
+            else f"{url}?reverse={str(reverse).lower()}"
+        )
+    client_ = get_client(client)
+    response = client_.get(url)
+
+    return TaskStatus(**response.json())
+
+
+def wait_for_task(
+    client: HttpxClient | Client,
+    task_id: int,
+    *,
+    timeout_in_ms: int | None = 5000,
+    interval_in_ms: int = 50,
+    raise_for_status: bool = False,
+) -> TaskResult:
+    client_ = get_client(client)
+    handler = _get_json_handler(client)
+    url = f"tasks/{task_id}"
+    http_requests = HttpRequests(client_, json_handler=handler)
+    start_time = datetime.now()
+    elapsed_time = 0.0
+
+    if timeout_in_ms:
+        while elapsed_time < timeout_in_ms:
+            response = http_requests.get(url)
+            status = TaskResult(**response.json())
+            if status.status in ("succeeded", "failed"):
+                if raise_for_status and status.status == "failed":
+                    raise MeilisearchTaskFailedError(f"Task {task_id} failed")
+                return status
+            time.sleep(interval_in_ms / 1000)
+            time_delta = datetime.now() - start_time
+            elapsed_time = time_delta.seconds * 1000 + time_delta.microseconds / 1000
+        raise MeilisearchTimeoutError(
+            f"timeout of {timeout_in_ms}ms has exceeded on process {task_id} when waiting for pending update to resolve."
+        )
+    else:
+        while True:
+            response = http_requests.get(url)
+            status = TaskResult(**response.json())
+            if status.status in ("succeeded", "failed"):
+                if raise_for_status and status.status == "failed":
+                    raise MeilisearchTaskFailedError(f"Task {task_id} failed")
+                return status
+            time.sleep(interval_in_ms / 1000)
+
+
+def _get_json_handler(
+    client: AsyncClient | Client | HttpxAsyncClient | HttpxClient,
+) -> BuiltinHandler | OrjsonHandler | UjsonHandler:
+    if isinstance(client, (HttpxAsyncClient, HttpxClient)):
+        return BuiltinHandler()
+
+    return client.json_handler
+
+
+def _process_params(
+    uids: list[int] | None = None,
+    index_uids: list[int] | None = None,
+    statuses: list[str] | None = None,
+    types: list[str] | None = None,
+    before_enqueued_at: datetime | None = None,
+    after_enqueued_at: datetime | None = None,
+    before_started_at: datetime | None = None,
+    after_finished_at: datetime | None = None,
+) -> dict[str, str]:
+    parameters = {}
+    if uids:
+        parameters["uids"] = ",".join([str(x) for x in uids])
+    if index_uids:
+        parameters["indexUids"] = ",".join([str(x) for x in index_uids])
+    if statuses:
+        parameters["statuses"] = ",".join(statuses)
+    if types:
+        parameters["types"] = ",".join(types)
+    if before_enqueued_at:
+        parameters["beforeEnqueuedAt"] = f"{before_enqueued_at.isoformat()}Z"
+    if after_enqueued_at:
+        parameters["afterEnqueuedAt"] = f"{after_enqueued_at.isoformat()}Z"
+    if before_started_at:
+        parameters["beforeStartedAt"] = f"{before_started_at.isoformat()}Z"
+    if after_finished_at:
+        parameters["afterFinishedAt"] = f"{after_finished_at.isoformat()}Z"
+
+    return parameters

meilisearch_python_sdk/_utils.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import sys
+from datetime import datetime
+from functools import lru_cache
+from typing import TYPE_CHECKING
+
+from httpx import AsyncClient as HttpxAsyncClient
+from httpx import Client as HttpxClient
+
+if TYPE_CHECKING:
+    from meilisearch_python_sdk._client import AsyncClient, Client  # pragma: no cover
+
+
+def get_async_client(
+    client: AsyncClient | HttpxAsyncClient,
+) -> HttpxAsyncClient:
+    if isinstance(client, HttpxAsyncClient):
+        return client
+
+    return client.http_client
+
+
+def get_client(
+    client: Client | HttpxClient,
+) -> HttpxClient:
+    if isinstance(client, HttpxClient):
+        return client
+
+    return client.http_client
+
+
+def iso_to_date_time(iso_date: datetime | str | None) -> datetime | None:
+    """Handle conversion of iso string to datetime.
+
+    The microseconds from Meilisearch are sometimes too long for python to convert so this
+    strips off the last digits to shorten it when that happens.
+    """
+    if not iso_date:
+        return None
+
+    if isinstance(iso_date, datetime):
+        return iso_date
+
+    try:
+        return datetime.strptime(iso_date, "%Y-%m-%dT%H:%M:%S.%fZ")
+    except ValueError:
+        split = iso_date.split(".")
+        if len(split) < 2:
+            raise
+        reduce = len(split[1]) - 6
+        reduced = f"{split[0]}.{split[1][:-reduce]}Z"
+        return datetime.strptime(reduced, "%Y-%m-%dT%H:%M:%S.%fZ")
+
+
+@lru_cache(maxsize=1)
+def use_task_groups() -> bool:
+    return True if sys.version_info >= (3, 11) else False

meilisearch_python_sdk/_version.py

@@ -0,0 +1 @@
+VERSION = "5.5.0"