hypha-rpc 0.20.87__py3-none-any.whl → 0.20.89__py3-none-any.whl

hypha_rpc/VERSION

@@ -1,3 +1,3 @@
 {
-  "version": "0.20.87"
+  "version": "0.20.89"
 }

hypha_rpc/__init__.py

@@ -15,13 +15,9 @@ 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 .websocket_client import (
-    connect_to_server,
-    get_remote_service,
-    login,
-    logout,
-    setup_local_client,
-)
+from .client import connect_to_server, get_remote_service
+from .websocket_client import login, logout, setup_local_client
+from .http_client import HTTPStreamingRPCConnection
 
 # read the version from the VERSION file; but get the path from the __file__
 with open(os.path.join(os.path.dirname(__file__), "VERSION"), "r") as f:
@@ -118,6 +114,7 @@ __all__ = [
     "logout",
     "connect_to_server",
     "get_remote_service",
+    "HTTPStreamingRPCConnection",
     "login_sync",
     "logout_sync",
     "connect_to_server_sync",

hypha_rpc/client.py

@@ -0,0 +1,123 @@
+"""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)

hypha_rpc/http_client.py

@@ -0,0 +1,565 @@
+"""HTTP Streaming RPC Client.
+
+This module provides HTTP-based RPC transport as an alternative to WebSocket.
+It uses:
+- HTTP GET with streaming (NDJSON) for server-to-client messages
+- HTTP POST for client-to-server messages
+
+Benefits:
+- More resilient to network issues (each POST is independent)
+- Automatic reconnection for the stream
+- Works through more proxies and firewalls
+- Supports callbacks through the streaming channel
+"""
+
+import asyncio
+import inspect
+import io
+import json
+import logging
+import os
+import sys
+from typing import Callable, Optional
+
+import httpx
+import msgpack
+import shortuuid
+
+from .rpc import RPC
+from .utils import ObjectProxy, parse_service_url
+from .utils.schema import schema_function
+
+LOGLEVEL = os.environ.get("HYPHA_LOGLEVEL", "WARNING").upper()
+logging.basicConfig(level=LOGLEVEL, stream=sys.stdout)
+logger = logging.getLogger("http-client")
+logger.setLevel(LOGLEVEL)
+
+MAX_RETRY = 1000000
+
+
+class HTTPStreamingRPCConnection:
+    """HTTP Streaming RPC Connection.
+
+    Uses HTTP GET with streaming for receiving messages and HTTP POST for sending messages.
+    Supports two formats:
+    - NDJSON (default): JSON lines for text-based messages
+    - msgpack: Binary format with length-prefixed frames for binary data support
+    """
+
+    def __init__(
+        self,
+        server_url: str,
+        client_id: str,
+        workspace: Optional[str] = None,
+        token: Optional[str] = None,
+        reconnection_token: Optional[str] = None,
+        timeout: float = 60,
+        ssl=None,
+        token_refresh_interval: float = 2 * 60 * 60,
+        format: str = "json",  # "json" or "msgpack"
+    ):
+        """Initialize HTTP streaming connection.
+
+        Args:
+            server_url: The server URL (http:// or https://)
+            client_id: Unique client identifier
+            workspace: Target workspace
+            token: Authentication token
+            reconnection_token: Token for reconnection
+            timeout: Request timeout in seconds
+            ssl: SSL configuration (True/False/SSLContext)
+            token_refresh_interval: Interval for token refresh
+            format: Stream format - "json" (NDJSON) or "msgpack" (binary with length prefix)
+        """
+        self._server_url = server_url.rstrip("/")
+        self._client_id = client_id
+        self._workspace = workspace
+        self._token = token
+        self._reconnection_token = reconnection_token
+        self._timeout = timeout
+        self._ssl = ssl
+        self._token_refresh_interval = token_refresh_interval
+        self._format = format
+
+        self._handle_message: Optional[Callable] = None
+        self._handle_disconnected: Optional[Callable] = None
+        self._handle_connected: Optional[Callable] = None
+        self._is_async = False
+
+        self._closed = False
+        self._enable_reconnect = False
+        self._stream_task: Optional[asyncio.Task] = None
+        self._http_client: Optional[httpx.AsyncClient] = None
+
+        self.connection_info = None
+        self.manager_id = None
+
+    def on_message(self, handler: Callable):
+        """Register message handler."""
+        self._handle_message = handler
+        self._is_async = inspect.iscoroutinefunction(handler)
+
+    def on_disconnected(self, handler: Callable):
+        """Register disconnection handler."""
+        self._handle_disconnected = handler
+
+    def on_connected(self, handler: Callable):
+        """Register connection handler."""
+        self._handle_connected = handler
+        assert inspect.iscoroutinefunction(handler), "Handler must be async"
+
+    def _get_headers(self, for_stream: bool = False) -> dict:
+        """Get HTTP headers with authentication.
+
+        Args:
+            for_stream: If True, set Accept header based on format preference
+        """
+        headers = {
+            "Content-Type": "application/msgpack",
+        }
+        if for_stream:
+            if self._format == "msgpack":
+                headers["Accept"] = "application/x-msgpack-stream"
+            else:
+                headers["Accept"] = "application/x-ndjson"
+        if self._token:
+            headers["Authorization"] = f"Bearer {self._token}"
+        return headers
+
+    async def _create_http_client(self) -> httpx.AsyncClient:
+        """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
+        elif self._ssl is not None:
+            verify = self._ssl
+
+        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):
+        """Open the streaming connection."""
+        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"
+        params = {"client_id": self._client_id}
+        if self._format == "msgpack":
+            params["format"] = "msgpack"
+
+        try:
+            # Start streaming in background task
+            self._stream_task = asyncio.create_task(
+                self._stream_loop(stream_url, params)
+            )
+
+            # Wait for connection info (first message)
+            wait_start = asyncio.get_event_loop().time()
+            while self.connection_info is None:
+                await asyncio.sleep(0.1)
+                if asyncio.get_event_loop().time() - wait_start > self._timeout:
+                    raise TimeoutError("Timeout waiting for connection info")
+                if self._closed:
+                    raise ConnectionError("Connection closed during setup")
+
+            self.manager_id = self.connection_info.get("manager_id")
+            if self._workspace:
+                actual_ws = self.connection_info.get("workspace")
+                if actual_ws != self._workspace:
+                    raise ConnectionError(
+                        f"Connected to wrong workspace: {actual_ws}, expected: {self._workspace}"
+                    )
+            self._workspace = self.connection_info.get("workspace")
+
+            if "reconnection_token" in self.connection_info:
+                self._reconnection_token = self.connection_info["reconnection_token"]
+
+            logger.info(
+                f"HTTP streaming connected to workspace: {self._workspace}, "
+                f"manager_id: {self.manager_id}"
+            )
+
+            if self._handle_connected:
+                await self._handle_connected(self.connection_info)
+
+            return self.connection_info
+
+        except Exception as e:
+            logger.error(f"Failed to connect: {e}")
+            await self._cleanup()
+            raise
+
+    async def _stream_loop(self, url: str, params: dict):
+        """Main loop for receiving streaming messages."""
+        self._enable_reconnect = True
+        self._closed = False
+        retry = 0
+
+        while not self._closed and retry < MAX_RETRY:
+            try:
+                async with self._http_client.stream(
+                    "GET",
+                    url,
+                    params=params,
+                    headers=self._get_headers(for_stream=True),
+                ) as response:
+                    if response.status_code != 200:
+                        error_text = await response.aread()
+                        raise ConnectionError(
+                            f"Stream failed with status {response.status_code}: {error_text}"
+                        )
+
+                    retry = 0  # Reset retry counter on successful connection
+
+                    if self._format == "msgpack":
+                        # Binary msgpack stream with 4-byte length prefix
+                        await self._process_msgpack_stream(response)
+                    else:
+                        # NDJSON stream (line-based)
+                        await self._process_ndjson_stream(response)
+
+            except httpx.ReadTimeout:
+                logger.warning("Stream read timeout, reconnecting...")
+            except httpx.ConnectError as e:
+                logger.error(f"Connection error: {e}")
+            except ConnectionError as e:
+                logger.error(f"Connection error: {e}")
+                if not self._enable_reconnect:
+                    break
+            except asyncio.CancelledError:
+                logger.info("Stream task cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Stream error: {e}")
+
+            # Reconnection logic
+            if not self._closed and self._enable_reconnect:
+                retry += 1
+                delay = min(1.0 * (2 ** min(retry, 6)), 60.0)  # Max 60s
+                logger.info(f"Reconnecting in {delay:.1f}s (attempt {retry})")
+                await asyncio.sleep(delay)
+            else:
+                break
+
+        if not self._closed and self._handle_disconnected:
+            self._handle_disconnected("Stream ended")
+
+    async def _process_ndjson_stream(self, response):
+        """Process NDJSON (line-based JSON) stream."""
+        async for line in response.aiter_lines():
+            if self._closed:
+                break
+
+            if not line.strip():
+                continue
+
+            try:
+                message = json.loads(line)
+                await self._handle_stream_message(message)
+            except json.JSONDecodeError as e:
+                logger.warning(f"Failed to parse JSON message: {e}")
+            except Exception as e:
+                logger.error(f"Error handling message: {e}")
+
+    async def _process_msgpack_stream(self, response):
+        """Process msgpack stream with 4-byte length prefix."""
+        buffer = b""
+        async for chunk in response.aiter_bytes():
+            if self._closed:
+                break
+
+            buffer += chunk
+
+            # Process complete frames from buffer
+            while len(buffer) >= 4:
+                # Read 4-byte length prefix (big-endian)
+                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:]
+
+                try:
+                    # For msgpack, first check if it's a control message
+                    # Control messages have a "type" field we need to check
+                    unpacker = msgpack.Unpacker(io.BytesIO(frame_data))
+                    message = unpacker.unpack()
+
+                    # Check for control messages
+                    if isinstance(message, dict):
+                        msg_type = message.get("type")
+                        if msg_type == "connection_info":
+                            self.connection_info = message
+                            continue
+                        elif msg_type == "ping":
+                            continue
+                        elif msg_type == "reconnection_token":
+                            self._reconnection_token = message.get("reconnection_token")
+                            continue
+                        elif msg_type == "error":
+                            logger.error(f"Server error: {message.get('message')}")
+                            continue
+
+                    # For RPC messages, pass the raw frame data to the handler
+                    # The RPC layer expects raw msgpack bytes
+                    if self._handle_message:
+                        if self._is_async:
+                            await self._handle_message(frame_data)
+                        else:
+                            self._handle_message(frame_data)
+                except Exception as e:
+                    logger.error(f"Error handling msgpack message: {e}")
+
+    async def _handle_stream_message(self, message: dict):
+        """Handle a decoded stream message."""
+        # Handle connection info
+        if message.get("type") == "connection_info":
+            self.connection_info = message
+            return
+
+        # Handle ping (keep-alive)
+        if message.get("type") == "ping":
+            return
+
+        # Handle reconnection token refresh
+        if message.get("type") == "reconnection_token":
+            self._reconnection_token = message.get("reconnection_token")
+            return
+
+        # Handle errors
+        if message.get("type") == "error":
+            logger.error(f"Server error: {message.get('message')}")
+            return
+
+        # Pass to message handler (convert to msgpack for RPC)
+        if self._handle_message:
+            # Convert to msgpack bytes for RPC layer
+            data = msgpack.packb(message)
+            if self._is_async:
+                await self._handle_message(data)
+            else:
+                self._handle_message(data)
+
+    async def emit_message(self, data: bytes):
+        """Send a message to the server via HTTP POST."""
+        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"
+        params = {"client_id": self._client_id}
+
+        try:
+            response = await self._http_client.post(
+                url,
+                content=data,
+                params=params,
+                headers=self._get_headers(),
+            )
+
+            if response.status_code != 200:
+                error = response.json() if response.content else {"detail": "Unknown error"}
+                raise ConnectionError(f"POST failed: {error.get('detail', error)}")
+
+        except httpx.TimeoutException:
+            logger.error("Request timeout")
+            raise TimeoutError("Request timeout")
+        except Exception as e:
+            logger.error(f"Failed to send message: {e}")
+            raise
+
+    async def disconnect(self, reason: Optional[str] = None):
+        """Disconnect and cleanup."""
+        self._closed = True
+        self._enable_reconnect = False
+        await self._cleanup()
+        logger.info(f"HTTP streaming connection disconnected ({reason})")
+
+    async def _cleanup(self):
+        """Cleanup resources."""
+        if self._stream_task and not self._stream_task.done():
+            self._stream_task.cancel()
+            try:
+                await asyncio.wait_for(self._stream_task, timeout=1.0)
+            except (asyncio.CancelledError, asyncio.TimeoutError):
+                pass
+            self._stream_task = None
+
+        if self._http_client:
+            await self._http_client.aclose()
+            self._http_client = None
+
+
+def normalize_server_url(server_url: str) -> str:
+    """Normalize server URL for HTTP transport."""
+    if not server_url:
+        raise ValueError("server_url is required")
+
+    # Convert ws:// to http://
+    if server_url.startswith("ws://"):
+        server_url = server_url.replace("ws://", "http://")
+    elif server_url.startswith("wss://"):
+        server_url = server_url.replace("wss://", "https://")
+
+    # Remove /ws suffix if present (WebSocket endpoint)
+    if server_url.endswith("/ws"):
+        server_url = server_url[:-3]
+
+    return server_url.rstrip("/")
+
+
+def connect_to_server_http(config=None, **kwargs):
+    """Connect to server using HTTP streaming transport.
+
+    This is a convenience function that sets transport="http" automatically.
+    For a unified interface, use connect_to_server(transport="http") instead.
+
+    Args:
+        config: Configuration dict with server_url, token, workspace, etc.
+        **kwargs: Additional configuration options
+
+    Returns:
+        ServerContextManager that can be used as async context manager
+    """
+    from .client import connect_to_server
+    config = config or {}
+    config.update(kwargs)
+    config["transport"] = "http"
+    return connect_to_server(config)
+
+
+async def _connect_to_server_http(config: dict):
+    """Internal function to establish HTTP streaming connection."""
+    client_id = config.get("client_id")
+    if client_id is None:
+        client_id = shortuuid.uuid()
+
+    server_url = normalize_server_url(config["server_url"])
+
+    connection = HTTPStreamingRPCConnection(
+        server_url,
+        client_id,
+        workspace=config.get("workspace"),
+        token=config.get("token"),
+        reconnection_token=config.get("reconnection_token"),
+        timeout=config.get("method_timeout", 30),
+        ssl=config.get("ssl"),
+        token_refresh_interval=config.get("token_refresh_interval", 2 * 60 * 60),
+        # Default to msgpack for full binary support and proper RPC message handling
+        format=config.get("format", "msgpack"),
+    )
+
+    connection_info = await connection.open()
+    assert connection_info, "Failed to connect to server"
+
+    await asyncio.sleep(0.1)
+
+    workspace = connection_info["workspace"]
+
+    rpc = RPC(
+        connection,
+        client_id=client_id,
+        workspace=workspace,
+        default_context={"connection_type": "http_streaming"},
+        name=config.get("name"),
+        method_timeout=config.get("method_timeout"),
+        loop=config.get("loop"),
+        app_id=config.get("app_id"),
+        server_base_url=connection_info.get("public_base_url"),
+    )
+
+    await rpc.wait_for("services_registered", timeout=config.get("method_timeout", 120))
+
+    wm = await rpc.get_manager_service(
+        {"timeout": config.get("method_timeout", 30), "case_conversion": "snake"}
+    )
+    wm.rpc = rpc
+
+    # Add standard methods
+    wm.disconnect = schema_function(
+        rpc.disconnect,
+        name="disconnect",
+        description="Disconnect from server",
+        parameters={"properties": {}, "type": "object"},
+    )
+
+    wm.register_service = schema_function(
+        rpc.register_service,
+        name="register_service",
+        description="Register a service",
+        parameters={
+            "properties": {
+                "service": {"description": "Service to register", "type": "object"},
+            },
+            "required": ["service"],
+            "type": "object",
+        },
+    )
+
+    _get_service = wm.get_service
+
+    async def get_service(query, config=None, **kwargs):
+        config = config or {}
+        config.update(kwargs)
+        return await _get_service(query, config=config)
+
+    if hasattr(wm.get_service, "__schema__"):
+        get_service.__schema__ = wm.get_service.__schema__
+    wm.get_service = get_service
+
+    async def serve():
+        await asyncio.Event().wait()
+
+    wm.serve = schema_function(
+        serve, name="serve", description="Run event loop forever", parameters={}
+    )
+
+    if connection_info:
+        wm.config.update(connection_info)
+
+    # 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')}")
+                await rpc.disconnect()
+
+        rpc.on("force-exit", handle_disconnect)
+
+    return wm
+
+
+def get_remote_service_http(service_uri: str, config=None, **kwargs):
+    """Get a remote service using HTTP transport.
+
+    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
+    config = config or {}
+    config.update(kwargs)
+    config["transport"] = "http"
+    return get_remote_service(service_uri, config)

hypha_rpc/rpc.py

@@ -1237,7 +1237,11 @@ class RPC(MessageEmitter):
         service = self._services.get(service_id)
         if not service:
             raise KeyError("Service not found: %s", service_id)
-        service["config"]["workspace"] = context["ws"]
+        # Note: Do NOT mutate service["config"]["workspace"] here!
+        # Doing so would corrupt the stored service config when called from
+        # a different workspace (e.g., "public"), causing reconnection to fail
+        # because _extract_service_info would use the wrong workspace value.
+
         # allow access for the same workspace
         if service["config"].get("visibility", "protected") in ["public", "unlisted"]:
             return service

hypha_rpc/websocket_client.py

@@ -738,69 +738,8 @@ async def logout(config):
         await server.disconnect()
 
 
-class ServerContextManager:
-    """Server context manager."""
-
-    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.wm = None
-
-    async def __aenter__(self):
-        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 the server."""
-    return ServerContextManager(config=config, **kwargs)
-
-
-def get_remote_service(service_uri, config=None, **kwargs):
-    """Get a remote service."""
-    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)
+# 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):

