hypha-rpc 0.20.88__tar.gz → 0.20.90__tar.gz

{hypha_rpc-0.20.88 → hypha_rpc-0.20.90}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypha_rpc
-Version: 0.20.88
+Version: 0.20.90
 Summary: Hypha RPC client for connecting to Hypha server for data management and AI model serving
 Author-email: Wei Ouyang <oeway007@gmail.com>
 Requires-Python: >=3.9

hypha_rpc-0.20.90/hypha_rpc/VERSION

@@ -0,0 +1,3 @@
+{
+  "version": "0.20.90"
+}

{hypha_rpc-0.20.88 → hypha_rpc-0.20.90}/hypha_rpc/http_client.py

@@ -89,6 +89,7 @@ class HTTPStreamingRPCConnection:
         self._closed = False
         self._enable_reconnect = False
         self._stream_task: Optional[asyncio.Task] = None
+        self._refresh_token_task: Optional[asyncio.Task] = None
         self._http_client: Optional[httpx.AsyncClient] = None
 
         self.connection_info = None
@@ -108,6 +109,41 @@ class HTTPStreamingRPCConnection:
         self._handle_connected = handler
         assert inspect.iscoroutinefunction(handler), "Handler must be async"
 
+    async def _send_refresh_token(self, token_refresh_interval: float):
+        """Send refresh token request at regular intervals.
+
+        Similar to WebSocket, this periodically requests a new reconnection token
+        to keep the session alive and allow reconnection with a fresh token.
+        """
+        try:
+            await asyncio.sleep(2)  # Initial delay
+            while not self._closed and self._http_client:
+                try:
+                    # Send refresh token request via POST
+                    workspace = self._workspace or "public"
+                    url = f"{self._server_url}/{workspace}/rpc"
+                    params = {"client_id": self._client_id}
+
+                    refresh_message = msgpack.packb({"type": "refresh_token"})
+                    response = await self._http_client.post(
+                        url,
+                        content=refresh_message,
+                        params=params,
+                        headers=self._get_headers(),
+                    )
+                    if response.status_code == 200:
+                        logger.debug("Token refresh requested successfully")
+                    else:
+                        logger.warning(f"Token refresh request failed: {response.status_code}")
+                except Exception as e:
+                    logger.warning(f"Failed to send refresh token request: {e}")
+
+                await asyncio.sleep(token_refresh_interval)
+        except asyncio.CancelledError:
+            logger.debug("Token refresh task was cancelled")
+        except Exception as e:
+            logger.error(f"Error in token refresh task: {e}")
+
     def _get_headers(self, for_stream: bool = False) -> dict:
         """Get HTTP headers with authentication.
 
@@ -127,7 +163,11 @@ class HTTPStreamingRPCConnection:
         return headers
 
     async def _create_http_client(self) -> httpx.AsyncClient:
-        """Create configured HTTP client."""
+        """Create configured HTTP client with connection pooling.
+
+        Connection pooling improves performance by reusing TCP connections
+        for multiple requests, reducing connection overhead.
+        """
         verify = True
         if self._ssl is False:
             verify = False
@@ -137,6 +177,12 @@ class HTTPStreamingRPCConnection:
         return httpx.AsyncClient(
             timeout=httpx.Timeout(self._timeout, connect=30.0),
             verify=verify,
+            # Connection pooling for better performance with many requests
+            limits=httpx.Limits(
+                max_connections=100,  # Max total connections
+                max_keepalive_connections=20,  # Keep-alive connections for reuse
+                keepalive_expiry=30.0,  # Keep connections alive for 30 seconds
+            ),
         )
 
     async def open(self):
@@ -153,6 +199,11 @@ class HTTPStreamingRPCConnection:
         if self._format == "msgpack":
             params["format"] = "msgpack"
 
+        # Add reconnection token if available (for reconnection)
+        if self._reconnection_token:
+            params["reconnection_token"] = self._reconnection_token
+            logger.info(f"Using reconnection token for HTTP streaming connection")
+
         try:
             # Start streaming in background task
             self._stream_task = asyncio.create_task(
@@ -180,11 +231,27 @@ class HTTPStreamingRPCConnection:
             if "reconnection_token" in self.connection_info:
                 self._reconnection_token = self.connection_info["reconnection_token"]
 
+            # Adjust token refresh interval based on server's token lifetime
+            if "reconnection_token_life_time" in self.connection_info:
+                token_life_time = self.connection_info["reconnection_token_life_time"]
+                if self._token_refresh_interval > token_life_time / 1.5:
+                    logger.warning(
+                        f"Token refresh interval ({self._token_refresh_interval}s) is too long, "
+                        f"adjusting to {token_life_time / 1.5:.0f}s based on token lifetime"
+                    )
+                    self._token_refresh_interval = token_life_time / 1.5
+
             logger.info(
                 f"HTTP streaming connected to workspace: {self._workspace}, "
                 f"manager_id: {self.manager_id}"
             )
 
+            # Start token refresh task
+            if self._token_refresh_interval > 0:
+                self._refresh_token_task = asyncio.create_task(
+                    self._send_refresh_token(self._token_refresh_interval)
+                )
+
             if self._handle_connected:
                 await self._handle_connected(self.connection_info)
 
@@ -390,6 +457,16 @@ class HTTPStreamingRPCConnection:
 
     async def _cleanup(self):
         """Cleanup resources."""
+        # Cancel token refresh task
+        if self._refresh_token_task and not self._refresh_token_task.done():
+            self._refresh_token_task.cancel()
+            try:
+                await asyncio.wait_for(self._refresh_token_task, timeout=1.0)
+            except (asyncio.CancelledError, asyncio.TimeoutError):
+                pass
+            self._refresh_token_task = None
+
+        # Cancel stream task
         if self._stream_task and not self._stream_task.done():
             self._stream_task.cancel()
             try:

{hypha_rpc-0.20.88 → hypha_rpc-0.20.90}/hypha_rpc.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypha_rpc
-Version: 0.20.88
+Version: 0.20.90
 Summary: Hypha RPC client for connecting to Hypha server for data management and AI model serving
 Author-email: Wei Ouyang <oeway007@gmail.com>
 Requires-Python: >=3.9

{hypha_rpc-0.20.88 → hypha_rpc-0.20.90}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hypha_rpc"
-version = "0.20.88"
+version = "0.20.90"
 description = "Hypha RPC client for connecting to Hypha server for data management and AI model serving"
 readme = "README.md"
 requires-python = ">=3.9"

hypha_rpc-0.20.88/hypha_rpc/VERSION

@@ -1,3 +0,0 @@
-{
-  "version": "0.20.88"
-}