meilisearch-python-sdk 2.12.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

meilisearch_python_sdk/json_handler.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import json
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:  # pragma: no cover
+    pass
+
+try:
+    import orjson
+except ImportError:  # pragma: nocover
+    orjson = None  # type: ignore
+
+try:
+    import ujson
+except ImportError:  # pragma: nocover
+    ujson = None  # type: ignore
+
+
+class _JsonHandler(ABC):
+    @staticmethod
+    @abstractmethod
+    def dumps(obj: Any) -> str: ...
+
+    @staticmethod
+    @abstractmethod
+    def loads(json_string: str | bytes | bytearray) -> Any: ...
+
+
+class BuiltinHandler(_JsonHandler):
+    serializer: type[json.JSONEncoder] | None = None
+
+    def __init__(self, serializer: type[json.JSONEncoder] | None = None) -> None:
+        """Uses the json module from the Python standard library.
+
+        Args:
+            serializer: A custom JSONEncode to handle serializing fields that the build in
+                json.dumps cannot handle, for example UUID and datetime. Defaults to None.
+        """
+        BuiltinHandler.serializer = serializer
+
+    @staticmethod
+    def dumps(obj: Any) -> str:
+        return json.dumps(obj, cls=BuiltinHandler.serializer)
+
+    @staticmethod
+    def loads(json_string: str | bytes | bytearray) -> Any:
+        return json.loads(json_string)
+
+
+class OrjsonHandler(_JsonHandler):
+    def __init__(self) -> None:
+        if orjson is None:  # pragma: no cover
+            raise ValueError("orjson must be installed to use the OrjsonHandler")
+
+    @staticmethod
+    def dumps(obj: Any) -> str:
+        return orjson.dumps(obj).decode("utf-8")
+
+    @staticmethod
+    def loads(json_string: str | bytes | bytearray) -> Any:
+        return orjson.loads(json_string)
+
+
+class UjsonHandler(_JsonHandler):
+    def __init__(self) -> None:
+        if ujson is None:  # pragma: no cover
+            raise ValueError("ujson must be installed to use the UjsonHandler")
+
+    @staticmethod
+    def dumps(obj: Any) -> str:
+        return ujson.dumps(obj)
+
+    @staticmethod
+    def loads(json_string: str | bytes | bytearray) -> Any:
+        return ujson.loads(json_string)

meilisearch_python_sdk/models/client.py

@@ -1,185 +1,85 @@
+from __future__ import annotations
+
 from datetime import datetime
-from typing import Dict, List, Optional, Union
-from warnings import warn
 
 import pydantic
 from camel_converter.pydantic_base import CamelBase
 
-from meilisearch_python_sdk._utils import is_pydantic_2, iso_to_date_time
+from meilisearch_python_sdk._utils import iso_to_date_time
 from meilisearch_python_sdk.models.index import IndexStats
 
 
 class ClientStats(CamelBase):
     database_size: int
-    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
-        warn(
-            "The use of Pydantic less than version 2 is depreciated and will be removed in a future release",
-            DeprecationWarning,
-            stacklevel=2,
-        )
+    last_update: datetime | None = None
+    indexes: dict[str, IndexStats] | None = None
 
-        @pydantic.validator("last_update", pre=True)
-        @classmethod
-        def validate_last_update(cls, v: str) -> Union[datetime, None]:
-            return iso_to_date_time(v)
+    @pydantic.field_validator("last_update", mode="before")  # type: ignore[attr-defined]
+    @classmethod
+    def validate_last_update(cls, v: str) -> datetime | None:
+        return iso_to_date_time(v)
 
 
 class _KeyBase(CamelBase):
     uid: str
-    name: Optional[str] = None
+    name: str | None = None
     description: str
-    actions: List[str]
-    indexes: List[str]
-    expires_at: Optional[datetime] = None
-
-    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
-        warn(
-            "The use of Pydantic less than version 2 is depreciated and will be removed in a future release",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        @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"
-                    if "+" in str(v)
-                    else f"{str(v).replace(' ', 'T')}Z"
-                )
-            }
+    actions: list[str]
+    indexes: list[str]
+    expires_at: datetime | None = None
+
+    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) -> datetime | None:
+        return iso_to_date_time(v)
 
 
 class Key(_KeyBase):
     key: str
     created_at: datetime
-    updated_at: Optional[datetime] = None
-
-    if is_pydantic_2():
+    updated_at: datetime | None = None
 
-        @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)
+    @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")
+        if not converted:  # pragma: no cover
+            raise ValueError("created_at is required")
 
-            return converted
+        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
-        warn(
-            "The use of Pydantic less than version 2 is depreciated and will be removed in a future release",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        @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)
+    @pydantic.field_validator("updated_at", mode="before")  # type: ignore[attr-defined]
+    @classmethod
+    def validate_updated_at(cls, v: str) -> datetime | None:
+        return iso_to_date_time(v)
 
 
 class KeyCreate(CamelBase):
