meilisearch-python-sdk 2.12.1__tar.gz → 3.0.1__tar.gz

{meilisearch_python_sdk-2.12.1 → meilisearch_python_sdk-3.0.1}/PKG-INFO

@@ -1,29 +1,34 @@
 Metadata-Version: 2.1
 Name: meilisearch-python-sdk
-Version: 2.12.1
+Version: 3.0.1
 Summary: A Python client providing both async and sync support for the Meilisearch API
 Home-page: https://github.com/sanders41/meilisearch-python-sdk
 License: MIT
 Keywords: meilisearch,async,python,client,sdk
 Author: Paul Sanders
 Author-email: psanders1@gmail.com
-Requires-Python: >=3.8,<4.0
+Requires-Python: >=3.9,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Typing :: Typed
+Provides-Extra: all
+Provides-Extra: orjson
+Provides-Extra: ujson
 Requires-Dist: PyJWT (>=2.3.0)
 Requires-Dist: aiofiles (>=0.7)
 Requires-Dist: camel-converter (>=1.0.0)
+Requires-Dist: eval-type-backport (>=0.2.0) ; python_version < "3.10"
 Requires-Dist: httpx (>=0.17)
-Requires-Dist: pydantic (>=1.8)
+Requires-Dist: orjson (>=3.10.6) ; extra == "orjson" or extra == "all"
+Requires-Dist: pydantic (>=2.0.0)
+Requires-Dist: ujson (>=5.10.0) ; extra == "ujson" or extra == "all"
 Project-URL: Documentation, https://meilisearch-python-sdk.paulsanders.dev
 Project-URL: Repository, https://github.com/sanders41/meilisearch-python-sdk
 Description-Content-Type: text/markdown

{meilisearch_python_sdk-2.12.1 → meilisearch_python_sdk-3.0.1}/meilisearch_python_sdk/_client.py

@@ -1,10 +1,8 @@
 from __future__ import annotations
 
-import json
 from datetime import datetime, timezone
 from ssl import SSLContext
 from typing import TYPE_CHECKING
-from warnings import warn
 
 import jwt
 from httpx import AsyncClient as HttpxAsyncClient
@@ -12,9 +10,9 @@ from httpx import Client as HttpxClient
 
 from meilisearch_python_sdk import _task
 from meilisearch_python_sdk._http_requests import AsyncHttpRequests, HttpRequests
-from meilisearch_python_sdk._utils import is_pydantic_2
 from meilisearch_python_sdk.errors import InvalidRestriction, MeilisearchApiError
 from meilisearch_python_sdk.index import AsyncIndex, Index
+from meilisearch_python_sdk.json_handler import BuiltinHandler, OrjsonHandler, UjsonHandler
 from meilisearch_python_sdk.models.client import (
     ClientStats,
     Key,
@@ -47,7 +45,9 @@ class BaseClient:
         self,
         api_key: str | None = None,
         custom_headers: dict[str, str] | None = None,
+        json_handler: BuiltinHandler | OrjsonHandler | UjsonHandler | None = None,
     ) -> None:
+        self.json_handler = json_handler if json_handler else BuiltinHandler()
         self._headers: dict[str, str] | None = None
         if api_key:
             self._headers = {"Authorization": f"Bearer {api_key}"}
@@ -143,6 +143,7 @@ class AsyncClient(BaseClient):
         timeout: int | None = None,
         verify: str | bool | SSLContext = True,
         custom_headers: dict[str, str] | None = None,
+        json_handler: BuiltinHandler | OrjsonHandler | UjsonHandler | None = None,
     ) -> None:
         """Class initializer.
 
@@ -157,13 +158,17 @@ class AsyncClient(BaseClient):
                 a path to an SSL certificate file, or `False` (disable verification)
             custom_headers: Custom headers to add when sending data to Meilisearch. Defaults to
                 None.
+            json_handler: The module to use for json operations. The options are BuiltinHandler
+                (uses the json module from the standard library), OrjsonHandler (uses orjson), or
+                UjsonHandler (uses ujson). Note that in order use orjson or ujson the corresponding
+                extra needs to be included. Default: BuiltinHandler.
         """
