AsyncIndex

AsyncIndex Usage

The AsyncIndex is the the same as the Index, but gives asyncronous methods to work with, and and should be used when using the AsyncClient. When you create a new index with the AsyncClient it will create an AsyncIndex instance.

AsyncIndex API

Bases: _BaseIndex

AsyncIndex class gives access to all indexes routes and child routes.

https://docs.meilisearch.com/reference/api/indexes.html

Source code in meilisearch_python_sdk/index.py

class AsyncIndex(_BaseIndex):
    """AsyncIndex class gives access to all indexes routes and child routes.

    https://docs.meilisearch.com/reference/api/indexes.html
    """

    def __init__(
        self,
        http_client: AsyncClient,
        uid: str,
        primary_key: str | None = None,
        created_at: str | datetime | None = None,
        updated_at: str | datetime | None = None,
        plugins: AsyncIndexPlugins | None = None,
        json_handler: BuiltinHandler | OrjsonHandler | UjsonHandler | None = None,
        *,
        hits_type: Any = JsonDict,
    ):
        """Class initializer.

        Args:
            http_client: An instance of the AsyncClient. This automatically gets passed by the
                AsyncClient when creating and AsyncIndex instance.
            uid: The index's unique identifier.
            primary_key: The primary key of the documents. Defaults to None.
            created_at: The date and time the index was created. Defaults to None.
            updated_at: The date and time the index was last updated. Defaults to None.
            plugins: Optional plugins can be provided to extend functionality.
            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.
            hits_type: Allows for a custom type to be passed to use for hits. Defaults to
                JsonDict
        """
        super().__init__(
            uid=uid,
            primary_key=primary_key,
            created_at=created_at,
            updated_at=updated_at,
            json_handler=json_handler,
            hits_type=hits_type,
        )
        self.http_client = http_client
        self._http_requests = AsyncHttpRequests(http_client, json_handler=self._json_handler)
        self.plugins = plugins

    @cached_property
    def _concurrent_add_documents_plugins(self) -> list[AsyncPlugin | AsyncDocumentPlugin] | None:
        if not self.plugins or not self.plugins.add_documents_plugins:
            return None

        plugins = [
            plugin for plugin in self.plugins.add_documents_plugins if plugin.CONCURRENT_EVENT
        ]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _post_add_documents_plugins(self) -> list[AsyncPlugin | AsyncDocumentPlugin] | None:
        if not self.plugins or not self.plugins.add_documents_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.add_documents_plugins if plugin.POST_EVENT]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _pre_add_documents_plugins(self) -> list[AsyncPlugin | AsyncDocumentPlugin] | None:
        if not self.plugins or not self.plugins.add_documents_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.add_documents_plugins if plugin.PRE_EVENT]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _concurrent_delete_all_documents_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.delete_all_documents_plugins:
            return None

        plugins = [
            plugin
            for plugin in self.plugins.delete_all_documents_plugins
            if plugin.CONCURRENT_EVENT
        ]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _post_delete_all_documents_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.delete_all_documents_plugins:
            return None

        plugins = [
            plugin for plugin in self.plugins.delete_all_documents_plugins if plugin.POST_EVENT
        ]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _pre_delete_all_documents_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.delete_all_documents_plugins:
            return None

        plugins = [
            plugin for plugin in self.plugins.delete_all_documents_plugins if plugin.PRE_EVENT
        ]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _concurrent_delete_document_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.delete_document_plugins:
            return None

        plugins = [
            plugin for plugin in self.plugins.delete_document_plugins if plugin.CONCURRENT_EVENT
        ]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _post_delete_document_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.delete_document_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.delete_document_plugins if plugin.POST_EVENT]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _pre_delete_document_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.delete_document_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.delete_document_plugins if plugin.PRE_EVENT]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _concurrent_delete_documents_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.delete_documents_plugins:
            return None

        plugins = [
            plugin for plugin in self.plugins.delete_documents_plugins if plugin.CONCURRENT_EVENT
        ]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _post_delete_documents_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.delete_documents_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.delete_documents_plugins if plugin.POST_EVENT]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _pre_delete_documents_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.delete_documents_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.delete_documents_plugins if plugin.PRE_EVENT]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _concurrent_delete_documents_by_filter_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.delete_documents_by_filter_plugins:
            return None

        plugins = [
            plugin
            for plugin in self.plugins.delete_documents_by_filter_plugins
            if plugin.CONCURRENT_EVENT
        ]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _post_delete_documents_by_filter_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.delete_documents_by_filter_plugins:
            return None

        plugins = [
            plugin
            for plugin in self.plugins.delete_documents_by_filter_plugins
            if plugin.POST_EVENT
        ]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _pre_delete_documents_by_filter_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.delete_documents_by_filter_plugins:
            return None

        plugins = [
            plugin for plugin in self.plugins.delete_documents_by_filter_plugins if plugin.PRE_EVENT
        ]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _concurrent_facet_search_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.facet_search_plugins:
            return None

        plugins = [
            plugin for plugin in self.plugins.facet_search_plugins if plugin.CONCURRENT_EVENT
        ]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _post_facet_search_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.facet_search_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.facet_search_plugins if plugin.POST_EVENT]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _pre_facet_search_plugins(self) -> list[AsyncPlugin] | None:
        if not self.plugins or not self.plugins.facet_search_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.facet_search_plugins if plugin.PRE_EVENT]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _concurrent_search_plugins(self) -> list[AsyncPlugin | AsyncPostSearchPlugin] | None:
        if not self.plugins or not self.plugins.search_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.search_plugins if plugin.CONCURRENT_EVENT]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _post_search_plugins(self) -> list[AsyncPlugin | AsyncPostSearchPlugin] | None:
        if not self.plugins or not self.plugins.search_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.search_plugins if plugin.POST_EVENT]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _pre_search_plugins(self) -> list[AsyncPlugin | AsyncPostSearchPlugin] | None:
        if not self.plugins or not self.plugins.search_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.search_plugins if plugin.PRE_EVENT]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _concurrent_update_documents_plugins(
        self,
    ) -> list[AsyncPlugin | AsyncDocumentPlugin] | None:
        if not self.plugins or not self.plugins.update_documents_plugins:
            return None

        plugins = [
            plugin for plugin in self.plugins.update_documents_plugins if plugin.CONCURRENT_EVENT
        ]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _post_update_documents_plugins(self) -> list[AsyncPlugin | AsyncDocumentPlugin] | None:
        if not self.plugins or not self.plugins.update_documents_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.update_documents_plugins if plugin.POST_EVENT]

        if not plugins:
            return None

        return plugins

    @cached_property
    def _pre_update_documents_plugins(self) -> list[AsyncPlugin | AsyncDocumentPlugin] | None:
        if not self.plugins or not self.plugins.update_documents_plugins:
            return None

        plugins = [plugin for plugin in self.plugins.update_documents_plugins if plugin.PRE_EVENT]

        if not plugins:
            return None

        return plugins

    async def delete(self) -> TaskInfo:
        """Deletes the index.

        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.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.delete()
        """
        response = await self._http_requests.delete(self._base_url_with_uid)
        return TaskInfo(**response.json())

    async def delete_if_exists(self) -> bool:
        """Delete the index if it already exists.

        Returns:
            True if the index was deleted or False if not.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.delete_if_exists()
        """
        response = await self.delete()
        status = await async_wait_for_task(
            self.http_client, response.task_uid, timeout_in_ms=100000
        )
        if status.status == "succeeded":
            return True

        return False

    async def update(self, primary_key: str) -> Self:
        """Update the index primary key.

        Args:
            primary_key: The primary key of the documents.

        Returns:
            An instance of the AsyncIndex with the updated information.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     updated_index = await index.update()
        """
        payload = {"primaryKey": primary_key}
        response = await self._http_requests.patch(self._base_url_with_uid, payload)
        await async_wait_for_task(
            self.http_client, response.json()["taskUid"], timeout_in_ms=100000
        )
        index_response = await self._http_requests.get(f"{self._base_url_with_uid}")
        self.primary_key = index_response.json()["primaryKey"]
        return self

    async def fetch_info(self) -> Self:
        """Gets the infromation about the index.

        Returns:
            An instance of the AsyncIndex containing the retrieved information.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     index_info = await index.fetch_info()
        """
        response = await self._http_requests.get(self._base_url_with_uid)
        index_dict = response.json()
        self._set_fetch_info(
            index_dict["primaryKey"], index_dict["createdAt"], index_dict["updatedAt"]
        )
        return self

    async def get_primary_key(self) -> str | None:
        """Get the primary key.

        Returns:
            The primary key for the documents in the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     primary_key = await index.get_primary_key()
        """
        info = await self.fetch_info()
        return info.primary_key

    @classmethod
    async def create(
        cls,
        http_client: AsyncClient,
        uid: str,
        primary_key: str | None = None,
        *,
        settings: MeilisearchSettings | None = None,
        wait: bool = True,
        timeout_in_ms: int | None = None,
        plugins: AsyncIndexPlugins | None = None,
        json_handler: BuiltinHandler | OrjsonHandler | UjsonHandler | None = None,
        hits_type: Any = JsonDict,
    ) -> Self:
        """Creates a new index.

        In general this method should not be used directly and instead the index should be created
        through the `Client`.

        Args:
            http_client: An instance of the AsyncClient. This automatically gets passed by the
                Client when creating an AsyncIndex instance.
            uid: The index's unique identifier.
            primary_key: The primary key of the documents. Defaults to None.
            settings: Settings for the index. The settings can also be updated independently of
                creating the index. The advantage to updating them here is updating the settings after
                adding documents will cause the documents to be re-indexed. Because of this it will be
                faster to update them before adding documents. Defaults to None (i.e. default
                Meilisearch index settings).
            wait: If set to True and settings are being updated, the index will be returned after
                the settings update has completed. If False it will not wait for settings to complete.
                Default: True
            timeout_in_ms: Amount of time in milliseconds to wait before raising a
                MeilisearchTimeoutError. `None` can also be passed to wait indefinitely. Be aware that
                if the `None` option is used the wait time could be very long. Defaults to None.
            plugins: Optional plugins can be provided to extend functionality.
            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.
            hits_type: Allows for a custom type to be passed to use for hits. Defaults to
                JsonDict

        Returns:
            An instance of AsyncIndex containing the information of the newly created index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = await index.create(client, "movies")
        """
        if not primary_key:
            payload = {"uid": uid}
        else:
            payload = {"primaryKey": primary_key, "uid": uid}

        url = "indexes"
        handler = json_handler if json_handler else BuiltinHandler()
        http_request = AsyncHttpRequests(http_client, json_handler=handler)
        response = await http_request.post(url, payload)
        await async_wait_for_task(
            http_client,
            response.json()["taskUid"],
            timeout_in_ms=timeout_in_ms,
        )

        index_response = await http_request.get(f"{url}/{uid}")
        index_dict = index_response.json()
        index = cls(
            http_client=http_client,
            uid=index_dict["uid"],
            primary_key=index_dict["primaryKey"],
            created_at=index_dict["createdAt"],
            updated_at=index_dict["updatedAt"],
            plugins=plugins,
            json_handler=json_handler,
            hits_type=hits_type,
        )

        if settings:
            settings_task = await index.update_settings(settings)
            if wait:
                await async_wait_for_task(
                    http_client, settings_task.task_uid, timeout_in_ms=timeout_in_ms
                )

        return index

    async def get_stats(self) -> IndexStats:
        """Get stats of the index.

        Returns:
            Stats of the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     stats = await index.get_stats()
        """
        response = await self._http_requests.get(self._stats_url)

        return IndexStats(**response.json())

    async def search(
        self,
        query: str | None = None,
        *,
        offset: int = 0,
        limit: int = 20,
        filter: Filter | None = None,
        facets: list[str] | None = None,
        attributes_to_retrieve: list[str] | None = None,
        attributes_to_crop: list[str] | None = None,
        crop_length: int = 200,
        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: Literal["all", "last", "frequency"] = "last",
        hits_per_page: int | None = None,
        page: int | None = None,
        attributes_to_search_on: list[str] | None = None,
        distinct: str | None = None,
        show_ranking_score: bool = False,
        show_ranking_score_details: bool = False,
        ranking_score_threshold: float | None = None,
        vector: list[float] | None = None,
        hybrid: Hybrid | None = None,
        locales: list[str] | None = None,
    ) -> SearchResults:
        """Search the index.

        Args:
            query: String containing the word(s) to search
            offset: Number of documents to skip. Defaults to 0.
            limit: Maximum number of documents returned. Defaults to 20.
            filter: Filter queries by an attribute value. Defaults to None.
            facets: Facets for which to retrieve the matching count. Defaults to None.
            attributes_to_retrieve: Attributes to display in the returned documents.
                Defaults to ["*"].
            attributes_to_crop: Attributes whose values have to be cropped. Defaults to None.
            crop_length: The maximun number of words to display. Defaults to 200.
            attributes_to_highlight: Attributes whose values will contain highlighted matching terms.
                Defaults to None.
            sort: Attributes by which to sort the results. Defaults to None.
            show_matches_position: Defines whether an object that contains information about the
                matches should be returned or not. Defaults to False.
            highlight_pre_tag: The opening tag for highlighting text. Defaults to <em>.
            highlight_post_tag: The closing tag for highlighting text. Defaults to </em>
            crop_marker: Marker to display when the number of words excedes the `crop_length`.
                Defaults to ...
            matching_strategy: Specifies the matching strategy Meilisearch should use. Defaults to
                `last`.
            hits_per_page: Sets the number of results returned per page.
            page: Sets the specific results page to fetch.
            attributes_to_search_on: List of field names. Allow search over a subset of searchable
                attributes without modifying the index settings. Defaults to None.
            distinct: If set the distinct value will return at most one result for the
                filterable attribute. Note that a filterable attributes must be set for this work.
                Defaults to None.
            show_ranking_score: If set to True the ranking score will be returned with each document
                in the search. Defaults to False.
            show_ranking_score_details: If set to True the ranking details will be returned with
                each document in the search. Defaults to False. Note: This parameter can only be
                used with Meilisearch >= v1.3.0, and is experimental in Meilisearch v1.3.0. In order
                to use this feature in Meilisearch v1.3.0 you first need to enable the feature by
                sending a PATCH request to /experimental-features with { "scoreDetails": true }.
                Because this feature is experimental it may be removed or updated causing breaking
                changes in this library without a major version bump so use with caution. This
                feature became stable in Meiliseach v1.7.0.
            ranking_score_threshold: If set, no document whose _rankingScore is under the
                rankingScoreThreshold is returned. The value must be between 0.0 and 1.0. Defaults
                to None.
            vector: List of vectors for vector search. Defaults to None. Note: This parameter can
                only be used with Meilisearch >= v1.3.0, and is experimental in Meilisearch v1.3.0.
                In order to use this feature in Meilisearch v1.3.0 you first need to enable the
                feature by sending a PATCH request to /experimental-features with
                { "vectorStore": true }. Because this feature is experimental it may be removed or
                updated causing breaking changes in this library without a major version bump so use
                with caution.
            hybrid: Hybrid search information. Defaults to None. Note: This parameter can
                only be used with Meilisearch >= v1.6.0, and is experimental in Meilisearch v1.6.0.
                In order to use this feature in Meilisearch v1.6.0 you first need to enable the
                feature by sending a PATCH request to /experimental-features with
                { "vectorStore": true }. Because this feature is experimental it may be removed or
                updated causing breaking changes in this library without a major version bump so use
                with caution.
            locales: Specifies the languages for the search. This parameter can only be used with
                Milisearch >= v1.10.0. Defaults to None letting the Meilisearch pick.

        Returns:
            Results of the search

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     search_results = await index.search("Tron")
        """
        if ranking_score_threshold:
            _validate_ranking_score_threshold(ranking_score_threshold)

        body = _process_search_parameters(
            q=query,
            offset=offset,
            limit=limit,
            filter=filter,
            facets=facets,
            attributes_to_retrieve=attributes_to_retrieve,
            attributes_to_crop=attributes_to_crop,
            crop_length=crop_length,
            attributes_to_highlight=attributes_to_highlight,
            sort=sort,
            show_matches_position=show_matches_position,
            highlight_pre_tag=highlight_pre_tag,
            highlight_post_tag=highlight_post_tag,
            crop_marker=crop_marker,
            matching_strategy=matching_strategy,
            hits_per_page=hits_per_page,
            page=page,
            attributes_to_search_on=attributes_to_search_on,
            distinct=distinct,
            show_ranking_score=show_ranking_score,
            show_ranking_score_details=show_ranking_score_details,
            vector=vector,
            hybrid=hybrid,
            ranking_score_threshold=ranking_score_threshold,
            locales=locales,
        )
        search_url = f"{self._base_url_with_uid}/search"

        if self._pre_search_plugins:
            await AsyncIndex._run_plugins(
                self._pre_search_plugins,
                AsyncEvent.PRE,
                query=query,
                offset=offset,
                limit=limit,
                filter=filter,
                facets=facets,
                attributes_to_retrieve=attributes_to_retrieve,
                attributes_to_crop=attributes_to_crop,
                crop_length=crop_length,
                attributes_to_highlight=attributes_to_highlight,
                sort=sort,
                show_matches_position=show_matches_position,
                highlight_pre_tag=highlight_pre_tag,
                highlight_post_tag=highlight_post_tag,
                crop_marker=crop_marker,
                matching_strategy=matching_strategy,
                hits_per_page=hits_per_page,
                page=page,
                attributes_to_search_on=attributes_to_search_on,
                distinct=distinct,
                show_ranking_score=show_ranking_score,
                show_ranking_score_details=show_ranking_score_details,
                vector=vector,
                hybrid=hybrid,
            )

        if self._concurrent_search_plugins:
            if not use_task_groups():
                concurrent_tasks: Any = []
                for plugin in self._concurrent_search_plugins:
                    if _plugin_has_method(plugin, "run_plugin"):
                        concurrent_tasks.append(
                            plugin.run_plugin(  # type: ignore[union-attr]
                                event=AsyncEvent.CONCURRENT,
                                query=query,
                                offset=offset,
                                limit=limit,
                                filter=filter,
                                facets=facets,
                                attributes_to_retrieve=attributes_to_retrieve,
                                attributes_to_crop=attributes_to_crop,
                                crop_length=crop_length,
                                attributes_to_highlight=attributes_to_highlight,
                                sort=sort,
                                show_matches_position=show_matches_position,
                                highlight_pre_tag=highlight_pre_tag,
                                highlight_post_tag=highlight_post_tag,
                                crop_marker=crop_marker,
                                matching_strategy=matching_strategy,
                                hits_per_page=hits_per_page,
                                page=page,
                                attributes_to_search_on=attributes_to_search_on,
                                distinct=distinct,
                                show_ranking_score=show_ranking_score,
                                show_ranking_score_details=show_ranking_score_details,
                                vector=vector,
                            )
                        )

                concurrent_tasks.append(self._http_requests.post(search_url, body=body))

                responses = await asyncio.gather(*concurrent_tasks)
                result = SearchResults[self.hits_type](**responses[-1].json())  # type: ignore[name-defined]
                if self._post_search_plugins:
                    post = await AsyncIndex._run_plugins(
                        self._post_search_plugins, AsyncEvent.POST, search_results=result
                    )
                    if post.get("search_result"):
                        result = post["search_result"]

                return result

            async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                for plugin in self._concurrent_search_plugins:
                    if _plugin_has_method(plugin, "run_plugin"):
                        tg.create_task(
                            plugin.run_plugin(  # type: ignore[union-attr]
                                event=AsyncEvent.CONCURRENT,
                                query=query,
                                offset=offset,
                                limit=limit,
                                filter=filter,
                                facets=facets,
                                attributes_to_retrieve=attributes_to_retrieve,
                                attributes_to_crop=attributes_to_crop,
                                crop_length=crop_length,
                                attributes_to_highlight=attributes_to_highlight,
                                sort=sort,
                                show_matches_position=show_matches_position,
                                highlight_pre_tag=highlight_pre_tag,
                                highlight_post_tag=highlight_post_tag,
                                crop_marker=crop_marker,
                                matching_strategy=matching_strategy,
                                hits_per_page=hits_per_page,
                                page=page,
                                attributes_to_search_on=attributes_to_search_on,
                                distinct=distinct,
                                show_ranking_score=show_ranking_score,
                                show_ranking_score_details=show_ranking_score_details,
                                vector=vector,
                            )
                        )

                response_coroutine = tg.create_task(self._http_requests.post(search_url, body=body))

            response = await response_coroutine
            result = SearchResults[self.hits_type](**response.json())  # type: ignore[name-defined]
            if self._post_search_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_search_plugins, AsyncEvent.POST, search_results=result
                )
                if post.get("search_result"):
                    result = post["search_result"]

            return result

        response = await self._http_requests.post(search_url, body=body)
        result = SearchResults[self.hits_type](**response.json())  # type: ignore[name-defined]

        if self._post_search_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_search_plugins, AsyncEvent.POST, search_results=result
            )
            if post.get("search_result"):
                result = post["search_result"]

        return result

    async def facet_search(
        self,
        query: str | None = None,
        *,
        facet_name: str,
        facet_query: str,
        offset: int = 0,
        limit: int = 20,
        filter: Filter | None = None,
        facets: list[str] | None = None,
        attributes_to_retrieve: list[str] | None = None,
        attributes_to_crop: list[str] | None = None,
        crop_length: int = 200,
        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: Literal["all", "last", "frequency"] = "last",
        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: float | None = None,
        vector: list[float] | None = None,
        locales: list[str] | None = None,
    ) -> FacetSearchResults:
        """Search the index.

        Args:
            query: String containing the word(s) to search
            facet_name: The name of the facet to search
            facet_query: The facet search value
            offset: Number of documents to skip. Defaults to 0.
            limit: Maximum number of documents returned. Defaults to 20.
            filter: Filter queries by an attribute value. Defaults to None.
            facets: Facets for which to retrieve the matching count. Defaults to None.
            attributes_to_retrieve: Attributes to display in the returned documents.
                Defaults to ["*"].
            attributes_to_crop: Attributes whose values have to be cropped. Defaults to None.
            crop_length: The maximun number of words to display. Defaults to 200.
            attributes_to_highlight: Attributes whose values will contain highlighted matching terms.
                Defaults to None.
            sort: Attributes by which to sort the results. Defaults to None.
            show_matches_position: Defines whether an object that contains information about the
                matches should be returned or not. Defaults to False.
            highlight_pre_tag: The opening tag for highlighting text. Defaults to <em>.
            highlight_post_tag: The closing tag for highlighting text. Defaults to </em>
            crop_marker: Marker to display when the number of words excedes the `crop_length`.
                Defaults to ...
            matching_strategy: Specifies the matching strategy Meilisearch should use. Defaults to
                `last`.
            hits_per_page: Sets the number of results returned per page.
            page: Sets the specific results page to fetch.
            attributes_to_search_on: List of field names. Allow search over a subset of searchable
                attributes without modifying the index settings. Defaults to None.
            show_ranking_score: If set to True the ranking score will be returned with each document
                in the search. Defaults to False.
            show_ranking_score_details: If set to True the ranking details will be returned with
                each document in the search. Defaults to False. Note: This parameter can only be
                used with Meilisearch >= v1.3.0, and is experimental in Meilisearch v1.3.0. In order
                to use this feature in Meilisearch v1.3.0 you first need to enable the feature by
                sending a PATCH request to /experimental-features with { "scoreDetails": true }.
                Because this feature is experimental it may be removed or updated causing breaking
                changes in this library without a major version bump so use with caution. This
                feature became stable in Meiliseach v1.7.0.
            ranking_score_threshold: If set, no document whose _rankingScore is under the
                rankingScoreThreshold is returned. The value must be between 0.0 and 1.0. Defaults
                to None.
            vector: List of vectors for vector search. Defaults to None. Note: This parameter can
                only be used with Meilisearch >= v1.3.0, and is experimental in Meilisearch v1.3.0.
                In order to use this feature in Meilisearch v1.3.0 you first need to enable the
                feature by sending a PATCH request to /experimental-features with
                { "vectorStore": true }. Because this feature is experimental it may be removed or
                updated causing breaking changes in this library without a major version bump so use
                with caution.
            locales: Specifies the languages for the search. This parameter can only be used with
                Milisearch >= v1.10.0. Defaults to None letting the Meilisearch pick.

        Returns:
            Results of the search

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     search_results = await index.search(
            >>>         "Tron",
            >>>         facet_name="genre",
            >>>         facet_query="Sci-fi"
            >>>     )
        """
        if ranking_score_threshold:
            _validate_ranking_score_threshold(ranking_score_threshold)

        body = _process_search_parameters(
            q=query,
            facet_name=facet_name,
            facet_query=facet_query,
            offset=offset,
            limit=limit,
            filter=filter,
            facets=facets,
            attributes_to_retrieve=attributes_to_retrieve,
            attributes_to_crop=attributes_to_crop,
            crop_length=crop_length,
            attributes_to_highlight=attributes_to_highlight,
            sort=sort,
            show_matches_position=show_matches_position,
            highlight_pre_tag=highlight_pre_tag,
            highlight_post_tag=highlight_post_tag,
            crop_marker=crop_marker,
            matching_strategy=matching_strategy,
            hits_per_page=hits_per_page,
            page=page,
            attributes_to_search_on=attributes_to_search_on,
            show_ranking_score=show_ranking_score,
            show_ranking_score_details=show_ranking_score_details,
            ranking_score_threshold=ranking_score_threshold,
            vector=vector,
            locales=locales,
        )
        search_url = f"{self._base_url_with_uid}/facet-search"

        if self._pre_facet_search_plugins:
            await AsyncIndex._run_plugins(
                self._pre_facet_search_plugins,
                AsyncEvent.PRE,
                query=query,
                offset=offset,
                limit=limit,
                filter=filter,
                facets=facets,
                attributes_to_retrieve=attributes_to_retrieve,
                attributes_to_crop=attributes_to_crop,
                crop_length=crop_length,
                attributes_to_highlight=attributes_to_highlight,
                sort=sort,
                show_matches_position=show_matches_position,
                highlight_pre_tag=highlight_pre_tag,
                highlight_post_tag=highlight_post_tag,
                crop_marker=crop_marker,
                matching_strategy=matching_strategy,
                hits_per_page=hits_per_page,
                page=page,
                attributes_to_search_on=attributes_to_search_on,
                show_ranking_score=show_ranking_score,
                show_ranking_score_details=show_ranking_score_details,
                ranking_score_threshold=ranking_score_threshold,
                vector=vector,
            )

        if self._concurrent_facet_search_plugins:
            if not use_task_groups():
                tasks: Any = []
                for plugin in self._concurrent_facet_search_plugins:
                    if _plugin_has_method(plugin, "run_plugin"):
                        tasks.append(
                            plugin.run_plugin(  # type: ignore[union-attr]
                                event=AsyncEvent.CONCURRENT,
                                query=query,
                                offset=offset,
                                limit=limit,
                                filter=filter,
                                facets=facets,
                                attributes_to_retrieve=attributes_to_retrieve,
                                attributes_to_crop=attributes_to_crop,
                                crop_length=crop_length,
                                attributes_to_highlight=attributes_to_highlight,
                                sort=sort,
                                show_matches_position=show_matches_position,
                                highlight_pre_tag=highlight_pre_tag,
                                highlight_post_tag=highlight_post_tag,
                                crop_marker=crop_marker,
                                matching_strategy=matching_strategy,
                                hits_per_page=hits_per_page,
                                page=page,
                                attributes_to_search_on=attributes_to_search_on,
                                show_ranking_score=show_ranking_score,
                                show_ranking_score_details=show_ranking_score_details,
                                ranking_score_threshold=ranking_score_threshold,
                                vector=vector,
                            )
                        )

                tasks.append(self._http_requests.post(search_url, body=body))
                responses = await asyncio.gather(*tasks)
                result = FacetSearchResults(**responses[-1].json())
                if self._post_facet_search_plugins:
                    post = await AsyncIndex._run_plugins(
                        self._post_facet_search_plugins, AsyncEvent.POST, result=result
                    )
                    if isinstance(post["generic_result"], FacetSearchResults):
                        result = post["generic_result"]

                return result

            async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                for plugin in self._concurrent_facet_search_plugins:
                    if _plugin_has_method(plugin, "run_plugin"):
                        tg.create_task(
                            plugin.run_plugin(  # type: ignore[union-attr]
                                event=AsyncEvent.CONCURRENT,
                                query=query,
                                offset=offset,
                                limit=limit,
                                filter=filter,
                                facets=facets,
                                attributes_to_retrieve=attributes_to_retrieve,
                                attributes_to_crop=attributes_to_crop,
                                crop_length=crop_length,
                                attributes_to_highlight=attributes_to_highlight,
                                sort=sort,
                                show_matches_position=show_matches_position,
                                highlight_pre_tag=highlight_pre_tag,
                                highlight_post_tag=highlight_post_tag,
                                crop_marker=crop_marker,
                                matching_strategy=matching_strategy,
                                hits_per_page=hits_per_page,
                                page=page,
                                attributes_to_search_on=attributes_to_search_on,
                                show_ranking_score=show_ranking_score,
                                show_ranking_score_details=show_ranking_score_details,
                                ranking_score_threshold=ranking_score_threshold,
                                vector=vector,
                            )
                        )

                response_coroutine = tg.create_task(self._http_requests.post(search_url, body=body))

            response = await response_coroutine
            result = FacetSearchResults(**response.json())
            if self._post_facet_search_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_facet_search_plugins, AsyncEvent.POST, result=result
                )
                if isinstance(post["generic_result"], FacetSearchResults):
                    result = post["generic_result"]

            return result

        response = await self._http_requests.post(search_url, body=body)
        result = FacetSearchResults(**response.json())
        if self._post_facet_search_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_facet_search_plugins, AsyncEvent.POST, result=result
            )
            if isinstance(post["generic_result"], FacetSearchResults):
                result = post["generic_result"]

        return result

    async def search_similar_documents(
        self,
        id: str,
        *,
        offset: int | None = None,
        limit: int | None = None,
        filter: str | None = None,
        embedder: str = "default",
        attributes_to_retrieve: list[str] | None = None,
        show_ranking_score: bool = False,
        show_ranking_score_details: bool = False,
        ranking_score_threshold: float | None = None,
    ) -> SimilarSearchResults:
        """Search the index.

        Args:
            id: The id for the target document that is being used to find similar documents.
            offset: Number of documents to skip. Defaults to 0.
            limit: Maximum number of documents returned. Defaults to 20.
            filter: Filter queries by an attribute value. Defaults to None.
            embedder: The vector DB to use for the search.
            attributes_to_retrieve: Attributes to display in the returned documents.
                Defaults to ["*"].
            show_ranking_score: If set to True the ranking score will be returned with each document
                in the search. Defaults to False.
            show_ranking_score_details: If set to True the ranking details will be returned with
                each document in the search. Defaults to False.
            ranking_score_threshold: If set, no document whose _rankingScore is under the
                rankingScoreThreshold is returned. The value must be between 0.0 and 1.0. Defaults
                to None.

        Returns:
            Results of the search

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     search_results = await index.search_similar_documents("123")
        """
        payload = {
            "id": id,
            "filter": filter,
            "embedder": embedder,
            "attributesToRetrieve": attributes_to_retrieve,
            "showRankingScore": show_ranking_score,
            "showRankingScoreDetails": show_ranking_score_details,
            "rankingScoreThreshold": ranking_score_threshold,
        }

        if offset:
            payload["offset"] = offset

        if limit:
            payload["limit"] = limit

        response = await self._http_requests.post(
            f"{self._base_url_with_uid}/similar", body=payload
        )

        return SimilarSearchResults[self.hits_type](**response.json())  # type: ignore[name-defined]

    async def get_document(self, document_id: str) -> JsonDict:
        """Get one document with given document identifier.

        Args:
            document_id: Unique identifier of the document.

        Returns:
            The document information

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     document = await index.get_document("1234")
        """
        response = await self._http_requests.get(f"{self._documents_url}/{document_id}")

        return response.json()

    async def get_documents(
        self,
        *,
        offset: int = 0,
        limit: int = 20,
        fields: list[str] | None = None,
        filter: Filter | None = None,
    ) -> DocumentsInfo:
        """Get a batch documents from the index.

        Args:
            offset: Number of documents to skip. Defaults to 0.
            limit: Maximum number of documents returnedd. Defaults to 20.
            fields: Document attributes to show. If this value is None then all
                attributes are retrieved. Defaults to None.
            filter: Filter value information. Defaults to None. Note: This parameter can only be
                used with Meilisearch >= v1.2.0

        Returns:
            Documents info.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.


        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     documents = await index.get_documents()
        """
        parameters: JsonDict = {
            "offset": offset,
            "limit": limit,
        }

        if not filter:
            if fields:
                parameters["fields"] = ",".join(fields)

            url = _build_encoded_url(self._documents_url, parameters)
            response = await self._http_requests.get(url)

            return DocumentsInfo(**response.json())

        if fields:
            parameters["fields"] = fields

        parameters["filter"] = filter

        response = await self._http_requests.post(f"{self._documents_url}/fetch", body=parameters)

        return DocumentsInfo(**response.json())

    async def add_documents(
        self,
        documents: Sequence[JsonMapping],
        primary_key: str | None = None,
        *,
        compress: bool = False,
    ) -> TaskInfo:
        """Add documents to the index.

        Args:
            documents: List of documents.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        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.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> documents = [
            >>>     {"id": 1, "title": "Movie 1", "genre": "comedy"},
            >>>     {"id": 2, "title": "Movie 2", "genre": "drama"},
            >>> ]
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.add_documents(documents)
        """
        if primary_key:
            url = _build_encoded_url(self._documents_url, {"primaryKey": primary_key})
        else:
            url = self._documents_url

        if self._pre_add_documents_plugins:
            pre = await AsyncIndex._run_plugins(
                self._pre_add_documents_plugins,
                AsyncEvent.PRE,
                documents=documents,
                primary_key=primary_key,
            )
            if pre.get("document_result"):
                documents = pre["document_result"]

        if self._concurrent_add_documents_plugins:
            if not use_task_groups():
                tasks: Any = []
                for plugin in self._concurrent_add_documents_plugins:
                    if _plugin_has_method(plugin, "run_plugin"):
                        tasks.append(
                            plugin.run_plugin(  # type: ignore[union-attr]
                                event=AsyncEvent.CONCURRENT,
                                documents=documents,
                                primary_key=primary_key,
                            )
                        )
                    if _plugin_has_method(plugin, "run_document_plugin"):
                        tasks.append(
                            plugin.run_document_plugin(  # type: ignore[union-attr]
                                event=AsyncEvent.CONCURRENT,
                                documents=documents,
                                primary_key=primary_key,
                            )
                        )

                tasks.append(self._http_requests.post(url, documents, compress=compress))

                responses = await asyncio.gather(*tasks)
                result = TaskInfo(**responses[-1].json())
                if self._post_add_documents_plugins:
                    post = await AsyncIndex._run_plugins(
                        self._post_add_documents_plugins,
                        AsyncEvent.POST,
                        result=result,
                        documents=documents,
                        primary_key=primary_key,
                    )
                    if isinstance(post["generic_result"], TaskInfo):
                        result = post["generic_result"]
                return result

            async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                for plugin in self._concurrent_add_documents_plugins:
                    if _plugin_has_method(plugin, "run_plugin"):
                        tg.create_task(
                            plugin.run_plugin(  # type: ignore[union-attr]
                                event=AsyncEvent.CONCURRENT,
                                documents=documents,
                                primary_key=primary_key,
                            )
                        )
                    if _plugin_has_method(plugin, "run_document_plugin"):
                        tg.create_task(
                            plugin.run_document_plugin(  # type: ignore[union-attr]
                                event=AsyncEvent.CONCURRENT,
                                documents=documents,
                                primary_key=primary_key,
                            )
                        )

                response_coroutine = tg.create_task(
                    self._http_requests.post(url, documents, compress=compress)
                )

            response = await response_coroutine
            result = TaskInfo(**response.json())
            if self._post_add_documents_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_add_documents_plugins,
                    AsyncEvent.POST,
                    result=result,
                    documents=documents,
                    primary_key=primary_key,
                )
                if isinstance(post["generic_result"], TaskInfo):
                    result = post["generic_result"]

            return result

        response = await self._http_requests.post(url, documents, compress=compress)

        result = TaskInfo(**response.json())
        if self._post_add_documents_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_add_documents_plugins,
                AsyncEvent.POST,
                result=result,
                documents=documents,
                primary_key=primary_key,
            )
            if isinstance(post["generic_result"], TaskInfo):
                result = post["generic_result"]

        return result

    async def add_documents_in_batches(
        self,
        documents: Sequence[JsonMapping],
        *,
        batch_size: int = 1000,
        primary_key: str | None = None,
        compress: bool = False,
        concurrency_limit: int | None = None,
    ) -> list[TaskInfo]:
        """Adds documents in batches to reduce RAM usage with indexing.

        Args:
            documents: List of documents.
            batch_size: The number of documents that should be included in each batch.
                Defaults to 1000.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            compress: If set to True the data will be sent in gzip format. Defaults to False.
            concurrency_limit: If set this will limit the number of batches that will be sent
                concurrently. This can be helpful if you find you are overloading the Meilisearch
                server with requests. Defaults to None.

        Returns:
            List of update ids to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> >>> documents = [
            >>>     {"id": 1, "title": "Movie 1", "genre": "comedy"},
            >>>     {"id": 2, "title": "Movie 2", "genre": "drama"},
            >>> ]
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.add_documents_in_batches(documents)
        """
        if concurrency_limit:
            async with asyncio.Semaphore(concurrency_limit):
                if not use_task_groups():
                    batches = [
                        self.add_documents(x, primary_key, compress=compress)
                        for x in _batch(documents, batch_size)
                    ]
                    return await asyncio.gather(*batches)

                async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                    tasks = [
                        tg.create_task(self.add_documents(x, primary_key, compress=compress))
                        for x in _batch(documents, batch_size)
                    ]

                return [x.result() for x in tasks]

        if not use_task_groups():
            batches = [
                self.add_documents(x, primary_key, compress=compress)
                for x in _batch(documents, batch_size)
            ]
            return await asyncio.gather(*batches)

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            tasks = [
                tg.create_task(self.add_documents(x, primary_key, compress=compress))
                for x in _batch(documents, batch_size)
            ]

        return [x.result() for x in tasks]

    async def add_documents_from_directory(
        self,
        directory_path: Path | str,
        *,
        primary_key: str | None = None,
        document_type: str = "json",
        csv_delimiter: str | None = None,
        combine_documents: bool = True,
        compress: bool = False,
        concurrency_limit: int | None = None,
    ) -> list[TaskInfo]:
        """Load all json files from a directory and add the documents to the index.

        Args:
            directory_path: Path to the directory that contains the json files.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            document_type: The type of document being added. Accepted types are json, csv, and
                ndjson. For csv files the first row of the document should be a header row contining
                the field names, and ever for should have a title.
            csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
                can only be used if the file is a csv file. Defaults to comma.
            combine_documents: If set to True this will combine the documents from all the files
                before indexing them. Defaults to True.
            compress: If set to True the data will be sent in gzip format. Defaults to False.
            concurrency_limit: If set this will limit the number of batches that will be sent
                concurrently. This can be helpful if you find you are overloading the Meilisearch
                server with requests. Defaults to None.

        Returns:
            The details of the task status.

        Raises:
            InvalidDocumentError: If the docucment is not a valid format for Meilisearch.
            MeilisearchError: If the file path is not valid
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from pathlib import Path
            >>> from meilisearch_python_sdk import AsyncClient
            >>> directory_path = Path("/path/to/directory/containing/files")
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.add_documents_from_directory(directory_path)
        """
        directory = Path(directory_path) if isinstance(directory_path, str) else directory_path

        if combine_documents:
            all_documents = []
            for path in directory.iterdir():
                if path.suffix == f".{document_type}":
                    documents = await _async_load_documents_from_file(
                        path, csv_delimiter, json_handler=self._json_handler
                    )
                    all_documents.append(documents)

            _raise_on_no_documents(all_documents, document_type, directory_path)

            loop = asyncio.get_running_loop()
            combined = await loop.run_in_executor(None, partial(_combine_documents, all_documents))

            response = await self.add_documents(combined, primary_key, compress=compress)

            return [response]

        if concurrency_limit:
            async with asyncio.Semaphore(concurrency_limit):
                if not use_task_groups():
                    add_documents = []
                    for path in directory.iterdir():
                        if path.suffix == f".{document_type}":
                            documents = await _async_load_documents_from_file(
                                path, csv_delimiter, json_handler=self._json_handler
                            )
                            add_documents.append(
                                self.add_documents(documents, primary_key, compress=compress)
                            )

                    _raise_on_no_documents(add_documents, document_type, directory_path)

                    if len(add_documents) > 1:
                        # Send the first document on its own before starting the gather. Otherwise Meilisearch
                        # returns an error because it thinks all entries are trying to create the same index.
                        first_response = [await add_documents.pop()]

                        responses = await asyncio.gather(*add_documents)
                        responses = [*first_response, *responses]
                    else:
                        responses = [await add_documents[0]]

                    return responses

                async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                    tasks = []
                    all_results = []
                    for i, path in enumerate(directory.iterdir()):
                        if path.suffix == f".{document_type}":
                            documents = await _async_load_documents_from_file(
                                path, csv_delimiter, json_handler=self._json_handler
                            )
                            if i == 0:
                                all_results = [
                                    await self.add_documents(documents, compress=compress)
                                ]
                            else:
                                tasks.append(
                                    tg.create_task(
                                        self.add_documents(
                                            documents, primary_key, compress=compress
                                        )
                                    )
                                )

        if not use_task_groups():
            add_documents = []
            for path in directory.iterdir():
                if path.suffix == f".{document_type}":
                    documents = await _async_load_documents_from_file(
                        path, csv_delimiter, json_handler=self._json_handler
                    )
                    add_documents.append(
                        self.add_documents(documents, primary_key, compress=compress)
                    )

            _raise_on_no_documents(add_documents, document_type, directory_path)

            if len(add_documents) > 1:
                # Send the first document on its own before starting the gather. Otherwise Meilisearch
                # returns an error because it thinks all entries are trying to create the same index.
                first_response = [await add_documents.pop()]

                responses = await asyncio.gather(*add_documents)
                responses = [*first_response, *responses]
            else:
                responses = [await add_documents[0]]

            return responses

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            tasks = []
            all_results = []
            for i, path in enumerate(directory.iterdir()):
                if path.suffix == f".{document_type}":
                    documents = await _async_load_documents_from_file(
                        path, csv_delimiter, json_handler=self._json_handler
                    )
                    if i == 0:
                        all_results = [await self.add_documents(documents, compress=compress)]
                    else:
                        tasks.append(
                            tg.create_task(
                                self.add_documents(documents, primary_key, compress=compress)
                            )
                        )

        results = [x.result() for x in tasks]
        all_results = [*all_results, *results]
        _raise_on_no_documents(all_results, document_type, directory_path)
        return all_results

    async def add_documents_from_directory_in_batches(
        self,
        directory_path: Path | str,
        *,
        batch_size: int = 1000,
        primary_key: str | None = None,
        document_type: str = "json",
        csv_delimiter: str | None = None,
        combine_documents: bool = True,
        compress: bool = False,
        concurrency_limit: int | None = None,
    ) -> list[TaskInfo]:
        """Load all json files from a directory and add the documents to the index in batches.

        Args:
            directory_path: Path to the directory that contains the json files.
            batch_size: The number of documents that should be included in each batch.
                Defaults to 1000.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            document_type: The type of document being added. Accepted types are json, csv, and
                ndjson. For csv files the first row of the document should be a header row contining
                the field names, and ever for should have a title.
            csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
                can only be used if the file is a csv file. Defaults to comma.
            combine_documents: If set to True this will combine the documents from all the files
                before indexing them. Defaults to True.
            compress: If set to True the data will be sent in gzip format. Defaults to False.
            concurrency_limit: If set this will limit the number of batches that will be sent
                concurrently. This can be helpful if you find you are overloading the Meilisearch
                server with requests. Defaults to None.

        Returns:
            List of update ids to track the action.

        Raises:
            InvalidDocumentError: If the docucment is not a valid format for Meilisearch.
            MeilisearchError: If the file path is not valid
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from pathlib import Path
            >>> from meilisearch_python_sdk import AsyncClient
            >>> directory_path = Path("/path/to/directory/containing/files")
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.add_documents_from_directory_in_batches(directory_path)
        """
        directory = Path(directory_path) if isinstance(directory_path, str) else directory_path

        if combine_documents:
            all_documents = []
            for path in directory.iterdir():
                if path.suffix == f".{document_type}":
                    documents = await _async_load_documents_from_file(
                        path, csv_delimiter=csv_delimiter, json_handler=self._json_handler
                    )
                    all_documents.append(documents)

            _raise_on_no_documents(all_documents, document_type, directory_path)

            loop = asyncio.get_running_loop()
            combined = await loop.run_in_executor(None, partial(_combine_documents, all_documents))

            return await self.add_documents_in_batches(
                combined,
                batch_size=batch_size,
                primary_key=primary_key,
                compress=compress,
                concurrency_limit=concurrency_limit,
            )

        responses: list[TaskInfo] = []

        add_documents = []
        for path in directory.iterdir():
            if path.suffix == f".{document_type}":
                documents = await _async_load_documents_from_file(
                    path, csv_delimiter, json_handler=self._json_handler
                )
                add_documents.append(
                    self.add_documents_in_batches(
                        documents,
                        batch_size=batch_size,
                        primary_key=primary_key,
                        compress=compress,
                        concurrency_limit=concurrency_limit,
                    )
                )

        _raise_on_no_documents(add_documents, document_type, directory_path)

        if len(add_documents) > 1:
            # Send the first document on its own before starting the gather. Otherwise Meilisearch
            # returns an error because it thinks all entries are trying to create the same index.
            first_response = await add_documents.pop()
            responses_gather = await asyncio.gather(*add_documents)
            responses = [*first_response, *[x for y in responses_gather for x in y]]
        else:
            responses = await add_documents[0]

        return responses

    async def add_documents_from_file(
        self,
        file_path: Path | str,
        primary_key: str | None = None,
        *,
        compress: bool = False,
    ) -> TaskInfo:
        """Add documents to the index from a json file.

        Args:
            file_path: Path to the json file.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            InvalidDocumentError: If the docucment is not a valid format for Meilisearch.
            MeilisearchError: If the file path is not valid
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from pathlib import Path
            >>> from meilisearch_python_sdk import AsyncClient
            >>> file_path = Path("/path/to/file.json")
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.add_documents_from_file(file_path)
        """
        documents = await _async_load_documents_from_file(
            file_path, json_handler=self._json_handler
        )

        return await self.add_documents(documents, primary_key=primary_key, compress=compress)

    async def add_documents_from_file_in_batches(
        self,
        file_path: Path | str,
        *,
        batch_size: int = 1000,
        primary_key: str | None = None,
        csv_delimiter: str | None = None,
        compress: bool = False,
        concurrency_limit: int | None = None,
    ) -> list[TaskInfo]:
        """Adds documents form a json file in batches to reduce RAM usage with indexing.

        Args:
            file_path: Path to the json file.
            batch_size: The number of documents that should be included in each batch.
                Defaults to 1000.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
                can only be used if the file is a csv file. Defaults to comma.
            compress: If set to True the data will be sent in gzip format. Defaults to False.
            concurrency_limit: If set this will limit the number of batches that will be sent
                concurrently. This can be helpful if you find you are overloading the Meilisearch
                server with requests. Defaults to None.

        Returns:
            List of update ids to track the action.

        Raises:
            InvalidDocumentError: If the docucment is not a valid format for Meilisearch.
            MeilisearchError: If the file path is not valid
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from pathlib import Path
            >>> from meilisearch_python_sdk import AsyncClient
            >>> file_path = Path("/path/to/file.json")
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.add_documents_from_file_in_batches(file_path)
        """
        documents = await _async_load_documents_from_file(
            file_path, csv_delimiter, json_handler=self._json_handler
        )

        return await self.add_documents_in_batches(
            documents,
            batch_size=batch_size,
            primary_key=primary_key,
            compress=compress,
            concurrency_limit=concurrency_limit,
        )

    async def add_documents_from_raw_file(
        self,
        file_path: Path | str,
        primary_key: str | None = None,
        *,
        csv_delimiter: str | None = None,
        compress: bool = False,
    ) -> TaskInfo:
        """Directly send csv or ndjson files to Meilisearch without pre-processing.

        The can reduce RAM usage from Meilisearch during indexing, but does not include the option
        for batching.

        Args:
            file_path: The path to the file to send to Meilisearch. Only csv and ndjson files are
                allowed.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
                can only be used if the file is a csv file. Defaults to comma.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task.

        Raises:
            ValueError: If the file is not a csv or ndjson file, or if a csv_delimiter is sent for
                a non-csv file.
            MeilisearchError: If the file path is not valid
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from pathlib import Path
            >>> from meilisearch_python_sdk import AsyncClient
            >>> file_path = Path("/path/to/file.csv")
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.add_documents_from_raw_file(file_path)
        """
        upload_path = Path(file_path) if isinstance(file_path, str) else file_path
        if not upload_path.exists():
            raise MeilisearchError("No file found at the specified path")

        if upload_path.suffix not in (".csv", ".ndjson"):
            raise ValueError("Only csv and ndjson files can be sent as binary files")

        if csv_delimiter and upload_path.suffix != ".csv":
            raise ValueError("A csv_delimiter can only be used with csv files")

        if (
            csv_delimiter
            and len(csv_delimiter) != 1
            or csv_delimiter
            and not csv_delimiter.isascii()
        ):
            raise ValueError("csv_delimiter must be a single ascii character")

        content_type = "text/csv" if upload_path.suffix == ".csv" else "application/x-ndjson"
        parameters = {}

        if primary_key:
            parameters["primaryKey"] = primary_key
        if csv_delimiter:
            parameters["csvDelimiter"] = csv_delimiter

        if parameters:
            url = _build_encoded_url(self._documents_url, parameters)
        else:
            url = self._documents_url

        async with aiofiles.open(upload_path) as f:
            data = await f.read()

        response = await self._http_requests.post(
            url, body=data, content_type=content_type, compress=compress
        )

        return TaskInfo(**response.json())

    async def edit_documents(
        self, function: str, *, context: JsonDict | None = None, filter: str | None = None
    ) -> TaskInfo:
        """Edit documents with a function.

        Edit documents is only available in Meilisearch >= v1.10.0, and is experimental in
        Meilisearch v1.10.0. In order to use this feature you first need to enable it by
        sending a PATCH request to /experimental-features with { "editDocumentsByFunction": true }.

        Args:
            function: Rhai function to use to update the documents.
            context: Parameters to use in the function. Defaults to None.
            filter: Filter the documents before applying the function. Defaults to None.

        Returns:
            The details of the task.

        Raises:
            MeilisearchError: If the file path is not valid
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.edit_documents("doc.title = `${doc.title.to_upper()}`")
        """
        url = f"{self._documents_url}/edit"
        payload: JsonDict = {"function": function}

        if context:
            payload["context"] = context

        if filter:
            payload["filter"] = filter

        response = await self._http_requests.post(url, payload)

        return TaskInfo(**response.json())

    async def update_documents(
        self,
        documents: Sequence[JsonMapping],
        primary_key: str | None = None,
        *,
        compress: bool = False,
    ) -> TaskInfo:
        """Update documents in the index.

        Args:
            documents: List of documents.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        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.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> documents = [
            >>>     {"id": 1, "title": "Movie 1", "genre": "comedy"},
            >>>     {"id": 2, "title": "Movie 2", "genre": "drama"},
            >>> ]
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_documents(documents)
        """
        if primary_key:
            url = _build_encoded_url(self._documents_url, {"primaryKey": primary_key})
        else:
            url = self._documents_url

        if self._pre_update_documents_plugins:
            pre = await AsyncIndex._run_plugins(
                self._pre_update_documents_plugins,
                AsyncEvent.PRE,
                documents=documents,
                primary_key=primary_key,
            )
            if pre.get("document_result"):
                documents = pre["document_result"]

        if self._concurrent_update_documents_plugins:
            if not use_task_groups():
                tasks: Any = []
                for plugin in self._concurrent_update_documents_plugins:
                    if _plugin_has_method(plugin, "run_plugin"):
                        tasks.append(
                            plugin.run_plugin(  # type: ignore[union-attr]
                                event=AsyncEvent.CONCURRENT,
                                documents=documents,
                                primary_key=primary_key,
                            )
                        )
                    if _plugin_has_method(plugin, "run_document_plugin"):
                        tasks.append(
                            plugin.run_document_plugin(  # type: ignore[union-attr]
                                event=AsyncEvent.CONCURRENT,
                                documents=documents,
                                primary_key=primary_key,
                            )
                        )

                tasks.append(self._http_requests.put(url, documents, compress=compress))

                responses = await asyncio.gather(*tasks)
                result = TaskInfo(**responses[-1].json())
                if self._post_update_documents_plugins:
                    post = await AsyncIndex._run_plugins(
                        self._post_update_documents_plugins,
                        AsyncEvent.POST,
                        result=result,
                        documents=documents,
                        primary_key=primary_key,
                    )
                    if isinstance(post["generic_result"], TaskInfo):
                        result = post["generic_result"]

                return result

            async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                for plugin in self._concurrent_update_documents_plugins:
                    if _plugin_has_method(plugin, "run_plugin"):
                        tg.create_task(
                            plugin.run_plugin(  # type: ignore[union-attr]
                                event=AsyncEvent.CONCURRENT,
                                documents=documents,
                                primary_key=primary_key,
                            )
                        )
                    if _plugin_has_method(plugin, "run_document_plugin"):
                        tg.create_task(
                            plugin.run_document_plugin(  # type: ignore[union-attr]
                                event=AsyncEvent.CONCURRENT,
                                documents=documents,
                                primary_key=primary_key,
                            )
                        )

                response_coroutine = tg.create_task(
                    self._http_requests.put(url, documents, compress=compress)
                )

            response = await response_coroutine
            result = TaskInfo(**response.json())
            if self._post_update_documents_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_update_documents_plugins,
                    AsyncEvent.POST,
                    result=result,
                    documents=documents,
                    primary_key=primary_key,
                )

                if isinstance(post["generic_result"], TaskInfo):
                    result = post["generic_result"]

            return result

        response = await self._http_requests.put(url, documents, compress=compress)
        result = TaskInfo(**response.json())
        if self._post_update_documents_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_update_documents_plugins,
                AsyncEvent.POST,
                result=result,
                documents=documents,
                primary_key=primary_key,
            )
            if isinstance(post["generic_result"], TaskInfo):
                result = post["generic_result"]

        return result

    async def update_documents_in_batches(
        self,
        documents: Sequence[JsonMapping],
        *,
        batch_size: int = 1000,
        primary_key: str | None = None,
        compress: bool = False,
        concurrency_limit: int | None = None,
    ) -> list[TaskInfo]:
        """Update documents in batches to reduce RAM usage with indexing.

        Each batch tries to fill the max_payload_size

        Args:
            documents: List of documents.
            batch_size: The number of documents that should be included in each batch.
                Defaults to 1000.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            compress: If set to True the data will be sent in gzip format. Defaults to False.
            concurrency_limit: If set this will limit the number of batches that will be sent
                concurrently. This can be helpful if you find you are overloading the Meilisearch
                server with requests. Defaults to None.

        Returns:
            List of update ids to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> documents = [
            >>>     {"id": 1, "title": "Movie 1", "genre": "comedy"},
            >>>     {"id": 2, "title": "Movie 2", "genre": "drama"},
            >>> ]
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_documents_in_batches(documents)
        """
        if concurrency_limit:
            async with asyncio.Semaphore(concurrency_limit):
                if not use_task_groups():
                    batches = [
                        self.update_documents(x, primary_key, compress=compress)
                        for x in _batch(documents, batch_size)
                    ]
                    return await asyncio.gather(*batches)

                async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                    tasks = [
                        tg.create_task(self.update_documents(x, primary_key, compress=compress))
                        for x in _batch(documents, batch_size)
                    ]
                return [x.result() for x in tasks]

        if not use_task_groups():
            batches = [
                self.update_documents(x, primary_key, compress=compress)
                for x in _batch(documents, batch_size)
            ]
            return await asyncio.gather(*batches)

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            tasks = [
                tg.create_task(self.update_documents(x, primary_key, compress=compress))
                for x in _batch(documents, batch_size)
            ]
        return [x.result() for x in tasks]

    async def update_documents_from_directory(
        self,
        directory_path: Path | str,
        *,
        primary_key: str | None = None,
        document_type: str = "json",
        csv_delimiter: str | None = None,
        combine_documents: bool = True,
        compress: bool = False,
    ) -> list[TaskInfo]:
        """Load all json files from a directory and update the documents.

        Args:
            directory_path: Path to the directory that contains the json files.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            document_type: The type of document being added. Accepted types are json, csv, and
                ndjson. For csv files the first row of the document should be a header row contining
                the field names, and ever for should have a title.
            csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
                can only be used if the file is a csv file. Defaults to comma.
            combine_documents: If set to True this will combine the documents from all the files
                before indexing them. Defaults to True.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            InvalidDocumentError: If the docucment is not a valid format for Meilisearch.
            MeilisearchError: If the file path is not valid
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from pathlib import Path
            >>> from meilisearch_python_sdk import AsyncClient
            >>> directory_path = Path("/path/to/directory/containing/files")
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_documents_from_directory(directory_path)
        """
        directory = Path(directory_path) if isinstance(directory_path, str) else directory_path

        if combine_documents:
            all_documents = []
            for path in directory.iterdir():
                if path.suffix == f".{document_type}":
                    documents = await _async_load_documents_from_file(
                        path, csv_delimiter, json_handler=self._json_handler
                    )
                    all_documents.append(documents)

            _raise_on_no_documents(all_documents, document_type, directory_path)

            loop = asyncio.get_running_loop()
            combined = await loop.run_in_executor(None, partial(_combine_documents, all_documents))

            response = await self.update_documents(combined, primary_key, compress=compress)
            return [response]

        if not use_task_groups():
            update_documents = []
            for path in directory.iterdir():
                if path.suffix == f".{document_type}":
                    documents = await _async_load_documents_from_file(
                        path, csv_delimiter, json_handler=self._json_handler
                    )
                    update_documents.append(
                        self.update_documents(documents, primary_key, compress=compress)
                    )

            _raise_on_no_documents(update_documents, document_type, directory_path)

            if len(update_documents) > 1:
                # Send the first document on its own before starting the gather. Otherwise Meilisearch
                # returns an error because it thinks all entries are trying to create the same index.
                first_response = [await update_documents.pop()]
                responses = await asyncio.gather(*update_documents)
                responses = [*first_response, *responses]
            else:
                responses = [await update_documents[0]]

            return responses

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            tasks = []
            results = []
            for i, path in enumerate(directory.iterdir()):
                if path.suffix == f".{document_type}":
                    documents = await _async_load_documents_from_file(
                        path, csv_delimiter, json_handler=self._json_handler
                    )
                    if i == 0:
                        results = [
                            await self.update_documents(documents, primary_key, compress=compress)
                        ]
                    else:
                        tasks.append(
                            tg.create_task(
                                self.update_documents(documents, primary_key, compress=compress)
                            )
                        )

        results = [*results, *[x.result() for x in tasks]]
        _raise_on_no_documents(results, document_type, directory_path)
        return results

    async def update_documents_from_directory_in_batches(
        self,
        directory_path: Path | str,
        *,
        batch_size: int = 1000,
        primary_key: str | None = None,
        document_type: str = "json",
        csv_delimiter: str | None = None,
        combine_documents: bool = True,
        compress: bool = False,
        concurrency_limit: int | None = None,
    ) -> list[TaskInfo]:
        """Load all json files from a directory and update the documents.

        Args:
            directory_path: Path to the directory that contains the json files.
            batch_size: The number of documents that should be included in each batch.
                Defaults to 1000.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            document_type: The type of document being added. Accepted types are json, csv, and
                ndjson. For csv files the first row of the document should be a header row contining
                the field names, and ever for should have a title.
            csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
                can only be used if the file is a csv file. Defaults to comma.
            combine_documents: If set to True this will combine the documents from all the files
                before indexing them. Defaults to True.
            compress: If set to True the data will be sent in gzip format. Defaults to False.
            concurrency_limit: If set this will limit the number of batches that will be sent
                concurrently. This can be helpful if you find you are overloading the Meilisearch
                server with requests. Defaults to None.

        Returns:
            List of update ids to track the action.

        Raises:
            InvalidDocumentError: If the docucment is not a valid format for Meilisearch.
            MeilisearchError: If the file path is not valid
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from pathlib import Path
            >>> from meilisearch_python_sdk import AsyncClient
            >>> directory_path = Path("/path/to/directory/containing/files")
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_documents_from_directory_in_batches(directory_path)
        """
        directory = Path(directory_path) if isinstance(directory_path, str) else directory_path

        if combine_documents:
            all_documents = []
            for path in directory.iterdir():
                if path.suffix == f".{document_type}":
                    documents = await _async_load_documents_from_file(
                        path, csv_delimiter, json_handler=self._json_handler
                    )
                    all_documents.append(documents)

            _raise_on_no_documents(all_documents, document_type, directory_path)

            loop = asyncio.get_running_loop()
            combined = await loop.run_in_executor(None, partial(_combine_documents, all_documents))

            return await self.update_documents_in_batches(
                combined,
                batch_size=batch_size,
                primary_key=primary_key,
                compress=compress,
                concurrency_limit=concurrency_limit,
            )

        if not use_task_groups():
            responses: list[TaskInfo] = []

            update_documents = []
            for path in directory.iterdir():
                if path.suffix == f".{document_type}":
                    documents = await _async_load_documents_from_file(
                        path, csv_delimiter, json_handler=self._json_handler
                    )
                    update_documents.append(
                        self.update_documents_in_batches(
                            documents,
                            batch_size=batch_size,
                            primary_key=primary_key,
                            compress=compress,
                            concurrency_limit=concurrency_limit,
                        )
                    )

            _raise_on_no_documents(update_documents, document_type, directory_path)

            if len(update_documents) > 1:
                # Send the first document on its own before starting the gather. Otherwise Meilisearch
                # returns an error because it thinks all entries are trying to create the same index.
                first_response = await update_documents.pop()
                responses_gather = await asyncio.gather(*update_documents)
                responses = [*first_response, *[x for y in responses_gather for x in y]]
            else:
                responses = await update_documents[0]

            return responses

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            results = []
            tasks = []
            for i, path in enumerate(directory.iterdir()):
                if path.suffix == f".{document_type}":
                    documents = await _async_load_documents_from_file(
                        path, csv_delimiter, json_handler=self._json_handler
                    )
                    if i == 0:
                        results = await self.update_documents_in_batches(
                            documents,
                            batch_size=batch_size,
                            primary_key=primary_key,
                            compress=compress,
                            concurrency_limit=concurrency_limit,
                        )
                    else:
                        tasks.append(
                            tg.create_task(
                                self.update_documents_in_batches(
                                    documents,
                                    batch_size=batch_size,
                                    primary_key=primary_key,
                                    compress=compress,
                                    concurrency_limit=concurrency_limit,
                                )
                            )
                        )

        results = [*results, *[x for y in tasks for x in y.result()]]
        _raise_on_no_documents(results, document_type, directory_path)
        return results

    async def update_documents_from_file(
        self,
        file_path: Path | str,
        primary_key: str | None = None,
        csv_delimiter: str | None = None,
        *,
        compress: bool = False,
    ) -> TaskInfo:
        """Add documents in the index from a json file.

        Args:
            file_path: Path to the json file.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
                can only be used if the file is a csv file. Defaults to comma.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from pathlib import Path
            >>> from meilisearch_python_sdk import AsyncClient
            >>> file_path = Path("/path/to/file.json")
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_documents_from_file(file_path)
        """
        documents = await _async_load_documents_from_file(
            file_path, csv_delimiter, json_handler=self._json_handler
        )

        return await self.update_documents(documents, primary_key=primary_key, compress=compress)

    async def update_documents_from_file_in_batches(
        self,
        file_path: Path | str,
        *,
        batch_size: int = 1000,
        primary_key: str | None = None,
        compress: bool = False,
        concurrency_limit: int | None = None,
    ) -> list[TaskInfo]:
        """Updates documents form a json file in batches to reduce RAM usage with indexing.

        Args:
            file_path: Path to the json file.
            batch_size: The number of documents that should be included in each batch.
                Defaults to 1000.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            compress: If set to True the data will be sent in gzip format. Defaults to False.
            concurrency_limit: If set this will limit the number of batches that will be sent
                concurrently. This can be helpful if you find you are overloading the Meilisearch
                server with requests. Defaults to None.

        Returns:
            List of update ids to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from pathlib import Path
            >>> from meilisearch_python_sdk import AsyncClient
            >>> file_path = Path("/path/to/file.json")
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_documents_from_file_in_batches(file_path)
        """
        documents = await _async_load_documents_from_file(
            file_path, json_handler=self._json_handler
        )

        return await self.update_documents_in_batches(
            documents,
            batch_size=batch_size,
            primary_key=primary_key,
            compress=compress,
            concurrency_limit=concurrency_limit,
        )

    async def update_documents_from_raw_file(
        self,
        file_path: Path | str,
        primary_key: str | None = None,
        csv_delimiter: str | None = None,
        *,
        compress: bool = False,
    ) -> TaskInfo:
        """Directly send csv or ndjson files to Meilisearch without pre-processing.

        The can reduce RAM usage from Meilisearch during indexing, but does not include the option
        for batching.

        Args:
            file_path: The path to the file to send to Meilisearch. Only csv and ndjson files are
                allowed.
            primary_key: The primary key of the documents. This will be ignored if already set.
                Defaults to None.
            csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
                can only be used if the file is a csv file. Defaults to comma.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            ValueError: If the file is not a csv or ndjson file, or if a csv_delimiter is sent for
                a non-csv file.
            MeilisearchError: If the file path is not valid
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from pathlib import Path
            >>> from meilisearch_python_sdk import AsyncClient
            >>> file_path = Path("/path/to/file.csv")
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_documents_from_raw_file(file_path)
        """
        upload_path = Path(file_path) if isinstance(file_path, str) else file_path
        if not upload_path.exists():
            raise MeilisearchError("No file found at the specified path")

        if upload_path.suffix not in (".csv", ".ndjson"):
            raise ValueError("Only csv and ndjson files can be sent as binary files")

        if csv_delimiter and upload_path.suffix != ".csv":
            raise ValueError("A csv_delimiter can only be used with csv files")

        if (
            csv_delimiter
            and len(csv_delimiter) != 1
            or csv_delimiter
            and not csv_delimiter.isascii()
        ):
            raise ValueError("csv_delimiter must be a single ascii character")

        content_type = "text/csv" if upload_path.suffix == ".csv" else "application/x-ndjson"
        parameters = {}

        if primary_key:
            parameters["primaryKey"] = primary_key
        if csv_delimiter:
            parameters["csvDelimiter"] = csv_delimiter

        if parameters:
            url = _build_encoded_url(self._documents_url, parameters)
        else:
            url = self._documents_url

        async with aiofiles.open(upload_path) as f:
            data = await f.read()

        response = await self._http_requests.put(
            url, body=data, content_type=content_type, compress=compress
        )

        return TaskInfo(**response.json())

    async def delete_document(self, document_id: str) -> TaskInfo:
        """Delete one document from the index.

        Args:
            document_id: Unique identifier of the document.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.delete_document("1234")
        """
        url = f"{self._documents_url}/{document_id}"

        if self._pre_delete_document_plugins:
            await AsyncIndex._run_plugins(
                self._pre_delete_document_plugins, AsyncEvent.PRE, document_id=document_id
            )

        if self._concurrent_delete_document_plugins:
            if not use_task_groups():
                tasks: Any = []
                for plugin in self._concurrent_delete_document_plugins:
                    tasks.append(
                        plugin.run_plugin(event=AsyncEvent.CONCURRENT, document_id=document_id)
                    )

                tasks.append(self._http_requests.delete(url))

                responses = await asyncio.gather(*tasks)
                result = TaskInfo(**responses[-1].json())
                if self._post_delete_document_plugins:
                    post = await AsyncIndex._run_plugins(
                        self._post_delete_document_plugins, AsyncEvent.POST, result=result
                    )
                    if isinstance(post.get("generic_result"), TaskInfo):
                        result = post["generic_result"]
                return result

            async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                for plugin in self._concurrent_delete_document_plugins:
                    tg.create_task(
                        plugin.run_plugin(event=AsyncEvent.CONCURRENT, document_id=document_id)
                    )

                response_coroutine = tg.create_task(self._http_requests.delete(url))

            response = await response_coroutine
            result = TaskInfo(**response.json())
            if self._post_delete_document_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_delete_document_plugins, event=AsyncEvent.POST, result=result
                )
                if isinstance(post["generic_result"], TaskInfo):
                    result = post["generic_result"]
            return result

        response = await self._http_requests.delete(url)
        result = TaskInfo(**response.json())
        if self._post_delete_document_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_delete_document_plugins, AsyncEvent.POST, result=result
            )
            if isinstance(post["generic_result"], TaskInfo):
                result = post["generic_result"]

        return result

    async def delete_documents(self, ids: list[str]) -> TaskInfo:
        """Delete multiple documents from the index.

        Args:
            ids: List of unique identifiers of documents.

        Returns:
            List of update ids to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.delete_documents(["1234", "5678"])
        """
        url = f"{self._documents_url}/delete-batch"

        if self._pre_delete_documents_plugins:
            await AsyncIndex._run_plugins(
                self._pre_delete_documents_plugins, AsyncEvent.PRE, ids=ids
            )

        if self._concurrent_delete_documents_plugins:
            if not use_task_groups():
                tasks: Any = []
                for plugin in self._concurrent_delete_documents_plugins:
                    tasks.append(plugin.run_plugin(event=AsyncEvent.CONCURRENT, ids=ids))

                tasks.append(self._http_requests.post(url, ids))

                responses = await asyncio.gather(*tasks)
                result = TaskInfo(**responses[-1].json())
                if self._post_delete_documents_plugins:
                    post = await AsyncIndex._run_plugins(
                        self._post_delete_documents_plugins, AsyncEvent.POST, result=result
                    )
                    if isinstance(post.get("generic_result"), TaskInfo):
                        result = post["generic_result"]
                return result

            async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                for plugin in self._concurrent_delete_documents_plugins:
                    tg.create_task(plugin.run_plugin(event=AsyncEvent.CONCURRENT, ids=ids))

                response_coroutine = tg.create_task(self._http_requests.post(url, ids))

            response = await response_coroutine
            result = TaskInfo(**response.json())
            if self._post_delete_documents_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_delete_documents_plugins, AsyncEvent.POST, result=result
                )
                if isinstance(post["generic_result"], TaskInfo):
                    result = post["generic_result"]
            return result

        response = await self._http_requests.post(url, ids)
        result = TaskInfo(**response.json())
        if self._post_delete_documents_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_delete_documents_plugins, AsyncEvent.POST, result=result
            )
            if isinstance(post["generic_result"], TaskInfo):
                result = post["generic_result"]

        return result

    async def delete_documents_by_filter(self, filter: Filter) -> TaskInfo:
        """Delete documents from the index by filter.

        Args:
            filter: The filter value information.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_pyrhon_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.delete_documents_by_filter("genre=horor"))
        """
        url = f"{self._documents_url}/delete"

        if self._pre_delete_documents_by_filter_plugins:
            await AsyncIndex._run_plugins(
                self._pre_delete_documents_by_filter_plugins, AsyncEvent.PRE, filter=filter
            )

        if self._concurrent_delete_documents_by_filter_plugins:
            if not use_task_groups():
                tasks: Any = []
                for plugin in self._concurrent_delete_documents_by_filter_plugins:
                    tasks.append(plugin.run_plugin(event=AsyncEvent.CONCURRENT, filter=filter))

                tasks.append(self._http_requests.post(url, body={"filter": filter}))

                responses = await asyncio.gather(*tasks)
                result = TaskInfo(**responses[-1].json())
                if self._post_delete_documents_by_filter_plugins:
                    post = await AsyncIndex._run_plugins(
                        self._post_delete_documents_by_filter_plugins,
                        AsyncEvent.POST,
                        result=result,
                    )
                    if isinstance(post["generic_result"], TaskInfo):
                        result = post["generic_result"]
                return result

            async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                for plugin in self._concurrent_delete_documents_by_filter_plugins:
                    tg.create_task(plugin.run_plugin(event=AsyncEvent.CONCURRENT, filter=filter))

                response_coroutine = tg.create_task(
                    self._http_requests.post(url, body={"filter": filter})
                )

            response = await response_coroutine
            result = TaskInfo(**response.json())
            if self._post_delete_documents_by_filter_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_delete_documents_by_filter_plugins, AsyncEvent.POST, result=result
                )
                if isinstance(post["generic_result"], TaskInfo):
                    result = post["generic_result"]

            return result

        response = await self._http_requests.post(url, body={"filter": filter})
        result = TaskInfo(**response.json())
        if self._post_delete_documents_by_filter_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_delete_documents_by_filter_plugins, AsyncEvent.POST, result=result
            )
            if isinstance(post.get("generic_result"), TaskInfo):
                result = post["generic_result"]
        return result

    async def delete_documents_in_batches_by_filter(
        self, filters: list[str | list[str | list[str]]], concurrency_limit: int | None = None
    ) -> list[TaskInfo]:
        """Delete batches of documents from the index by filter.

        Args:
            filters: A list of filter value information.
            concurrency_limit: If set this will limit the number of batches that will be sent
                concurrently. This can be helpful if you find you are overloading the Meilisearch
                server with requests. Defaults to None.

        Returns:
            The a list of details of the task statuses.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.delete_documents_in_batches_by_filter(
            >>>         [
            >>>             "genre=horor"),
            >>>             "release_date=1520035200"),
            >>>         ]
            >>>     )
        """
        if concurrency_limit:
            async with asyncio.Semaphore(concurrency_limit):
                if not use_task_groups():
                    tasks = [self.delete_documents_by_filter(filter) for filter in filters]
                    return await asyncio.gather(*tasks)

                async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                    tg_tasks = [
                        tg.create_task(self.delete_documents_by_filter(filter))
                        for filter in filters
                    ]

                return [x.result() for x in tg_tasks]

        if not use_task_groups():
            tasks = [self.delete_documents_by_filter(filter) for filter in filters]
            return await asyncio.gather(*tasks)

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            tg_tasks = [
                tg.create_task(self.delete_documents_by_filter(filter)) for filter in filters
            ]

        return [x.result() for x in tg_tasks]

    async def delete_all_documents(self) -> TaskInfo:
        """Delete all documents from the index.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.delete_all_document()
        """
        if self._pre_delete_all_documents_plugins:
            await AsyncIndex._run_plugins(self._pre_delete_all_documents_plugins, AsyncEvent.PRE)

        if self._concurrent_delete_all_documents_plugins:
            if not use_task_groups():
                tasks: Any = []
                for plugin in self._concurrent_delete_all_documents_plugins:
                    tasks.append(plugin.run_plugin(event=AsyncEvent.CONCURRENT))

                tasks.append(self._http_requests.delete(self._documents_url))

                responses = await asyncio.gather(*tasks)
                result = TaskInfo(**responses[-1].json())
                if self._post_delete_all_documents_plugins:
                    post = await AsyncIndex._run_plugins(
                        self._post_delete_all_documents_plugins, AsyncEvent.POST, result=result
                    )
                    if isinstance(post.get("generic_result"), TaskInfo):
                        result = post["generic_result"]
                return result

            async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                for plugin in self._concurrent_delete_all_documents_plugins:
                    tg.create_task(plugin.run_plugin(event=AsyncEvent.CONCURRENT))

                response_coroutine = tg.create_task(self._http_requests.delete(self._documents_url))

            response = await response_coroutine
            result = TaskInfo(**response.json())
            if self._post_delete_all_documents_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_delete_all_documents_plugins, AsyncEvent.POST, result=result
                )
                if isinstance(post.get("generic_result"), TaskInfo):
                    result = post["generic_result"]
            return result

        response = await self._http_requests.delete(self._documents_url)
        result = TaskInfo(**response.json())
        if self._post_delete_all_documents_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_delete_all_documents_plugins, AsyncEvent.POST, result=result
            )
            if isinstance(post.get("generic_result"), TaskInfo):
                result = post["generic_result"]
        return result

    async def get_settings(self) -> MeilisearchSettings:
        """Get settings of the index.

        Returns:
            Settings of the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     settings = await index.get_settings()
        """
        response = await self._http_requests.get(self._settings_url)
        response_json = response.json()
        settings = MeilisearchSettings(**response_json)

        if response_json.get("embedders"):
            # TODO: Add back after embedder setting issue fixed https://github.com/meilisearch/meilisearch/issues/4585
            settings.embedders = _embedder_json_to_settings_model(  # pragma: no cover
                response_json["embedders"]
            )

        return settings

    async def update_settings(
        self, body: MeilisearchSettings, *, compress: bool = False
    ) -> TaskInfo:
        """Update settings of the index.

        Args:
            body: Settings of the index.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> from meilisearch_python_sdk import MeilisearchSettings
            >>> new_settings = MeilisearchSettings(
            >>>     synonyms={"wolverine": ["xmen", "logan"], "logan": ["wolverine"]},
            >>>     stop_words=["the", "a", "an"],
            >>>     ranking_rules=[
            >>>         "words",
            >>>         "typo",
            >>>         "proximity",
            >>>         "attribute",
            >>>         "sort",
            >>>         "exactness",
            >>>         "release_date:desc",
            >>>         "rank:desc",
            >>>    ],
            >>>    filterable_attributes=["genre", "director"],
            >>>    distinct_attribute="url",
            >>>    searchable_attributes=["title", "description", "genre"],
            >>>    displayed_attributes=["title", "description", "genre", "release_date"],
            >>>    sortable_attributes=["title", "release_date"],
            >>> )
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_settings(new_settings)
        """
        body_dict = {
            k: v
            for k, v in body.model_dump(by_alias=True, exclude_none=True).items()
            if v is not None
        }
        response = await self._http_requests.patch(self._settings_url, body_dict, compress=compress)

        return TaskInfo(**response.json())

    async def reset_settings(self) -> TaskInfo:
        """Reset settings of the index to default values.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_settings()
        """
        response = await self._http_requests.delete(self._settings_url)

        return TaskInfo(**response.json())

    async def get_ranking_rules(self) -> list[str]:
        """Get ranking rules of the index.

        Returns:
            List containing the ranking rules of the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     ranking_rules = await index.get_ranking_rules()
        """
        response = await self._http_requests.get(f"{self._settings_url}/ranking-rules")

        return response.json()

    async def update_ranking_rules(
        self, ranking_rules: list[str], *, compress: bool = False
    ) -> TaskInfo:
        """Update ranking rules of the index.

        Args:
            ranking_rules: List containing the ranking rules.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> ranking_rules=[
            >>>      "words",
            >>>      "typo",
            >>>      "proximity",
            >>>      "attribute",
            >>>      "sort",
            >>>      "exactness",
            >>>      "release_date:desc",
            >>>      "rank:desc",
            >>> ],
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_ranking_rules(ranking_rules)
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/ranking-rules", ranking_rules, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_ranking_rules(self) -> TaskInfo:
        """Reset ranking rules of the index to default values.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_ranking_rules()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/ranking-rules")

        return TaskInfo(**response.json())

    async def get_distinct_attribute(self) -> str | None:
        """Get distinct attribute of the index.

        Returns:
            String containing the distinct attribute of the index. If no distinct attribute
                `None` is returned.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     distinct_attribute = await index.get_distinct_attribute()
        """
        response = await self._http_requests.get(f"{self._settings_url}/distinct-attribute")

        if not response.json():
            return None

        return response.json()

    async def update_distinct_attribute(self, body: str, *, compress: bool = False) -> TaskInfo:
        """Update distinct attribute of the index.

        Args:
            body: Distinct attribute.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_distinct_attribute("url")
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/distinct-attribute", body, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_distinct_attribute(self) -> TaskInfo:
        """Reset distinct attribute of the index to default values.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_distinct_attributes()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/distinct-attribute")

        return TaskInfo(**response.json())

    async def get_searchable_attributes(self) -> list[str]:
        """Get searchable attributes of the index.

        Returns:
            List containing the searchable attributes of the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     searchable_attributes = await index.get_searchable_attributes()
        """
        response = await self._http_requests.get(f"{self._settings_url}/searchable-attributes")

        return response.json()

    async def update_searchable_attributes(
        self, body: list[str], *, compress: bool = False
    ) -> TaskInfo:
        """Update searchable attributes of the index.

        Args:
            body: List containing the searchable attributes.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_searchable_attributes(["title", "description", "genre"])
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/searchable-attributes", body, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_searchable_attributes(self) -> TaskInfo:
        """Reset searchable attributes of the index to default values.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_searchable_attributes()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/searchable-attributes")

        return TaskInfo(**response.json())

    async def get_displayed_attributes(self) -> list[str]:
        """Get displayed attributes of the index.

        Returns:
            List containing the displayed attributes of the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     displayed_attributes = await index.get_displayed_attributes()
        """
        response = await self._http_requests.get(f"{self._settings_url}/displayed-attributes")

        return response.json()

    async def update_displayed_attributes(
        self, body: list[str], *, compress: bool = False
    ) -> TaskInfo:
        """Update displayed attributes of the index.

        Args:
            body: List containing the displayed attributes.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_displayed_attributes(
            >>>         ["title", "description", "genre", "release_date"]
            >>>     )
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/displayed-attributes", body, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_displayed_attributes(self) -> TaskInfo:
        """Reset displayed attributes of the index to default values.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_displayed_attributes()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/displayed-attributes")

        return TaskInfo(**response.json())

    async def get_stop_words(self) -> list[str] | None:
        """Get stop words of the index.

        Returns:
            List containing the stop words of the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     stop_words = await index.get_stop_words()
        """
        response = await self._http_requests.get(f"{self._settings_url}/stop-words")

        if not response.json():
            return None

        return response.json()

    async def update_stop_words(self, body: list[str], *, compress: bool = False) -> TaskInfo:
        """Update stop words of the index.

        Args:
            body: List containing the stop words of the index.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_stop_words(["the", "a", "an"])
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/stop-words", body, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_stop_words(self) -> TaskInfo:
        """Reset stop words of the index to default values.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_stop_words()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/stop-words")

        return TaskInfo(**response.json())

    async def get_synonyms(self) -> dict[str, list[str]] | None:
        """Get synonyms of the index.

        Returns:
            The synonyms of the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     synonyms = await index.get_synonyms()
        """
        response = await self._http_requests.get(f"{self._settings_url}/synonyms")

        if not response.json():
            return None

        return response.json()

    async def update_synonyms(
        self, body: dict[str, list[str]], *, compress: bool = False
    ) -> TaskInfo:
        """Update synonyms of the index.

        Args:
            body: The synonyms of the index.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_synonyms(
            >>>         {"wolverine": ["xmen", "logan"], "logan": ["wolverine"]}
            >>>     )
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/synonyms", body, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_synonyms(self) -> TaskInfo:
        """Reset synonyms of the index to default values.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_synonyms()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/synonyms")

        return TaskInfo(**response.json())

    async def get_filterable_attributes(self) -> list[str] | None:
        """Get filterable attributes of the index.

        Returns:
            List containing the filterable attributes of the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     filterable_attributes = await index.get_filterable_attributes()
        """
        response = await self._http_requests.get(f"{self._settings_url}/filterable-attributes")

        if not response.json():
            return None

        return response.json()

    async def update_filterable_attributes(
        self, body: list[str], *, compress: bool = False
    ) -> TaskInfo:
        """Update filterable attributes of the index.

        Args:
            body: List containing the filterable attributes of the index.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_filterable_attributes(["genre", "director"])
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/filterable-attributes", body, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_filterable_attributes(self) -> TaskInfo:
        """Reset filterable attributes of the index to default values.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_filterable_attributes()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/filterable-attributes")

        return TaskInfo(**response.json())

    async def get_sortable_attributes(self) -> list[str]:
        """Get sortable attributes of the AsyncIndex.

        Returns:
            List containing the sortable attributes of the AsyncIndex.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     sortable_attributes = await index.get_sortable_attributes()
        """
        response = await self._http_requests.get(f"{self._settings_url}/sortable-attributes")

        return response.json()

    async def update_sortable_attributes(
        self, sortable_attributes: list[str], *, compress: bool = False
    ) -> TaskInfo:
        """Get sortable attributes of the AsyncIndex.

        Args:
            sortable_attributes: List of attributes for searching.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_sortable_attributes(["title", "release_date"])
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/sortable-attributes", sortable_attributes, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_sortable_attributes(self) -> TaskInfo:
        """Reset sortable attributes of the index to default values.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_sortable_attributes()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/sortable-attributes")

        return TaskInfo(**response.json())

    async def get_typo_tolerance(self) -> TypoTolerance:
        """Get typo tolerance for the index.

        Returns:
            TypoTolerance for the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     sortable_attributes = await index.get_typo_tolerance()
        """
        response = await self._http_requests.get(f"{self._settings_url}/typo-tolerance")

        return TypoTolerance(**response.json())

    async def update_typo_tolerance(
        self, typo_tolerance: TypoTolerance, *, compress: bool = False
    ) -> TaskInfo:
        """Update typo tolerance.

        Args:
            typo_tolerance: Typo tolerance settings.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            Task to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     TypoTolerance(enabled=False)
            >>>     await index.update_typo_tolerance()
        """
        response = await self._http_requests.patch(
            f"{self._settings_url}/typo-tolerance",
            typo_tolerance.model_dump(by_alias=True),
            compress=compress,
        )

        return TaskInfo(**response.json())

    async def reset_typo_tolerance(self) -> TaskInfo:
        """Reset typo tolerance to default values.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_typo_tolerance()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/typo-tolerance")

        return TaskInfo(**response.json())

    async def get_faceting(self) -> Faceting:
        """Get faceting for the index.

        Returns:
            Faceting for the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     faceting = await index.get_faceting()
        """
        response = await self._http_requests.get(f"{self._settings_url}/faceting")

        return Faceting(**response.json())

    async def update_faceting(self, faceting: Faceting, *, compress: bool = False) -> TaskInfo:
        """Partially update the faceting settings for an index.

        Args:
            faceting: Faceting values.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            Task to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_faceting(faceting=Faceting(max_values_per_facet=100))
        """
        response = await self._http_requests.patch(
            f"{self._settings_url}/faceting",
            faceting.model_dump(by_alias=True),
            compress=compress,
        )

        return TaskInfo(**response.json())

    async def reset_faceting(self) -> TaskInfo:
        """Reset an index's faceting settings to their default value.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_faceting()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/faceting")

        return TaskInfo(**response.json())

    async def get_pagination(self) -> Pagination:
        """Get pagination settings for the index.

        Returns:
            Pagination for the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     pagination_settings = await index.get_pagination()
        """
        response = await self._http_requests.get(f"{self._settings_url}/pagination")

        return Pagination(**response.json())

    async def update_pagination(self, settings: Pagination, *, compress: bool = False) -> TaskInfo:
        """Partially update the pagination settings for an index.

        Args:
            settings: settings for pagination.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            Task to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> from meilisearch_python_sdk.models.settings import Pagination
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_pagination(settings=Pagination(max_total_hits=123))
        """
        response = await self._http_requests.patch(
            f"{self._settings_url}/pagination",
            settings.model_dump(by_alias=True),
            compress=compress,
        )

        return TaskInfo(**response.json())

    async def reset_pagination(self) -> TaskInfo:
        """Reset an index's pagination settings to their default value.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_pagination()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/pagination")

        return TaskInfo(**response.json())

    async def get_separator_tokens(self) -> list[str]:
        """Get separator token settings for the index.

        Returns:
            Separator tokens for the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     separator_token_settings = await index.get_separator_tokens()
        """
        response = await self._http_requests.get(f"{self._settings_url}/separator-tokens")

        return response.json()

    async def update_separator_tokens(
        self, separator_tokens: list[str], *, compress: bool = False
    ) -> TaskInfo:
        """Update the separator tokens settings for an index.

        Args:
            separator_tokens: List of separator tokens.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            Task to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_separator_tokens(separator_tokenes=["|", "/")
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/separator-tokens", separator_tokens, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_separator_tokens(self) -> TaskInfo:
        """Reset an index's separator tokens settings to the default value.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_separator_tokens()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/separator-tokens")

        return TaskInfo(**response.json())

    async def get_non_separator_tokens(self) -> list[str]:
        """Get non-separator token settings for the index.

        Returns:
            Non-separator tokens for the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     non_separator_token_settings = await index.get_non_separator_tokens()
        """
        response = await self._http_requests.get(f"{self._settings_url}/non-separator-tokens")

        return response.json()

    async def update_non_separator_tokens(
        self, non_separator_tokens: list[str], *, compress: bool = False
    ) -> TaskInfo:
        """Update the non-separator tokens settings for an index.

        Args:
            non_separator_tokens: List of non-separator tokens.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            Task to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_non_separator_tokens(non_separator_tokens=["@", "#")
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/non-separator-tokens", non_separator_tokens, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_non_separator_tokens(self) -> TaskInfo:
        """Reset an index's non-separator tokens settings to the default value.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_non_separator_tokens()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/non-separator-tokens")

        return TaskInfo(**response.json())

    async def get_search_cutoff_ms(self) -> int | None:
        """Get search cutoff time in ms.

        Returns:
            Integer representing the search cutoff time in ms, or None.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     search_cutoff_ms_settings = await index.get_search_cutoff_ms()
        """
        response = await self._http_requests.get(f"{self._settings_url}/search-cutoff-ms")

        return response.json()

    async def update_search_cutoff_ms(
        self, search_cutoff_ms: int, *, compress: bool = False
    ) -> TaskInfo:
        """Update the search cutoff for an index.

        Args:
            search_cutoff_ms: Integer value of the search cutoff time in ms.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_search_cutoff_ms(100)
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/search-cutoff-ms", search_cutoff_ms, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_search_cutoff_ms(self) -> TaskInfo:
        """Reset the search cutoff time to the default value.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_search_cutoff_ms()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/search-cutoff-ms")

        return TaskInfo(**response.json())

    async def get_word_dictionary(self) -> list[str]:
        """Get word dictionary settings for the index.

        Returns:
            Word dictionary for the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     word_dictionary = await index.get_word_dictionary()
        """
        response = await self._http_requests.get(f"{self._settings_url}/dictionary")

        return response.json()

    async def update_word_dictionary(
        self, dictionary: list[str], *, compress: bool = False
    ) -> TaskInfo:
        """Update the word dictionary settings for an index.

        Args:
            dictionary: List of dictionary values.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            Task to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_word_dictionary(dictionary=["S.O.S", "S.O")
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/dictionary", dictionary, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_word_dictionary(self) -> TaskInfo:
        """Reset an index's word dictionary settings to the default value.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_word_dictionary()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/dictionary")

        return TaskInfo(**response.json())

    async def get_proximity_precision(self) -> ProximityPrecision:
        """Get proximity precision settings for the index.

        Returns:
            Proximity precision for the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     proximity_precision = await index.get_proximity_precision()
        """
        response = await self._http_requests.get(f"{self._settings_url}/proximity-precision")

        return ProximityPrecision[to_snake(response.json()).upper()]

    async def update_proximity_precision(
        self, proximity_precision: ProximityPrecision, *, compress: bool = False
    ) -> TaskInfo:
        """Update the proximity precision settings for an index.

        Args:
            proximity_precision: The proximity precision value.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            Task to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> from meilisearch_python_sdk.models.settings import ProximityPrecision
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_proximity_precision(ProximityPrecision.BY_ATTRIBUTE)
        """
        response = await self._http_requests.put(
            f"{self._settings_url}/proximity-precision",
            proximity_precision.value,
            compress=compress,
        )

        return TaskInfo(**response.json())

    async def reset_proximity_precision(self) -> TaskInfo:
        """Reset an index's proximity precision settings to the default value.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_proximity_precision()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/proximity-precision")

        return TaskInfo(**response.json())

    async def get_embedders(self) -> Embedders | None:
        """Get embedder settings for the index.

        Returns:
            Embedders for the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     embedders = await index.get_embedders()
        """
        response = await self._http_requests.get(f"{self._settings_url}/embedders")

        return _embedder_json_to_embedders_model(response.json())

    async def update_embedders(self, embedders: Embedders, *, compress: bool = False) -> TaskInfo:
        """Update the embedders settings for an index.

        Args:
            embedders: The embedders value.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            Task to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> from meilisearch_python_sdk.models.settings import Embedders, UserProvidedEmbedder
            >>>
            >>>
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_embedders(
            >>>         Embedders(embedders={"default": UserProvidedEmbedder(dimensions=512)})
            >>>     )
        """
        payload = {}
        for key, embedder in embedders.embedders.items():
            payload[key] = {
                k: v
                for k, v in embedder.model_dump(by_alias=True, exclude_none=True).items()
                if v is not None
            }

        response = await self._http_requests.patch(
            f"{self._settings_url}/embedders", payload, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_embedders(self) -> TaskInfo:
        """Reset an index's embedders settings to the default value.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_embedders()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/embedders")

        return TaskInfo(**response.json())

    async def get_localized_attributes(self) -> list[LocalizedAttributes] | None:
        """Get localized attributes settings for the index.

        Returns:
            Localized attributes for the index.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     localized_attributes = await index.get_localized_attributes()
        """
        response = await self._http_requests.get(f"{self._settings_url}/localized-attributes")

        if not response.json():
            return None

        return [LocalizedAttributes(**x) for x in response.json()]

    async def update_localized_attributes(
        self, localized_attributes: list[LocalizedAttributes], *, compress: bool = False
    ) -> TaskInfo:
        """Update the localized attributes settings for an index.

        Args:
            localized_attributes: The localized attributes value.
            compress: If set to True the data will be sent in gzip format. Defaults to False.

        Returns:
            Task to track the action.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_python_sdk import AsyncClient
            >>> from meilisearch_python_sdk.models.settings import LocalizedAttributes
            >>>
            >>>
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.update_localized_attributes([
            >>>         LocalizedAttributes(locales=["eng", "spa"], attribute_patterns=["*"]),
            >>>         LocalizedAttributes(locales=["ita"], attribute_patterns=["*_it"]),
            >>>     ])
        """
        payload = [x.model_dump(by_alias=True) for x in localized_attributes]
        response = await self._http_requests.put(
            f"{self._settings_url}/localized-attributes", payload, compress=compress
        )

        return TaskInfo(**response.json())

    async def reset_localized_attributes(self) -> TaskInfo:
        """Reset an index's localized attributes settings to the default value.

        Returns:
            The details of the task status.

        Raises:
            MeilisearchCommunicationError: If there was an error communicating with the server.
            MeilisearchApiError: If the Meilisearch API returned an error.

        Examples
            >>> from meilisearch_async_client import AsyncClient
            >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
            >>>     index = client.index("movies")
            >>>     await index.reset_localized_attributes()
        """
        response = await self._http_requests.delete(f"{self._settings_url}/localized-attributes")

        return TaskInfo(**response.json())

    @staticmethod
    async def _run_plugins(
        plugins: Sequence[AsyncPlugin | AsyncDocumentPlugin | AsyncPostSearchPlugin],
        event: AsyncEvent,
        **kwargs: Any,
    ) -> dict[str, Any]:
        generic_plugins = []
        document_plugins = []
        search_plugins = []
        results: dict[str, Any] = {
            "generic_result": None,
            "document_result": None,
            "search_result": None,
        }
        if not use_task_groups():
            for plugin in plugins:
                if _plugin_has_method(plugin, "run_plugin"):
                    generic_plugins.append(plugin.run_plugin(event=event, **kwargs))  # type: ignore[union-attr]
                if _plugin_has_method(plugin, "run_document_plugin"):
                    document_plugins.append(plugin.run_document_plugin(event=event, **kwargs))  # type: ignore[union-attr]
                if _plugin_has_method(plugin, "run_post_search_plugin"):
                    search_plugins.append(plugin.run_post_search_plugin(event=event, **kwargs))  # type: ignore[union-attr]
            if generic_plugins:
                generic_results = await asyncio.gather(*generic_plugins)
                if generic_results:
                    results["generic_result"] = generic_results[-1]

            if document_plugins:
                document_results = await asyncio.gather(*document_plugins)
                if document_results:
                    results["document_result"] = document_results[-1]
            if search_plugins:
                search_results = await asyncio.gather(*search_plugins)
                if search_results:
                    results["search_result"] = search_results[-1]

            return results

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            generic_tasks = []
            document_tasks = []
            search_tasks = []
            for plugin in plugins:
                if _plugin_has_method(plugin, "run_plugin"):
                    generic_tasks.append(tg.create_task(plugin.run_plugin(event=event, **kwargs)))  # type: ignore[union-attr]
                if _plugin_has_method(plugin, "run_document_plugin"):
                    document_tasks.append(
                        tg.create_task(plugin.run_document_plugin(event=event, **kwargs))  # type: ignore[union-attr]
                    )
                if _plugin_has_method(plugin, "run_post_search_plugin"):
                    search_tasks.append(
                        tg.create_task(plugin.run_post_search_plugin(event=event, **kwargs))  # type: ignore[union-attr]
                    )

        if generic_tasks:
            for result in reversed(generic_tasks):
                if result:
                    results["generic_result"] = await result
                    break

        if document_tasks:
            results["document_result"] = await document_tasks[-1]

        if search_tasks:
            results["search_result"] = await search_tasks[-1]

        return results

__init__(http_client, uid, primary_key=None, created_at=None, updated_at=None, plugins=None, json_handler=None, *, hits_type=JsonDict)

Class initializer.

Parameters:

Name	Type	Description	Default
http_client	AsyncClient	An instance of the AsyncClient. This automatically gets passed by the AsyncClient when creating and AsyncIndex instance.	required
uid	str	The index's unique identifier.	required
primary_key	str | None	The primary key of the documents. Defaults to None.	None
created_at	str | datetime | None	The date and time the index was created. Defaults to None.	None
updated_at	str | datetime | None	The date and time the index was last updated. Defaults to None.	None
plugins	AsyncIndexPlugins | None	Optional plugins can be provided to extend functionality.	None
json_handler	BuiltinHandler | OrjsonHandler | UjsonHandler | None	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.	None
hits_type	Any	Allows for a custom type to be passed to use for hits. Defaults to JsonDict	JsonDict

Source code in meilisearch_python_sdk/index.py

def __init__(
    self,
    http_client: AsyncClient,
    uid: str,
    primary_key: str | None = None,
    created_at: str | datetime | None = None,
    updated_at: str | datetime | None = None,
    plugins: AsyncIndexPlugins | None = None,
    json_handler: BuiltinHandler | OrjsonHandler | UjsonHandler | None = None,
    *,
    hits_type: Any = JsonDict,
):
    """Class initializer.

    Args:
        http_client: An instance of the AsyncClient. This automatically gets passed by the
            AsyncClient when creating and AsyncIndex instance.
        uid: The index's unique identifier.
        primary_key: The primary key of the documents. Defaults to None.
        created_at: The date and time the index was created. Defaults to None.
        updated_at: The date and time the index was last updated. Defaults to None.
        plugins: Optional plugins can be provided to extend functionality.
        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.
        hits_type: Allows for a custom type to be passed to use for hits. Defaults to
            JsonDict
    """
    super().__init__(
        uid=uid,
        primary_key=primary_key,
        created_at=created_at,
        updated_at=updated_at,
        json_handler=json_handler,
        hits_type=hits_type,
    )
    self.http_client = http_client
    self._http_requests = AsyncHttpRequests(http_client, json_handler=self._json_handler)
    self.plugins = plugins

add_documents(documents, primary_key=None, *, compress=False) async

Add documents to the index.

Parameters:

Name	Type	Description	Default
documents	Sequence[JsonMapping]	List of documents.	required
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> documents = [ >>> {"id": 1, "title": "Movie 1", "genre": "comedy"}, >>> {"id": 2, "title": "Movie 2", "genre": "drama"}, >>> ] >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.add_documents(documents)

Source code in meilisearch_python_sdk/index.py

async def add_documents(
    self,
    documents: Sequence[JsonMapping],
    primary_key: str | None = None,
    *,
    compress: bool = False,
) -> TaskInfo:
    """Add documents to the index.

    Args:
        documents: List of documents.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    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.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> documents = [
        >>>     {"id": 1, "title": "Movie 1", "genre": "comedy"},
        >>>     {"id": 2, "title": "Movie 2", "genre": "drama"},
        >>> ]
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.add_documents(documents)
    """
    if primary_key:
        url = _build_encoded_url(self._documents_url, {"primaryKey": primary_key})
    else:
        url = self._documents_url

    if self._pre_add_documents_plugins:
        pre = await AsyncIndex._run_plugins(
            self._pre_add_documents_plugins,
            AsyncEvent.PRE,
            documents=documents,
            primary_key=primary_key,
        )
        if pre.get("document_result"):
            documents = pre["document_result"]

    if self._concurrent_add_documents_plugins:
        if not use_task_groups():
            tasks: Any = []
            for plugin in self._concurrent_add_documents_plugins:
                if _plugin_has_method(plugin, "run_plugin"):
                    tasks.append(
                        plugin.run_plugin(  # type: ignore[union-attr]
                            event=AsyncEvent.CONCURRENT,
                            documents=documents,
                            primary_key=primary_key,
                        )
                    )
                if _plugin_has_method(plugin, "run_document_plugin"):
                    tasks.append(
                        plugin.run_document_plugin(  # type: ignore[union-attr]
                            event=AsyncEvent.CONCURRENT,
                            documents=documents,
                            primary_key=primary_key,
                        )
                    )

            tasks.append(self._http_requests.post(url, documents, compress=compress))

            responses = await asyncio.gather(*tasks)
            result = TaskInfo(**responses[-1].json())
            if self._post_add_documents_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_add_documents_plugins,
                    AsyncEvent.POST,
                    result=result,
                    documents=documents,
                    primary_key=primary_key,
                )
                if isinstance(post["generic_result"], TaskInfo):
                    result = post["generic_result"]
            return result

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            for plugin in self._concurrent_add_documents_plugins:
                if _plugin_has_method(plugin, "run_plugin"):
                    tg.create_task(
                        plugin.run_plugin(  # type: ignore[union-attr]
                            event=AsyncEvent.CONCURRENT,
                            documents=documents,
                            primary_key=primary_key,
                        )
                    )
                if _plugin_has_method(plugin, "run_document_plugin"):
                    tg.create_task(
                        plugin.run_document_plugin(  # type: ignore[union-attr]
                            event=AsyncEvent.CONCURRENT,
                            documents=documents,
                            primary_key=primary_key,
                        )
                    )

            response_coroutine = tg.create_task(
                self._http_requests.post(url, documents, compress=compress)
            )

        response = await response_coroutine
        result = TaskInfo(**response.json())
        if self._post_add_documents_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_add_documents_plugins,
                AsyncEvent.POST,
                result=result,
                documents=documents,
                primary_key=primary_key,
            )
            if isinstance(post["generic_result"], TaskInfo):
                result = post["generic_result"]

        return result

    response = await self._http_requests.post(url, documents, compress=compress)

    result = TaskInfo(**response.json())
    if self._post_add_documents_plugins:
        post = await AsyncIndex._run_plugins(
            self._post_add_documents_plugins,
            AsyncEvent.POST,
            result=result,
            documents=documents,
            primary_key=primary_key,
        )
        if isinstance(post["generic_result"], TaskInfo):
            result = post["generic_result"]

    return result

add_documents_from_directory(directory_path, *, primary_key=None, document_type='json', csv_delimiter=None, combine_documents=True, compress=False, concurrency_limit=None) async

Load all json files from a directory and add the documents to the index.

Parameters:

Name	Type	Description	Default
directory_path	Path | str	Path to the directory that contains the json files.	required
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
document_type	str	The type of document being added. Accepted types are json, csv, and ndjson. For csv files the first row of the document should be a header row contining the field names, and ever for should have a title.	'json'
csv_delimiter	str | None	A single ASCII character to specify the delimiter for csv files. This can only be used if the file is a csv file. Defaults to comma.	None
combine_documents	bool	If set to True this will combine the documents from all the files before indexing them. Defaults to True.	True
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False
concurrency_limit	int | None	If set this will limit the number of batches that will be sent concurrently. This can be helpful if you find you are overloading the Meilisearch server with requests. Defaults to None.	None

Returns:

Type	Description
list[TaskInfo]	The details of the task status.

Raises:

Type	Description
InvalidDocumentError	If the docucment is not a valid format for Meilisearch.
MeilisearchError	If the file path is not valid
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from pathlib import Path >>> from meilisearch_python_sdk import AsyncClient >>> directory_path = Path("/path/to/directory/containing/files") >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.add_documents_from_directory(directory_path)

Source code in meilisearch_python_sdk/index.py

async def add_documents_from_directory(
    self,
    directory_path: Path | str,
    *,
    primary_key: str | None = None,
    document_type: str = "json",
    csv_delimiter: str | None = None,
    combine_documents: bool = True,
    compress: bool = False,
    concurrency_limit: int | None = None,
) -> list[TaskInfo]:
    """Load all json files from a directory and add the documents to the index.

    Args:
        directory_path: Path to the directory that contains the json files.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        document_type: The type of document being added. Accepted types are json, csv, and
            ndjson. For csv files the first row of the document should be a header row contining
            the field names, and ever for should have a title.
        csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
            can only be used if the file is a csv file. Defaults to comma.
        combine_documents: If set to True this will combine the documents from all the files
            before indexing them. Defaults to True.
        compress: If set to True the data will be sent in gzip format. Defaults to False.
        concurrency_limit: If set this will limit the number of batches that will be sent
            concurrently. This can be helpful if you find you are overloading the Meilisearch
            server with requests. Defaults to None.

    Returns:
        The details of the task status.

    Raises:
        InvalidDocumentError: If the docucment is not a valid format for Meilisearch.
        MeilisearchError: If the file path is not valid
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from pathlib import Path
        >>> from meilisearch_python_sdk import AsyncClient
        >>> directory_path = Path("/path/to/directory/containing/files")
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.add_documents_from_directory(directory_path)
    """
    directory = Path(directory_path) if isinstance(directory_path, str) else directory_path

    if combine_documents:
        all_documents = []
        for path in directory.iterdir():
            if path.suffix == f".{document_type}":
                documents = await _async_load_documents_from_file(
                    path, csv_delimiter, json_handler=self._json_handler
                )
                all_documents.append(documents)

        _raise_on_no_documents(all_documents, document_type, directory_path)

        loop = asyncio.get_running_loop()
        combined = await loop.run_in_executor(None, partial(_combine_documents, all_documents))

        response = await self.add_documents(combined, primary_key, compress=compress)

        return [response]

    if concurrency_limit:
        async with asyncio.Semaphore(concurrency_limit):
            if not use_task_groups():
                add_documents = []
                for path in directory.iterdir():
                    if path.suffix == f".{document_type}":
                        documents = await _async_load_documents_from_file(
                            path, csv_delimiter, json_handler=self._json_handler
                        )
                        add_documents.append(
                            self.add_documents(documents, primary_key, compress=compress)
                        )

                _raise_on_no_documents(add_documents, document_type, directory_path)

                if len(add_documents) > 1:
                    # Send the first document on its own before starting the gather. Otherwise Meilisearch
                    # returns an error because it thinks all entries are trying to create the same index.
                    first_response = [await add_documents.pop()]

                    responses = await asyncio.gather(*add_documents)
                    responses = [*first_response, *responses]
                else:
                    responses = [await add_documents[0]]

                return responses

            async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                tasks = []
                all_results = []
                for i, path in enumerate(directory.iterdir()):
                    if path.suffix == f".{document_type}":
                        documents = await _async_load_documents_from_file(
                            path, csv_delimiter, json_handler=self._json_handler
                        )
                        if i == 0:
                            all_results = [
                                await self.add_documents(documents, compress=compress)
                            ]
                        else:
                            tasks.append(
                                tg.create_task(
                                    self.add_documents(
                                        documents, primary_key, compress=compress
                                    )
                                )
                            )

    if not use_task_groups():
        add_documents = []
        for path in directory.iterdir():
            if path.suffix == f".{document_type}":
                documents = await _async_load_documents_from_file(
                    path, csv_delimiter, json_handler=self._json_handler
                )
                add_documents.append(
                    self.add_documents(documents, primary_key, compress=compress)
                )

        _raise_on_no_documents(add_documents, document_type, directory_path)

        if len(add_documents) > 1:
            # Send the first document on its own before starting the gather. Otherwise Meilisearch
            # returns an error because it thinks all entries are trying to create the same index.
            first_response = [await add_documents.pop()]

            responses = await asyncio.gather(*add_documents)
            responses = [*first_response, *responses]
        else:
            responses = [await add_documents[0]]

        return responses

    async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
        tasks = []
        all_results = []
        for i, path in enumerate(directory.iterdir()):
            if path.suffix == f".{document_type}":
                documents = await _async_load_documents_from_file(
                    path, csv_delimiter, json_handler=self._json_handler
                )
                if i == 0:
                    all_results = [await self.add_documents(documents, compress=compress)]
                else:
                    tasks.append(
                        tg.create_task(
                            self.add_documents(documents, primary_key, compress=compress)
                        )
                    )

    results = [x.result() for x in tasks]
    all_results = [*all_results, *results]
    _raise_on_no_documents(all_results, document_type, directory_path)
    return all_results

add_documents_from_directory_in_batches(directory_path, *, batch_size=1000, primary_key=None, document_type='json', csv_delimiter=None, combine_documents=True, compress=False, concurrency_limit=None) async

Load all json files from a directory and add the documents to the index in batches.

Parameters:

Name	Type	Description	Default
directory_path	Path | str	Path to the directory that contains the json files.	required
batch_size	int	The number of documents that should be included in each batch. Defaults to 1000.	1000
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
document_type	str	The type of document being added. Accepted types are json, csv, and ndjson. For csv files the first row of the document should be a header row contining the field names, and ever for should have a title.	'json'
csv_delimiter	str | None	A single ASCII character to specify the delimiter for csv files. This can only be used if the file is a csv file. Defaults to comma.	None
combine_documents	bool	If set to True this will combine the documents from all the files before indexing them. Defaults to True.	True
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False
concurrency_limit	int | None	If set this will limit the number of batches that will be sent concurrently. This can be helpful if you find you are overloading the Meilisearch server with requests. Defaults to None.	None

Returns:

Type	Description
list[TaskInfo]	List of update ids to track the action.

Raises:

Type	Description
InvalidDocumentError	If the docucment is not a valid format for Meilisearch.
MeilisearchError	If the file path is not valid
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from pathlib import Path >>> from meilisearch_python_sdk import AsyncClient >>> directory_path = Path("/path/to/directory/containing/files") >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.add_documents_from_directory_in_batches(directory_path)

Source code in meilisearch_python_sdk/index.py

async def add_documents_from_directory_in_batches(
    self,
    directory_path: Path | str,
    *,
    batch_size: int = 1000,
    primary_key: str | None = None,
    document_type: str = "json",
    csv_delimiter: str | None = None,
    combine_documents: bool = True,
    compress: bool = False,
    concurrency_limit: int | None = None,
) -> list[TaskInfo]:
    """Load all json files from a directory and add the documents to the index in batches.

    Args:
        directory_path: Path to the directory that contains the json files.
        batch_size: The number of documents that should be included in each batch.
            Defaults to 1000.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        document_type: The type of document being added. Accepted types are json, csv, and
            ndjson. For csv files the first row of the document should be a header row contining
            the field names, and ever for should have a title.
        csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
            can only be used if the file is a csv file. Defaults to comma.
        combine_documents: If set to True this will combine the documents from all the files
            before indexing them. Defaults to True.
        compress: If set to True the data will be sent in gzip format. Defaults to False.
        concurrency_limit: If set this will limit the number of batches that will be sent
            concurrently. This can be helpful if you find you are overloading the Meilisearch
            server with requests. Defaults to None.

    Returns:
        List of update ids to track the action.

    Raises:
        InvalidDocumentError: If the docucment is not a valid format for Meilisearch.
        MeilisearchError: If the file path is not valid
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from pathlib import Path
        >>> from meilisearch_python_sdk import AsyncClient
        >>> directory_path = Path("/path/to/directory/containing/files")
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.add_documents_from_directory_in_batches(directory_path)
    """
    directory = Path(directory_path) if isinstance(directory_path, str) else directory_path

    if combine_documents:
        all_documents = []
        for path in directory.iterdir():
            if path.suffix == f".{document_type}":
                documents = await _async_load_documents_from_file(
                    path, csv_delimiter=csv_delimiter, json_handler=self._json_handler
                )
                all_documents.append(documents)

        _raise_on_no_documents(all_documents, document_type, directory_path)

        loop = asyncio.get_running_loop()
        combined = await loop.run_in_executor(None, partial(_combine_documents, all_documents))

        return await self.add_documents_in_batches(
            combined,
            batch_size=batch_size,
            primary_key=primary_key,
            compress=compress,
            concurrency_limit=concurrency_limit,
        )

    responses: list[TaskInfo] = []

    add_documents = []
    for path in directory.iterdir():
        if path.suffix == f".{document_type}":
            documents = await _async_load_documents_from_file(
                path, csv_delimiter, json_handler=self._json_handler
            )
            add_documents.append(
                self.add_documents_in_batches(
                    documents,
                    batch_size=batch_size,
                    primary_key=primary_key,
                    compress=compress,
                    concurrency_limit=concurrency_limit,
                )
            )

    _raise_on_no_documents(add_documents, document_type, directory_path)

    if len(add_documents) > 1:
        # Send the first document on its own before starting the gather. Otherwise Meilisearch
        # returns an error because it thinks all entries are trying to create the same index.
        first_response = await add_documents.pop()
        responses_gather = await asyncio.gather(*add_documents)
        responses = [*first_response, *[x for y in responses_gather for x in y]]
    else:
        responses = await add_documents[0]

    return responses

add_documents_from_file(file_path, primary_key=None, *, compress=False) async

Add documents to the index from a json file.

Parameters:

Name	Type	Description	Default
file_path	Path | str	Path to the json file.	required
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
InvalidDocumentError	If the docucment is not a valid format for Meilisearch.
MeilisearchError	If the file path is not valid
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from pathlib import Path >>> from meilisearch_python_sdk import AsyncClient >>> file_path = Path("/path/to/file.json") >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.add_documents_from_file(file_path)

Source code in meilisearch_python_sdk/index.py

async def add_documents_from_file(
    self,
    file_path: Path | str,
    primary_key: str | None = None,
    *,
    compress: bool = False,
) -> TaskInfo:
    """Add documents to the index from a json file.

    Args:
        file_path: Path to the json file.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        InvalidDocumentError: If the docucment is not a valid format for Meilisearch.
        MeilisearchError: If the file path is not valid
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from pathlib import Path
        >>> from meilisearch_python_sdk import AsyncClient
        >>> file_path = Path("/path/to/file.json")
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.add_documents_from_file(file_path)
    """
    documents = await _async_load_documents_from_file(
        file_path, json_handler=self._json_handler
    )

    return await self.add_documents(documents, primary_key=primary_key, compress=compress)

add_documents_from_file_in_batches(file_path, *, batch_size=1000, primary_key=None, csv_delimiter=None, compress=False, concurrency_limit=None) async

Adds documents form a json file in batches to reduce RAM usage with indexing.

Parameters:

Name	Type	Description	Default
file_path	Path | str	Path to the json file.	required
batch_size	int	The number of documents that should be included in each batch. Defaults to 1000.	1000
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
csv_delimiter	str | None	A single ASCII character to specify the delimiter for csv files. This can only be used if the file is a csv file. Defaults to comma.	None
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False
concurrency_limit	int | None	If set this will limit the number of batches that will be sent concurrently. This can be helpful if you find you are overloading the Meilisearch server with requests. Defaults to None.	None

Returns:

Type	Description
list[TaskInfo]	List of update ids to track the action.

Raises:

Type	Description
InvalidDocumentError	If the docucment is not a valid format for Meilisearch.
MeilisearchError	If the file path is not valid
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from pathlib import Path >>> from meilisearch_python_sdk import AsyncClient >>> file_path = Path("/path/to/file.json") >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.add_documents_from_file_in_batches(file_path)

Source code in meilisearch_python_sdk/index.py

async def add_documents_from_file_in_batches(
    self,
    file_path: Path | str,
    *,
    batch_size: int = 1000,
    primary_key: str | None = None,
    csv_delimiter: str | None = None,
    compress: bool = False,
    concurrency_limit: int | None = None,
) -> list[TaskInfo]:
    """Adds documents form a json file in batches to reduce RAM usage with indexing.

    Args:
        file_path: Path to the json file.
        batch_size: The number of documents that should be included in each batch.
            Defaults to 1000.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
            can only be used if the file is a csv file. Defaults to comma.
        compress: If set to True the data will be sent in gzip format. Defaults to False.
        concurrency_limit: If set this will limit the number of batches that will be sent
            concurrently. This can be helpful if you find you are overloading the Meilisearch
            server with requests. Defaults to None.

    Returns:
        List of update ids to track the action.

    Raises:
        InvalidDocumentError: If the docucment is not a valid format for Meilisearch.
        MeilisearchError: If the file path is not valid
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from pathlib import Path
        >>> from meilisearch_python_sdk import AsyncClient
        >>> file_path = Path("/path/to/file.json")
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.add_documents_from_file_in_batches(file_path)
    """
    documents = await _async_load_documents_from_file(
        file_path, csv_delimiter, json_handler=self._json_handler
    )

    return await self.add_documents_in_batches(
        documents,
        batch_size=batch_size,
        primary_key=primary_key,
        compress=compress,
        concurrency_limit=concurrency_limit,
    )

add_documents_from_raw_file(file_path, primary_key=None, *, csv_delimiter=None, compress=False) async

Directly send csv or ndjson files to Meilisearch without pre-processing.

The can reduce RAM usage from Meilisearch during indexing, but does not include the option for batching.

Parameters:

Name	Type	Description	Default
file_path	Path | str	The path to the file to send to Meilisearch. Only csv and ndjson files are allowed.	required
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
csv_delimiter	str | None	A single ASCII character to specify the delimiter for csv files. This can only be used if the file is a csv file. Defaults to comma.	None
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task.

Raises:

Type	Description
ValueError	If the file is not a csv or ndjson file, or if a csv_delimiter is sent for a non-csv file.
MeilisearchError	If the file path is not valid
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from pathlib import Path >>> from meilisearch_python_sdk import AsyncClient >>> file_path = Path("/path/to/file.csv") >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.add_documents_from_raw_file(file_path)

Source code in meilisearch_python_sdk/index.py

async def add_documents_from_raw_file(
    self,
    file_path: Path | str,
    primary_key: str | None = None,
    *,
    csv_delimiter: str | None = None,
    compress: bool = False,
) -> TaskInfo:
    """Directly send csv or ndjson files to Meilisearch without pre-processing.

    The can reduce RAM usage from Meilisearch during indexing, but does not include the option
    for batching.

    Args:
        file_path: The path to the file to send to Meilisearch. Only csv and ndjson files are
            allowed.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
            can only be used if the file is a csv file. Defaults to comma.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task.

    Raises:
        ValueError: If the file is not a csv or ndjson file, or if a csv_delimiter is sent for
            a non-csv file.
        MeilisearchError: If the file path is not valid
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from pathlib import Path
        >>> from meilisearch_python_sdk import AsyncClient
        >>> file_path = Path("/path/to/file.csv")
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.add_documents_from_raw_file(file_path)
    """
    upload_path = Path(file_path) if isinstance(file_path, str) else file_path
    if not upload_path.exists():
        raise MeilisearchError("No file found at the specified path")

    if upload_path.suffix not in (".csv", ".ndjson"):
        raise ValueError("Only csv and ndjson files can be sent as binary files")

    if csv_delimiter and upload_path.suffix != ".csv":
        raise ValueError("A csv_delimiter can only be used with csv files")

    if (
        csv_delimiter
        and len(csv_delimiter) != 1
        or csv_delimiter
        and not csv_delimiter.isascii()
    ):
        raise ValueError("csv_delimiter must be a single ascii character")

    content_type = "text/csv" if upload_path.suffix == ".csv" else "application/x-ndjson"
    parameters = {}

    if primary_key:
        parameters["primaryKey"] = primary_key
    if csv_delimiter:
        parameters["csvDelimiter"] = csv_delimiter

    if parameters:
        url = _build_encoded_url(self._documents_url, parameters)
    else:
        url = self._documents_url

    async with aiofiles.open(upload_path) as f:
        data = await f.read()

    response = await self._http_requests.post(
        url, body=data, content_type=content_type, compress=compress
    )

    return TaskInfo(**response.json())

add_documents_in_batches(documents, *, batch_size=1000, primary_key=None, compress=False, concurrency_limit=None) async

Adds documents in batches to reduce RAM usage with indexing.

Parameters:

Name	Type	Description	Default
documents	Sequence[JsonMapping]	List of documents.	required
batch_size	int	The number of documents that should be included in each batch. Defaults to 1000.	1000
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False
concurrency_limit	int | None	If set this will limit the number of batches that will be sent concurrently. This can be helpful if you find you are overloading the Meilisearch server with requests. Defaults to None.	None

Returns:

Type	Description
list[TaskInfo]	List of update ids to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> >>> documents = [ >>> {"id": 1, "title": "Movie 1", "genre": "comedy"}, >>> {"id": 2, "title": "Movie 2", "genre": "drama"}, >>> ] >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.add_documents_in_batches(documents)

Source code in meilisearch_python_sdk/index.py

async def add_documents_in_batches(
    self,
    documents: Sequence[JsonMapping],
    *,
    batch_size: int = 1000,
    primary_key: str | None = None,
    compress: bool = False,
    concurrency_limit: int | None = None,
) -> list[TaskInfo]:
    """Adds documents in batches to reduce RAM usage with indexing.

    Args:
        documents: List of documents.
        batch_size: The number of documents that should be included in each batch.
            Defaults to 1000.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        compress: If set to True the data will be sent in gzip format. Defaults to False.
        concurrency_limit: If set this will limit the number of batches that will be sent
            concurrently. This can be helpful if you find you are overloading the Meilisearch
            server with requests. Defaults to None.

    Returns:
        List of update ids to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> >>> documents = [
        >>>     {"id": 1, "title": "Movie 1", "genre": "comedy"},
        >>>     {"id": 2, "title": "Movie 2", "genre": "drama"},
        >>> ]
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.add_documents_in_batches(documents)
    """
    if concurrency_limit:
        async with asyncio.Semaphore(concurrency_limit):
            if not use_task_groups():
                batches = [
                    self.add_documents(x, primary_key, compress=compress)
                    for x in _batch(documents, batch_size)
                ]
                return await asyncio.gather(*batches)

            async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                tasks = [
                    tg.create_task(self.add_documents(x, primary_key, compress=compress))
                    for x in _batch(documents, batch_size)
                ]

            return [x.result() for x in tasks]

    if not use_task_groups():
        batches = [
            self.add_documents(x, primary_key, compress=compress)
            for x in _batch(documents, batch_size)
        ]
        return await asyncio.gather(*batches)

    async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
        tasks = [
            tg.create_task(self.add_documents(x, primary_key, compress=compress))
            for x in _batch(documents, batch_size)
        ]

    return [x.result() for x in tasks]

create(http_client, uid, primary_key=None, *, settings=None, wait=True, timeout_in_ms=None, plugins=None, json_handler=None, hits_type=JsonDict) async classmethod

Creates a new index.

In general this method should not be used directly and instead the index should be created through the Client.

Parameters:

Name	Type	Description	Default
http_client	AsyncClient	An instance of the AsyncClient. This automatically gets passed by the Client when creating an AsyncIndex instance.	required
uid	str	The index's unique identifier.	required
primary_key	str | None	The primary key of the documents. Defaults to None.	None
settings	MeilisearchSettings | None	Settings for the index. The settings can also be updated independently of creating the index. The advantage to updating them here is updating the settings after adding documents will cause the documents to be re-indexed. Because of this it will be faster to update them before adding documents. Defaults to None (i.e. default Meilisearch index settings).	None
wait	bool	If set to True and settings are being updated, the index will be returned after the settings update has completed. If False it will not wait for settings to complete. Default: True	True
timeout_in_ms	int | None	Amount of time in milliseconds to wait before raising a MeilisearchTimeoutError. None can also be passed to wait indefinitely. Be aware that if the None option is used the wait time could be very long. Defaults to None.	None
plugins	AsyncIndexPlugins | None	Optional plugins can be provided to extend functionality.	None
json_handler	BuiltinHandler | OrjsonHandler | UjsonHandler | None	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.	None
hits_type	Any	Allows for a custom type to be passed to use for hits. Defaults to JsonDict	JsonDict

Returns:

Type	Description
Self	An instance of AsyncIndex containing the information of the newly created index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = await index.create(client, "movies")

Source code in meilisearch_python_sdk/index.py

@classmethod
async def create(
    cls,
    http_client: AsyncClient,
    uid: str,
    primary_key: str | None = None,
    *,
    settings: MeilisearchSettings | None = None,
    wait: bool = True,
    timeout_in_ms: int | None = None,
    plugins: AsyncIndexPlugins | None = None,
    json_handler: BuiltinHandler | OrjsonHandler | UjsonHandler | None = None,
    hits_type: Any = JsonDict,
) -> Self:
    """Creates a new index.

    In general this method should not be used directly and instead the index should be created
    through the `Client`.

    Args:
        http_client: An instance of the AsyncClient. This automatically gets passed by the
            Client when creating an AsyncIndex instance.
        uid: The index's unique identifier.
        primary_key: The primary key of the documents. Defaults to None.
        settings: Settings for the index. The settings can also be updated independently of
            creating the index. The advantage to updating them here is updating the settings after
            adding documents will cause the documents to be re-indexed. Because of this it will be
            faster to update them before adding documents. Defaults to None (i.e. default
            Meilisearch index settings).
        wait: If set to True and settings are being updated, the index will be returned after
            the settings update has completed. If False it will not wait for settings to complete.
            Default: True
        timeout_in_ms: Amount of time in milliseconds to wait before raising a
            MeilisearchTimeoutError. `None` can also be passed to wait indefinitely. Be aware that
            if the `None` option is used the wait time could be very long. Defaults to None.
        plugins: Optional plugins can be provided to extend functionality.
        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.
        hits_type: Allows for a custom type to be passed to use for hits. Defaults to
            JsonDict

    Returns:
        An instance of AsyncIndex containing the information of the newly created index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = await index.create(client, "movies")
    """
    if not primary_key:
        payload = {"uid": uid}
    else:
        payload = {"primaryKey": primary_key, "uid": uid}

    url = "indexes"
    handler = json_handler if json_handler else BuiltinHandler()
    http_request = AsyncHttpRequests(http_client, json_handler=handler)
    response = await http_request.post(url, payload)
    await async_wait_for_task(
        http_client,
        response.json()["taskUid"],
        timeout_in_ms=timeout_in_ms,
    )

    index_response = await http_request.get(f"{url}/{uid}")
    index_dict = index_response.json()
    index = cls(
        http_client=http_client,
        uid=index_dict["uid"],
        primary_key=index_dict["primaryKey"],
        created_at=index_dict["createdAt"],
        updated_at=index_dict["updatedAt"],
        plugins=plugins,
        json_handler=json_handler,
        hits_type=hits_type,
    )

    if settings:
        settings_task = await index.update_settings(settings)
        if wait:
            await async_wait_for_task(
                http_client, settings_task.task_uid, timeout_in_ms=timeout_in_ms
            )

    return index

delete() async

Deletes the index.

Returns:

Type	Description
TaskInfo	The details of the task.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.delete()

Source code in meilisearch_python_sdk/index.py

async def delete(self) -> TaskInfo:
    """Deletes the index.

    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.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.delete()
    """
    response = await self._http_requests.delete(self._base_url_with_uid)
    return TaskInfo(**response.json())

delete_all_documents() async

Delete all documents from the index.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.delete_all_document()

Source code in meilisearch_python_sdk/index.py

async def delete_all_documents(self) -> TaskInfo:
    """Delete all documents from the index.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.delete_all_document()
    """
    if self._pre_delete_all_documents_plugins:
        await AsyncIndex._run_plugins(self._pre_delete_all_documents_plugins, AsyncEvent.PRE)

    if self._concurrent_delete_all_documents_plugins:
        if not use_task_groups():
            tasks: Any = []
            for plugin in self._concurrent_delete_all_documents_plugins:
                tasks.append(plugin.run_plugin(event=AsyncEvent.CONCURRENT))

            tasks.append(self._http_requests.delete(self._documents_url))

            responses = await asyncio.gather(*tasks)
            result = TaskInfo(**responses[-1].json())
            if self._post_delete_all_documents_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_delete_all_documents_plugins, AsyncEvent.POST, result=result
                )
                if isinstance(post.get("generic_result"), TaskInfo):
                    result = post["generic_result"]
            return result

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            for plugin in self._concurrent_delete_all_documents_plugins:
                tg.create_task(plugin.run_plugin(event=AsyncEvent.CONCURRENT))

            response_coroutine = tg.create_task(self._http_requests.delete(self._documents_url))

        response = await response_coroutine
        result = TaskInfo(**response.json())
        if self._post_delete_all_documents_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_delete_all_documents_plugins, AsyncEvent.POST, result=result
            )
            if isinstance(post.get("generic_result"), TaskInfo):
                result = post["generic_result"]
        return result

    response = await self._http_requests.delete(self._documents_url)
    result = TaskInfo(**response.json())
    if self._post_delete_all_documents_plugins:
        post = await AsyncIndex._run_plugins(
            self._post_delete_all_documents_plugins, AsyncEvent.POST, result=result
        )
        if isinstance(post.get("generic_result"), TaskInfo):
            result = post["generic_result"]
    return result

delete_document(document_id) async

Delete one document from the index.

Parameters:

Name	Type	Description	Default
document_id	str	Unique identifier of the document.	required

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.delete_document("1234")

Source code in meilisearch_python_sdk/index.py

async def delete_document(self, document_id: str) -> TaskInfo:
    """Delete one document from the index.

    Args:
        document_id: Unique identifier of the document.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.delete_document("1234")
    """
    url = f"{self._documents_url}/{document_id}"

    if self._pre_delete_document_plugins:
        await AsyncIndex._run_plugins(
            self._pre_delete_document_plugins, AsyncEvent.PRE, document_id=document_id
        )

    if self._concurrent_delete_document_plugins:
        if not use_task_groups():
            tasks: Any = []
            for plugin in self._concurrent_delete_document_plugins:
                tasks.append(
                    plugin.run_plugin(event=AsyncEvent.CONCURRENT, document_id=document_id)
                )

            tasks.append(self._http_requests.delete(url))

            responses = await asyncio.gather(*tasks)
            result = TaskInfo(**responses[-1].json())
            if self._post_delete_document_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_delete_document_plugins, AsyncEvent.POST, result=result
                )
                if isinstance(post.get("generic_result"), TaskInfo):
                    result = post["generic_result"]
            return result

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            for plugin in self._concurrent_delete_document_plugins:
                tg.create_task(
                    plugin.run_plugin(event=AsyncEvent.CONCURRENT, document_id=document_id)
                )

            response_coroutine = tg.create_task(self._http_requests.delete(url))

        response = await response_coroutine
        result = TaskInfo(**response.json())
        if self._post_delete_document_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_delete_document_plugins, event=AsyncEvent.POST, result=result
            )
            if isinstance(post["generic_result"], TaskInfo):
                result = post["generic_result"]
        return result

    response = await self._http_requests.delete(url)
    result = TaskInfo(**response.json())
    if self._post_delete_document_plugins:
        post = await AsyncIndex._run_plugins(
            self._post_delete_document_plugins, AsyncEvent.POST, result=result
        )
        if isinstance(post["generic_result"], TaskInfo):
            result = post["generic_result"]

    return result

delete_documents(ids) async

Delete multiple documents from the index.

Parameters:

Name	Type	Description	Default
ids	list[str]	List of unique identifiers of documents.	required

Returns:

Type	Description
TaskInfo	List of update ids to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.delete_documents(["1234", "5678"])

Source code in meilisearch_python_sdk/index.py

async def delete_documents(self, ids: list[str]) -> TaskInfo:
    """Delete multiple documents from the index.

    Args:
        ids: List of unique identifiers of documents.

    Returns:
        List of update ids to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.delete_documents(["1234", "5678"])
    """
    url = f"{self._documents_url}/delete-batch"

    if self._pre_delete_documents_plugins:
        await AsyncIndex._run_plugins(
            self._pre_delete_documents_plugins, AsyncEvent.PRE, ids=ids
        )

    if self._concurrent_delete_documents_plugins:
        if not use_task_groups():
            tasks: Any = []
            for plugin in self._concurrent_delete_documents_plugins:
                tasks.append(plugin.run_plugin(event=AsyncEvent.CONCURRENT, ids=ids))

            tasks.append(self._http_requests.post(url, ids))

            responses = await asyncio.gather(*tasks)
            result = TaskInfo(**responses[-1].json())
            if self._post_delete_documents_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_delete_documents_plugins, AsyncEvent.POST, result=result
                )
                if isinstance(post.get("generic_result"), TaskInfo):
                    result = post["generic_result"]
            return result

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            for plugin in self._concurrent_delete_documents_plugins:
                tg.create_task(plugin.run_plugin(event=AsyncEvent.CONCURRENT, ids=ids))

            response_coroutine = tg.create_task(self._http_requests.post(url, ids))

        response = await response_coroutine
        result = TaskInfo(**response.json())
        if self._post_delete_documents_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_delete_documents_plugins, AsyncEvent.POST, result=result
            )
            if isinstance(post["generic_result"], TaskInfo):
                result = post["generic_result"]
        return result

    response = await self._http_requests.post(url, ids)
    result = TaskInfo(**response.json())
    if self._post_delete_documents_plugins:
        post = await AsyncIndex._run_plugins(
            self._post_delete_documents_plugins, AsyncEvent.POST, result=result
        )
        if isinstance(post["generic_result"], TaskInfo):
            result = post["generic_result"]

    return result

delete_documents_by_filter(filter) async

Delete documents from the index by filter.

Parameters:

Name	Type	Description	Default
filter	Filter	The filter value information.	required

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_pyrhon_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.delete_documents_by_filter("genre=horor"))

Source code in meilisearch_python_sdk/index.py

async def delete_documents_by_filter(self, filter: Filter) -> TaskInfo:
    """Delete documents from the index by filter.

    Args:
        filter: The filter value information.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_pyrhon_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.delete_documents_by_filter("genre=horor"))
    """
    url = f"{self._documents_url}/delete"

    if self._pre_delete_documents_by_filter_plugins:
        await AsyncIndex._run_plugins(
            self._pre_delete_documents_by_filter_plugins, AsyncEvent.PRE, filter=filter
        )

    if self._concurrent_delete_documents_by_filter_plugins:
        if not use_task_groups():
            tasks: Any = []
            for plugin in self._concurrent_delete_documents_by_filter_plugins:
                tasks.append(plugin.run_plugin(event=AsyncEvent.CONCURRENT, filter=filter))

            tasks.append(self._http_requests.post(url, body={"filter": filter}))

            responses = await asyncio.gather(*tasks)
            result = TaskInfo(**responses[-1].json())
            if self._post_delete_documents_by_filter_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_delete_documents_by_filter_plugins,
                    AsyncEvent.POST,
                    result=result,
                )
                if isinstance(post["generic_result"], TaskInfo):
                    result = post["generic_result"]
            return result

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            for plugin in self._concurrent_delete_documents_by_filter_plugins:
                tg.create_task(plugin.run_plugin(event=AsyncEvent.CONCURRENT, filter=filter))

            response_coroutine = tg.create_task(
                self._http_requests.post(url, body={"filter": filter})
            )

        response = await response_coroutine
        result = TaskInfo(**response.json())
        if self._post_delete_documents_by_filter_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_delete_documents_by_filter_plugins, AsyncEvent.POST, result=result
            )
            if isinstance(post["generic_result"], TaskInfo):
                result = post["generic_result"]

        return result

    response = await self._http_requests.post(url, body={"filter": filter})
    result = TaskInfo(**response.json())
    if self._post_delete_documents_by_filter_plugins:
        post = await AsyncIndex._run_plugins(
            self._post_delete_documents_by_filter_plugins, AsyncEvent.POST, result=result
        )
        if isinstance(post.get("generic_result"), TaskInfo):
            result = post["generic_result"]
    return result

delete_documents_in_batches_by_filter(filters, concurrency_limit=None) async

Delete batches of documents from the index by filter.

Parameters:

Name	Type	Description	Default
filters	list[str | list[str | list[str]]]	A list of filter value information.	required
concurrency_limit	int | None	If set this will limit the number of batches that will be sent concurrently. This can be helpful if you find you are overloading the Meilisearch server with requests. Defaults to None.	None

Returns:

Type	Description
list[TaskInfo]	The a list of details of the task statuses.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.delete_documents_in_batches_by_filter( >>> [ >>> "genre=horor"), >>> "release_date=1520035200"), >>> ] >>> )

Source code in meilisearch_python_sdk/index.py

async def delete_documents_in_batches_by_filter(
    self, filters: list[str | list[str | list[str]]], concurrency_limit: int | None = None
) -> list[TaskInfo]:
    """Delete batches of documents from the index by filter.

    Args:
        filters: A list of filter value information.
        concurrency_limit: If set this will limit the number of batches that will be sent
            concurrently. This can be helpful if you find you are overloading the Meilisearch
            server with requests. Defaults to None.

    Returns:
        The a list of details of the task statuses.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.delete_documents_in_batches_by_filter(
        >>>         [
        >>>             "genre=horor"),
        >>>             "release_date=1520035200"),
        >>>         ]
        >>>     )
    """
    if concurrency_limit:
        async with asyncio.Semaphore(concurrency_limit):
            if not use_task_groups():
                tasks = [self.delete_documents_by_filter(filter) for filter in filters]
                return await asyncio.gather(*tasks)

            async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                tg_tasks = [
                    tg.create_task(self.delete_documents_by_filter(filter))
                    for filter in filters
                ]

            return [x.result() for x in tg_tasks]

    if not use_task_groups():
        tasks = [self.delete_documents_by_filter(filter) for filter in filters]
        return await asyncio.gather(*tasks)

    async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
        tg_tasks = [
            tg.create_task(self.delete_documents_by_filter(filter)) for filter in filters
        ]

    return [x.result() for x in tg_tasks]

delete_if_exists() async

Delete the index if it already exists.

Returns:

Type	Description
bool	True if the index was deleted or False if not.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.delete_if_exists()

Source code in meilisearch_python_sdk/index.py

async def delete_if_exists(self) -> bool:
    """Delete the index if it already exists.

    Returns:
        True if the index was deleted or False if not.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.delete_if_exists()
    """
    response = await self.delete()
    status = await async_wait_for_task(
        self.http_client, response.task_uid, timeout_in_ms=100000
    )
    if status.status == "succeeded":
        return True

    return False

edit_documents(function, *, context=None, filter=None) async

Edit documents with a function.

Edit documents is only available in Meilisearch >= v1.10.0, and is experimental in Meilisearch v1.10.0. In order to use this feature you first need to enable it by sending a PATCH request to /experimental-features with { "editDocumentsByFunction": true }.

Parameters:

Name	Type	Description	Default
function	str	Rhai function to use to update the documents.	required
context	JsonDict | None	Parameters to use in the function. Defaults to None.	None
filter	str | None	Filter the documents before applying the function. Defaults to None.	None

Returns:

Type	Description
TaskInfo	The details of the task.

Raises:

Type	Description
MeilisearchError	If the file path is not valid
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.edit_documents("doc.title = ${doc.title.to_upper()}")

Source code in meilisearch_python_sdk/index.py

async def edit_documents(
    self, function: str, *, context: JsonDict | None = None, filter: str | None = None
) -> TaskInfo:
    """Edit documents with a function.

    Edit documents is only available in Meilisearch >= v1.10.0, and is experimental in
    Meilisearch v1.10.0. In order to use this feature you first need to enable it by
    sending a PATCH request to /experimental-features with { "editDocumentsByFunction": true }.

    Args:
        function: Rhai function to use to update the documents.
        context: Parameters to use in the function. Defaults to None.
        filter: Filter the documents before applying the function. Defaults to None.

    Returns:
        The details of the task.

    Raises:
        MeilisearchError: If the file path is not valid
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.edit_documents("doc.title = `${doc.title.to_upper()}`")
    """
    url = f"{self._documents_url}/edit"
    payload: JsonDict = {"function": function}

    if context:
        payload["context"] = context

    if filter:
        payload["filter"] = filter

    response = await self._http_requests.post(url, payload)

    return TaskInfo(**response.json())

facet_search(query=None, *, facet_name, facet_query, offset=0, limit=20, filter=None, facets=None, attributes_to_retrieve=None, attributes_to_crop=None, crop_length=200, attributes_to_highlight=None, sort=None, show_matches_position=False, highlight_pre_tag='<em>', highlight_post_tag='</em>', crop_marker='...', matching_strategy='last', hits_per_page=None, page=None, attributes_to_search_on=None, show_ranking_score=False, show_ranking_score_details=False, ranking_score_threshold=None, vector=None, locales=None) async

Search the index.

Parameters:

Name	Type	Description	Default
query	str | None	String containing the word(s) to search	None
facet_name	str	The name of the facet to search	required
facet_query	str	The facet search value	required
offset	int	Number of documents to skip. Defaults to 0.	0
limit	int	Maximum number of documents returned. Defaults to 20.	20
filter	Filter | None	Filter queries by an attribute value. Defaults to None.	None
facets	list[str] | None	Facets for which to retrieve the matching count. Defaults to None.	None
attributes_to_retrieve	list[str] | None	Attributes to display in the returned documents. Defaults to ["*"].	None
attributes_to_crop	list[str] | None	Attributes whose values have to be cropped. Defaults to None.	None
crop_length	int	The maximun number of words to display. Defaults to 200.	200
attributes_to_highlight	list[str] | None	Attributes whose values will contain highlighted matching terms. Defaults to None.	None
sort	list[str] | None	Attributes by which to sort the results. Defaults to None.	None
show_matches_position	bool	Defines whether an object that contains information about the matches should be returned or not. Defaults to False.	False
highlight_pre_tag	str	The opening tag for highlighting text. Defaults to .	'<em>'
highlight_post_tag	str	The closing tag for highlighting text. Defaults to	'</em>'
crop_marker	str	Marker to display when the number of words excedes the crop_length. Defaults to ...	'...'
matching_strategy	Literal['all', 'last', 'frequency']	Specifies the matching strategy Meilisearch should use. Defaults to last.	'last'
hits_per_page	int | None	Sets the number of results returned per page.	None
page	int | None	Sets the specific results page to fetch.	None
attributes_to_search_on	list[str] | None	List of field names. Allow search over a subset of searchable attributes without modifying the index settings. Defaults to None.	None
show_ranking_score	bool	If set to True the ranking score will be returned with each document in the search. Defaults to False.	False
show_ranking_score_details	bool	If set to True the ranking details will be returned with each document in the search. Defaults to False. Note: This parameter can only be used with Meilisearch >= v1.3.0, and is experimental in Meilisearch v1.3.0. In order to use this feature in Meilisearch v1.3.0 you first need to enable the feature by sending a PATCH request to /experimental-features with { "scoreDetails": true }. Because this feature is experimental it may be removed or updated causing breaking changes in this library without a major version bump so use with caution. This feature became stable in Meiliseach v1.7.0.	False
ranking_score_threshold	float | None	If set, no document whose _rankingScore is under the rankingScoreThreshold is returned. The value must be between 0.0 and 1.0. Defaults to None.	None
vector	list[float] | None	List of vectors for vector search. Defaults to None. Note: This parameter can only be used with Meilisearch >= v1.3.0, and is experimental in Meilisearch v1.3.0. In order to use this feature in Meilisearch v1.3.0 you first need to enable the feature by sending a PATCH request to /experimental-features with { "vectorStore": true }. Because this feature is experimental it may be removed or updated causing breaking changes in this library without a major version bump so use with caution.	None
locales	list[str] | None	Specifies the languages for the search. This parameter can only be used with Milisearch >= v1.10.0. Defaults to None letting the Meilisearch pick.	None

Returns:

Type	Description
FacetSearchResults	Results of the search

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> search_results = await index.search( >>> "Tron", >>> facet_name="genre", >>> facet_query="Sci-fi" >>> )

Source code in meilisearch_python_sdk/index.py

async def facet_search(
    self,
    query: str | None = None,
    *,
    facet_name: str,
    facet_query: str,
    offset: int = 0,
    limit: int = 20,
    filter: Filter | None = None,
    facets: list[str] | None = None,
    attributes_to_retrieve: list[str] | None = None,
    attributes_to_crop: list[str] | None = None,
    crop_length: int = 200,
    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: Literal["all", "last", "frequency"] = "last",
    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: float | None = None,
    vector: list[float] | None = None,
    locales: list[str] | None = None,
) -> FacetSearchResults:
    """Search the index.

    Args:
        query: String containing the word(s) to search
        facet_name: The name of the facet to search
        facet_query: The facet search value
        offset: Number of documents to skip. Defaults to 0.
        limit: Maximum number of documents returned. Defaults to 20.
        filter: Filter queries by an attribute value. Defaults to None.
        facets: Facets for which to retrieve the matching count. Defaults to None.
        attributes_to_retrieve: Attributes to display in the returned documents.
            Defaults to ["*"].
        attributes_to_crop: Attributes whose values have to be cropped. Defaults to None.
        crop_length: The maximun number of words to display. Defaults to 200.
        attributes_to_highlight: Attributes whose values will contain highlighted matching terms.
            Defaults to None.
        sort: Attributes by which to sort the results. Defaults to None.
        show_matches_position: Defines whether an object that contains information about the
            matches should be returned or not. Defaults to False.
        highlight_pre_tag: The opening tag for highlighting text. Defaults to <em>.
        highlight_post_tag: The closing tag for highlighting text. Defaults to </em>
        crop_marker: Marker to display when the number of words excedes the `crop_length`.
            Defaults to ...
        matching_strategy: Specifies the matching strategy Meilisearch should use. Defaults to
            `last`.
        hits_per_page: Sets the number of results returned per page.
        page: Sets the specific results page to fetch.
        attributes_to_search_on: List of field names. Allow search over a subset of searchable
            attributes without modifying the index settings. Defaults to None.
        show_ranking_score: If set to True the ranking score will be returned with each document
            in the search. Defaults to False.
        show_ranking_score_details: If set to True the ranking details will be returned with
            each document in the search. Defaults to False. Note: This parameter can only be
            used with Meilisearch >= v1.3.0, and is experimental in Meilisearch v1.3.0. In order
            to use this feature in Meilisearch v1.3.0 you first need to enable the feature by
            sending a PATCH request to /experimental-features with { "scoreDetails": true }.
            Because this feature is experimental it may be removed or updated causing breaking
            changes in this library without a major version bump so use with caution. This
            feature became stable in Meiliseach v1.7.0.
        ranking_score_threshold: If set, no document whose _rankingScore is under the
            rankingScoreThreshold is returned. The value must be between 0.0 and 1.0. Defaults
            to None.
        vector: List of vectors for vector search. Defaults to None. Note: This parameter can
            only be used with Meilisearch >= v1.3.0, and is experimental in Meilisearch v1.3.0.
            In order to use this feature in Meilisearch v1.3.0 you first need to enable the
            feature by sending a PATCH request to /experimental-features with
            { "vectorStore": true }. Because this feature is experimental it may be removed or
            updated causing breaking changes in this library without a major version bump so use
            with caution.
        locales: Specifies the languages for the search. This parameter can only be used with
            Milisearch >= v1.10.0. Defaults to None letting the Meilisearch pick.

    Returns:
        Results of the search

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     search_results = await index.search(
        >>>         "Tron",
        >>>         facet_name="genre",
        >>>         facet_query="Sci-fi"
        >>>     )
    """
    if ranking_score_threshold:
        _validate_ranking_score_threshold(ranking_score_threshold)

    body = _process_search_parameters(
        q=query,
        facet_name=facet_name,
        facet_query=facet_query,
        offset=offset,
        limit=limit,
        filter=filter,
        facets=facets,
        attributes_to_retrieve=attributes_to_retrieve,
        attributes_to_crop=attributes_to_crop,
        crop_length=crop_length,
        attributes_to_highlight=attributes_to_highlight,
        sort=sort,
        show_matches_position=show_matches_position,
        highlight_pre_tag=highlight_pre_tag,
        highlight_post_tag=highlight_post_tag,
        crop_marker=crop_marker,
        matching_strategy=matching_strategy,
        hits_per_page=hits_per_page,
        page=page,
        attributes_to_search_on=attributes_to_search_on,
        show_ranking_score=show_ranking_score,
        show_ranking_score_details=show_ranking_score_details,
        ranking_score_threshold=ranking_score_threshold,
        vector=vector,
        locales=locales,
    )
    search_url = f"{self._base_url_with_uid}/facet-search"

    if self._pre_facet_search_plugins:
        await AsyncIndex._run_plugins(
            self._pre_facet_search_plugins,
            AsyncEvent.PRE,
            query=query,
            offset=offset,
            limit=limit,
            filter=filter,
            facets=facets,
            attributes_to_retrieve=attributes_to_retrieve,
            attributes_to_crop=attributes_to_crop,
            crop_length=crop_length,
            attributes_to_highlight=attributes_to_highlight,
            sort=sort,
            show_matches_position=show_matches_position,
            highlight_pre_tag=highlight_pre_tag,
            highlight_post_tag=highlight_post_tag,
            crop_marker=crop_marker,
            matching_strategy=matching_strategy,
            hits_per_page=hits_per_page,
            page=page,
            attributes_to_search_on=attributes_to_search_on,
            show_ranking_score=show_ranking_score,
            show_ranking_score_details=show_ranking_score_details,
            ranking_score_threshold=ranking_score_threshold,
            vector=vector,
        )

    if self._concurrent_facet_search_plugins:
        if not use_task_groups():
            tasks: Any = []
            for plugin in self._concurrent_facet_search_plugins:
                if _plugin_has_method(plugin, "run_plugin"):
                    tasks.append(
                        plugin.run_plugin(  # type: ignore[union-attr]
                            event=AsyncEvent.CONCURRENT,
                            query=query,
                            offset=offset,
                            limit=limit,
                            filter=filter,
                            facets=facets,
                            attributes_to_retrieve=attributes_to_retrieve,
                            attributes_to_crop=attributes_to_crop,
                            crop_length=crop_length,
                            attributes_to_highlight=attributes_to_highlight,
                            sort=sort,
                            show_matches_position=show_matches_position,
                            highlight_pre_tag=highlight_pre_tag,
                            highlight_post_tag=highlight_post_tag,
                            crop_marker=crop_marker,
                            matching_strategy=matching_strategy,
                            hits_per_page=hits_per_page,
                            page=page,
                            attributes_to_search_on=attributes_to_search_on,
                            show_ranking_score=show_ranking_score,
                            show_ranking_score_details=show_ranking_score_details,
                            ranking_score_threshold=ranking_score_threshold,
                            vector=vector,
                        )
                    )

            tasks.append(self._http_requests.post(search_url, body=body))
            responses = await asyncio.gather(*tasks)
            result = FacetSearchResults(**responses[-1].json())
            if self._post_facet_search_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_facet_search_plugins, AsyncEvent.POST, result=result
                )
                if isinstance(post["generic_result"], FacetSearchResults):
                    result = post["generic_result"]

            return result

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            for plugin in self._concurrent_facet_search_plugins:
                if _plugin_has_method(plugin, "run_plugin"):
                    tg.create_task(
                        plugin.run_plugin(  # type: ignore[union-attr]
                            event=AsyncEvent.CONCURRENT,
                            query=query,
                            offset=offset,
                            limit=limit,
                            filter=filter,
                            facets=facets,
                            attributes_to_retrieve=attributes_to_retrieve,
                            attributes_to_crop=attributes_to_crop,
                            crop_length=crop_length,
                            attributes_to_highlight=attributes_to_highlight,
                            sort=sort,
                            show_matches_position=show_matches_position,
                            highlight_pre_tag=highlight_pre_tag,
                            highlight_post_tag=highlight_post_tag,
                            crop_marker=crop_marker,
                            matching_strategy=matching_strategy,
                            hits_per_page=hits_per_page,
                            page=page,
                            attributes_to_search_on=attributes_to_search_on,
                            show_ranking_score=show_ranking_score,
                            show_ranking_score_details=show_ranking_score_details,
                            ranking_score_threshold=ranking_score_threshold,
                            vector=vector,
                        )
                    )

            response_coroutine = tg.create_task(self._http_requests.post(search_url, body=body))

        response = await response_coroutine
        result = FacetSearchResults(**response.json())
        if self._post_facet_search_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_facet_search_plugins, AsyncEvent.POST, result=result
            )
            if isinstance(post["generic_result"], FacetSearchResults):
                result = post["generic_result"]

        return result

    response = await self._http_requests.post(search_url, body=body)
    result = FacetSearchResults(**response.json())
    if self._post_facet_search_plugins:
        post = await AsyncIndex._run_plugins(
            self._post_facet_search_plugins, AsyncEvent.POST, result=result
        )
        if isinstance(post["generic_result"], FacetSearchResults):
            result = post["generic_result"]

    return result

fetch_info() async

Gets the infromation about the index.

Returns:

Type	Description
Self	An instance of the AsyncIndex containing the retrieved information.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> index_info = await index.fetch_info()

Source code in meilisearch_python_sdk/index.py

async def fetch_info(self) -> Self:
    """Gets the infromation about the index.

    Returns:
        An instance of the AsyncIndex containing the retrieved information.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     index_info = await index.fetch_info()
    """
    response = await self._http_requests.get(self._base_url_with_uid)
    index_dict = response.json()
    self._set_fetch_info(
        index_dict["primaryKey"], index_dict["createdAt"], index_dict["updatedAt"]
    )
    return self

get_displayed_attributes() async

Get displayed attributes of the index.

Returns:

Type	Description
list[str]	List containing the displayed attributes of the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> displayed_attributes = await index.get_displayed_attributes()

Source code in meilisearch_python_sdk/index.py

async def get_displayed_attributes(self) -> list[str]:
    """Get displayed attributes of the index.

    Returns:
        List containing the displayed attributes of the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     displayed_attributes = await index.get_displayed_attributes()
    """
    response = await self._http_requests.get(f"{self._settings_url}/displayed-attributes")

    return response.json()

get_distinct_attribute() async

Get distinct attribute of the index.

Returns:

Type	Description
str | None	String containing the distinct attribute of the index. If no distinct attribute None is returned.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> distinct_attribute = await index.get_distinct_attribute()

Source code in meilisearch_python_sdk/index.py

async def get_distinct_attribute(self) -> str | None:
    """Get distinct attribute of the index.

    Returns:
        String containing the distinct attribute of the index. If no distinct attribute
            `None` is returned.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     distinct_attribute = await index.get_distinct_attribute()
    """
    response = await self._http_requests.get(f"{self._settings_url}/distinct-attribute")

    if not response.json():
        return None

    return response.json()

get_document(document_id) async

Get one document with given document identifier.

Parameters:

Name	Type	Description	Default
document_id	str	Unique identifier of the document.	required

Returns:

Type	Description
JsonDict	The document information

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> document = await index.get_document("1234")

Source code in meilisearch_python_sdk/index.py

async def get_document(self, document_id: str) -> JsonDict:
    """Get one document with given document identifier.

    Args:
        document_id: Unique identifier of the document.

    Returns:
        The document information

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     document = await index.get_document("1234")
    """
    response = await self._http_requests.get(f"{self._documents_url}/{document_id}")

    return response.json()

get_documents(*, offset=0, limit=20, fields=None, filter=None) async

Get a batch documents from the index.

Parameters:

Name	Type	Description	Default
offset	int	Number of documents to skip. Defaults to 0.	0
limit	int	Maximum number of documents returnedd. Defaults to 20.	20
fields	list[str] | None	Document attributes to show. If this value is None then all attributes are retrieved. Defaults to None.	None
filter	Filter | None	Filter value information. Defaults to None. Note: This parameter can only be used with Meilisearch >= v1.2.0	None

Returns:

Type	Description
DocumentsInfo	Documents info.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> documents = await index.get_documents()

Source code in meilisearch_python_sdk/index.py

async def get_documents(
    self,
    *,
    offset: int = 0,
    limit: int = 20,
    fields: list[str] | None = None,
    filter: Filter | None = None,
) -> DocumentsInfo:
    """Get a batch documents from the index.

    Args:
        offset: Number of documents to skip. Defaults to 0.
        limit: Maximum number of documents returnedd. Defaults to 20.
        fields: Document attributes to show. If this value is None then all
            attributes are retrieved. Defaults to None.
        filter: Filter value information. Defaults to None. Note: This parameter can only be
            used with Meilisearch >= v1.2.0

    Returns:
        Documents info.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.


    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     documents = await index.get_documents()
    """
    parameters: JsonDict = {
        "offset": offset,
        "limit": limit,
    }

    if not filter:
        if fields:
            parameters["fields"] = ",".join(fields)

        url = _build_encoded_url(self._documents_url, parameters)
        response = await self._http_requests.get(url)

        return DocumentsInfo(**response.json())

    if fields:
        parameters["fields"] = fields

    parameters["filter"] = filter

    response = await self._http_requests.post(f"{self._documents_url}/fetch", body=parameters)

    return DocumentsInfo(**response.json())

get_embedders() async

Get embedder settings for the index.

Returns:

Type	Description
Embedders | None	Embedders for the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> embedders = await index.get_embedders()

Source code in meilisearch_python_sdk/index.py

async def get_embedders(self) -> Embedders | None:
    """Get embedder settings for the index.

    Returns:
        Embedders for the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     embedders = await index.get_embedders()
    """
    response = await self._http_requests.get(f"{self._settings_url}/embedders")

    return _embedder_json_to_embedders_model(response.json())

get_faceting() async

Get faceting for the index.

Returns:

Type	Description
Faceting	Faceting for the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> faceting = await index.get_faceting()

Source code in meilisearch_python_sdk/index.py

async def get_faceting(self) -> Faceting:
    """Get faceting for the index.

    Returns:
        Faceting for the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     faceting = await index.get_faceting()
    """
    response = await self._http_requests.get(f"{self._settings_url}/faceting")

    return Faceting(**response.json())

get_filterable_attributes() async

Get filterable attributes of the index.

Returns:

Type	Description
list[str] | None	List containing the filterable attributes of the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> filterable_attributes = await index.get_filterable_attributes()

Source code in meilisearch_python_sdk/index.py

async def get_filterable_attributes(self) -> list[str] | None:
    """Get filterable attributes of the index.

    Returns:
        List containing the filterable attributes of the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     filterable_attributes = await index.get_filterable_attributes()
    """
    response = await self._http_requests.get(f"{self._settings_url}/filterable-attributes")

    if not response.json():
        return None

    return response.json()

get_localized_attributes() async

Get localized attributes settings for the index.

Returns:

Type	Description
list[LocalizedAttributes] | None	Localized attributes for the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> localized_attributes = await index.get_localized_attributes()

Source code in meilisearch_python_sdk/index.py

async def get_localized_attributes(self) -> list[LocalizedAttributes] | None:
    """Get localized attributes settings for the index.

    Returns:
        Localized attributes for the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     localized_attributes = await index.get_localized_attributes()
    """
    response = await self._http_requests.get(f"{self._settings_url}/localized-attributes")

    if not response.json():
        return None

    return [LocalizedAttributes(**x) for x in response.json()]

get_non_separator_tokens() async

Get non-separator token settings for the index.

Returns:

Type	Description
list[str]	Non-separator tokens for the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> non_separator_token_settings = await index.get_non_separator_tokens()

Source code in meilisearch_python_sdk/index.py

async def get_non_separator_tokens(self) -> list[str]:
    """Get non-separator token settings for the index.

    Returns:
        Non-separator tokens for the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     non_separator_token_settings = await index.get_non_separator_tokens()
    """
    response = await self._http_requests.get(f"{self._settings_url}/non-separator-tokens")

    return response.json()

get_pagination() async

Get pagination settings for the index.

Returns:

Type	Description
Pagination	Pagination for the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> pagination_settings = await index.get_pagination()

Source code in meilisearch_python_sdk/index.py

async def get_pagination(self) -> Pagination:
    """Get pagination settings for the index.

    Returns:
        Pagination for the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     pagination_settings = await index.get_pagination()
    """
    response = await self._http_requests.get(f"{self._settings_url}/pagination")

    return Pagination(**response.json())

get_primary_key() async

Get the primary key.

Returns:

Type	Description
str | None	The primary key for the documents in the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> primary_key = await index.get_primary_key()

Source code in meilisearch_python_sdk/index.py

async def get_primary_key(self) -> str | None:
    """Get the primary key.

    Returns:
        The primary key for the documents in the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     primary_key = await index.get_primary_key()
    """
    info = await self.fetch_info()
    return info.primary_key

get_proximity_precision() async

Get proximity precision settings for the index.

Returns:

Type	Description
ProximityPrecision	Proximity precision for the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> proximity_precision = await index.get_proximity_precision()

Source code in meilisearch_python_sdk/index.py

async def get_proximity_precision(self) -> ProximityPrecision:
    """Get proximity precision settings for the index.

    Returns:
        Proximity precision for the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     proximity_precision = await index.get_proximity_precision()
    """
    response = await self._http_requests.get(f"{self._settings_url}/proximity-precision")

    return ProximityPrecision[to_snake(response.json()).upper()]

get_ranking_rules() async

Get ranking rules of the index.

Returns:

Type	Description
list[str]	List containing the ranking rules of the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> ranking_rules = await index.get_ranking_rules()

Source code in meilisearch_python_sdk/index.py

async def get_ranking_rules(self) -> list[str]:
    """Get ranking rules of the index.

    Returns:
        List containing the ranking rules of the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     ranking_rules = await index.get_ranking_rules()
    """
    response = await self._http_requests.get(f"{self._settings_url}/ranking-rules")

    return response.json()

get_search_cutoff_ms() async

Get search cutoff time in ms.

Returns:

Type	Description
int | None	Integer representing the search cutoff time in ms, or None.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> search_cutoff_ms_settings = await index.get_search_cutoff_ms()

Source code in meilisearch_python_sdk/index.py

async def get_search_cutoff_ms(self) -> int | None:
    """Get search cutoff time in ms.

    Returns:
        Integer representing the search cutoff time in ms, or None.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     search_cutoff_ms_settings = await index.get_search_cutoff_ms()
    """
    response = await self._http_requests.get(f"{self._settings_url}/search-cutoff-ms")

    return response.json()

get_searchable_attributes() async

Get searchable attributes of the index.

Returns:

Type	Description
list[str]	List containing the searchable attributes of the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> searchable_attributes = await index.get_searchable_attributes()

Source code in meilisearch_python_sdk/index.py

async def get_searchable_attributes(self) -> list[str]:
    """Get searchable attributes of the index.

    Returns:
        List containing the searchable attributes of the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     searchable_attributes = await index.get_searchable_attributes()
    """
    response = await self._http_requests.get(f"{self._settings_url}/searchable-attributes")

    return response.json()

get_separator_tokens() async

Get separator token settings for the index.

Returns:

Type	Description
list[str]	Separator tokens for the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> separator_token_settings = await index.get_separator_tokens()

Source code in meilisearch_python_sdk/index.py

async def get_separator_tokens(self) -> list[str]:
    """Get separator token settings for the index.

    Returns:
        Separator tokens for the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     separator_token_settings = await index.get_separator_tokens()
    """
    response = await self._http_requests.get(f"{self._settings_url}/separator-tokens")

    return response.json()

get_settings() async

Get settings of the index.

Returns:

Type	Description
MeilisearchSettings	Settings of the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> settings = await index.get_settings()

Source code in meilisearch_python_sdk/index.py

async def get_settings(self) -> MeilisearchSettings:
    """Get settings of the index.

    Returns:
        Settings of the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     settings = await index.get_settings()
    """
    response = await self._http_requests.get(self._settings_url)
    response_json = response.json()
    settings = MeilisearchSettings(**response_json)

    if response_json.get("embedders"):
        # TODO: Add back after embedder setting issue fixed https://github.com/meilisearch/meilisearch/issues/4585
        settings.embedders = _embedder_json_to_settings_model(  # pragma: no cover
            response_json["embedders"]
        )

    return settings

get_sortable_attributes() async

Get sortable attributes of the AsyncIndex.

Returns:

Type	Description
list[str]	List containing the sortable attributes of the AsyncIndex.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> sortable_attributes = await index.get_sortable_attributes()

Source code in meilisearch_python_sdk/index.py

async def get_sortable_attributes(self) -> list[str]:
    """Get sortable attributes of the AsyncIndex.

    Returns:
        List containing the sortable attributes of the AsyncIndex.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     sortable_attributes = await index.get_sortable_attributes()
    """
    response = await self._http_requests.get(f"{self._settings_url}/sortable-attributes")

    return response.json()

get_stats() async

Get stats of the index.

Returns:

Type	Description
IndexStats	Stats of the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> stats = await index.get_stats()

Source code in meilisearch_python_sdk/index.py

async def get_stats(self) -> IndexStats:
    """Get stats of the index.

    Returns:
        Stats of the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     stats = await index.get_stats()
    """
    response = await self._http_requests.get(self._stats_url)

    return IndexStats(**response.json())

get_stop_words() async

Get stop words of the index.

Returns:

Type	Description
list[str] | None	List containing the stop words of the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> stop_words = await index.get_stop_words()

Source code in meilisearch_python_sdk/index.py

async def get_stop_words(self) -> list[str] | None:
    """Get stop words of the index.

    Returns:
        List containing the stop words of the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     stop_words = await index.get_stop_words()
    """
    response = await self._http_requests.get(f"{self._settings_url}/stop-words")

    if not response.json():
        return None

    return response.json()

get_synonyms() async

Get synonyms of the index.

Returns:

Type	Description
dict[str, list[str]] | None	The synonyms of the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> synonyms = await index.get_synonyms()

Source code in meilisearch_python_sdk/index.py

async def get_synonyms(self) -> dict[str, list[str]] | None:
    """Get synonyms of the index.

    Returns:
        The synonyms of the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     synonyms = await index.get_synonyms()
    """
    response = await self._http_requests.get(f"{self._settings_url}/synonyms")

    if not response.json():
        return None

    return response.json()

get_typo_tolerance() async

Get typo tolerance for the index.

Returns:

Type	Description
TypoTolerance	TypoTolerance for the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> sortable_attributes = await index.get_typo_tolerance()

Source code in meilisearch_python_sdk/index.py

async def get_typo_tolerance(self) -> TypoTolerance:
    """Get typo tolerance for the index.

    Returns:
        TypoTolerance for the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     sortable_attributes = await index.get_typo_tolerance()
    """
    response = await self._http_requests.get(f"{self._settings_url}/typo-tolerance")

    return TypoTolerance(**response.json())

get_word_dictionary() async

Get word dictionary settings for the index.

Returns:

Type	Description
list[str]	Word dictionary for the index.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> word_dictionary = await index.get_word_dictionary()

Source code in meilisearch_python_sdk/index.py

async def get_word_dictionary(self) -> list[str]:
    """Get word dictionary settings for the index.

    Returns:
        Word dictionary for the index.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     word_dictionary = await index.get_word_dictionary()
    """
    response = await self._http_requests.get(f"{self._settings_url}/dictionary")

    return response.json()

reset_displayed_attributes() async

Reset displayed attributes of the index to default values.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_displayed_attributes()

Source code in meilisearch_python_sdk/index.py

async def reset_displayed_attributes(self) -> TaskInfo:
    """Reset displayed attributes of the index to default values.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_displayed_attributes()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/displayed-attributes")

    return TaskInfo(**response.json())

reset_distinct_attribute() async

Reset distinct attribute of the index to default values.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_distinct_attributes()

Source code in meilisearch_python_sdk/index.py

async def reset_distinct_attribute(self) -> TaskInfo:
    """Reset distinct attribute of the index to default values.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_distinct_attributes()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/distinct-attribute")

    return TaskInfo(**response.json())

reset_embedders() async

Reset an index's embedders settings to the default value.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_embedders()

Source code in meilisearch_python_sdk/index.py

async def reset_embedders(self) -> TaskInfo:
    """Reset an index's embedders settings to the default value.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_embedders()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/embedders")

    return TaskInfo(**response.json())

reset_faceting() async

Reset an index's faceting settings to their default value.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_faceting()

Source code in meilisearch_python_sdk/index.py

async def reset_faceting(self) -> TaskInfo:
    """Reset an index's faceting settings to their default value.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_faceting()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/faceting")

    return TaskInfo(**response.json())

reset_filterable_attributes() async

Reset filterable attributes of the index to default values.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_filterable_attributes()

Source code in meilisearch_python_sdk/index.py

async def reset_filterable_attributes(self) -> TaskInfo:
    """Reset filterable attributes of the index to default values.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_filterable_attributes()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/filterable-attributes")

    return TaskInfo(**response.json())

reset_localized_attributes() async

Reset an index's localized attributes settings to the default value.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_localized_attributes()

Source code in meilisearch_python_sdk/index.py

async def reset_localized_attributes(self) -> TaskInfo:
    """Reset an index's localized attributes settings to the default value.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_localized_attributes()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/localized-attributes")

    return TaskInfo(**response.json())

reset_non_separator_tokens() async

Reset an index's non-separator tokens settings to the default value.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_non_separator_tokens()

Source code in meilisearch_python_sdk/index.py

async def reset_non_separator_tokens(self) -> TaskInfo:
    """Reset an index's non-separator tokens settings to the default value.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_non_separator_tokens()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/non-separator-tokens")

    return TaskInfo(**response.json())

reset_pagination() async

Reset an index's pagination settings to their default value.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_pagination()

Source code in meilisearch_python_sdk/index.py

async def reset_pagination(self) -> TaskInfo:
    """Reset an index's pagination settings to their default value.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_pagination()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/pagination")

    return TaskInfo(**response.json())

reset_proximity_precision() async

Reset an index's proximity precision settings to the default value.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_proximity_precision()

Source code in meilisearch_python_sdk/index.py

async def reset_proximity_precision(self) -> TaskInfo:
    """Reset an index's proximity precision settings to the default value.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_proximity_precision()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/proximity-precision")

    return TaskInfo(**response.json())

reset_ranking_rules() async

Reset ranking rules of the index to default values.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_ranking_rules()

Source code in meilisearch_python_sdk/index.py

async def reset_ranking_rules(self) -> TaskInfo:
    """Reset ranking rules of the index to default values.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_ranking_rules()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/ranking-rules")

    return TaskInfo(**response.json())

reset_search_cutoff_ms() async

Reset the search cutoff time to the default value.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_search_cutoff_ms()

Source code in meilisearch_python_sdk/index.py

async def reset_search_cutoff_ms(self) -> TaskInfo:
    """Reset the search cutoff time to the default value.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_search_cutoff_ms()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/search-cutoff-ms")

    return TaskInfo(**response.json())

reset_searchable_attributes() async

Reset searchable attributes of the index to default values.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_searchable_attributes()

Source code in meilisearch_python_sdk/index.py

async def reset_searchable_attributes(self) -> TaskInfo:
    """Reset searchable attributes of the index to default values.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_searchable_attributes()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/searchable-attributes")

    return TaskInfo(**response.json())

reset_separator_tokens() async

Reset an index's separator tokens settings to the default value.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_separator_tokens()

Source code in meilisearch_python_sdk/index.py

async def reset_separator_tokens(self) -> TaskInfo:
    """Reset an index's separator tokens settings to the default value.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_separator_tokens()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/separator-tokens")

    return TaskInfo(**response.json())

reset_settings() async

Reset settings of the index to default values.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_settings()

Source code in meilisearch_python_sdk/index.py

async def reset_settings(self) -> TaskInfo:
    """Reset settings of the index to default values.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_settings()
    """
    response = await self._http_requests.delete(self._settings_url)

    return TaskInfo(**response.json())

reset_sortable_attributes() async

Reset sortable attributes of the index to default values.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_sortable_attributes()

Source code in meilisearch_python_sdk/index.py

async def reset_sortable_attributes(self) -> TaskInfo:
    """Reset sortable attributes of the index to default values.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_sortable_attributes()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/sortable-attributes")

    return TaskInfo(**response.json())

reset_stop_words() async

Reset stop words of the index to default values.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_stop_words()

Source code in meilisearch_python_sdk/index.py

async def reset_stop_words(self) -> TaskInfo:
    """Reset stop words of the index to default values.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_stop_words()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/stop-words")

    return TaskInfo(**response.json())

reset_synonyms() async

Reset synonyms of the index to default values.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_synonyms()

Source code in meilisearch_python_sdk/index.py

async def reset_synonyms(self) -> TaskInfo:
    """Reset synonyms of the index to default values.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_synonyms()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/synonyms")

    return TaskInfo(**response.json())

reset_typo_tolerance() async

Reset typo tolerance to default values.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_typo_tolerance()

Source code in meilisearch_python_sdk/index.py

async def reset_typo_tolerance(self) -> TaskInfo:
    """Reset typo tolerance to default values.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_typo_tolerance()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/typo-tolerance")

    return TaskInfo(**response.json())

reset_word_dictionary() async

Reset an index's word dictionary settings to the default value.

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_async_client import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.reset_word_dictionary()

Source code in meilisearch_python_sdk/index.py

async def reset_word_dictionary(self) -> TaskInfo:
    """Reset an index's word dictionary settings to the default value.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_async_client import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.reset_word_dictionary()
    """
    response = await self._http_requests.delete(f"{self._settings_url}/dictionary")

    return TaskInfo(**response.json())

search(query=None, *, offset=0, limit=20, filter=None, facets=None, attributes_to_retrieve=None, attributes_to_crop=None, crop_length=200, attributes_to_highlight=None, sort=None, show_matches_position=False, highlight_pre_tag='<em>', highlight_post_tag='</em>', crop_marker='...', matching_strategy='last', hits_per_page=None, page=None, attributes_to_search_on=None, distinct=None, show_ranking_score=False, show_ranking_score_details=False, ranking_score_threshold=None, vector=None, hybrid=None, locales=None) async

Search the index.

Parameters:

Name	Type	Description	Default
query	str | None	String containing the word(s) to search	None
offset	int	Number of documents to skip. Defaults to 0.	0
limit	int	Maximum number of documents returned. Defaults to 20.	20
filter	Filter | None	Filter queries by an attribute value. Defaults to None.	None
facets	list[str] | None	Facets for which to retrieve the matching count. Defaults to None.	None
attributes_to_retrieve	list[str] | None	Attributes to display in the returned documents. Defaults to ["*"].	None
attributes_to_crop	list[str] | None	Attributes whose values have to be cropped. Defaults to None.	None
crop_length	int	The maximun number of words to display. Defaults to 200.	200
attributes_to_highlight	list[str] | None	Attributes whose values will contain highlighted matching terms. Defaults to None.	None
sort	list[str] | None	Attributes by which to sort the results. Defaults to None.	None
show_matches_position	bool	Defines whether an object that contains information about the matches should be returned or not. Defaults to False.	False
highlight_pre_tag	str	The opening tag for highlighting text. Defaults to .	'<em>'
highlight_post_tag	str	The closing tag for highlighting text. Defaults to	'</em>'
crop_marker	str	Marker to display when the number of words excedes the crop_length. Defaults to ...	'...'
matching_strategy	Literal['all', 'last', 'frequency']	Specifies the matching strategy Meilisearch should use. Defaults to last.	'last'
hits_per_page	int | None	Sets the number of results returned per page.	None
page	int | None	Sets the specific results page to fetch.	None
attributes_to_search_on	list[str] | None	List of field names. Allow search over a subset of searchable attributes without modifying the index settings. Defaults to None.	None
distinct	str | None	If set the distinct value will return at most one result for the filterable attribute. Note that a filterable attributes must be set for this work. Defaults to None.	None
show_ranking_score	bool	If set to True the ranking score will be returned with each document in the search. Defaults to False.	False
show_ranking_score_details	bool	If set to True the ranking details will be returned with each document in the search. Defaults to False. Note: This parameter can only be used with Meilisearch >= v1.3.0, and is experimental in Meilisearch v1.3.0. In order to use this feature in Meilisearch v1.3.0 you first need to enable the feature by sending a PATCH request to /experimental-features with { "scoreDetails": true }. Because this feature is experimental it may be removed or updated causing breaking changes in this library without a major version bump so use with caution. This feature became stable in Meiliseach v1.7.0.	False
ranking_score_threshold	float | None	If set, no document whose _rankingScore is under the rankingScoreThreshold is returned. The value must be between 0.0 and 1.0. Defaults to None.	None
vector	list[float] | None	List of vectors for vector search. Defaults to None. Note: This parameter can only be used with Meilisearch >= v1.3.0, and is experimental in Meilisearch v1.3.0. In order to use this feature in Meilisearch v1.3.0 you first need to enable the feature by sending a PATCH request to /experimental-features with { "vectorStore": true }. Because this feature is experimental it may be removed or updated causing breaking changes in this library without a major version bump so use with caution.	None
hybrid	Hybrid | None	Hybrid search information. Defaults to None. Note: This parameter can only be used with Meilisearch >= v1.6.0, and is experimental in Meilisearch v1.6.0. In order to use this feature in Meilisearch v1.6.0 you first need to enable the feature by sending a PATCH request to /experimental-features with { "vectorStore": true }. Because this feature is experimental it may be removed or updated causing breaking changes in this library without a major version bump so use with caution.	None
locales	list[str] | None	Specifies the languages for the search. This parameter can only be used with Milisearch >= v1.10.0. Defaults to None letting the Meilisearch pick.	None

Returns:

Type	Description
SearchResults	Results of the search

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> search_results = await index.search("Tron")

Source code in meilisearch_python_sdk/index.py

async def search(
    self,
    query: str | None = None,
    *,
    offset: int = 0,
    limit: int = 20,
    filter: Filter | None = None,
    facets: list[str] | None = None,
    attributes_to_retrieve: list[str] | None = None,
    attributes_to_crop: list[str] | None = None,
    crop_length: int = 200,
    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: Literal["all", "last", "frequency"] = "last",
    hits_per_page: int | None = None,
    page: int | None = None,
    attributes_to_search_on: list[str] | None = None,
    distinct: str | None = None,
    show_ranking_score: bool = False,
    show_ranking_score_details: bool = False,
    ranking_score_threshold: float | None = None,
    vector: list[float] | None = None,
    hybrid: Hybrid | None = None,
    locales: list[str] | None = None,
) -> SearchResults:
    """Search the index.

    Args:
        query: String containing the word(s) to search
        offset: Number of documents to skip. Defaults to 0.
        limit: Maximum number of documents returned. Defaults to 20.
        filter: Filter queries by an attribute value. Defaults to None.
        facets: Facets for which to retrieve the matching count. Defaults to None.
        attributes_to_retrieve: Attributes to display in the returned documents.
            Defaults to ["*"].
        attributes_to_crop: Attributes whose values have to be cropped. Defaults to None.
        crop_length: The maximun number of words to display. Defaults to 200.
        attributes_to_highlight: Attributes whose values will contain highlighted matching terms.
            Defaults to None.
        sort: Attributes by which to sort the results. Defaults to None.
        show_matches_position: Defines whether an object that contains information about the
            matches should be returned or not. Defaults to False.
        highlight_pre_tag: The opening tag for highlighting text. Defaults to <em>.
        highlight_post_tag: The closing tag for highlighting text. Defaults to </em>
        crop_marker: Marker to display when the number of words excedes the `crop_length`.
            Defaults to ...
        matching_strategy: Specifies the matching strategy Meilisearch should use. Defaults to
            `last`.
        hits_per_page: Sets the number of results returned per page.
        page: Sets the specific results page to fetch.
        attributes_to_search_on: List of field names. Allow search over a subset of searchable
            attributes without modifying the index settings. Defaults to None.
        distinct: If set the distinct value will return at most one result for the
            filterable attribute. Note that a filterable attributes must be set for this work.
            Defaults to None.
        show_ranking_score: If set to True the ranking score will be returned with each document
            in the search. Defaults to False.
        show_ranking_score_details: If set to True the ranking details will be returned with
            each document in the search. Defaults to False. Note: This parameter can only be
            used with Meilisearch >= v1.3.0, and is experimental in Meilisearch v1.3.0. In order
            to use this feature in Meilisearch v1.3.0 you first need to enable the feature by
            sending a PATCH request to /experimental-features with { "scoreDetails": true }.
            Because this feature is experimental it may be removed or updated causing breaking
            changes in this library without a major version bump so use with caution. This
            feature became stable in Meiliseach v1.7.0.
        ranking_score_threshold: If set, no document whose _rankingScore is under the
            rankingScoreThreshold is returned. The value must be between 0.0 and 1.0. Defaults
            to None.
        vector: List of vectors for vector search. Defaults to None. Note: This parameter can
            only be used with Meilisearch >= v1.3.0, and is experimental in Meilisearch v1.3.0.
            In order to use this feature in Meilisearch v1.3.0 you first need to enable the
            feature by sending a PATCH request to /experimental-features with
            { "vectorStore": true }. Because this feature is experimental it may be removed or
            updated causing breaking changes in this library without a major version bump so use
            with caution.
        hybrid: Hybrid search information. Defaults to None. Note: This parameter can
            only be used with Meilisearch >= v1.6.0, and is experimental in Meilisearch v1.6.0.
            In order to use this feature in Meilisearch v1.6.0 you first need to enable the
            feature by sending a PATCH request to /experimental-features with
            { "vectorStore": true }. Because this feature is experimental it may be removed or
            updated causing breaking changes in this library without a major version bump so use
            with caution.
        locales: Specifies the languages for the search. This parameter can only be used with
            Milisearch >= v1.10.0. Defaults to None letting the Meilisearch pick.

    Returns:
        Results of the search

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     search_results = await index.search("Tron")
    """
    if ranking_score_threshold:
        _validate_ranking_score_threshold(ranking_score_threshold)

    body = _process_search_parameters(
        q=query,
        offset=offset,
        limit=limit,
        filter=filter,
        facets=facets,
        attributes_to_retrieve=attributes_to_retrieve,
        attributes_to_crop=attributes_to_crop,
        crop_length=crop_length,
        attributes_to_highlight=attributes_to_highlight,
        sort=sort,
        show_matches_position=show_matches_position,
        highlight_pre_tag=highlight_pre_tag,
        highlight_post_tag=highlight_post_tag,
        crop_marker=crop_marker,
        matching_strategy=matching_strategy,
        hits_per_page=hits_per_page,
        page=page,
        attributes_to_search_on=attributes_to_search_on,
        distinct=distinct,
        show_ranking_score=show_ranking_score,
        show_ranking_score_details=show_ranking_score_details,
        vector=vector,
        hybrid=hybrid,
        ranking_score_threshold=ranking_score_threshold,
        locales=locales,
    )
    search_url = f"{self._base_url_with_uid}/search"

    if self._pre_search_plugins:
        await AsyncIndex._run_plugins(
            self._pre_search_plugins,
            AsyncEvent.PRE,
            query=query,
            offset=offset,
            limit=limit,
            filter=filter,
            facets=facets,
            attributes_to_retrieve=attributes_to_retrieve,
            attributes_to_crop=attributes_to_crop,
            crop_length=crop_length,
            attributes_to_highlight=attributes_to_highlight,
            sort=sort,
            show_matches_position=show_matches_position,
            highlight_pre_tag=highlight_pre_tag,
            highlight_post_tag=highlight_post_tag,
            crop_marker=crop_marker,
            matching_strategy=matching_strategy,
            hits_per_page=hits_per_page,
            page=page,
            attributes_to_search_on=attributes_to_search_on,
            distinct=distinct,
            show_ranking_score=show_ranking_score,
            show_ranking_score_details=show_ranking_score_details,
            vector=vector,
            hybrid=hybrid,
        )

    if self._concurrent_search_plugins:
        if not use_task_groups():
            concurrent_tasks: Any = []
            for plugin in self._concurrent_search_plugins:
                if _plugin_has_method(plugin, "run_plugin"):
                    concurrent_tasks.append(
                        plugin.run_plugin(  # type: ignore[union-attr]
                            event=AsyncEvent.CONCURRENT,
                            query=query,
                            offset=offset,
                            limit=limit,
                            filter=filter,
                            facets=facets,
                            attributes_to_retrieve=attributes_to_retrieve,
                            attributes_to_crop=attributes_to_crop,
                            crop_length=crop_length,
                            attributes_to_highlight=attributes_to_highlight,
                            sort=sort,
                            show_matches_position=show_matches_position,
                            highlight_pre_tag=highlight_pre_tag,
                            highlight_post_tag=highlight_post_tag,
                            crop_marker=crop_marker,
                            matching_strategy=matching_strategy,
                            hits_per_page=hits_per_page,
                            page=page,
                            attributes_to_search_on=attributes_to_search_on,
                            distinct=distinct,
                            show_ranking_score=show_ranking_score,
                            show_ranking_score_details=show_ranking_score_details,
                            vector=vector,
                        )
                    )

            concurrent_tasks.append(self._http_requests.post(search_url, body=body))

            responses = await asyncio.gather(*concurrent_tasks)
            result = SearchResults[self.hits_type](**responses[-1].json())  # type: ignore[name-defined]
            if self._post_search_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_search_plugins, AsyncEvent.POST, search_results=result
                )
                if post.get("search_result"):
                    result = post["search_result"]

            return result

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            for plugin in self._concurrent_search_plugins:
                if _plugin_has_method(plugin, "run_plugin"):
                    tg.create_task(
                        plugin.run_plugin(  # type: ignore[union-attr]
                            event=AsyncEvent.CONCURRENT,
                            query=query,
                            offset=offset,
                            limit=limit,
                            filter=filter,
                            facets=facets,
                            attributes_to_retrieve=attributes_to_retrieve,
                            attributes_to_crop=attributes_to_crop,
                            crop_length=crop_length,
                            attributes_to_highlight=attributes_to_highlight,
                            sort=sort,
                            show_matches_position=show_matches_position,
                            highlight_pre_tag=highlight_pre_tag,
                            highlight_post_tag=highlight_post_tag,
                            crop_marker=crop_marker,
                            matching_strategy=matching_strategy,
                            hits_per_page=hits_per_page,
                            page=page,
                            attributes_to_search_on=attributes_to_search_on,
                            distinct=distinct,
                            show_ranking_score=show_ranking_score,
                            show_ranking_score_details=show_ranking_score_details,
                            vector=vector,
                        )
                    )

            response_coroutine = tg.create_task(self._http_requests.post(search_url, body=body))

        response = await response_coroutine
        result = SearchResults[self.hits_type](**response.json())  # type: ignore[name-defined]
        if self._post_search_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_search_plugins, AsyncEvent.POST, search_results=result
            )
            if post.get("search_result"):
                result = post["search_result"]

        return result

    response = await self._http_requests.post(search_url, body=body)
    result = SearchResults[self.hits_type](**response.json())  # type: ignore[name-defined]

    if self._post_search_plugins:
        post = await AsyncIndex._run_plugins(
            self._post_search_plugins, AsyncEvent.POST, search_results=result
        )
        if post.get("search_result"):
            result = post["search_result"]

    return result

