Merge branch 'meilisearch:main' into make-task-results-from-optional

Author: ddboline

.github/release-draft-template.yml

@@ -31,10 +31,6 @@ replacers:
     replace: ''
   - search: '/(?:and )?@dependabot(?:\[bot\])?,?/g'
     replace: ''
-  - search: '/(?:and )?@bors(?:\[bot\])?,?/g'
-    replace: ''
-  - search: '/(?:and )?@meili-bors(?:\[bot\])?,?/g'
-    replace: ''
   - search: '/(?:and )?@meili-bot,?/g'
     replace: ''
   - search: '/(?:and )?@meili-bot(?:\[bot\])?,?/g'

.github/workflows/tests.yml

@@ -3,10 +3,7 @@ name: Tests
 on:
   pull_request:
   push:
-    # trying and staging branches are for BORS config
     branches:
-      - trying
-      - staging
       - main
   merge_group:
 

CONTRIBUTING.md

@@ -108,19 +108,14 @@ Some notes on GitHub PRs:
 
 - [Convert your PR as a draft](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/changing-the-stage-of-a-pull-request) if your changes are a work in progress: no one will review it until you pass your PR as ready for review.<br>
   The draft PR can be very useful if you want to show that you are working on something and make your work visible.
-- The branch related to the PR must be **up-to-date with `main`** before merging. Fortunately, this project [integrates a bot](https://github.com/meilisearch/integration-guides/blob/main/resources/bors.md) to automatically enforce this requirement without the PR author having to do it manually.
+- The branch related to the PR must be **up-to-date with `main`** before merging.
 - All PRs must be reviewed and approved by at least one maintainer.
 - The PR title should be accurate and descriptive of the changes. The title of the PR will be indeed automatically added to the next [release changelogs](https://github.com/meilisearch/meilisearch-python/releases/).
 
 ## Release Process (for the internal team only)
 
 Meilisearch tools follow the [Semantic Versioning Convention](https://semver.org/).
 
-### Automation to Rebase and Merge the PRs <!-- omit in toc -->
-
-This project integrates a bot that helps us manage pull requests merging.<br>
-_[Read more about this](https://github.com/meilisearch/integration-guides/blob/main/resources/bors.md)._
-
 ### Automated Changelogs <!-- omit in toc -->
 
 This project integrates a tool to create automated changelogs.<br>

README.md

@@ -18,7 +18,6 @@
   <a href="https://badge.fury.io/py/meilisearch"><img src="https://badge.fury.io/py/meilisearch.svg" alt="PyPI version"></a>
   <a href="https://github.com/meilisearch/meilisearch-python/actions"><img src="https://github.com/meilisearch/meilisearch-python/workflows/Tests/badge.svg" alt="Test Status"></a>
   <a href="https://github.com/meilisearch/meilisearch-python/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-informational" alt="License"></a>
-  <a href="https://ms-bors.herokuapp.com/repositories/57"><img src="https://bors.tech/images/badge_small.svg" alt="Bors enabled"></a>
 </p>
 
 <p align="center">⚡ The Meilisearch API client written for Python 🐍</p>

bors.toml

@@ -146,6 +146,72 @@ def delete(
     ) -> Any:
         return self.send_request(requests.delete, path, body)
 
+    def post_stream(
+        self,
+        path: str,
+        body: Optional[
+            Union[Mapping[str, Any], Sequence[Mapping[str, Any]], List[str], bytes, str]
+        ] = None,
+        content_type: Optional[str] = "application/json",
+        *,
+        serializer: Optional[Type[json.JSONEncoder]] = None,
+    ) -> requests.Response:
+        """Send a POST request with streaming enabled.
+
+        Returns the raw response object for streaming consumption.
+        """
+        if content_type:
+            self.headers["Content-Type"] = content_type
+        try:
+            request_path = self.config.url + "/" + path
+
+            if isinstance(body, bytes):
+                response = requests.post(
+                    request_path,
+                    timeout=self.config.timeout,
+                    headers=self.headers,
+                    data=body,
+                    stream=True,
+                )
+            else:
+                serialize_body = isinstance(body, dict) or body
+                data = (
+                    json.dumps(body, cls=serializer)
+                    if isinstance(body, bool) or serialize_body
+                    else "" if body == "" else "null"
+                )
+
+                response = requests.post(
+                    request_path,
+                    timeout=self.config.timeout,
+                    headers=self.headers,
+                    data=data,
+                    stream=True,
+                )
+
+            # For streaming responses, we validate status but don't parse JSON
+            if not response.ok:
+                response.raise_for_status()
+
+            return response
+
+        except requests.exceptions.Timeout as err:
+            raise MeilisearchTimeoutError(str(err)) from err
+        except requests.exceptions.ConnectionError as err:
+            raise MeilisearchCommunicationError(str(err)) from err
+        except requests.exceptions.HTTPError as err:
+            raise MeilisearchApiError(str(err), response) from err
+        except requests.exceptions.InvalidSchema as err:
+            if "://" not in self.config.url:
+                raise MeilisearchCommunicationError(
+                    f"""
+                    Invalid URL {self.config.url}, no scheme/protocol supplied.
+                    Did you mean https://{self.config.url}?
+                    """
+                ) from err
+
+            raise MeilisearchCommunicationError(str(err)) from err
+
     @staticmethod
     def __to_json(request: requests.Response) -> Any:
         if request.content == b"":

meilisearch/_httprequests.py

@@ -8,12 +8,27 @@
 import hmac
 import json
 import re
-from typing import Any, Dict, List, Mapping, MutableMapping, Optional, Sequence, Tuple, Union
+from typing import (
+    Any,
+    Dict,
+    Iterator,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
 from urllib import parse
 
 from meilisearch._httprequests import HttpRequests
 from meilisearch.config import Config
-from meilisearch.errors import MeilisearchError
+from meilisearch.errors import (  # noqa: F401
+    MeilisearchApiError,
+    MeilisearchCommunicationError,
+    MeilisearchError,
+)
 from meilisearch.index import Index
 from meilisearch.models.key import Key, KeysResults
 from meilisearch.models.task import Batch, BatchResults, Task, TaskInfo, TaskResults
@@ -28,6 +43,9 @@ class Client:
     Meilisearch and its permissions.
     """
 
+    # Import aliases to satisfy pylint (used in docstrings)
+    MeilisearchApiError = MeilisearchApiError
+
     def __init__(
         self,
         url: str,
@@ -795,6 +813,177 @@ def get_all_networks(self) -> Dict[str, str]:
         """
         return self.http.get(path=f"{self.config.paths.network}")
 
+    def create_chat_completion(
+        self,
+        workspace_uid: str,
+        messages: List[Dict[str, str]],
+        model: str = "gpt-3.5-turbo",
+        stream: bool = True,
+    ) -> Iterator[Dict[str, Any]]:
+        """Streams a chat completion from the Meilisearch chat API.
+
+        Parameters
+        ----------
+        workspace_uid:
+            Unique identifier of the chat workspace to use.
+        messages:
+            List of message dicts (e.g. {"role": "user", "content": "..."}) comprising the chat history.
+        model:
+            The model name to use for completion (should correspond to the LLM in workspace settings).
+        stream:
+            Whether to stream the response. Must be True for now (only streaming is supported).
+
+        Returns
+        -------
+        chunks:
+            Parsed chunks of the completion as Python dicts. Each chunk is a partial response (in OpenAI format).
+            Iteration ends when the completion is done.
+
+        Raises
+        ------
+        MeilisearchApiError
+            An error containing details about why Meilisearch can't process your request. Meilisearch error codes are described here: https://www.meilisearch.com/docs/reference/errors/error_codes#meilisearch-errors
+        MeilisearchCommunicationError
+            If a network error occurs.
+        ValueError
+            If stream=False is passed (not currently supported), or if workspace_uid is empty or contains path separators.
+        """
+        if not stream:
+            # The API currently only supports streaming responses:
+            raise ValueError("Non-streaming chat completions are not supported. Use stream=True.")
+
+        # Basic security validation (only what's needed)
+        if not workspace_uid:
+            raise ValueError("workspace_uid is required and cannot be empty")
+        if "/" in workspace_uid or "\\" in workspace_uid:
+            raise ValueError("Invalid workspace_uid: must not contain path separators")
+
+        payload = {"model": model, "messages": messages, "stream": True}
+
+        # Construct the URL for the chat completions route.
+        endpoint = f"chats/{workspace_uid}/chat/completions"
+
+        # Initiate the HTTP POST request in streaming mode.
+        response = self.http.post_stream(endpoint, body=payload)
+
+        try:
+            # Iterate over the streaming response lines
+            for raw_line in response.iter_lines():
+                if raw_line is None or raw_line == b"":
+                    continue
+
+                line = raw_line.decode("utf-8")
+                if line.startswith("data: "):
+                    data = line[len("data: ") :]
+                    if data.strip() == "[DONE]":
+                        break
+
+                    try:
+                        chunk = json.loads(data)
+                        yield chunk
+                    except json.JSONDecodeError as e:
+                        raise MeilisearchCommunicationError(
+                            f"Failed to parse chat chunk: {e}"
+                        ) from e
+        finally:
+            response.close()
+
+    def get_chat_workspaces(
+        self,
+        *,
+        offset: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Get all chat workspaces.
+
+        Parameters
+        ----------
+        offset (optional):
+            Number of workspaces to skip.
+        limit (optional):
+            Maximum number of workspaces to return.
+
+        Returns
+        -------
+        workspaces
+            Dictionary containing the list of chat workspaces and pagination information.
+
+        Raises
+        ------
+        MeilisearchApiError
+            An error containing details about why Meilisearch can't process your request. Meilisearch error codes are described here: https://www.meilisearch.com/docs/reference/errors/error_codes#meilisearch-errors
+        """
+        params = {}
+        if offset is not None:
+            params["offset"] = offset
+        if limit is not None:
+            params["limit"] = limit
+        path = "chats" + ("?" + parse.urlencode(params) if params else "")
+        return self.http.get(path)
+
+    def get_chat_workspace_settings(self, workspace_uid: str) -> Dict[str, Any]:
+        """Get the settings for a specific chat workspace.
+
+        Parameters
+        ----------
+        workspace_uid:
+            Unique identifier of the chat workspace.
+
+        Returns
+        -------
+        settings:
+            Dictionary containing the workspace settings.
+
+        Raises
+        ------
+        MeilisearchApiError
+            An error containing details about why Meilisearch can't process your request. Meilisearch error codes are described here: https://www.meilisearch.com/docs/reference/errors/error_codes#meilisearch-errors
+        ValueError
+            If workspace_uid is empty or contains path separators.
+        """
+        # Basic security validation (only what's needed)
+        if not workspace_uid:
+            raise ValueError("workspace_uid is required and cannot be empty")
+        if "/" in workspace_uid or "\\" in workspace_uid:
+            raise ValueError("Invalid workspace_uid: must not contain path separators")
+
+        return self.http.get(f"chats/{workspace_uid}/settings")
+
+    def update_chat_workspace_settings(
+        self, workspace_uid: str, settings: Mapping[str, Any]
+    ) -> Dict[str, Any]:
+        """Update the settings for a specific chat workspace.
+
+        Parameters
+        ----------
+        workspace_uid:
+            Unique identifier of the chat workspace.
+        settings:
+            Dictionary containing the settings to update.
+
+        Returns
+        -------
+        settings:
+            Dictionary containing the updated workspace settings.
+
+        Raises
+        ------
+        MeilisearchApiError
+            An error containing details about why Meilisearch can't process your request. Meilisearch error codes are described here: https://www.meilisearch.com/docs/reference/errors/error_codes#meilisearch-errors
+        ValueError
+            If workspace_uid is empty or contains path separators, or if settings is empty.
+        """
+        # Basic security validation (only what's needed)
+        if not workspace_uid:
+            raise ValueError("workspace_uid is required and cannot be empty")
+        if "/" in workspace_uid or "\\" in workspace_uid:
+            raise ValueError("Invalid workspace_uid: must not contain path separators")
+
+        if not settings:
+            raise ValueError("settings cannot be empty")
+
+        return self.http.patch(f"chats/{workspace_uid}/settings", body=settings)
+
     @staticmethod
     def _base64url_encode(data: bytes) -> str:
         return base64.urlsafe_b64encode(data).decode("utf-8").replace("=", "")

meilisearch/client.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.36.0"
+__version__ = "0.37.0"
 
 
 def qualified_version() -> str: