hypha-rpc 0.20.91__py3-none-any.whl → 0.20.93__py3-none-any.whl

hypha_rpc/VERSION

@@ -1,3 +1,3 @@
 {
-  "version": "0.20.91"
+  "version": "0.20.93"
 }

hypha_rpc/__init__.py

@@ -15,8 +15,13 @@ from .sync import login as login_sync
 from .sync import logout as logout_sync
 from .sync import register_rtc_service as register_rtc_service_sync
 from .webrtc_client import get_rtc_service, register_rtc_service
-from .client import connect_to_server, get_remote_service
-from .websocket_client import login, logout, setup_local_client
+from .websocket_client import (
+    connect_to_server,
+    get_remote_service,
+    login,
+    logout,
+    setup_local_client,
+)
 from .http_client import HTTPStreamingRPCConnection
 
 # read the version from the VERSION file; but get the path from the __file__

hypha_rpc/http_client.py

@@ -174,15 +174,26 @@ 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):
@@ -418,7 +429,11 @@ 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")
 
@@ -430,6 +445,7 @@ class HTTPStreamingRPCConnection:
         params = {"client_id": self._client_id}
 
         try:
+            # httpx handles large payloads efficiently with connection pooling
             response = await self._http_client.post(
                 url,
                 content=data,
@@ -511,7 +527,7 @@ def connect_to_server_http(config=None, **kwargs):
     Returns:
         ServerContextManager that can be used as async context manager
     """
-    from .client import connect_to_server
+    from .websocket_client import connect_to_server
     config = config or {}
     config.update(kwargs)
     config["transport"] = "http"
@@ -625,7 +641,7 @@ def get_remote_service_http(service_uri: str, config=None, **kwargs):
     This is a convenience function that sets transport="http" automatically.
     For a unified interface, use get_remote_service with transport="http" instead.
     """
-    from .client import get_remote_service
+    from .websocket_client import get_remote_service
     config = config or {}
     config.update(kwargs)
     config["transport"] = "http"

hypha_rpc/websocket_client.py

@@ -738,10 +738,6 @@ async def logout(config):
         await server.disconnect()
 
 
-# Re-export from client.py for backwards compatibility
-from .client import ServerContextManager, connect_to_server, get_remote_service
-
-
 async def webrtc_get_service(wm, rtc_service_id, query, config=None, **kwargs):
     config = config or {}
     config.update(kwargs)
@@ -1151,6 +1147,118 @@ async def _connect_to_server(config):
     return wm
 
 
+class ServerContextManager:
+    """Server context manager.
+
+    Supports multiple transport types:
+    - "websocket" (default): Traditional WebSocket connection
+    - "http": HTTP streaming connection (more resilient to network issues)
+    """
+
+    def __init__(self, config=None, service_id=None, **kwargs):
+        self.config = config or {}
+        self.config.update(kwargs)
+
+        if not self.config:
+            # try to load from env
+            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:
+                    pass
+            self.config = {
+                "server_url": os.getenv("HYPHA_SERVER_URL"),
+                "token": os.getenv("HYPHA_TOKEN"),
+                "client_id": os.getenv("HYPHA_CLIENT_ID"),
+                "workspace": os.getenv("HYPHA_WORKSPACE"),
+            }
+            if not self.config["server_url"]:
+                raise ValueError(
+                    "Please set the HYPHA_SERVER_URL, HYPHA_TOKEN, "
+                    "HYPHA_CLIENT_ID, and HYPHA_WORKSPACE environment variables"
+                )
+        self._service_id = service_id
+        self._transport = self.config.pop("transport", "websocket")
+        self.wm = None
+
+    async def __aenter__(self):
+        if self._transport == "http":
+            from .http_client import _connect_to_server_http
+            self.wm = await _connect_to_server_http(self.config)
+        else:
+            self.wm = await _connect_to_server(self.config)
+        if self._service_id:
+            return await self.wm.get_service(
+                self._service_id,
+                {"case_conversion": self.config.get("case_conversion")},
+            )
+        return self.wm
+
+    async def __aexit__(self, exc_type, exc, tb):
+        await self.wm.disconnect()
+
+    def __await__(self):
+        return self.__aenter__().__await__()
+
+
+def connect_to_server(config=None, **kwargs):
+    """Connect to a Hypha server.
+
+    Args:
+        config: Configuration dict with connection options
+        **kwargs: Additional configuration options
+
+    Configuration options:
+        server_url: The server URL (required)
+        workspace: Target workspace (optional)
+        token: Authentication token (optional)
+        client_id: Unique client identifier (optional, auto-generated if not provided)
+        transport: Transport type - "websocket" (default) or "http"
+        method_timeout: Timeout for RPC method calls
+        ssl: SSL configuration (True/False/SSLContext)
+
+    Returns:
+        ServerContextManager that can be used as async context manager
+
+    Example:
+        async with connect_to_server({"server_url": "https://hypha.aicell.io"}) as server:
+            await server.register_service({"id": "my-service", ...})
+    """
+    return ServerContextManager(config=config, **kwargs)
+
+
+def get_remote_service(service_uri, config=None, **kwargs):
+    """Get a remote service by URI.
+
+    Args:
+        service_uri: Service URI in format "server_url/workspace/client_id:service_id"
+        config: Additional configuration options
+        **kwargs: Additional configuration options
+
+    Returns:
+        ServerContextManager that resolves to the service when awaited
+
+    Example:
+        async with get_remote_service("https://hypha.aicell.io/public/client:service") as svc:
+            result = await svc.some_method()
+    """
+    server_url, workspace, client_id, service_id, app_id = parse_service_url(
+        service_uri
+    )
+    full_service_id = f"{workspace}/{client_id}:{service_id}@{app_id}"
+    config = config or {}
+    config.update(kwargs)
+    if "server_url" in config:
+        assert (
+            config["server_url"] == server_url
+        ), "server_url in config does not match the server_url in the url"
+    config["server_url"] = server_url
+    return ServerContextManager(config, service_id=full_service_id)
+
+
 def setup_local_client(enable_execution=False, on_ready=None):
     """Set up a local client."""
     fut = safe_create_future()

{hypha_rpc-0.20.91.dist-info → hypha_rpc-0.20.93.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypha_rpc
-Version: 0.20.91
+Version: 0.20.93
 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.91.dist-info → hypha_rpc-0.20.93.dist-info}/RECORD

@@ -1,20 +1,19 @@
-hypha_rpc/VERSION,sha256=j1kFO_lywKnDlLe-woiBFEziTNuwai-qeVyGIhLgkhY,26
-hypha_rpc/__init__.py,sha256=Nm01vho0uIMXET8-lqxaWTRgoKQD-0SEhpmS9odRed0,4721
-hypha_rpc/client.py,sha256=9c3Qd1bboNiEc_5P4jRLi233VFHyyME8alZYZ5ZZq6s,4551
-hypha_rpc/http_client.py,sha256=z1fbomvF9wk7ZxFmzfw8qnheE_ueXrg1C4c8Ss5hgWU,23545
+hypha_rpc/VERSION,sha256=oQt6CaFAJvGH-g-tZewKKFq1_1EOjSExWvGzeFGpmac,26
+hypha_rpc/__init__.py,sha256=kWNHbAl-a0RhgKgWm5r0cvs-qd1ujlpmPbXV_0QWuQQ,4727
+hypha_rpc/http_client.py,sha256=9ni8yx_2ZwJ5ibhN4tD8EMtfmvzTEm4UcRRggJ8pnRY,24307
 hypha_rpc/pyodide_sse.py,sha256=o1-6Bqb7bcplSy7pwkmtQb6vKeJsyxex_RebqNd3wX8,2960
 hypha_rpc/pyodide_websocket.py,sha256=XjrgKYySUSNYma-rXjHrSv08YCxj5t4hYEQnK15D6cE,18749
 hypha_rpc/rpc.py,sha256=lnNiPAm_BNT5JjDhAPFRlxs6HioXw77TelUtYd_blYk,115579
 hypha_rpc/sync.py,sha256=HcQwpGHsZjDNcSnDRuyxGu7bquOi5_jWrVL5vTwraZY,12268
 hypha_rpc/webrtc_client.py,sha256=JVbSTWr6Y6vMaeoAPsfecD2SuCtXOuoBVuhpwG5-Qm0,11944
-hypha_rpc/websocket_client.py,sha256=haH-SKxaAWNnest3doBVhp7H5XlgqVFjFOW-KnFqxPo,48914
+hypha_rpc/websocket_client.py,sha256=tk8mID_zd0SaKTnwCHMTDIIeWvmatDbr5LHXbo6WwJ8,52920
 hypha_rpc/utils/__init__.py,sha256=1UWExsUWzNRFkuYa7RSDXH3welrelIxOmGLtzdJ2oIA,20042
 hypha_rpc/utils/launch.py,sha256=GB1Ranb5E_oNFBLw2ARfT78SbqGEwUmWwfMo3E82kAM,3976
 hypha_rpc/utils/mcp.py,sha256=AW48yjCovc0jyekRLeD_1U8mRaA8-nEqh4DotSE_s3Y,17348
 hypha_rpc/utils/pydantic.py,sha256=a09_ys4BSXc4Yi6OgZjdspbtLvQVoRCChr6uInY4fN4,5144
 hypha_rpc/utils/schema.py,sha256=WabBJiDheMKRXUroVe9JRlI5P4Wlv6kc0roxVNQZHH8,22110
 hypha_rpc/utils/serve.py,sha256=xr_3oAQDyignQbz1fcm4kuRMBOb52-i0VSYCjZou51c,11882
-hypha_rpc-0.20.91.dist-info/METADATA,sha256=rIb0SqctYBNrj2IrRKSUBj2UBhAP1VFFECVRsScmAeg,924
-hypha_rpc-0.20.91.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-hypha_rpc-0.20.91.dist-info/top_level.txt,sha256=uShPbaPGP-Ig8OVnQcT6sEzV0Qhb6wfxSJ3uCmYaB58,10
-hypha_rpc-0.20.91.dist-info/RECORD,,
+hypha_rpc-0.20.93.dist-info/METADATA,sha256=HHPwYXpCX8PcZFYANkT5KTuDUPQ3S6-c_i2OCyIY2BI,924
+hypha_rpc-0.20.93.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+hypha_rpc-0.20.93.dist-info/top_level.txt,sha256=uShPbaPGP-Ig8OVnQcT6sEzV0Qhb6wfxSJ3uCmYaB58,10
+hypha_rpc-0.20.93.dist-info/RECORD,,

hypha_rpc/client.py

@@ -1,123 +0,0 @@
-"""Hypha RPC client - unified connection interface.
-
-This module provides the main entry point for connecting to Hypha servers.
-It supports multiple transport types:
-- "websocket" (default): Traditional WebSocket connection
-- "http": HTTP streaming connection (more resilient to network issues)
-"""
-
-import os
-from .utils import parse_service_url
-
-
-class ServerContextManager:
-    """Server context manager.
-
-    Supports multiple transport types:
-    - "websocket" (default): Traditional WebSocket connection
-    - "http": HTTP streaming connection (more resilient to network issues)
-    """
-
-    def __init__(self, config=None, service_id=None, **kwargs):
-        self.config = config or {}
-        self.config.update(kwargs)
-
-        if not self.config:
-            # try to load from env
-            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:
-                    pass
-            self.config = {
-                "server_url": os.getenv("HYPHA_SERVER_URL"),
-                "token": os.getenv("HYPHA_TOKEN"),
-                "client_id": os.getenv("HYPHA_CLIENT_ID"),
-                "workspace": os.getenv("HYPHA_WORKSPACE"),
-            }
-            if not self.config["server_url"]:
-                raise ValueError(
-                    "Please set the HYPHA_SERVER_URL, HYPHA_TOKEN, "
-                    "HYPHA_CLIENT_ID, and HYPHA_WORKSPACE environment variables"
-                )
-        self._service_id = service_id
-        self._transport = self.config.pop("transport", "websocket")
-        self.wm = None
-
-    async def __aenter__(self):
-        if self._transport == "http":
-            from .http_client import _connect_to_server_http
-            self.wm = await _connect_to_server_http(self.config)
-        else:
-            from .websocket_client import _connect_to_server
-            self.wm = await _connect_to_server(self.config)
-        if self._service_id:
-            return await self.wm.get_service(
-                self._service_id,
-                {"case_conversion": self.config.get("case_conversion")},
-            )
-        return self.wm
-
-    async def __aexit__(self, exc_type, exc, tb):
-        await self.wm.disconnect()
-
-    def __await__(self):
-        return self.__aenter__().__await__()
-
-
-def connect_to_server(config=None, **kwargs):
-    """Connect to a Hypha server.
-
-    Args:
-        config: Configuration dict with connection options
-        **kwargs: Additional configuration options
-
-    Configuration options:
-        server_url: The server URL (required)
-        workspace: Target workspace (optional)
-        token: Authentication token (optional)
-        client_id: Unique client identifier (optional, auto-generated if not provided)
-        transport: Transport type - "websocket" (default) or "http"
-        method_timeout: Timeout for RPC method calls
-        ssl: SSL configuration (True/False/SSLContext)
-
-    Returns:
-        ServerContextManager that can be used as async context manager
-
-    Example:
-        async with connect_to_server({"server_url": "https://hypha.aicell.io"}) as server:
-            await server.register_service({"id": "my-service", ...})
-    """
-    return ServerContextManager(config=config, **kwargs)
-
-
-def get_remote_service(service_uri, config=None, **kwargs):
-    """Get a remote service by URI.
-
-    Args:
-        service_uri: Service URI in format "server_url/workspace/client_id:service_id"
-        config: Additional configuration options
-        **kwargs: Additional configuration options
-
-    Returns:
-        ServerContextManager that resolves to the service when awaited
-
-    Example:
-        async with get_remote_service("https://hypha.aicell.io/public/client:service") as svc:
-            result = await svc.some_method()
-    """
-    server_url, workspace, client_id, service_id, app_id = parse_service_url(
-        service_uri
-    )
-    full_service_id = f"{workspace}/{client_id}:{service_id}@{app_id}"
-    config = config or {}
-    config.update(kwargs)
-    if "server_url" in config:
-        assert (
-            config["server_url"] == server_url
-        ), "server_url in config does not match the server_url in the url"
-    config["server_url"] = server_url
-    return ServerContextManager(config, service_id=full_service_id)