add py.typed marker for Python client v3.0.2

paddler_client_python/paddler_client/error.py

@@ -21,17 +21,13 @@ def __init__(self, message: str, raw_data: str) -> None:
 
 class PoolExhaustedError(PaddlerError):
     def __init__(self) -> None:
-        super().__init__(
-            "No available WebSocket connections in the pool"
-        )
+        super().__init__("No available WebSocket connections in the pool")
 
 
 class ConnectionDroppedError(PaddlerError):
     def __init__(self, request_id: str) -> None:
         self.request_id = request_id
-        super().__init__(
-            f"WebSocket connection dropped for request {request_id}"
-        )
+        super().__init__(f"WebSocket connection dropped for request {request_id}")
 
 
 class ServerError(PaddlerError):

paddler_client_python/paddler_client/inference_socket_connection.py

@@ -48,9 +48,7 @@ class InferenceSocketConnection:
     def __init__(self, url: str) -> None:
         self._url = url
         self._ws: ClientConnection | None = None
-        self._pending: dict[
-            str, asyncio.Queue[InferenceMessage | Exception]
-        ] = {}
+        self._pending: dict[str, asyncio.Queue[InferenceMessage | Exception]] = {}
         self._write_queue: asyncio.Queue[str] = asyncio.Queue()
         self._read_task: asyncio.Task[None] | None = None
         self._write_task: asyncio.Task[None] | None = None