search_similar_documents(id, *, offset=None, limit=None, filter=None, embedder='default', attributes_to_retrieve=None, show_ranking_score=False, show_ranking_score_details=False, ranking_score_threshold=None) async

Search the index.

Parameters:

Name	Type	Description	Default
id	str	The id for the target document that is being used to find similar documents.	required
offset	int | None	Number of documents to skip. Defaults to 0.	None
limit	int | None	Maximum number of documents returned. Defaults to 20.	None
filter	str | None	Filter queries by an attribute value. Defaults to None.	None
embedder	str	The vector DB to use for the search.	'default'
attributes_to_retrieve	list[str] | None	Attributes to display in the returned documents. Defaults to ["*"].	None
show_ranking_score	bool	If set to True the ranking score will be returned with each document in the search. Defaults to False.	False
show_ranking_score_details	bool	If set to True the ranking details will be returned with each document in the search. Defaults to False.	False
ranking_score_threshold	float | None	If set, no document whose _rankingScore is under the rankingScoreThreshold is returned. The value must be between 0.0 and 1.0. Defaults to None.	None

Returns:

Type	Description
SimilarSearchResults	Results of the search

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> search_results = await index.search_similar_documents("123")

Source code in meilisearch_python_sdk/index.py

async def search_similar_documents(
    self,
    id: str,
    *,
    offset: int | None = None,
    limit: int | None = None,
    filter: str | None = None,
    embedder: str = "default",
    attributes_to_retrieve: list[str] | None = None,
    show_ranking_score: bool = False,
    show_ranking_score_details: bool = False,
    ranking_score_threshold: float | None = None,
) -> SimilarSearchResults:
    """Search the index.

    Args:
        id: The id for the target document that is being used to find similar documents.
        offset: Number of documents to skip. Defaults to 0.
        limit: Maximum number of documents returned. Defaults to 20.
        filter: Filter queries by an attribute value. Defaults to None.
        embedder: The vector DB to use for the search.
        attributes_to_retrieve: Attributes to display in the returned documents.
            Defaults to ["*"].
        show_ranking_score: If set to True the ranking score will be returned with each document
            in the search. Defaults to False.
        show_ranking_score_details: If set to True the ranking details will be returned with
            each document in the search. Defaults to False.
        ranking_score_threshold: If set, no document whose _rankingScore is under the
            rankingScoreThreshold is returned. The value must be between 0.0 and 1.0. Defaults
            to None.

    Returns:
        Results of the search

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     search_results = await index.search_similar_documents("123")
    """
    payload = {
        "id": id,
        "filter": filter,
        "embedder": embedder,
        "attributesToRetrieve": attributes_to_retrieve,
        "showRankingScore": show_ranking_score,
        "showRankingScoreDetails": show_ranking_score_details,
        "rankingScoreThreshold": ranking_score_threshold,
    }

    if offset:
        payload["offset"] = offset

    if limit:
        payload["limit"] = limit

    response = await self._http_requests.post(
        f"{self._base_url_with_uid}/similar", body=payload
    )

    return SimilarSearchResults[self.hits_type](**response.json())  # type: ignore[name-defined]

