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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypha_rpc
-Version: 0.20.93
+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.93 → 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.93 → 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}")
 
@@ -177,11 +179,14 @@ class HTTPStreamingRPCConnection:
         # 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)")
+            logger.debug(
+                "HTTP/2 not available (install httpx[http2] for better performance)"
+            )
 
         return httpx.AsyncClient(
             timeout=httpx.Timeout(self._timeout, connect=30.0),
@@ -198,14 +203,16 @@ class HTTPStreamingRPCConnection:
 
     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"
@@ -357,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
@@ -440,8 +447,9 @@ class HTTPStreamingRPCConnection:
         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:
@@ -454,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:
@@ -528,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"
@@ -625,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')}")
@@ -642,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"