-        super().__init__(api_key, custom_headers)
+        super().__init__(api_key, custom_headers, json_handler)
 
         self.http_client = HttpxAsyncClient(
             base_url=url, timeout=timeout, headers=self._headers, verify=verify
         )
-        self._http_requests = AsyncHttpRequests(self.http_client)
+        self._http_requests = AsyncHttpRequests(self.http_client, json_handler=self.json_handler)
 
     async def __aenter__(self) -> Self:
         return self
@@ -257,6 +262,7 @@ class AsyncClient(BaseClient):
             wait=wait,
             timeout_in_ms=timeout_in_ms,
             plugins=plugins,
+            json_handler=self.json_handler,
         )
 
     async def create_snapshot(self) -> TaskInfo:
@@ -348,6 +354,7 @@ class AsyncClient(BaseClient):
                 primary_key=x["primaryKey"],
                 created_at=x["createdAt"],
                 updated_at=x["updatedAt"],
+                json_handler=self.json_handler,
             )
             for x in response.json()["results"]
         ]
@@ -374,7 +381,7 @@ class AsyncClient(BaseClient):
             >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
             >>>     index = await client.get_index()
         """
-        return await AsyncIndex(self.http_client, uid).fetch_info()
+        return await AsyncIndex(self.http_client, uid, json_handler=self.json_handler).fetch_info()
 
     def index(self, uid: str, *, plugins: AsyncIndexPlugins | None = None) -> AsyncIndex:
         """Create a local reference to an index identified by UID, without making an HTTP call.
@@ -401,7 +408,9 @@ class AsyncClient(BaseClient):
             >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
             >>>     index = client.index("movies")
         """
-        return AsyncIndex(self.http_client, uid=uid, plugins=plugins)
+        return AsyncIndex(
+            self.http_client, uid=uid, plugins=plugins, json_handler=self.json_handler
+        )
 
     async def get_all_stats(self) -> ClientStats:
         """Get stats for all indexes.
@@ -490,17 +499,9 @@ class AsyncClient(BaseClient):
             >>>     )
             >>>     keys = await client.create_key(key_info)
         """
-        if is_pydantic_2():
-            response = await self._http_requests.post(
-                "keys", json.loads(key.model_dump_json(by_alias=True))
-            )  # type: ignore[attr-defined]
-        else:  # pragma: no cover
-            warn(
-                "The use of Pydantic less than version 2 is depreciated and will be removed in a future release",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            response = await self._http_requests.post("keys", json.loads(key.json(by_alias=True)))  # type: ignore[attr-defined]
+        response = await self._http_requests.post(
+            "keys", self.json_handler.loads(key.model_dump_json(by_alias=True))
+        )  # type: ignore[attr-defined]
 
         return Key(**response.json())
 
@@ -612,7 +613,7 @@ class AsyncClient(BaseClient):
             >>>     )
             >>>     keys = await client.update_key(key_info)
         """
-        payload = _build_update_key_payload(key)
+        payload = _build_update_key_payload(key, self.json_handler)
         response = await self._http_requests.patch(f"keys/{key.key}", payload)
 
         return Key(**response.json())
@@ -645,21 +646,10 @@ class AsyncClient(BaseClient):
             >>>     search_results = await client.search(queries)
         """
         url = "multi-search"
-        if is_pydantic_2():
-            response = await self._http_requests.post(
-                url,
-                body={"queries": [x.model_dump(by_alias=True) for x in queries]},  # type: ignore[attr-defined]
-            )
-        else:  # pragma: no cover
-            warn(
-                "The use of Pydantic less than version 2 is depreciated and will be removed in a future release",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            response = await self._http_requests.post(
-                url,
-                body={"queries": [x.dict(by_alias=True) for x in queries]},  # type: ignore[attr-defined]
-            )
+        response = await self._http_requests.post(
+            url,
+            body={"queries": [x.model_dump(by_alias=True) for x in queries]},  # type: ignore[attr-defined]
+        )
 
         return [SearchResultsWithUID(**x) for x in response.json()["results"]]
 
@@ -1035,6 +1025,7 @@ class Client(BaseClient):
         timeout: int | None = None,
         verify: str | bool | SSLContext = True,
         custom_headers: dict[str, str] | None = None,
+        json_handler: BuiltinHandler | OrjsonHandler | UjsonHandler | None = None,
     ) -> None:
         """Class initializer.
 