update(primary_key) async

Update the index primary key.

Parameters:

Name	Type	Description	Default
primary_key	str	The primary key of the documents.	required

Returns:

Type	Description
Self	An instance of the AsyncIndex with the updated information.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> updated_index = await index.update()

Source code in meilisearch_python_sdk/index.py

async def update(self, primary_key: str) -> Self:
    """Update the index primary key.

    Args:
        primary_key: The primary key of the documents.

    Returns:
        An instance of the AsyncIndex with the updated information.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     updated_index = await index.update()
    """
    payload = {"primaryKey": primary_key}
    response = await self._http_requests.patch(self._base_url_with_uid, payload)
    await async_wait_for_task(
        self.http_client, response.json()["taskUid"], timeout_in_ms=100000
    )
    index_response = await self._http_requests.get(f"{self._base_url_with_uid}")
    self.primary_key = index_response.json()["primaryKey"]
    return self

update_displayed_attributes(body, *, compress=False) async

Update displayed attributes of the index.

Parameters:

Name	Type	Description	Default
body	list[str]	List containing the displayed attributes.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_displayed_attributes( >>> ["title", "description", "genre", "release_date"] >>> )

Source code in meilisearch_python_sdk/index.py

async def update_displayed_attributes(
    self, body: list[str], *, compress: bool = False
) -> TaskInfo:
    """Update displayed attributes of the index.

    Args:
        body: List containing the displayed attributes.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_displayed_attributes(
        >>>         ["title", "description", "genre", "release_date"]
        >>>     )
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/displayed-attributes", body, compress=compress
    )

    return TaskInfo(**response.json())

update_distinct_attribute(body, *, compress=False) async

Update distinct attribute of the index.

Parameters:

Name	Type	Description	Default
body	str	Distinct attribute.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_distinct_attribute("url")

Source code in meilisearch_python_sdk/index.py

async def update_distinct_attribute(self, body: str, *, compress: bool = False) -> TaskInfo:
    """Update distinct attribute of the index.

    Args:
        body: Distinct attribute.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_distinct_attribute("url")
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/distinct-attribute", body, compress=compress
    )

    return TaskInfo(**response.json())