@@ -74,9 +72,7 @@ async def send(
         if not self._connected:
             raise ConnectionDroppedError(request_id)
 
-        response_queue: asyncio.Queue[InferenceMessage | Exception] = (
-            asyncio.Queue()
-        )
+        response_queue: asyncio.Queue[InferenceMessage | Exception] = asyncio.Queue()
         self._pending[request_id] = response_queue
         await self._write_queue.put(json_message)
 
@@ -107,9 +103,7 @@ async def _read_loop(self) -> None:
 
             async for raw_message in self._ws:
                 if not isinstance(raw_message, str):
-                    logger.warning(
-                        "Received unexpected binary WebSocket message"
-                    )
+                    logger.warning("Received unexpected binary WebSocket message")
                     continue
 
                 try:

paddler_client_python/paddler_client/inference_socket_pool.py

@@ -20,9 +20,7 @@ def __init__(self, url: str, pool_size: int) -> None:
 
         self._url = url
         self._pool_size = pool_size
-        self._connections: list[InferenceSocketConnection | None] = (
-            [None] * pool_size
-        )
+        self._connections: list[InferenceSocketConnection | None] = [None] * pool_size
         self._next_idx = 0
         self._lock = asyncio.Lock()
 

paddler_client_python/paddler_client/inference_socket_url.py

@@ -15,11 +15,13 @@ def inference_socket_url(url: str) -> str:
     if new_scheme is None:
         raise ValueError(f"Unsupported URL scheme: {parsed.scheme}")
 
-    return urlunparse((
-        new_scheme,
-        parsed.netloc,
-        "/api/v1/inference_socket",
-        "",
-        parsed.query,
-        "",
-    ))
+    return urlunparse(
+        (
+            new_scheme,
+            parsed.netloc,
+            "/api/v1/inference_socket",
+            "",
+            parsed.query,
+            "",
+        )
+    )

paddler_client_python/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "paddler-client"
-version = "3.0.1"
+version = "3.0.2"
 description = "Python client for Paddler LLM load balancer"
 authors = ["Intentee"]
 license = "Apache-2.0"

paddler_client_python/tests/conftest.py

@@ -70,19 +70,15 @@ async def _wait_for_available_slots(client: ClientManagement) -> None:
     while elapsed < WAIT_FOR_SLOTS_TIMEOUT_SECONDS:
         snapshot = await client.get_agents()
         total_slots = sum(agent.slots_total for agent in snapshot.agents)
-        total_processing = sum(
-            agent.slots_processing for agent in snapshot.agents
-        )
+        total_processing = sum(agent.slots_processing for agent in snapshot.agents)
 
         if total_slots > 0 and total_processing == 0:
             return
 
         await asyncio.sleep(POLL_INTERVAL_SECONDS)
         elapsed += POLL_INTERVAL_SECONDS
 
-    raise TimeoutError(
-        f"No idle agent slots within {WAIT_FOR_SLOTS_TIMEOUT_SECONDS}s"
-    )
+    raise TimeoutError(f"No idle agent slots within {WAIT_FOR_SLOTS_TIMEOUT_SECONDS}s")
 
 
 @pytest.fixture

paddler_client_python/tests/test_client_inference.py

@@ -23,21 +23,25 @@ def _make_ndjson_token_response(
     request_id: str,
     token: str,
 ) -> str:
-    return json.dumps({
-        "Response": {
-            "request_id": request_id,
-            "response": {"GeneratedToken": {"Token": token}},
+    return json.dumps(
+        {
+            "Response": {
+                "request_id": request_id,
+                "response": {"GeneratedToken": {"Token": token}},
+            }
         }
-    })
+    )
 
 
 def _make_ndjson_done_response(request_id: str) -> str:
-    return json.dumps({
-        "Response": {
-            "request_id": request_id,
-            "response": {"GeneratedToken": "Done"},
+    return json.dumps(
+        {
+            "Response": {
+                "request_id": request_id,
+                "response": {"GeneratedToken": "Done"},
+            }
         }
-    })
+    )
 
 
 async def test_get_health_returns_text() -> None:
@@ -125,36 +129,38 @@ def handler(request: httpx.Request) -> httpx.Response:
         body = json.loads(received_requests[0].content)
         assert body["add_generation_prompt"] is True
         assert body["max_tokens"] == 100
-        assert body["conversation_history"] == [
-            {"content": "Hello", "role": "user"}
-        ]
+        assert body["conversation_history"] == [{"content": "Hello", "role": "user"}]
     finally:
         await client.close()
 
 
 async def test_generate_embedding_batch() -> None:
     def handler(request: httpx.Request) -> httpx.Response:
-        embedding_response = json.dumps({
-            "Response": {
-                "request_id": "r1",
-                "response": {
-                    "Embedding": {
+        embedding_response = json.dumps(
+            {
+                "Response": {
+                    "request_id": "r1",
+                    "response": {
                         "Embedding": {
-                            "embedding": [0.1, 0.2],
-                            "normalization_method": "None",
-                            "pooling_type": "Mean",
-                            "source_document_id": "doc-1",
+                            "Embedding": {
+                                "embedding": [0.1, 0.2],
+                                "normalization_method": "None",
+                                "pooling_type": "Mean",
+                                "source_document_id": "doc-1",
+                            }
                         }
-                    }
-                },
+                    },
+                }
             }
-        })
-        done_response = json.dumps({
-            "Response": {
-                "request_id": "r1",
-                "response": {"Embedding": "Done"},
+        )
+        done_response = json.dumps(
+            {
+                "Response": {
+                    "request_id": "r1",
+                    "response": {"Embedding": "Done"},
+                }
             }
-        })
+        )
 
         return httpx.Response(
             200,

paddler_client_python/tests/test_inference_message.py

@@ -81,9 +81,7 @@ def test_parse_chat_template_error() -> None:
     data = {
         "Response": {
             "request_id": "req-1",
-            "response": {
-                "GeneratedToken": {"ChatTemplateError": "bad template"}
-            },
+            "response": {"GeneratedToken": {"ChatTemplateError": "bad template"}},
         }
     }
     message = parse_inference_client_message(data)
@@ -97,9 +95,7 @@ def test_parse_image_decoding_failed() -> None:
     data = {
         "Response": {
             "request_id": "req-1",
-            "response": {
-                "GeneratedToken": {"ImageDecodingFailed": "corrupt image"}
-            },
+            "response": {"GeneratedToken": {"ImageDecodingFailed": "corrupt image"}},
         }
     }
     message = parse_inference_client_message(data)
@@ -113,11 +109,7 @@ def test_parse_multimodal_not_supported() -> None:
     data = {
         "Response": {
             "request_id": "req-1",
-            "response": {
-                "GeneratedToken": {
-                    "MultimodalNotSupported": "no multimodal"
-                }
-            },
+            "response": {"GeneratedToken": {"MultimodalNotSupported": "no multimodal"}},
         }
     }
     message = parse_inference_client_message(data)
@@ -181,8 +173,7 @@ def test_parse_embedding_error() -> None:
 
 def test_parse_json_string() -> None:
     json_str = (
-        '{"Response": {"request_id": "req-1",'
-        ' "response": {"GeneratedToken": "Done"}}}'
+        '{"Response": {"request_id": "req-1", "response": {"GeneratedToken": "Done"}}}'
     )
     message = parse_inference_client_message(json_str)
 

paddler_client_python/tests/test_stream_ndjson.py

@@ -9,29 +9,30 @@
 
 
 def _make_token_line(request_id: str, token: str) -> str:
-    return json.dumps({
-        "Response": {
-            "request_id": request_id,
-            "response": {"GeneratedToken": {"Token": token}},
+    return json.dumps(
+        {
+            "Response": {
+                "request_id": request_id,
+                "response": {"GeneratedToken": {"Token": token}},
+            }
         }
-    })
+    )
 
 
 def _make_done_line(request_id: str) -> str:
-    return json.dumps({
-        "Response": {
-            "request_id": request_id,
-            "response": {"GeneratedToken": "Done"},
+    return json.dumps(
+        {
+            "Response": {
+                "request_id": request_id,
+                "response": {"GeneratedToken": "Done"},
+            }
         }
-    })
+    )
 
 
 async def test_parses_multiple_ndjson_lines() -> None:
     ndjson_content = (
-        _make_token_line("r1", "hello")
-        + "\n"
-        + _make_done_line("r1")
-        + "\n"
+        _make_token_line("r1", "hello") + "\n" + _make_done_line("r1") + "\n"
     )
 
     def handler(request: httpx.Request) -> httpx.Response:
@@ -53,11 +54,7 @@ def handler(request: httpx.Request) -> httpx.Response:
 
 
 async def test_skips_empty_lines() -> None:
-    ndjson_content = (
-        "\n\n"
-        + _make_done_line("r1")
-        + "\n\n"
-    )
+    ndjson_content = "\n\n" + _make_done_line("r1") + "\n\n"
 
     def handler(request: httpx.Request) -> httpx.Response:
         return httpx.Response(200, text=ndjson_content)