{hypha_rpc-0.20.87.dist-info → hypha_rpc-0.20.89.dist-info}/METADATA

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

@@ -1,18 +1,20 @@
-hypha_rpc/VERSION,sha256=t0-iGHxhjY_DwlQzE8653E1Bi0iVQX8Fua4G775GVSw,26
-hypha_rpc/__init__.py,sha256=l4WUo9cku9B5Hx_vMvgmFwQ3eOIsuoSzLy4Z-Amqf6I,4641
+hypha_rpc/VERSION,sha256=vpnrMBAiB3l6wEQDy9_zHUIqw7t3BxjiItBOfzE1WXU,26
+hypha_rpc/__init__.py,sha256=Nm01vho0uIMXET8-lqxaWTRgoKQD-0SEhpmS9odRed0,4721
+hypha_rpc/client.py,sha256=9c3Qd1bboNiEc_5P4jRLi233VFHyyME8alZYZ5ZZq6s,4551
+hypha_rpc/http_client.py,sha256=xdMhU64kte2T7uPVtwzRRWKOnYB_wRTCVg0qKzLllh8,20285
 hypha_rpc/pyodide_sse.py,sha256=o1-6Bqb7bcplSy7pwkmtQb6vKeJsyxex_RebqNd3wX8,2960
 hypha_rpc/pyodide_websocket.py,sha256=XjrgKYySUSNYma-rXjHrSv08YCxj5t4hYEQnK15D6cE,18749