update_documents(documents, primary_key=None, *, compress=False) async

Update documents in the index.

Parameters:

Name	Type	Description	Default
documents	Sequence[JsonMapping]	List of documents.	required
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> documents = [ >>> {"id": 1, "title": "Movie 1", "genre": "comedy"}, >>> {"id": 2, "title": "Movie 2", "genre": "drama"}, >>> ] >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_documents(documents)

Source code in meilisearch_python_sdk/index.py

async def update_documents(
    self,
    documents: Sequence[JsonMapping],
    primary_key: str | None = None,
    *,
    compress: bool = False,
) -> TaskInfo:
    """Update documents in the index.

    Args:
        documents: List of documents.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    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.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> documents = [
        >>>     {"id": 1, "title": "Movie 1", "genre": "comedy"},
        >>>     {"id": 2, "title": "Movie 2", "genre": "drama"},
        >>> ]
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_documents(documents)
    """
    if primary_key:
        url = _build_encoded_url(self._documents_url, {"primaryKey": primary_key})
    else:
        url = self._documents_url

    if self._pre_update_documents_plugins:
        pre = await AsyncIndex._run_plugins(
            self._pre_update_documents_plugins,
            AsyncEvent.PRE,
            documents=documents,
            primary_key=primary_key,
        )
        if pre.get("document_result"):
            documents = pre["document_result"]

    if self._concurrent_update_documents_plugins:
        if not use_task_groups():
            tasks: Any = []
            for plugin in self._concurrent_update_documents_plugins:
                if _plugin_has_method(plugin, "run_plugin"):
                    tasks.append(
                        plugin.run_plugin(  # type: ignore[union-attr]
                            event=AsyncEvent.CONCURRENT,
                            documents=documents,
                            primary_key=primary_key,
                        )
                    )
                if _plugin_has_method(plugin, "run_document_plugin"):
                    tasks.append(
                        plugin.run_document_plugin(  # type: ignore[union-attr]
                            event=AsyncEvent.CONCURRENT,
                            documents=documents,
                            primary_key=primary_key,
                        )
                    )

            tasks.append(self._http_requests.put(url, documents, compress=compress))

            responses = await asyncio.gather(*tasks)
            result = TaskInfo(**responses[-1].json())
            if self._post_update_documents_plugins:
                post = await AsyncIndex._run_plugins(
                    self._post_update_documents_plugins,
                    AsyncEvent.POST,
                    result=result,
                    documents=documents,
                    primary_key=primary_key,
                )
                if isinstance(post["generic_result"], TaskInfo):
                    result = post["generic_result"]

            return result

        async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
            for plugin in self._concurrent_update_documents_plugins:
                if _plugin_has_method(plugin, "run_plugin"):
                    tg.create_task(
                        plugin.run_plugin(  # type: ignore[union-attr]
                            event=AsyncEvent.CONCURRENT,
                            documents=documents,
                            primary_key=primary_key,
                        )
                    )
                if _plugin_has_method(plugin, "run_document_plugin"):
                    tg.create_task(
                        plugin.run_document_plugin(  # type: ignore[union-attr]
                            event=AsyncEvent.CONCURRENT,
                            documents=documents,
                            primary_key=primary_key,
                        )
                    )

            response_coroutine = tg.create_task(
                self._http_requests.put(url, documents, compress=compress)
            )

        response = await response_coroutine
        result = TaskInfo(**response.json())
        if self._post_update_documents_plugins:
            post = await AsyncIndex._run_plugins(
                self._post_update_documents_plugins,
                AsyncEvent.POST,
                result=result,
                documents=documents,
                primary_key=primary_key,
            )

            if isinstance(post["generic_result"], TaskInfo):
                result = post["generic_result"]

        return result

    response = await self._http_requests.put(url, documents, compress=compress)
    result = TaskInfo(**response.json())
    if self._post_update_documents_plugins:
        post = await AsyncIndex._run_plugins(
            self._post_update_documents_plugins,
            AsyncEvent.POST,
            result=result,
            documents=documents,
            primary_key=primary_key,
        )
        if isinstance(post["generic_result"], TaskInfo):
            result = post["generic_result"]

    return result