-    name: Optional[str] = None
+    name: str | None = None
     description: str
-    actions: List[str]
-    indexes: List[str]
-    expires_at: Optional[datetime] = None
-
-    if is_pydantic_2():
-        model_config = pydantic.ConfigDict(ser_json_timedelta="iso8601")  # type: ignore[typeddict-unknown-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,
-        )
-
-        class Config:
-            json_encoders = {
-                datetime: lambda v: None
-                if not v
-                else (
-                    f"{str(v).split('+')[0].replace(' ', 'T')}Z"
-                    if "+" in str(v)
-                    else f"{str(v).replace(' ', 'T')}Z"
-                )
-            }
+    actions: list[str]
+    indexes: list[str]
+    expires_at: datetime | None = None
+
+    model_config = pydantic.ConfigDict(ser_json_timedelta="iso8601")  # type: ignore[typeddict-unknown-key]
 
 
 class KeyUpdate(CamelBase):
     key: str
-    name: Optional[str] = None
-    description: Optional[str] = None
-    actions: Optional[List[str]] = None
-    indexes: Optional[List[str]] = None
-    expires_at: Optional[datetime] = None
-
-    if is_pydantic_2():
-        model_config = pydantic.ConfigDict(ser_json_timedelta="iso8601")  # type: ignore[typeddict-unknown-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,
-        )
-
-        class Config:
-            json_encoders = {
-                datetime: lambda v: None
-                if not v
-                else (
-                    f"{str(v).split('+')[0].replace(' ', 'T')}Z"
-                    if "+" in str(v)
-                    else f"{str(v).replace(' ', 'T')}Z"
-                )
-            }
+    name: str | None = None
+    description: str | None = None
+    actions: list[str] | None = None
+    indexes: list[str] | None = None
+    expires_at: datetime | None = None
+
+    model_config = pydantic.ConfigDict(ser_json_timedelta="iso8601")  # type: ignore[typeddict-unknown-key]
 
 
 class KeySearch(CamelBase):
-    results: List[Key]
+    results: list[Key]
     offset: int
     limit: int
     total: int

meilisearch_python_sdk/models/documents.py

@@ -1,4 +1,4 @@
-from typing import List
+from __future__ import annotations
 
 from camel_converter.pydantic_base import CamelBase
 
@@ -6,7 +6,7 @@ from meilisearch_python_sdk.types import JsonDict
 
 
 class DocumentsInfo(CamelBase):
-    results: List[JsonDict]
+    results: list[JsonDict]
     offset: int
     limit: int
     total: int

meilisearch_python_sdk/models/index.py

@@ -1,73 +1,44 @@
+from __future__ import annotations
+
 from datetime import datetime
-from typing import Dict, Optional
-from warnings import warn
 
 import pydantic
 from camel_converter.pydantic_base import CamelBase
 
-from meilisearch_python_sdk._utils import is_pydantic_2, iso_to_date_time
+from meilisearch_python_sdk._utils import iso_to_date_time
 
 
 class IndexBase(CamelBase):
     uid: str
-    primary_key: Optional[str] = None
+    primary_key: str | None = None
 
 
 class IndexInfo(IndexBase):
     created_at: datetime
     updated_at: datetime
 
-    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) -> datetime:
-            converted = iso_to_date_time(v)
-
-            if not converted:  # pragma: no cover
-                raise ValueError("updated_at is required")
-
-            return converted
-
-    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,
-        )
-
-        @pydantic.validator("created_at", pre=True)
-        @classmethod
-        def validate_created_at(cls, v: str) -> datetime:
-            converted = iso_to_date_time(v)
+    @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:
-                raise ValueError("created_at is required")
+        if not converted:  # pragma: no cover
+            raise ValueError("created_at is required")
 
-            return converted
+        return converted
 
-        @pydantic.validator("updated_at", pre=True)
-        @classmethod
-        def validate_updated_at(cls, v: str) -> datetime:
-            converted = iso_to_date_time(v)
+    @pydantic.field_validator("updated_at", mode="before")  # type: ignore[attr-defined]
+    @classmethod
+    def validate_updated_at(cls, v: str) -> datetime:
+        converted = iso_to_date_time(v)
 
-            if not converted:
-                raise ValueError("updated_at is required")
+        if not converted:  # pragma: no cover
+            raise ValueError("updated_at is required")
 
-            return converted
+        return converted
 
 
 class IndexStats(CamelBase):
     number_of_documents: int
     is_indexing: bool
-    field_distribution: Dict[str, int]
+    field_distribution: dict[str, int]

meilisearch_python_sdk/models/search.py

@@ -1,10 +1,8 @@
-from typing import List, Optional
-from warnings import warn
+from __future__ import annotations
 
 import pydantic
 from camel_converter.pydantic_base import CamelBase
 