-hypha_rpc/rpc.py,sha256=KIq1KiYqnDBi9iVmN9lvmWucyIpkG_fmyflmnBi9MZI,115334
+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=are48UpC4WUva3y8DhrD10gPcVeOfXE-9B6I9Zu-4wA,51166
+hypha_rpc/websocket_client.py,sha256=haH-SKxaAWNnest3doBVhp7H5XlgqVFjFOW-KnFqxPo,48914
 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.87.dist-info/METADATA,sha256=QVo6wQUTWi8bqEMU698IJ0A0FqhSYUWQq24qeOnA47I,924
-hypha_rpc-0.20.87.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-hypha_rpc-0.20.87.dist-info/top_level.txt,sha256=uShPbaPGP-Ig8OVnQcT6sEzV0Qhb6wfxSJ3uCmYaB58,10
-hypha_rpc-0.20.87.dist-info/RECORD,,
+hypha_rpc-0.20.89.dist-info/METADATA,sha256=Kybx_aqgy8mSAGioAlrqRJHmnjJwn29rcer8V5lBpV0,924
+hypha_rpc-0.20.89.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+hypha_rpc-0.20.89.dist-info/top_level.txt,sha256=uShPbaPGP-Ig8OVnQcT6sEzV0Qhb6wfxSJ3uCmYaB58,10
+hypha_rpc-0.20.89.dist-info/RECORD,,