update_documents_from_directory(directory_path, *, primary_key=None, document_type='json', csv_delimiter=None, combine_documents=True, compress=False) async

Load all json files from a directory and update the documents.

Parameters:

Name	Type	Description	Default
directory_path	Path | str	Path to the directory that contains the json files.	required
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
document_type	str	The type of document being added. Accepted types are json, csv, and ndjson. For csv files the first row of the document should be a header row contining the field names, and ever for should have a title.	'json'
csv_delimiter	str | None	A single ASCII character to specify the delimiter for csv files. This can only be used if the file is a csv file. Defaults to comma.	None
combine_documents	bool	If set to True this will combine the documents from all the files before indexing them. Defaults to True.	True
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
list[TaskInfo]	The details of the task status.

Raises:

Type	Description
InvalidDocumentError	If the docucment is not a valid format for Meilisearch.
MeilisearchError	If the file path is not valid
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from pathlib import Path >>> from meilisearch_python_sdk import AsyncClient >>> directory_path = Path("/path/to/directory/containing/files") >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_documents_from_directory(directory_path)

Source code in meilisearch_python_sdk/index.py

async def update_documents_from_directory(
    self,
    directory_path: Path | str,
    *,
    primary_key: str | None = None,
    document_type: str = "json",
    csv_delimiter: str | None = None,
    combine_documents: bool = True,
    compress: bool = False,
) -> list[TaskInfo]:
    """Load all json files from a directory and update the documents.

    Args:
        directory_path: Path to the directory that contains the json files.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        document_type: The type of document being added. Accepted types are json, csv, and
            ndjson. For csv files the first row of the document should be a header row contining
            the field names, and ever for should have a title.
        csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
            can only be used if the file is a csv file. Defaults to comma.
        combine_documents: If set to True this will combine the documents from all the files
            before indexing them. Defaults to True.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        InvalidDocumentError: If the docucment is not a valid format for Meilisearch.
        MeilisearchError: If the file path is not valid
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from pathlib import Path
        >>> from meilisearch_python_sdk import AsyncClient
        >>> directory_path = Path("/path/to/directory/containing/files")
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_documents_from_directory(directory_path)
    """
    directory = Path(directory_path) if isinstance(directory_path, str) else directory_path

    if combine_documents:
        all_documents = []
        for path in directory.iterdir():
            if path.suffix == f".{document_type}":
                documents = await _async_load_documents_from_file(
                    path, csv_delimiter, json_handler=self._json_handler
                )
                all_documents.append(documents)

        _raise_on_no_documents(all_documents, document_type, directory_path)

        loop = asyncio.get_running_loop()
        combined = await loop.run_in_executor(None, partial(_combine_documents, all_documents))

        response = await self.update_documents(combined, primary_key, compress=compress)
        return [response]

    if not use_task_groups():
        update_documents = []
        for path in directory.iterdir():
            if path.suffix == f".{document_type}":
                documents = await _async_load_documents_from_file(
                    path, csv_delimiter, json_handler=self._json_handler
                )
                update_documents.append(
                    self.update_documents(documents, primary_key, compress=compress)
                )

        _raise_on_no_documents(update_documents, document_type, directory_path)

        if len(update_documents) > 1:
            # Send the first document on its own before starting the gather. Otherwise Meilisearch
            # returns an error because it thinks all entries are trying to create the same index.
            first_response = [await update_documents.pop()]
            responses = await asyncio.gather(*update_documents)
            responses = [*first_response, *responses]
        else:
            responses = [await update_documents[0]]

        return responses

    async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
        tasks = []
        results = []
        for i, path in enumerate(directory.iterdir()):
            if path.suffix == f".{document_type}":
                documents = await _async_load_documents_from_file(
                    path, csv_delimiter, json_handler=self._json_handler
                )
                if i == 0:
                    results = [
                        await self.update_documents(documents, primary_key, compress=compress)
                    ]
                else:
                    tasks.append(
                        tg.create_task(
                            self.update_documents(documents, primary_key, compress=compress)
                        )
                    )

    results = [*results, *[x.result() for x in tasks]]
    _raise_on_no_documents(results, document_type, directory_path)
    return results

update_documents_from_directory_in_batches(directory_path, *, batch_size=1000, primary_key=None, document_type='json', csv_delimiter=None, combine_documents=True, compress=False, concurrency_limit=None) async

Load all json files from a directory and update the documents.

Parameters:

Name	Type	Description	Default
directory_path	Path | str	Path to the directory that contains the json files.	required
batch_size	int	The number of documents that should be included in each batch. Defaults to 1000.	1000
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
document_type	str	The type of document being added. Accepted types are json, csv, and ndjson. For csv files the first row of the document should be a header row contining the field names, and ever for should have a title.	'json'
csv_delimiter	str | None	A single ASCII character to specify the delimiter for csv files. This can only be used if the file is a csv file. Defaults to comma.	None
combine_documents	bool	If set to True this will combine the documents from all the files before indexing them. Defaults to True.	True
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False
concurrency_limit	int | None	If set this will limit the number of batches that will be sent concurrently. This can be helpful if you find you are overloading the Meilisearch server with requests. Defaults to None.	None

Returns:

Type	Description
list[TaskInfo]	List of update ids to track the action.

Raises:

Type	Description
InvalidDocumentError	If the docucment is not a valid format for Meilisearch.
MeilisearchError	If the file path is not valid
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from pathlib import Path >>> from meilisearch_python_sdk import AsyncClient >>> directory_path = Path("/path/to/directory/containing/files") >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_documents_from_directory_in_batches(directory_path)

