improved formatting for integration workflow

Author: EazyAl

meilisearch/_httprequests.py

@@ -2,7 +2,7 @@
 
 import json
 from functools import lru_cache
-from typing import Any, Callable, Iterator, List, Mapping, Optional, Sequence, Tuple, Type, Union
+from typing import Any, Callable, List, Mapping, Optional, Sequence, Tuple, Type, Union
 
 import requests
 
@@ -157,14 +157,14 @@ def post_stream(
         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,
@@ -182,17 +182,17 @@ def post_stream(
                 )
 
                 response = requests.post(
-                    request_path, 
-                    timeout=self.config.timeout, 
-                    headers=self.headers, 
+                    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:

meilisearch/client.py

@@ -8,12 +8,23 @@
 import hmac
 import json
 import re
-from typing import Any, Dict, Iterator, 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 MeilisearchApiError, MeilisearchCommunicationError, MeilisearchError
+from meilisearch.errors import MeilisearchCommunicationError, MeilisearchError
 from meilisearch.index import Index
 from meilisearch.models.key import Key, KeysResults
 from meilisearch.models.task import Batch, BatchResults, Task, TaskInfo, TaskResults
@@ -839,31 +850,30 @@ def create_chat_completion(
             "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  
-                
+                    continue
+
                 line = raw_line.decode('utf-8')
                 if line.startswith("data: "):
-                    data = line[len("data: "):]  
+                    data = line[len("data: "):]
                     if data.strip() == "[DONE]":
-                        break 
-                    
+                        break
+
                     try:
                         chunk = json.loads(data)
                         yield chunk
                     except json.JSONDecodeError as e:
-                    
-                        raise MeilisearchCommunicationError(f"Failed to parse chat chunk: {e}")
+                        raise MeilisearchCommunicationError(f"Failed to parse chat chunk: {e}") from e
         finally:
             response.close()
 

tests/client/test_chat_completions.py

@@ -1,35 +1,31 @@
 # pylint: disable=invalid-name
 
-import json
 from unittest.mock import patch
 
 import pytest
 import requests
 
-import meilisearch
 from meilisearch.errors import MeilisearchApiError, MeilisearchCommunicationError
-from tests import BASE_URL, MASTER_KEY
 
 
 class MockStreamingResponse:
     """Mock response object for testing streaming functionality."""
-    
+
     def __init__(self, lines, ok=True, status_code=200, text=""):
         self.lines = lines
         self.ok = ok
         self.status_code = status_code
         self.text = text
         self._closed = False
-    
+
     def iter_lines(self):
         """Simulate iter_lines() method of requests.Response."""
-        for line in self.lines:
-            yield line
-    
+        yield from self.lines
+
     def close(self):
         """Simulate close() method of requests.Response."""
         self._closed = True
-    
+
     def raise_for_status(self):
         """Simulate raise_for_status() method of requests.Response."""
         if not self.ok:
@@ -44,11 +40,11 @@ def test_create_chat_completion_basic_stream(client):
         b'data: [DONE]'
     ]
     mock_resp = MockStreamingResponse(dummy_lines)
-    
+
     with patch.object(client.http, 'post_stream', return_value=mock_resp) as mock_post:
         messages = [{"role": "user", "content": "Hi"}]
         chunks = list(client.create_chat_completion("my-assistant", messages=messages))
-        
+
         # Verify the HTTP call was made correctly
         mock_post.assert_called_once_with(
             "chats/my-assistant/chat/completions",
@@ -58,18 +54,18 @@ def test_create_chat_completion_basic_stream(client):
                 "stream": True
             }
         )
-        
+
         # Verify the chunks are parsed correctly
         assert len(chunks) == 2
         assert chunks[0]["choices"][0]["delta"]["content"] == "Hello"
         assert chunks[1]["choices"][0]["delta"]["content"] == " world"
-        assert mock_resp._closed
+        assert mock_resp._closed  # pylint: disable=protected-access
 
 
 def test_create_chat_completion_stream_false_raises_error(client):
     """Test that stream=False raises ValueError."""
     messages = [{"role": "user", "content": "Test"}]
-    
+
     with pytest.raises(ValueError, match="Non-streaming chat completions are not supported"):
         list(client.create_chat_completion("my-assistant", messages=messages, stream=False))
 
@@ -80,10 +76,10 @@ def test_create_chat_completion_json_decode_error(client):
         b'data: {"invalid": json}',  # Malformed JSON
     ]
     mock_resp = MockStreamingResponse(dummy_lines)
-    
+
     with patch.object(client.http, 'post_stream', return_value=mock_resp):
         messages = [{"role": "user", "content": "Test"}]
-        
+
         with pytest.raises(MeilisearchCommunicationError, match="Failed to parse chat chunk"):
             list(client.create_chat_completion("my-assistant", messages=messages))
 
@@ -94,7 +90,7 @@ def test_create_chat_completion_http_error_propagated(client):
         error_response = MockStreamingResponse([], ok=False, status_code=400, text='{"message": "API Error"}')
         mock_post.side_effect = MeilisearchApiError("API Error", error_response)
         messages = [{"role": "user", "content": "Test"}]
-        
+
         with pytest.raises(MeilisearchApiError, match="API Error"):
             list(client.create_chat_completion("my-assistant", messages=messages))
 
@@ -110,13 +106,13 @@ def test_get_chat_workspaces(client):
         "limit": 20,
         "total": 2
     }
-    
+
     with patch.object(client.http, 'get', return_value=mock_response) as mock_get:
         result = client.get_chat_workspaces()
-        
+
         # Verify the HTTP call was made correctly
         mock_get.assert_called_once_with("chats")
-        
+
         # Verify the response is returned as-is
         assert result == mock_response
 
@@ -128,17 +124,17 @@ def test_update_chat_workspace_settings(client):
         "temperature": 0.8,
         "max_tokens": 1500
     }
-    
+
     settings_update = {
         "temperature": 0.8,
         "max_tokens": 1500
     }
-    
+
     with patch.object(client.http, 'patch', return_value=mock_response) as mock_patch:
         result = client.update_chat_workspace_settings("my-workspace", settings_update)
-        
+
         # Verify the HTTP call was made correctly
         mock_patch.assert_called_once_with("chats/my-workspace/settings", body=settings_update)
-        
+
         # Verify the response is returned as-is
-        assert result == mock_response
+        assert result == mock_response