hypha-rpc 0.20.92__tar.gz → 0.20.94__tar.gz

{hypha_rpc-0.20.92 → hypha_rpc-0.20.94}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypha_rpc
-Version: 0.20.92
+Version: 0.20.94
 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.94/hypha_rpc/VERSION

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

{hypha_rpc-0.20.92 → hypha_rpc-0.20.94}/hypha_rpc/__init__.py

@@ -28,11 +28,12 @@ from .http_client import HTTPStreamingRPCConnection
 with open(os.path.join(os.path.dirname(__file__), "VERSION"), "r") as f:
     __version__ = json.load(f)["version"]
 
+
 def is_user_defined_class_instance(obj):
     return (
-        not isinstance(obj, type) and              # not a class itself
-        hasattr(obj, "__class__") and
-        obj.__class__.__module__ != "builtins"     # not a built-in type
+        not isinstance(obj, type)  # not a class itself
+        and hasattr(obj, "__class__")
+        and obj.__class__.__module__ != "builtins"  # not a built-in type
     )
 
 
@@ -41,23 +42,34 @@ class API(ObjectProxy):
         super().__init__(*args, **kwargs)
         self._registry = {}
         self._export_handler = self._default_export_handler
-        
+
     async def _register_services(self, obj, config=None, **kwargs):
         if not os.environ.get("HYPHA_SERVER_URL"):
             try:
                 from dotenv import load_dotenv, find_dotenv
+
                 load_dotenv(dotenv_path=find_dotenv(usecwd=True))
                 # use info from .env file
                 print("✅ Loaded connection configuration from .env file.")
             except ImportError:
-                print("❌ Missing environment variables. Set HYPHA_SERVER_URL, HYPHA_TOKEN, HYPHA_WORKSPACE", file=sys.stderr)
+                print(
+                    "❌ Missing environment variables. Set HYPHA_SERVER_URL, HYPHA_TOKEN, HYPHA_WORKSPACE",
+                    file=sys.stderr,
+                )
                 sys.exit(1)
         SERVER_URL = os.environ.get("HYPHA_SERVER_URL")
         TOKEN = os.environ.get("HYPHA_TOKEN")
         CLIENT_ID = os.environ.get("HYPHA_CLIENT_ID")
         WORKSPACE = os.environ.get("HYPHA_WORKSPACE")
 
-        server = await connect_to_server({"client_id": CLIENT_ID, "server_url": SERVER_URL, "token": TOKEN, "workspace": WORKSPACE})
+        server = await connect_to_server(
+            {
+                "client_id": CLIENT_ID,
+                "server_url": SERVER_URL,
+                "token": TOKEN,
+                "workspace": WORKSPACE,
+            }
+        )
         # If obj is a class, instantiate it
         if isinstance(obj, type):
             obj = obj()
@@ -96,7 +108,6 @@ class API(ObjectProxy):
             asyncio.create_task(self._register_services(obj, config, **kwargs))
         else:
             asyncio.run(self._register_services(obj, config, **kwargs))
-            
 
     def set_export_handler(self, handler):
         self._export_handler = handler

{hypha_rpc-0.20.92 → hypha_rpc-0.20.94}/hypha_rpc/http_client.py

@@ -134,7 +134,9 @@ class HTTPStreamingRPCConnection:
                     if response.status_code == 200:
                         logger.debug("Token refresh requested successfully")
                     else:
-                        logger.warning(f"Token refresh request failed: {response.status_code}")
+                        logger.warning(
+                            f"Token refresh request failed: {response.status_code}"
+                        )
                 except Exception as e:
                     logger.warning(f"Failed to send refresh token request: {e}")
 
@@ -174,27 +176,43 @@ class HTTPStreamingRPCConnection:
         elif self._ssl is not None:
             verify = self._ssl
 
+        # Try to enable HTTP/2 if h2 is available
+        try:
+            import h2  # noqa
+
+            http2_enabled = True
+            logger.info("HTTP/2 enabled for improved performance")
+        except ImportError:
+            http2_enabled = False
+            logger.debug(
+                "HTTP/2 not available (install httpx[http2] for better performance)"
+            )
+
         return httpx.AsyncClient(
             timeout=httpx.Timeout(self._timeout, connect=30.0),
             verify=verify,
-            # Connection pooling for better performance with many requests
+            # Optimized connection pooling for high-performance RPC
             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
+                max_connections=200,  # Max total connections (increased for parallel requests)
+                max_keepalive_connections=50,  # More reusable connections (up from 20)
+                keepalive_expiry=300.0,  # Keep connections alive longer (5 minutes)
             ),