Source code in meilisearch_python_sdk/index.py

async def update_documents_from_directory_in_batches(
    self,
    directory_path: Path | str,
    *,
    batch_size: int = 1000,
    primary_key: str | None = None,
    document_type: str = "json",
    csv_delimiter: str | None = None,
    combine_documents: bool = True,
    compress: bool = False,
    concurrency_limit: int | None = None,
) -> list[TaskInfo]:
    """Load all json files from a directory and update the documents.

    Args:
        directory_path: Path to the directory that contains the json files.
        batch_size: The number of documents that should be included in each batch.
            Defaults to 1000.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        document_type: The type of document being added. Accepted types are json, csv, and
            ndjson. For csv files the first row of the document should be a header row contining
            the field names, and ever for should have a title.
        csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
            can only be used if the file is a csv file. Defaults to comma.
        combine_documents: If set to True this will combine the documents from all the files
            before indexing them. Defaults to True.
        compress: If set to True the data will be sent in gzip format. Defaults to False.
        concurrency_limit: If set this will limit the number of batches that will be sent
            concurrently. This can be helpful if you find you are overloading the Meilisearch
            server with requests. Defaults to None.

    Returns:
        List of update ids to track the action.

    Raises:
        InvalidDocumentError: If the docucment is not a valid format for Meilisearch.
        MeilisearchError: If the file path is not valid
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from pathlib import Path
        >>> from meilisearch_python_sdk import AsyncClient
        >>> directory_path = Path("/path/to/directory/containing/files")
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_documents_from_directory_in_batches(directory_path)
    """
    directory = Path(directory_path) if isinstance(directory_path, str) else directory_path

    if combine_documents:
        all_documents = []
        for path in directory.iterdir():
            if path.suffix == f".{document_type}":
                documents = await _async_load_documents_from_file(
                    path, csv_delimiter, json_handler=self._json_handler
                )
                all_documents.append(documents)

        _raise_on_no_documents(all_documents, document_type, directory_path)

        loop = asyncio.get_running_loop()
        combined = await loop.run_in_executor(None, partial(_combine_documents, all_documents))

        return await self.update_documents_in_batches(
            combined,
            batch_size=batch_size,
            primary_key=primary_key,
            compress=compress,
            concurrency_limit=concurrency_limit,
        )

    if not use_task_groups():
        responses: list[TaskInfo] = []

        update_documents = []
        for path in directory.iterdir():
            if path.suffix == f".{document_type}":
                documents = await _async_load_documents_from_file(
                    path, csv_delimiter, json_handler=self._json_handler
                )
                update_documents.append(
                    self.update_documents_in_batches(
                        documents,
                        batch_size=batch_size,
                        primary_key=primary_key,
                        compress=compress,
                        concurrency_limit=concurrency_limit,
                    )
                )

        _raise_on_no_documents(update_documents, document_type, directory_path)

        if len(update_documents) > 1:
            # Send the first document on its own before starting the gather. Otherwise Meilisearch
            # returns an error because it thinks all entries are trying to create the same index.
            first_response = await update_documents.pop()
            responses_gather = await asyncio.gather(*update_documents)
            responses = [*first_response, *[x for y in responses_gather for x in y]]
        else:
            responses = await update_documents[0]

        return responses

    async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
        results = []
        tasks = []
        for i, path in enumerate(directory.iterdir()):
            if path.suffix == f".{document_type}":
                documents = await _async_load_documents_from_file(
                    path, csv_delimiter, json_handler=self._json_handler
                )
                if i == 0:
                    results = await self.update_documents_in_batches(
                        documents,
                        batch_size=batch_size,
                        primary_key=primary_key,
                        compress=compress,
                        concurrency_limit=concurrency_limit,
                    )
                else:
                    tasks.append(
                        tg.create_task(
                            self.update_documents_in_batches(
                                documents,
                                batch_size=batch_size,
                                primary_key=primary_key,
                                compress=compress,
                                concurrency_limit=concurrency_limit,
                            )
                        )
                    )

    results = [*results, *[x for y in tasks for x in y.result()]]
    _raise_on_no_documents(results, document_type, directory_path)
    return results

