Merge pull request #557 from sanders41/pydantic2

Add support for Pydantic v2

Author: sanders41

meilisearch_python_async/_utils.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+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.
+
+    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(".")
+        reduce = len(split[1]) - 6
+        reduced = f"{split[0]}.{split[1][:-reduce]}Z"
+        return datetime.strptime(reduced, "%Y-%m-%dT%H:%M:%S.%fZ")

meilisearch_python_async/client.py

@@ -10,6 +10,7 @@
 from httpx import AsyncClient
 
 from meilisearch_python_async._http_requests import HttpRequests
+from meilisearch_python_async._utils import is_pydantic_2
 from meilisearch_python_async.errors import InvalidRestriction, MeilisearchApiError
 from meilisearch_python_async.index import Index
 from meilisearch_python_async.models.client import (
@@ -388,7 +389,10 @@ async def create_key(self, key: KeyCreate) -> Key:
         """
         # The json.loads(key.json()) is because Pydantic can't serialize a date in a Python dict,
         # but can when converting to a json string.
-        response = await self._http_requests.post("keys", json.loads(key.json(by_alias=True)))
+        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
+            response = await self._http_requests.post("keys", json.loads(key.json(by_alias=True)))  # type: ignore[attr-defined]
 
         return Key(**response.json())
 
@@ -495,11 +499,18 @@ async def update_key(self, key: KeyUpdate) -> Key:
         """
         # The json.loads(key.json()) is because Pydantic can't serialize a date in a Python dict,
         # but can when converting to a json string.
-        payload = {
-            k: v
-            for k, v in json.loads(key.json(by_alias=True)).items()
-            if v is not None and k != "key"
-        }
+        if is_pydantic_2:
+            payload = {  # 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
+            payload = {  # 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"
+            }
         response = await self._http_requests.patch(f"keys/{key.key}", payload)
 
         return Key(**response.json())
@@ -532,9 +543,14 @@ async def multi_search(self, queries: list[SearchParams]) -> list[SearchResultsW
             >>>     search_results = await client.search(queries)
         """
         url = "multi-search"
-        response = await self._http_requests.post(
-            url, body={"queries": [x.dict(by_alias=True) for x in queries]}
-        )
+        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
+            response = await self._http_requests.post(
+                url, body={"queries": [x.dict(by_alias=True) for x in queries]}  # type: ignore[attr-defined]
+            )
 
         return [SearchResultsWithUID(**x) for x in response.json()["results"]]
 

meilisearch_python_async/index.py

@@ -13,6 +13,7 @@
 from httpx import AsyncClient
 
 from meilisearch_python_async._http_requests import HttpRequests
+from meilisearch_python_async._utils import is_pydantic_2, iso_to_date_time
 from meilisearch_python_async.errors import InvalidDocumentError, MeilisearchError
 from meilisearch_python_async.models.documents import DocumentsInfo
 from meilisearch_python_async.models.index import IndexStats
@@ -54,8 +55,8 @@ def __init__(
         """
         self.uid = uid
         self.primary_key = primary_key
-        self.created_at: datetime | None = _iso_to_date_time(created_at)
-        self.updated_at: datetime | None = _iso_to_date_time(updated_at)
+        self.created_at: datetime | None = iso_to_date_time(created_at)
+        self.updated_at: datetime | None = iso_to_date_time(updated_at)
         self._base_url = "indexes/"
         self._base_url_with_uid = f"{self._base_url}{self.uid}"
         self._documents_url = f"{self._base_url_with_uid}/documents"
@@ -175,10 +176,10 @@ async def fetch_info(self) -> Index:
         self.primary_key = index_dict["primaryKey"]
         loop = get_running_loop()
         self.created_at = await loop.run_in_executor(
-            None, partial(_iso_to_date_time, index_dict["createdAt"])
+            None, partial(iso_to_date_time, index_dict["createdAt"])
         )
         self.updated_at = await loop.run_in_executor(
-            None, partial(_iso_to_date_time, index_dict["updatedAt"])
+            None, partial(iso_to_date_time, index_dict["updatedAt"])
         )
         return self
 
@@ -1477,7 +1478,10 @@ async def update_settings(self, body: MeilisearchSettings) -> TaskInfo:
             >>>     index = client.index("movies")
             >>>     await index.update_settings(new_settings)
         """
-        body_dict = {k: v for k, v in body.dict(by_alias=True).items() if v is not None}
+        if is_pydantic_2:
+            body_dict = {k: v for k, v in body.model_dump(by_alias=True).items() if v is not None}  # type: ignore[attr-defined]
+        else:  # pragma: no cover
+            body_dict = {k: v for k, v in body.dict(by_alias=True).items() if v is not None}  # type: ignore[attr-defined]
 
         url = f"{self._settings_url}"
         response = await self._http_requests.patch(url, body_dict)
@@ -2184,7 +2188,11 @@ async def update_typo_tolerance(self, typo_tolerance: TypoTolerance) -> TaskInfo
             >>>     await index.update_typo_tolerance()
         """
         url = f"{self._settings_url}/typo-tolerance"
-        response = await self._http_requests.patch(url, typo_tolerance.dict(by_alias=True))
+
+        if is_pydantic_2:
+            response = await self._http_requests.patch(url, typo_tolerance.model_dump(by_alias=True))  # type: ignore[attr-defined]
+        else:  # pragma: no cover
+            response = await self._http_requests.patch(url, typo_tolerance.dict(by_alias=True))  # type: ignore[attr-defined]
 
         return TaskInfo(**response.json())
 
@@ -2256,7 +2264,11 @@ async def update_faceting(self, faceting: Faceting) -> TaskInfo:
             >>>     await index.update_faceting(faceting=Faceting(max_values_per_facet=100))
         """
         url = f"{self._settings_url}/faceting"
-        response = await self._http_requests.patch(url, faceting.dict(by_alias=True))
+
+        if is_pydantic_2:
+            response = await self._http_requests.patch(url, faceting.model_dump(by_alias=True))  # type: ignore[attr-defined]
+        else:  # pragma: no cover
+            response = await self._http_requests.patch(url, faceting.dict(by_alias=True))  # type: ignore[attr-defined]
 
         return TaskInfo(**response.json())
 
@@ -2329,7 +2341,11 @@ async def update_pagination(self, settings: Pagination) -> TaskInfo:
             >>>     await index.update_pagination(settings=Pagination(max_total_hits=123))
         """
         url = f"{self._settings_url}/pagination"
-        response = await self._http_requests.patch(url, settings.dict(by_alias=True))
+
+        if is_pydantic_2:
+            response = await self._http_requests.patch(url, settings.model_dump(by_alias=True))  # type: ignore[attr-defined]
+        else:  # pragma: no cover
+            response = await self._http_requests.patch(url, settings.dict(by_alias=True))  # type: ignore[attr-defined]
 
         return TaskInfo(**response.json())
 
@@ -2375,27 +2391,6 @@ def _combine_documents(documents: list[list[Any]]) -> list[Any]:
     return [x for y in documents for x in y]
 
 
-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(".")
-        reduce = len(split[1]) - 6
-        reduced = f"{split[0]}.{split[1][:-reduce]}Z"
-        return datetime.strptime(reduced, "%Y-%m-%dT%H:%M:%S.%fZ")
-
-
 async def _load_documents_from_file(
     file_path: Path | str,
     csv_delimiter: str | None = None,

meilisearch_python_async/models/client.py

@@ -1,8 +1,10 @@
 from datetime import datetime
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Union
 
+import pydantic
 from camel_converter.pydantic_base import CamelBase
 
+from meilisearch_python_async._utils import is_pydantic_2, iso_to_date_time
 from meilisearch_python_async.models.index import IndexStats
 
 
@@ -11,6 +13,20 @@ class ClientStats(CamelBase):
     last_update: Optional[datetime] = None
     indexes: Optional[Dict[str, IndexStats]] = None
 
+    if is_pydantic_2:
+
+        @pydantic.field_validator("last_update", mode="before")  # type: ignore[attr-defined]
+        @classmethod
+        def validate_last_update(cls, v: str) -> Union[datetime, None]:
+            return iso_to_date_time(v)
+
+    else:  # pragma: no cover
+
+        @pydantic.validator("last_update", pre=True)
+        @classmethod
+        def validate_last_update(cls, v: str) -> Union[datetime, None]:
+            return iso_to_date_time(v)
+
 
 class _KeyBase(CamelBase):
     uid: str
@@ -20,17 +36,66 @@ class _KeyBase(CamelBase):
     indexes: List[str]
     expires_at: Optional[datetime] = None
 
-    class Config:
-        json_encoders = {
-            datetime: lambda v: None if not v else f"{str(v).split('.')[0].replace(' ', 'T')}Z"
-        }
+    if is_pydantic_2:
+        model_config = pydantic.ConfigDict(ser_json_timedelta="iso8601")  # type: ignore[typeddict-unknown-key]
+
+        @pydantic.field_validator("expires_at", mode="before")  # type: ignore[attr-defined]
+        @classmethod
+        def validate_expires_at(cls, v: str) -> Union[datetime, None]:
+            return iso_to_date_time(v)
+
+    else:  # pragma: no cover
+
+        @pydantic.validator("expires_at", pre=True)
+        @classmethod
+        def validate_expires_at(cls, v: str) -> Union[datetime, None]:
+            return iso_to_date_time(v)
+
+        class Config:
+            json_encoders = {
+                datetime: lambda v: None if not v else f"{str(v).split('.')[0].replace(' ', 'T')}Z"
+            }
 
 
 class Key(_KeyBase):
     key: str
     created_at: datetime
     updated_at: Optional[datetime] = None
 
+    if is_pydantic_2:
+
+        @pydantic.field_validator("created_at", mode="before")  # type: ignore[attr-defined]
+        @classmethod
+        def validate_created_at(cls, v: str) -> datetime:
+            converted = iso_to_date_time(v)
+
+            if not converted:  # pragma: no cover
+                raise ValueError("created_at is required")
+
+            return converted
+
+        @pydantic.field_validator("updated_at", mode="before")  # type: ignore[attr-defined]
+        @classmethod
+        def validate_updated_at(cls, v: str) -> Union[datetime, None]:
+            return iso_to_date_time(v)
+
+    else:  # pragma: no cover
+
+        @pydantic.validator("created_at", pre=True)
+        @classmethod
+        def validate_created_at(cls, v: str) -> datetime:
+            converted = iso_to_date_time(v)
+
+            if not converted:
+                raise ValueError("created_at is required")
+
+            return converted
+
+        @pydantic.validator("updated_at", pre=True)
+        @classmethod
+        def validate_updated_at(cls, v: str) -> Union[datetime, None]:
+            return iso_to_date_time(v)
+
 
 class KeyCreate(CamelBase):
     name: Optional[str] = None
@@ -39,10 +104,15 @@ class KeyCreate(CamelBase):
     indexes: List[str]
     expires_at: Optional[datetime] = None
 
-    class Config:
-        json_encoders = {
-            datetime: lambda v: None if not v else f"{str(v).split('.')[0].replace(' ', 'T')}Z"
-        }
+    if is_pydantic_2:
+        model_config = pydantic.ConfigDict(ser_json_timedelta="iso8601")  # type: ignore[typeddict-unknown-key]
+
+    else:  # pragma: no cover
+
+        class Config:
+            json_encoders = {
+                datetime: lambda v: None if not v else f"{str(v).split('.')[0].replace(' ', 'T')}Z"
+            }
 
 
 class KeyUpdate(CamelBase):
@@ -53,10 +123,15 @@ class KeyUpdate(CamelBase):
     indexes: Optional[List[str]] = None
     expires_at: Optional[datetime] = None
 
-    class Config:
-        json_encoders = {
-            datetime: lambda v: None if not v else f"{str(v).split('.')[0].replace(' ', 'T')}Z"
-        }
+    if is_pydantic_2:
+        model_config = pydantic.ConfigDict(ser_json_timedelta="iso8601")  # type: ignore[typeddict-unknown-key]
+
+    else:  # pragma: no cover
+
+        class Config:
+            json_encoders = {
+                datetime: lambda v: None if not v else f"{str(v).split('.')[0].replace(' ', 'T')}Z"
+            }
 
 
 class KeySearch(CamelBase):