@@ -1049,13 +1040,17 @@ class Client(BaseClient):
                 a path to an SSL certificate file, or `False` (disable verification)
             custom_headers: Custom headers to add when sending data to Meilisearch. Defaults to
                 None.
+            json_handler: The module to use for json operations. The options are BuiltinHandler
+                (uses the json module from the standard library), OrjsonHandler (uses orjson), or
+                UjsonHandler (uses ujson). Note that in order use orjson or ujson the corresponding
+                extra needs to be included. Default: BuiltinHandler.
         """
-        super().__init__(api_key, custom_headers)
+        super().__init__(api_key, custom_headers, json_handler)
 
         self.http_client = HttpxClient(
             base_url=url, timeout=timeout, headers=self._headers, verify=verify
         )
-        self._http_requests = HttpRequests(self.http_client)
+        self._http_requests = HttpRequests(self.http_client, json_handler=self.json_handler)
 
     def create_dump(self) -> TaskInfo:
         """Trigger the creation of a Meilisearch dump.
@@ -1131,6 +1126,7 @@ class Client(BaseClient):
             wait=wait,
             timeout_in_ms=timeout_in_ms,
             plugins=plugins,
+            json_handler=self.json_handler,
         )
 
     def create_snapshot(self) -> TaskInfo:
@@ -1222,6 +1218,7 @@ class Client(BaseClient):
                 primary_key=x["primaryKey"],
                 created_at=x["createdAt"],
                 updated_at=x["updatedAt"],
+                json_handler=self.json_handler,
             )
             for x in response.json()["results"]
         ]
@@ -1248,7 +1245,7 @@ class Client(BaseClient):
             >>> client = Client("http://localhost.com", "masterKey")
             >>> index = client.get_index()
         """
-        return Index(self.http_client, uid).fetch_info()
+        return Index(self.http_client, uid, json_handler=self.json_handler).fetch_info()
 
     def index(self, uid: str, *, plugins: IndexPlugins | None = None) -> Index:
         """Create a local reference to an index identified by UID, without making an HTTP call.
@@ -1273,7 +1270,7 @@ class Client(BaseClient):
             >>> client = Client("http://localhost.com", "masterKey")
             >>> index = client.index("movies")
         """
-        return Index(self.http_client, uid=uid, plugins=plugins)
+        return Index(self.http_client, uid=uid, plugins=plugins, json_handler=self.json_handler)
 
     def get_all_stats(self) -> ClientStats:
         """Get stats for all indexes.
@@ -1362,17 +1359,9 @@ class Client(BaseClient):
             >>> )
             >>> keys = client.create_key(key_info)
         """
-        if is_pydantic_2():
-            response = self._http_requests.post(
-                "keys", json.loads(key.model_dump_json(by_alias=True))
-            )  # type: ignore[attr-defined]
-        else:  # pragma: no cover
-            warn(
-                "The use of Pydantic less than version 2 is depreciated and will be removed in a future release",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            response = self._http_requests.post("keys", json.loads(key.json(by_alias=True)))  # type: ignore[attr-defined]
+        response = self._http_requests.post(
+            "keys", self.json_handler.loads(key.model_dump_json(by_alias=True))
+        )  # type: ignore[attr-defined]
 
         return Key(**response.json())
 
@@ -1484,7 +1473,7 @@ class Client(BaseClient):
             >>> )
             >>> keys = client.update_key(key_info)
         """
-        payload = _build_update_key_payload(key)
+        payload = _build_update_key_payload(key, self.json_handler)
         response = self._http_requests.patch(f"keys/{key.key}", payload)
 
         return Key(**response.json())