update_documents_from_file(file_path, primary_key=None, csv_delimiter=None, *, compress=False) async

Add documents in the index from a json file.

Parameters:

Name	Type	Description	Default
file_path	Path | str	Path to the json file.	required
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
csv_delimiter	str | None	A single ASCII character to specify the delimiter for csv files. This can only be used if the file is a csv file. Defaults to comma.	None
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from pathlib import Path >>> from meilisearch_python_sdk import AsyncClient >>> file_path = Path("/path/to/file.json") >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_documents_from_file(file_path)

Source code in meilisearch_python_sdk/index.py

async def update_documents_from_file(
    self,
    file_path: Path | str,
    primary_key: str | None = None,
    csv_delimiter: str | None = None,
    *,
    compress: bool = False,
) -> TaskInfo:
    """Add documents in the index from a json file.

    Args:
        file_path: Path to the json file.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
            can only be used if the file is a csv file. Defaults to comma.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from pathlib import Path
        >>> from meilisearch_python_sdk import AsyncClient
        >>> file_path = Path("/path/to/file.json")
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_documents_from_file(file_path)
    """
    documents = await _async_load_documents_from_file(
        file_path, csv_delimiter, json_handler=self._json_handler
    )

    return await self.update_documents(documents, primary_key=primary_key, compress=compress)

update_documents_from_file_in_batches(file_path, *, batch_size=1000, primary_key=None, compress=False, concurrency_limit=None) async

Updates documents form a json file in batches to reduce RAM usage with indexing.

Parameters:

Name	Type	Description	Default
file_path	Path | str	Path to the json file.	required
batch_size	int	The number of documents that should be included in each batch. Defaults to 1000.	1000
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False
concurrency_limit	int | None	If set this will limit the number of batches that will be sent concurrently. This can be helpful if you find you are overloading the Meilisearch server with requests. Defaults to None.	None

Returns:

Type	Description
list[TaskInfo]	List of update ids to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from pathlib import Path >>> from meilisearch_python_sdk import AsyncClient >>> file_path = Path("/path/to/file.json") >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_documents_from_file_in_batches(file_path)

Source code in meilisearch_python_sdk/index.py

async def update_documents_from_file_in_batches(
    self,
    file_path: Path | str,
    *,
    batch_size: int = 1000,
    primary_key: str | None = None,
    compress: bool = False,
    concurrency_limit: int | None = None,
) -> list[TaskInfo]:
    """Updates documents form a json file in batches to reduce RAM usage with indexing.

    Args:
        file_path: Path to the json file.
        batch_size: The number of documents that should be included in each batch.
            Defaults to 1000.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        compress: If set to True the data will be sent in gzip format. Defaults to False.
        concurrency_limit: If set this will limit the number of batches that will be sent
            concurrently. This can be helpful if you find you are overloading the Meilisearch
            server with requests. Defaults to None.

    Returns:
        List of update ids to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from pathlib import Path
        >>> from meilisearch_python_sdk import AsyncClient
        >>> file_path = Path("/path/to/file.json")
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_documents_from_file_in_batches(file_path)
    """
    documents = await _async_load_documents_from_file(
        file_path, json_handler=self._json_handler
    )

    return await self.update_documents_in_batches(
        documents,
        batch_size=batch_size,
        primary_key=primary_key,
        compress=compress,
        concurrency_limit=concurrency_limit,
    )

update_documents_from_raw_file(file_path, primary_key=None, csv_delimiter=None, *, compress=False) async

Directly send csv or ndjson files to Meilisearch without pre-processing.

The can reduce RAM usage from Meilisearch during indexing, but does not include the option for batching.

Parameters:

Name	Type	Description	Default
file_path	Path | str	The path to the file to send to Meilisearch. Only csv and ndjson files are allowed.	required
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
csv_delimiter	str | None	A single ASCII character to specify the delimiter for csv files. This can only be used if the file is a csv file. Defaults to comma.	None
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
ValueError	If the file is not a csv or ndjson file, or if a csv_delimiter is sent for a non-csv file.
MeilisearchError	If the file path is not valid
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from pathlib import Path >>> from meilisearch_python_sdk import AsyncClient >>> file_path = Path("/path/to/file.csv") >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_documents_from_raw_file(file_path)

Source code in meilisearch_python_sdk/index.py

async def update_documents_from_raw_file(
    self,
    file_path: Path | str,
    primary_key: str | None = None,
    csv_delimiter: str | None = None,
    *,
    compress: bool = False,
) -> TaskInfo:
    """Directly send csv or ndjson files to Meilisearch without pre-processing.

    The can reduce RAM usage from Meilisearch during indexing, but does not include the option
    for batching.

    Args:
        file_path: The path to the file to send to Meilisearch. Only csv and ndjson files are
            allowed.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        csv_delimiter: A single ASCII character to specify the delimiter for csv files. This
            can only be used if the file is a csv file. Defaults to comma.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        ValueError: If the file is not a csv or ndjson file, or if a csv_delimiter is sent for
            a non-csv file.
        MeilisearchError: If the file path is not valid
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from pathlib import Path
        >>> from meilisearch_python_sdk import AsyncClient
        >>> file_path = Path("/path/to/file.csv")
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_documents_from_raw_file(file_path)
    """
    upload_path = Path(file_path) if isinstance(file_path, str) else file_path
    if not upload_path.exists():
        raise MeilisearchError("No file found at the specified path")

    if upload_path.suffix not in (".csv", ".ndjson"):
        raise ValueError("Only csv and ndjson files can be sent as binary files")

    if csv_delimiter and upload_path.suffix != ".csv":
        raise ValueError("A csv_delimiter can only be used with csv files")

    if (
        csv_delimiter
        and len(csv_delimiter) != 1
        or csv_delimiter
        and not csv_delimiter.isascii()
    ):
        raise ValueError("csv_delimiter must be a single ascii character")

    content_type = "text/csv" if upload_path.suffix == ".csv" else "application/x-ndjson"
    parameters = {}

    if primary_key:
        parameters["primaryKey"] = primary_key
    if csv_delimiter:
        parameters["csvDelimiter"] = csv_delimiter

    if parameters:
        url = _build_encoded_url(self._documents_url, parameters)
    else:
        url = self._documents_url

    async with aiofiles.open(upload_path) as f:
        data = await f.read()

    response = await self._http_requests.put(
        url, body=data, content_type=content_type, compress=compress
    )

    return TaskInfo(**response.json())

update_documents_in_batches(documents, *, batch_size=1000, primary_key=None, compress=False, concurrency_limit=None) async

Update documents in batches to reduce RAM usage with indexing.

Each batch tries to fill the max_payload_size

Parameters:

Name	Type	Description	Default
documents	Sequence[JsonMapping]	List of documents.	required
batch_size	int	The number of documents that should be included in each batch. Defaults to 1000.	1000
primary_key	str | None	The primary key of the documents. This will be ignored if already set. Defaults to None.	None
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False
concurrency_limit	int | None	If set this will limit the number of batches that will be sent concurrently. This can be helpful if you find you are overloading the Meilisearch server with requests. Defaults to None.	None

Returns:

Type	Description
list[TaskInfo]	List of update ids to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> documents = [ >>> {"id": 1, "title": "Movie 1", "genre": "comedy"}, >>> {"id": 2, "title": "Movie 2", "genre": "drama"}, >>> ] >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_documents_in_batches(documents)

Source code in meilisearch_python_sdk/index.py

async def update_documents_in_batches(
    self,
    documents: Sequence[JsonMapping],
    *,
    batch_size: int = 1000,
    primary_key: str | None = None,
    compress: bool = False,
    concurrency_limit: int | None = None,
) -> list[TaskInfo]:
    """Update documents in batches to reduce RAM usage with indexing.

    Each batch tries to fill the max_payload_size

    Args:
        documents: List of documents.
        batch_size: The number of documents that should be included in each batch.
            Defaults to 1000.
        primary_key: The primary key of the documents. This will be ignored if already set.
            Defaults to None.
        compress: If set to True the data will be sent in gzip format. Defaults to False.
        concurrency_limit: If set this will limit the number of batches that will be sent
            concurrently. This can be helpful if you find you are overloading the Meilisearch
            server with requests. Defaults to None.

    Returns:
        List of update ids to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> documents = [
        >>>     {"id": 1, "title": "Movie 1", "genre": "comedy"},
        >>>     {"id": 2, "title": "Movie 2", "genre": "drama"},
        >>> ]
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_documents_in_batches(documents)
    """
    if concurrency_limit:
        async with asyncio.Semaphore(concurrency_limit):
            if not use_task_groups():
                batches = [
                    self.update_documents(x, primary_key, compress=compress)
                    for x in _batch(documents, batch_size)
                ]
                return await asyncio.gather(*batches)

            async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
                tasks = [
                    tg.create_task(self.update_documents(x, primary_key, compress=compress))
                    for x in _batch(documents, batch_size)
                ]
            return [x.result() for x in tasks]

    if not use_task_groups():
        batches = [
            self.update_documents(x, primary_key, compress=compress)
            for x in _batch(documents, batch_size)
        ]
        return await asyncio.gather(*batches)

    async with asyncio.TaskGroup() as tg:  # type: ignore[attr-defined]
        tasks = [
            tg.create_task(self.update_documents(x, primary_key, compress=compress))
            for x in _batch(documents, batch_size)
        ]
    return [x.result() for x in tasks]

update_embedders(embedders, *, compress=False) async

Update the embedders settings for an index.

Parameters:

Name	Type	Description	Default
embedders	Embedders	The embedders value.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	Task to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> from meilisearch_python_sdk.models.settings import Embedders, UserProvidedEmbedder >>> >>> >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_embedders( >>> Embedders(embedders={"default": UserProvidedEmbedder(dimensions=512)}) >>> )

Source code in meilisearch_python_sdk/index.py

async def update_embedders(self, embedders: Embedders, *, compress: bool = False) -> TaskInfo:
    """Update the embedders settings for an index.

    Args:
        embedders: The embedders value.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        Task to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> from meilisearch_python_sdk.models.settings import Embedders, UserProvidedEmbedder
        >>>
        >>>
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_embedders(
        >>>         Embedders(embedders={"default": UserProvidedEmbedder(dimensions=512)})
        >>>     )
    """
    payload = {}
    for key, embedder in embedders.embedders.items():
        payload[key] = {
            k: v
            for k, v in embedder.model_dump(by_alias=True, exclude_none=True).items()
            if v is not None
        }

    response = await self._http_requests.patch(
        f"{self._settings_url}/embedders", payload, compress=compress
    )

    return TaskInfo(**response.json())

update_faceting(faceting, *, compress=False) async

Partially update the faceting settings for an index.

Parameters:

Name	Type	Description	Default
faceting	Faceting	Faceting values.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	Task to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_faceting(faceting=Faceting(max_values_per_facet=100))

Source code in meilisearch_python_sdk/index.py

async def update_faceting(self, faceting: Faceting, *, compress: bool = False) -> TaskInfo:
    """Partially update the faceting settings for an index.

    Args:
        faceting: Faceting values.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        Task to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_faceting(faceting=Faceting(max_values_per_facet=100))
    """
    response = await self._http_requests.patch(
        f"{self._settings_url}/faceting",
        faceting.model_dump(by_alias=True),
        compress=compress,
    )

    return TaskInfo(**response.json())

update_filterable_attributes(body, *, compress=False) async

Update filterable attributes of the index.

Parameters:

Name	Type	Description	Default
body	list[str]	List containing the filterable attributes of the index.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_filterable_attributes(["genre", "director"])

Source code in meilisearch_python_sdk/index.py

async def update_filterable_attributes(
    self, body: list[str], *, compress: bool = False
) -> TaskInfo:
    """Update filterable attributes of the index.

    Args:
        body: List containing the filterable attributes of the index.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_filterable_attributes(["genre", "director"])
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/filterable-attributes", body, compress=compress
    )

    return TaskInfo(**response.json())

update_localized_attributes(localized_attributes, *, compress=False) async

Update the localized attributes settings for an index.

Parameters:

Name	Type	Description	Default
localized_attributes	list[LocalizedAttributes]	The localized attributes value.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	Task to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> from meilisearch_python_sdk.models.settings import LocalizedAttributes >>> >>> >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_localized_attributes([ >>> LocalizedAttributes(locales=["eng", "spa"], attribute_patterns=[""]), >>> LocalizedAttributes(locales=["ita"], attribute_patterns=["_it"]), >>> ])

Source code in meilisearch_python_sdk/index.py

async def update_localized_attributes(
    self, localized_attributes: list[LocalizedAttributes], *, compress: bool = False
) -> TaskInfo:
    """Update the localized attributes settings for an index.

    Args:
        localized_attributes: The localized attributes value.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        Task to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> from meilisearch_python_sdk.models.settings import LocalizedAttributes
        >>>
        >>>
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_localized_attributes([
        >>>         LocalizedAttributes(locales=["eng", "spa"], attribute_patterns=["*"]),
        >>>         LocalizedAttributes(locales=["ita"], attribute_patterns=["*_it"]),
        >>>     ])
    """
    payload = [x.model_dump(by_alias=True) for x in localized_attributes]
    response = await self._http_requests.put(
        f"{self._settings_url}/localized-attributes", payload, compress=compress
    )

    return TaskInfo(**response.json())

update_non_separator_tokens(non_separator_tokens, *, compress=False) async

Update the non-separator tokens settings for an index.

Parameters:

Name	Type	Description	Default
non_separator_tokens	list[str]	List of non-separator tokens.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	Task to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_non_separator_tokens(non_separator_tokens=["@", "#")

Source code in meilisearch_python_sdk/index.py

async def update_non_separator_tokens(
    self, non_separator_tokens: list[str], *, compress: bool = False
) -> TaskInfo:
    """Update the non-separator tokens settings for an index.

    Args:
        non_separator_tokens: List of non-separator tokens.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        Task to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_non_separator_tokens(non_separator_tokens=["@", "#")
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/non-separator-tokens", non_separator_tokens, compress=compress
    )

    return TaskInfo(**response.json())

update_pagination(settings, *, compress=False) async

Partially update the pagination settings for an index.

Parameters:

Name	Type	Description	Default
settings	Pagination	settings for pagination.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	Task to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> from meilisearch_python_sdk.models.settings import Pagination >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_pagination(settings=Pagination(max_total_hits=123))

Source code in meilisearch_python_sdk/index.py

async def update_pagination(self, settings: Pagination, *, compress: bool = False) -> TaskInfo:
    """Partially update the pagination settings for an index.

    Args:
        settings: settings for pagination.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        Task to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> from meilisearch_python_sdk.models.settings import Pagination
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_pagination(settings=Pagination(max_total_hits=123))
    """
    response = await self._http_requests.patch(
        f"{self._settings_url}/pagination",
        settings.model_dump(by_alias=True),
        compress=compress,
    )

    return TaskInfo(**response.json())

update_proximity_precision(proximity_precision, *, compress=False) async

Update the proximity precision settings for an index.

Parameters:

Name	Type	Description	Default
proximity_precision	ProximityPrecision	The proximity precision value.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	Task to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> from meilisearch_python_sdk.models.settings import ProximityPrecision >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_proximity_precision(ProximityPrecision.BY_ATTRIBUTE)

Source code in meilisearch_python_sdk/index.py

async def update_proximity_precision(
    self, proximity_precision: ProximityPrecision, *, compress: bool = False
) -> TaskInfo:
    """Update the proximity precision settings for an index.

    Args:
        proximity_precision: The proximity precision value.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        Task to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> from meilisearch_python_sdk.models.settings import ProximityPrecision
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_proximity_precision(ProximityPrecision.BY_ATTRIBUTE)
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/proximity-precision",
        proximity_precision.value,
        compress=compress,
    )

    return TaskInfo(**response.json())

update_ranking_rules(ranking_rules, *, compress=False) async

Update ranking rules of the index.

Parameters:

Name	Type	Description	Default
ranking_rules	list[str]	List containing the ranking rules.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> ranking_rules=[ >>> "words", >>> "typo", >>> "proximity", >>> "attribute", >>> "sort", >>> "exactness", >>> "release_date:desc", >>> "rank:desc", >>> ], >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_ranking_rules(ranking_rules)

Source code in meilisearch_python_sdk/index.py

async def update_ranking_rules(
    self, ranking_rules: list[str], *, compress: bool = False
) -> TaskInfo:
    """Update ranking rules of the index.

    Args:
        ranking_rules: List containing the ranking rules.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> ranking_rules=[
        >>>      "words",
        >>>      "typo",
        >>>      "proximity",
        >>>      "attribute",
        >>>      "sort",
        >>>      "exactness",
        >>>      "release_date:desc",
        >>>      "rank:desc",
        >>> ],
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_ranking_rules(ranking_rules)
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/ranking-rules", ranking_rules, compress=compress
    )

    return TaskInfo(**response.json())

update_search_cutoff_ms(search_cutoff_ms, *, compress=False) async

Update the search cutoff for an index.

Parameters:

Name	Type	Description	Default
search_cutoff_ms	int	Integer value of the search cutoff time in ms.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_search_cutoff_ms(100)

Source code in meilisearch_python_sdk/index.py

async def update_search_cutoff_ms(
    self, search_cutoff_ms: int, *, compress: bool = False
) -> TaskInfo:
    """Update the search cutoff for an index.

    Args:
        search_cutoff_ms: Integer value of the search cutoff time in ms.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_search_cutoff_ms(100)
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/search-cutoff-ms", search_cutoff_ms, compress=compress
    )

    return TaskInfo(**response.json())

update_searchable_attributes(body, *, compress=False) async

Update searchable attributes of the index.

Parameters:

Name	Type	Description	Default
body	list[str]	List containing the searchable attributes.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_searchable_attributes(["title", "description", "genre"])

Source code in meilisearch_python_sdk/index.py

async def update_searchable_attributes(
    self, body: list[str], *, compress: bool = False
) -> TaskInfo:
    """Update searchable attributes of the index.

    Args:
        body: List containing the searchable attributes.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_searchable_attributes(["title", "description", "genre"])
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/searchable-attributes", body, compress=compress
    )

    return TaskInfo(**response.json())

update_separator_tokens(separator_tokens, *, compress=False) async

Update the separator tokens settings for an index.

Parameters:

Name	Type	Description	Default
separator_tokens	list[str]	List of separator tokens.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	Task to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_separator_tokens(separator_tokenes=["|", "/")

Source code in meilisearch_python_sdk/index.py

async def update_separator_tokens(
    self, separator_tokens: list[str], *, compress: bool = False
) -> TaskInfo:
    """Update the separator tokens settings for an index.

    Args:
        separator_tokens: List of separator tokens.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        Task to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_separator_tokens(separator_tokenes=["|", "/")
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/separator-tokens", separator_tokens, compress=compress
    )

    return TaskInfo(**response.json())

update_settings(body, *, compress=False) async

Update settings of the index.

Parameters:

Name	Type	Description	Default
body	MeilisearchSettings	Settings of the index.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> from meilisearch_python_sdk import MeilisearchSettings >>> new_settings = MeilisearchSettings( >>> synonyms={"wolverine": ["xmen", "logan"], "logan": ["wolverine"]}, >>> stop_words=["the", "a", "an"], >>> ranking_rules=[ >>> "words", >>> "typo", >>> "proximity", >>> "attribute", >>> "sort", >>> "exactness", >>> "release_date:desc", >>> "rank:desc", >>> ], >>> filterable_attributes=["genre", "director"], >>> distinct_attribute="url", >>> searchable_attributes=["title", "description", "genre"], >>> displayed_attributes=["title", "description", "genre", "release_date"], >>> sortable_attributes=["title", "release_date"], >>> ) >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_settings(new_settings)

Source code in meilisearch_python_sdk/index.py

async def update_settings(
    self, body: MeilisearchSettings, *, compress: bool = False
) -> TaskInfo:
    """Update settings of the index.

    Args:
        body: Settings of the index.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> from meilisearch_python_sdk import MeilisearchSettings
        >>> new_settings = MeilisearchSettings(
        >>>     synonyms={"wolverine": ["xmen", "logan"], "logan": ["wolverine"]},
        >>>     stop_words=["the", "a", "an"],
        >>>     ranking_rules=[
        >>>         "words",
        >>>         "typo",
        >>>         "proximity",
        >>>         "attribute",
        >>>         "sort",
        >>>         "exactness",
        >>>         "release_date:desc",
        >>>         "rank:desc",
        >>>    ],
        >>>    filterable_attributes=["genre", "director"],
        >>>    distinct_attribute="url",
        >>>    searchable_attributes=["title", "description", "genre"],
        >>>    displayed_attributes=["title", "description", "genre", "release_date"],
        >>>    sortable_attributes=["title", "release_date"],
        >>> )
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_settings(new_settings)
    """
    body_dict = {
        k: v
        for k, v in body.model_dump(by_alias=True, exclude_none=True).items()
        if v is not None
    }
    response = await self._http_requests.patch(self._settings_url, body_dict, compress=compress)

    return TaskInfo(**response.json())

update_sortable_attributes(sortable_attributes, *, compress=False) async

Get sortable attributes of the AsyncIndex.

Parameters:

Name	Type	Description	Default
sortable_attributes	list[str]	List of attributes for searching.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_sortable_attributes(["title", "release_date"])

Source code in meilisearch_python_sdk/index.py

async def update_sortable_attributes(
    self, sortable_attributes: list[str], *, compress: bool = False
) -> TaskInfo:
    """Get sortable attributes of the AsyncIndex.

    Args:
        sortable_attributes: List of attributes for searching.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_sortable_attributes(["title", "release_date"])
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/sortable-attributes", sortable_attributes, compress=compress
    )

    return TaskInfo(**response.json())

update_stop_words(body, *, compress=False) async

Update stop words of the index.

Parameters:

Name	Type	Description	Default
body	list[str]	List containing the stop words of the index.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_stop_words(["the", "a", "an"])

Source code in meilisearch_python_sdk/index.py

async def update_stop_words(self, body: list[str], *, compress: bool = False) -> TaskInfo:
    """Update stop words of the index.

    Args:
        body: List containing the stop words of the index.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_stop_words(["the", "a", "an"])
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/stop-words", body, compress=compress
    )

    return TaskInfo(**response.json())

update_synonyms(body, *, compress=False) async

Update synonyms of the index.

Parameters:

Name	Type	Description	Default
body	dict[str, list[str]]	The synonyms of the index.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	The details of the task status.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_synonyms( >>> {"wolverine": ["xmen", "logan"], "logan": ["wolverine"]} >>> )

Source code in meilisearch_python_sdk/index.py

async def update_synonyms(
    self, body: dict[str, list[str]], *, compress: bool = False
) -> TaskInfo:
    """Update synonyms of the index.

    Args:
        body: The synonyms of the index.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        The details of the task status.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_synonyms(
        >>>         {"wolverine": ["xmen", "logan"], "logan": ["wolverine"]}
        >>>     )
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/synonyms", body, compress=compress
    )

    return TaskInfo(**response.json())

update_typo_tolerance(typo_tolerance, *, compress=False) async

Update typo tolerance.

Parameters:

Name	Type	Description	Default
typo_tolerance	TypoTolerance	Typo tolerance settings.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	Task to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> TypoTolerance(enabled=False) >>> await index.update_typo_tolerance()

Source code in meilisearch_python_sdk/index.py

async def update_typo_tolerance(
    self, typo_tolerance: TypoTolerance, *, compress: bool = False
) -> TaskInfo:
    """Update typo tolerance.

    Args:
        typo_tolerance: Typo tolerance settings.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        Task to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     TypoTolerance(enabled=False)
        >>>     await index.update_typo_tolerance()
    """
    response = await self._http_requests.patch(
        f"{self._settings_url}/typo-tolerance",
        typo_tolerance.model_dump(by_alias=True),
        compress=compress,
    )

    return TaskInfo(**response.json())

update_word_dictionary(dictionary, *, compress=False) async

Update the word dictionary settings for an index.

Parameters:

Name	Type	Description	Default
dictionary	list[str]	List of dictionary values.	required
compress	bool	If set to True the data will be sent in gzip format. Defaults to False.	False

Returns:

Type	Description
TaskInfo	Task to track the action.

Raises:

Type	Description
MeilisearchCommunicationError	If there was an error communicating with the server.
MeilisearchApiError	If the Meilisearch API returned an error.

Examples >>> from meilisearch_python_sdk import AsyncClient >>> async with AsyncClient("http://localhost.com", "masterKey") as client: >>> index = client.index("movies") >>> await index.update_word_dictionary(dictionary=["S.O.S", "S.O")

Source code in meilisearch_python_sdk/index.py

async def update_word_dictionary(
    self, dictionary: list[str], *, compress: bool = False
) -> TaskInfo:
    """Update the word dictionary settings for an index.

    Args:
        dictionary: List of dictionary values.
        compress: If set to True the data will be sent in gzip format. Defaults to False.

    Returns:
        Task to track the action.

    Raises:
        MeilisearchCommunicationError: If there was an error communicating with the server.
        MeilisearchApiError: If the Meilisearch API returned an error.

    Examples
        >>> from meilisearch_python_sdk import AsyncClient
        >>> async with AsyncClient("http://localhost.com", "masterKey") as client:
        >>>     index = client.index("movies")
        >>>     await index.update_word_dictionary(dictionary=["S.O.S", "S.O")
    """
    response = await self._http_requests.put(
        f"{self._settings_url}/dictionary", dictionary, compress=compress
    )

    return TaskInfo(**response.json())