+            # Enable HTTP/2 for better multiplexing if available
+            http2=http2_enabled,
         )
 
     async def open(self):
         """Open the streaming connection."""
-        logger.info(f"Opening HTTP streaming connection to {self._server_url} (format={self._format})")
+        logger.info(
+            f"Opening HTTP streaming connection to {self._server_url} (format={self._format})"
+        )
 
         if self._http_client is None:
             self._http_client = await self._create_http_client()
 
-        # Build stream URL
-        workspace = self._workspace or "public"
-        stream_url = f"{self._server_url}/{workspace}/rpc"
+        # Build stream URL - workspace is part of path, default to "public" for anonymous
+        ws = self._workspace or "public"
+        stream_url = f"{self._server_url}/{ws}/rpc"
         params = {"client_id": self._client_id}
         if self._format == "msgpack":
             params["format"] = "msgpack"
@@ -346,15 +364,15 @@ class HTTPStreamingRPCConnection:
             # Process complete frames from buffer
             while len(buffer) >= 4:
                 # Read 4-byte length prefix (big-endian)
-                length = int.from_bytes(buffer[:4], 'big')
+                length = int.from_bytes(buffer[:4], "big")
 
                 if len(buffer) < 4 + length:
                     # Incomplete frame, wait for more data
                     break
 
                 # Extract the frame
-                frame_data = buffer[4:4 + length]
-                buffer = buffer[4 + length:]
+                frame_data = buffer[4 : 4 + length]
+                buffer = buffer[4 + length :]
 
                 try:
                     # For msgpack, first check if it's a control message
@@ -418,18 +436,24 @@ class HTTPStreamingRPCConnection:
                 self._handle_message(data)
 
     async def emit_message(self, data: bytes):
-        """Send a message to the server via HTTP POST."""
+        """Send a message to the server via HTTP POST.
+
+        Uses optimized connection pooling with keep-alive for better performance.
+        HTTP client automatically handles efficient transfer for all payload sizes.
+        """
         if self._closed:
             raise ConnectionError("Connection is closed")
 
         if self._http_client is None:
             self._http_client = await self._create_http_client()
 
-        workspace = self._workspace or "public"
-        url = f"{self._server_url}/{workspace}/rpc"
+        # Build POST URL - workspace is part of path (must be set after connection)
+        ws = self._workspace or "public"
+        url = f"{self._server_url}/{ws}/rpc"
         params = {"client_id": self._client_id}
 
         try:
+            # httpx handles large payloads efficiently with connection pooling
             response = await self._http_client.post(
                 url,
                 content=data,
@@ -438,7 +462,9 @@ class HTTPStreamingRPCConnection:
             )
 
             if response.status_code != 200:
-                error = response.json() if response.content else {"detail": "Unknown error"}
+                error = (
+                    response.json() if response.content else {"detail": "Unknown error"}
+                )
                 raise ConnectionError(f"POST failed: {error.get('detail', error)}")
 
         except httpx.TimeoutException:
@@ -512,6 +538,7 @@ def connect_to_server_http(config=None, **kwargs):
         ServerContextManager that can be used as async context manager
     """
     from .websocket_client import connect_to_server
+
     config = config or {}
     config.update(kwargs)
     config["transport"] = "http"
@@ -609,6 +636,7 @@ async def _connect_to_server_http(config: dict):
 
     # Handle force-exit from manager
     if connection.manager_id:
+
         async def handle_disconnect(message):
             if message.get("from") == "*/" + connection.manager_id:
                 logger.info(f"Disconnecting from server: {message.get('reason')}")
@@ -626,6 +654,7 @@ def get_remote_service_http(service_uri: str, config=None, **kwargs):
     For a unified interface, use get_remote_service with transport="http" instead.
     """
     from .websocket_client import get_remote_service
+
     config = config or {}
     config.update(kwargs)
     config["transport"] = "http"