-from meilisearch_python_sdk._utils import is_pydantic_2
 from meilisearch_python_sdk.errors import MeilisearchError
 from meilisearch_python_sdk.types import Filter, JsonDict
 
@@ -15,81 +13,64 @@ class FacetHits(CamelBase):
 
 
 class FacetSearchResults(CamelBase):
-    facet_hits: List[FacetHits]
+    facet_hits: list[FacetHits]
     facet_query: str
     processing_time_ms: int
 
 
 class Hybrid(CamelBase):
     semantic_ratio: float
-    embedder: Optional[str] = None
+    embedder: str | None = None
 
 
 class SearchParams(CamelBase):
     index_uid: str
-    query: Optional[str] = pydantic.Field(None, alias="q")
+    query: str | None = pydantic.Field(None, alias="q")
     offset: int = 0
     limit: int = 20
-    filter: Optional[Filter] = None
-    facets: Optional[List[str]] = None
-    attributes_to_retrieve: List[str] = ["*"]
-    attributes_to_crop: Optional[List[str]] = None
+    filter: Filter | None = None
+    facets: list[str] | None = None
+    attributes_to_retrieve: list[str] = ["*"]
+    attributes_to_crop: list[str] | None = None
     crop_length: int = 200
-    attributes_to_highlight: Optional[List[str]] = None
-    sort: Optional[List[str]] = None
+    attributes_to_highlight: list[str] | None = None
+    sort: list[str] | None = None
     show_matches_position: bool = False
     highlight_pre_tag: str = "<em>"
     highlight_post_tag: str = "</em>"
     crop_marker: str = "..."
     matching_strategy: str = "all"
-    hits_per_page: Optional[int] = None
-    page: Optional[int] = None
-    attributes_to_search_on: Optional[List[str]] = None
+    hits_per_page: int | None = None
+    page: int | None = None
+    attributes_to_search_on: list[str] | None = None
     show_ranking_score: bool = False
     show_ranking_score_details: bool = False
-    ranking_score_threshold: Optional[float] = None
-    vector: Optional[List[float]] = None
-    hybrid: Optional[Hybrid] = None
+    ranking_score_threshold: float | None = None
+    vector: list[float] | None = None
+    hybrid: Hybrid | None = None
 
-    if is_pydantic_2():
+    @pydantic.field_validator("ranking_score_threshold", mode="before")  # type: ignore[attr-defined]
+    @classmethod
+    def validate_ranking_score_threshold(cls, v: float | None) -> float | None:
+        if v and not 0.0 <= v <= 1.0:
+            raise MeilisearchError("ranking_score_threshold must be between 0.0 and 1.0")
 
-        @pydantic.field_validator("ranking_score_threshold", mode="before")  # type: ignore[attr-defined]
-        @classmethod
-        def validate_ranking_score_threshold(cls, v: Optional[float]) -> Optional[float]:
-            if v and not 0.0 <= v <= 1.0:
-                raise MeilisearchError("ranking_score_threshold must be between 0.0 and 1.0")
-
-            return v
-
-    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,
-        )
-
-        @pydantic.validator("ranking_score_threshold", pre=True)
-        @classmethod
-        def validate_expires_at(cls, v: Optional[float]) -> Optional[float]:
-            if v and not 0.0 <= v <= 1.0:
-                raise MeilisearchError("ranking_score_threshold must be between 0.0 and 1.0")
-
-            return v
+        return v
 
 
 class SearchResults(CamelBase):
-    hits: List[JsonDict]
-    offset: Optional[int] = None
-    limit: Optional[int] = None
-    estimated_total_hits: Optional[int] = None
+    hits: list[JsonDict]
+    offset: int | None = None
+    limit: int | None = None
+    estimated_total_hits: int | None = None
     processing_time_ms: int
     query: str
-    facet_distribution: Optional[JsonDict] = None
-    total_pages: Optional[int] = None
-    total_hits: Optional[int] = None
-    page: Optional[int] = None
-    hits_per_page: Optional[int] = None
-    semantic_hit_count: Optional[int] = None
+    facet_distribution: JsonDict | None = None
+    total_pages: int | None = None
+    total_hits: int | None = None
+    page: int | None = None
+    hits_per_page: int | None = None
+    semantic_hit_count: int | None = None
 
 
 class SearchResultsWithUID(SearchResults):
@@ -97,9 +78,9 @@ class SearchResultsWithUID(SearchResults):
 
 
 class SimilarSearchResults(CamelBase):
-    hits: List[JsonDict]
+    hits: list[JsonDict]
     id: str
     processing_time_ms: int
-    limit: Optional[int] = None
-    offset: Optional[int] = None
-    estimated_total_hits: Optional[int] = None
+    limit: int | None = None
+    offset: int | None = None
+    estimated_total_hits: int | None = None