@@ -1517,21 +1506,10 @@ class Client(BaseClient):
             >>> search_results = client.search(queries)
         """
         url = "multi-search"
-        if is_pydantic_2():
-            response = self._http_requests.post(
-                url,
-                body={"queries": [x.model_dump(by_alias=True) for x in queries]},  # type: ignore[attr-defined]
-            )
-        else:  # pragma: no cover
-            warn(
-                "The use of Pydantic less than version 2 is depreciated and will be removed in a future release",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            response = self._http_requests.post(
-                url,
-                body={"queries": [x.dict(by_alias=True) for x in queries]},  # type: ignore[attr-defined]
-            )
+        response = self._http_requests.post(
+            url,
+            body={"queries": [x.model_dump(by_alias=True) for x in queries]},  # type: ignore[attr-defined]
+        )
 
         return [SearchResultsWithUID(**x) for x in response.json()["results"]]
 
@@ -1907,23 +1885,13 @@ def _build_offset_limit_url(base: str, offset: int | None, limit: int | None) ->
     return base
 
 
-def _build_update_key_payload(key: KeyUpdate) -> JsonDict:
-    # The json.loads(key.json()) is because Pydantic can't serialize a date in a Python dict,
+def _build_update_key_payload(
+    key: KeyUpdate, json_handler: BuiltinHandler | OrjsonHandler | UjsonHandler
+) -> JsonDict:
+    # The json_handler.loads(key.json()) is because Pydantic can't serialize a date in a Python dict,
     # but can when converting to a json string.
-    if is_pydantic_2():
-        return {  # type: ignore[attr-defined]
-            k: v
-            for k, v in json.loads(key.model_dump_json(by_alias=True)).items()
-            if v is not None and k != "key"
-        }
-    else:  # pragma: no cover
-        warn(
-            "The use of Pydantic less than version 2 is depreciated and will be removed in a future release",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return {  # type: ignore[attr-defined]
-            k: v
-            for k, v in json.loads(key.json(by_alias=True)).items()
-            if v is not None and k != "key"
-        }
+    return {  # type: ignore[attr-defined]
+        k: v
+        for k, v in json_handler.loads(key.model_dump_json(by_alias=True)).items()
+        if v is not None and k != "key"
+    }

{meilisearch_python_sdk-2.12.1 → meilisearch_python_sdk-3.0.1}/meilisearch_python_sdk/_http_requests.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import gzip
-import json
 from functools import lru_cache
 from typing import Any, Callable
 
@@ -21,11 +20,15 @@ from meilisearch_python_sdk.errors import (
     MeilisearchCommunicationError,
     MeilisearchError,
 )
+from meilisearch_python_sdk.json_handler import BuiltinHandler, OrjsonHandler, UjsonHandler
 
 
 class AsyncHttpRequests:
-    def __init__(self, http_client: AsyncClient) -> None:
+    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,
@@ -34,8 +37,6 @@ class AsyncHttpRequests:
         body: Any | None = None,
         content_type: str = "application/json",
         compress: bool = False,
-        *,
-        serializer: type[json.JSONEncoder] | None = None,
     ) -> Response:
         headers = build_headers(content_type, compress)
 
@@ -44,12 +45,12 @@ class AsyncHttpRequests:
                 response = await http_method(path)
             elif content_type == "application/json" and not compress:
                 response = await http_method(
-                    path, content=json.dumps(body, cls=serializer), headers=headers
+                    path, content=self.json_handler.dumps(body), headers=headers
                 )
             else:
                 if body and compress:
                     if content_type == "application/json":
-                        body = gzip.compress(json.dumps(body, cls=serializer).encode("utf-8"))
+                        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)
@@ -87,12 +88,8 @@ class AsyncHttpRequests:
         body: Any | None = None,
         content_type: str = "application/json",
         compress: bool = False,
-        *,
-        serializer: type[json.JSONEncoder] | None = None,
     ) -> Response:
-        return await self._send_request(
-            self.http_client.post, path, body, content_type, compress, serializer=serializer
-        )
+        return await self._send_request(self.http_client.post, path, body, content_type, compress)
 
     async def put(
         self,
@@ -100,20 +97,19 @@ class AsyncHttpRequests:
         body: Any | None = None,
         content_type: str = "application/json",
         compress: bool = False,
-        *,
-        serializer: type[json.JSONEncoder] | None = None,
     ) -> Response:
-        return await self._send_request(
-            self.http_client.put, path, body, content_type, compress, serializer=serializer
-        )
+        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) -> None:
+    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,
@@ -122,21 +118,17 @@ class HttpRequests:
         body: Any | None = None,
         content_type: str = "applicaton/json",
         compress: bool = False,
-        *,
-        serializer: type[json.JSONEncoder] | None = None,
     ) -> Response:
         headers = build_headers(content_type, compress)
         try:
             if not body:
                 response = http_method(path)
             elif content_type == "application/json" and not compress:
-                response = http_method(
-                    path, content=json.dumps(body, cls=serializer), headers=headers
-                )
+                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(json.dumps(body, cls=serializer).encode("utf-8"))
+                        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)
@@ -174,12 +166,8 @@ class HttpRequests:
         body: Any | None = None,
         content_type: str = "application/json",
         compress: bool = False,
-        *,
-        serializer: type[json.JSONEncoder] | None = None,
     ) -> Response:
-        return self._send_request(
-            self.http_client.post, path, body, content_type, compress, serializer=serializer
-        )
+        return self._send_request(self.http_client.post, path, body, content_type, compress)
 
     def put(
         self,
@@ -187,12 +175,8 @@ class HttpRequests:
         body: Any | None = None,
         content_type: str = "application/json",
         compress: bool = False,
-        *,
-        serializer: type[json.JSONEncoder] | None = None,
     ) -> Response:
-        return self._send_request(
-            self.http_client.put, path, body, content_type, compress, serializer=serializer
-        )
+        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)

{meilisearch_python_sdk-2.12.1 → meilisearch_python_sdk-3.0.1}/meilisearch_python_sdk/_task.py

@@ -11,6 +11,7 @@ from httpx import Client as HttpxClient
 
 from meilisearch_python_sdk._http_requests import AsyncHttpRequests, HttpRequests
 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:
@@ -151,8 +152,9 @@ async def async_wait_for_task(
     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_)
+    http_requests = AsyncHttpRequests(client_, handler)
     start_time = datetime.now()
     elapsed_time = 0.0
 
@@ -281,8 +283,9 @@ def wait_for_task(
     raise_for_status: bool = False,
 ) -> TaskResult:
     client_ = _get_client(client)
+    handler = _get_json_handler(client)
     url = f"tasks/{task_id}"
-    http_requests = HttpRequests(client_)
+    http_requests = HttpRequests(client_, json_handler=handler)
     start_time = datetime.now()
     elapsed_time = 0.0
 
@@ -311,7 +314,9 @@ def wait_for_task(
             time.sleep(interval_in_ms / 1000)
 
 
-def _get_async_client(client: AsyncClient | HttpxAsyncClient) -> HttpxAsyncClient:
+def _get_async_client(
+    client: AsyncClient | HttpxAsyncClient,
+) -> HttpxAsyncClient:
     if isinstance(client, HttpxAsyncClient):
         return client
 
@@ -327,6 +332,15 @@ def _get_client(
     return client.http_client
 
 
+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[str] | None = None,
     index_uids: list[str] | None = None,

{meilisearch_python_sdk-2.12.1 → meilisearch_python_sdk-3.0.1}/meilisearch_python_sdk/_utils.py

@@ -4,23 +4,6 @@ import sys
 from datetime import datetime
 from functools import lru_cache
 
-import pydantic
-
-
-@lru_cache(maxsize=1)
-def is_pydantic_2() -> bool:
-    try:
-        # __version__ was added with Pydantic 2 so we know if this errors the version is < 2.
-        # Still check the version as a fail safe incase __version__ gets added to verion 1.
-        if int(pydantic.__version__[:1]) >= 2:  # type: ignore[attr-defined]
-            return True
-        else:  # pragma: no cover
-            # Raise an AttributeError to match the AttributeError on __version__ because in either
-            # case we need to get to the same place.
-            raise AttributeError
-    except AttributeError:  # pragma: no cover
-        return False
-
 
 def iso_to_date_time(iso_date: datetime | str | None) -> datetime | None:
     """Handle conversion of iso string to datetime.

meilisearch_python_sdk-3.0.1/meilisearch_python_sdk/_version.py

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