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

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

@@ -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.93/hypha_rpc/VERSION

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

{hypha_rpc-0.20.91 → hypha_rpc-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-0.20.91 → hypha_rpc-0.20.93}/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-0.20.91 → hypha_rpc-0.20.93}/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 → hypha_rpc-0.20.93}/hypha_rpc.egg-info/PKG-INFO

@@ -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 → hypha_rpc-0.20.93}/hypha_rpc.egg-info/SOURCES.txt

@@ -4,7 +4,6 @@ pyproject.toml
 setup.cfg
 hypha_rpc/VERSION
 hypha_rpc/__init__.py
-hypha_rpc/client.py
 hypha_rpc/http_client.py
 hypha_rpc/pyodide_sse.py
 hypha_rpc/pyodide_websocket.py
@@ -23,6 +22,7 @@ hypha_rpc/utils/mcp.py
 hypha_rpc/utils/pydantic.py
 hypha_rpc/utils/schema.py
 hypha_rpc/utils/serve.py
+tests/test_http_rpc.py
 tests/test_mcp.py
 tests/test_reconnection_runner.py
 tests/test_reconnection_stability.py

{hypha_rpc-0.20.91 → hypha_rpc-0.20.93}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hypha_rpc"
-version = "0.20.91"
+version = "0.20.93"
 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.93/tests/test_http_rpc.py

@@ -0,0 +1,422 @@
+"""Test HTTP RPC transport for hypha-rpc standalone tests.
+
+These tests connect to a remote Hypha server to test HTTP transport functionality.
+"""
+
+import pytest
+import numpy as np
+import asyncio
+from hypha_rpc import connect_to_server
+
+
+# Use public test server - these tests require a running Hypha server
+SERVER_URL = "https://hypha.aicell.io"
+
+
+class TestHTTPObjectTransmission:
+    """Test HTTP transport with complex objects and callbacks."""
+
+    @pytest.mark.asyncio
+    async def test_http_numpy_array_transmission(self):
+        """Test transmitting numpy arrays over HTTP transport."""
+        # Service provider via WebSocket
+        ws_server = await connect_to_server({
+            "server_url": SERVER_URL,
+            "client_id": "numpy-provider-ws-test",
+        })
+
+        try:
+            workspace = ws_server.config["workspace"]
+
+            # Register service that works with numpy arrays
+            await ws_server.register_service({
+                "id": "numpy-service",
+                "name": "Numpy Service",
+                "config": {"visibility": "public"},
+                "process_array": lambda arr: {
+                    "shape": list(arr.shape),  # Convert to list for JSON
+                    "dtype": str(arr.dtype),
+                    "sum": float(np.sum(arr)),
+                    "mean": float(np.mean(arr)),
+                    "result_array": arr * 2,  # Return modified array
+                },
+                "reshape": lambda arr, shape: np.reshape(arr, shape),
+            })
+
+            token = await ws_server.generate_token()
+
+            # HTTP client connects
+            http_server = await connect_to_server({
+                "server_url": SERVER_URL,
+                "workspace": workspace,
+                "client_id": "numpy-consumer-http-test",
+                "transport": "http",
+                "token": token,
+            })
+
+            try:
+                service = await http_server.get_service(f"{ws_server.config['client_id']}:numpy-service")
+
+                # Test 1: Send and receive numpy array
+                test_array = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float32)
+                result = await service.process_array(test_array)
+
+                assert result["shape"] == [2, 3]
+                assert result["dtype"] == "float32"
+                assert result["sum"] == 21.0
+                assert result["mean"] == 3.5
+
+                result_array = result["result_array"]
+                assert isinstance(result_array, np.ndarray)
+                assert np.array_equal(result_array, test_array * 2)
+
+                # Test 2: Large array
+                large_array = np.random.rand(100, 100)
+                result2 = await service.process_array(large_array)
+                assert result2["shape"] == [100, 100]
+
+                # Test 3: Reshape operation
+                flat_array = np.arange(12)
+                reshaped = await service.reshape(flat_array, (3, 4))
+                assert reshaped.shape == (3, 4)
+                assert np.array_equal(reshaped, np.arange(12).reshape(3, 4))
+
+            finally:
+                await http_server.disconnect()
+
+        finally:
+            await ws_server.disconnect()
+
+    @pytest.mark.asyncio
+    async def test_http_nested_objects_transmission(self):
+        """Test transmitting nested complex objects over HTTP."""
+        ws_server = await connect_to_server({
+            "server_url": SERVER_URL,
+            "client_id": "nested-provider-ws-test",
+        })
+
+        try:
+            workspace = ws_server.config["workspace"]
+
+            # Service that handles nested objects
+            await ws_server.register_service({
+                "id": "nested-service",
+                "name": "Nested Object Service",
+                "config": {"visibility": "public"},
+                "process_nested": lambda data: {
+                    "received_keys": list(data.keys()),
+                    "array_sum": float(np.sum(data["array"])) if "array" in data else 0,
+                    "nested_count": len(data.get("nested", {}).get("items", [])),
+                    "echo": data,
+                },
+            })
+
+            token = await ws_server.generate_token()
+
+            http_server = await connect_to_server({
+                "server_url": SERVER_URL,
+                "workspace": workspace,
+                "client_id": "nested-consumer-http-test",
+                "transport": "http",
+                "token": token,
+            })
+
+            try:
+                service = await http_server.get_service(f"{ws_server.config['client_id']}:nested-service")
+
+                # Complex nested structure
+                test_data = {
+                    "string": "test",
+                    "number": 42,
+                    "array": np.array([1, 2, 3, 4, 5]),
+                    "nested": {
+                        "items": [1, 2, 3],
+                        "metadata": {
+                            "name": "test_item",
+                            "values": [10, 20, 30],
+                        },
+                    },
+                    "list_of_arrays": [
+                        np.array([1, 2]),
+                        np.array([3, 4]),
+                    ],
+                }
+
+                result = await service.process_nested(test_data)
+
+                assert set(result["received_keys"]) == set(test_data.keys())
+                assert result["array_sum"] == 15.0
+                assert result["nested_count"] == 3
+
+                # Verify echo preserves structure
+                echo = result["echo"]
+                assert echo["string"] == "test"
+                assert echo["number"] == 42
+                assert np.array_equal(echo["array"], test_data["array"])
+                assert echo["nested"]["metadata"]["name"] == "test_item"
+
+            finally:
+                await http_server.disconnect()
+
+        finally:
+            await ws_server.disconnect()
+
+    @pytest.mark.asyncio
+    async def test_http_callbacks_basic(self):
+        """Test basic callback functionality over HTTP transport."""
+        ws_server = await connect_to_server({
+            "server_url": SERVER_URL,
+            "client_id": "callback-provider-ws-test",
+        })
+
+        try:
+            workspace = ws_server.config["workspace"]
+
+            # Service that uses callbacks
+            async def call_multiple_times(callback, count):
+                results = []
+                for i in range(count):
+                    result = await callback(i)
+                    results.append(result)
+                return results
+
+            async def process_with_progress(data, progress_callback):
+                for i in range(len(data)):
+                    await progress_callback({"step": i, "total": len(data)})
+                return sum(data)
+
+            await ws_server.register_service({
+                "id": "callback-service",
+                "name": "Callback Service",
+                "config": {"visibility": "public"},
+                "call_multiple_times": call_multiple_times,
+                "process_with_progress": process_with_progress,
+            })
+
+            token = await ws_server.generate_token()
+
+            http_server = await connect_to_server({
+                "server_url": SERVER_URL,
+                "workspace": workspace,
+                "client_id": "callback-consumer-http-test",
+                "transport": "http",
+                "token": token,
+            })
+
+            try:
+                service = await http_server.get_service(f"{ws_server.config['client_id']}:callback-service")
+
+                # Test 1: Simple callback
+                callback_results = []
+
+                def test_callback(value):
+                    callback_results.append(value)
+                    return value * 2
+
+                results = await service.call_multiple_times(test_callback, 5)
+                assert len(callback_results) == 5
+                assert callback_results == [0, 1, 2, 3, 4]
+                assert results == [0, 2, 4, 6, 8]
+
+                # Test 2: Progress callback
+                progress_updates = []
+
+                def progress_callback(info):
+                    progress_updates.append(info)
+
+                test_data = [10, 20, 30, 40]
+                result = await service.process_with_progress(test_data, progress_callback)
+                assert result == 100
+                assert len(progress_updates) == 4
+                assert progress_updates[0] == {"step": 0, "total": 4}
+                assert progress_updates[-1] == {"step": 3, "total": 4}
+
+            finally:
+                await http_server.disconnect()
+
+        finally:
+            await ws_server.disconnect()
+
+    @pytest.mark.asyncio
+    async def test_http_async_callbacks(self):
+        """Test async callback functionality over HTTP transport."""
+        ws_server = await connect_to_server({
+            "server_url": SERVER_URL,
+            "client_id": "async-callback-provider-ws-test",
+        })
+
+        try:
+            workspace = ws_server.config["workspace"]
+
+            # Service with async callback support
+            async def process_async_callback(items, async_callback):
+                results = []
+                for item in items:
+                    result = await async_callback(item)
+                    results.append(result)
+                return results
+
+            await ws_server.register_service({
+                "id": "async-callback-service",
+                "name": "Async Callback Service",
+                "config": {"visibility": "public"},
+                "process_async": process_async_callback,
+            })
+
+            token = await ws_server.generate_token()
+
+            http_server = await connect_to_server({
+                "server_url": SERVER_URL,
+                "workspace": workspace,
+                "client_id": "async-callback-consumer-http-test",
+                "transport": "http",
+                "token": token,
+            })
+
+            try:
+                service = await http_server.get_service(f"{ws_server.config['client_id']}:async-callback-service")
+
+                # Async callback
+                async def async_transform(value):
+                    await asyncio.sleep(0.01)  # Simulate async work
+                    return value ** 2
+
+                test_items = [1, 2, 3, 4, 5]
+                results = await service.process_async(test_items, async_transform)
+                assert results == [1, 4, 9, 16, 25]
+
+            finally:
+                await http_server.disconnect()
+
+        finally:
+            await ws_server.disconnect()
+
+    @pytest.mark.asyncio
+    async def test_http_callback_with_numpy(self):
+        """Test callbacks that pass numpy arrays over HTTP."""
+        ws_server = await connect_to_server({
+            "server_url": SERVER_URL,
+            "client_id": "numpy-callback-provider-ws-test",
+        })
+
+        try:
+            workspace = ws_server.config["workspace"]
+
+            # Service that sends arrays to callbacks
+            async def transform_batch(arrays, transform_callback):
+                results = []
+                for arr in arrays:
+                    result = await transform_callback(arr)
+                    results.append(result)
+                return results
+
+            await ws_server.register_service({
+                "id": "numpy-callback-service",
+                "name": "Numpy Callback Service",
+                "config": {"visibility": "public"},
+                "transform_batch": transform_batch,
+            })
+
+            token = await ws_server.generate_token()
+
+            http_server = await connect_to_server({
+                "server_url": SERVER_URL,
+                "workspace": workspace,
+                "client_id": "numpy-callback-consumer-http-test",
+                "transport": "http",
+                "token": token,
+            })
+
+            try:
+                service = await http_server.get_service(f"{ws_server.config['client_id']}:numpy-callback-service")
+
+                # Callback that processes numpy arrays
+                def array_processor(arr):
+                    return {
+                        "sum": float(np.sum(arr)),
+                        "modified": arr * 3,
+                    }
+
+                test_arrays = [
+                    np.array([1, 2, 3]),
+                    np.array([4, 5, 6]),
+                    np.array([7, 8, 9]),
+                ]
+
+                results = await service.transform_batch(test_arrays, array_processor)
+
+                assert len(results) == 3
+                assert results[0]["sum"] == 6.0
+                assert results[1]["sum"] == 15.0
+                assert results[2]["sum"] == 24.0
+
+                assert np.array_equal(results[0]["modified"], np.array([3, 6, 9]))
+                assert np.array_equal(results[1]["modified"], np.array([12, 15, 18]))
+                assert np.array_equal(results[2]["modified"], np.array([21, 24, 27]))
+
+            finally:
+                await http_server.disconnect()
+
+        finally:
+            await ws_server.disconnect()
+
+    @pytest.mark.asyncio
+    async def test_http_binary_data_transmission(self):
+        """Test transmitting raw binary data over HTTP."""
+        ws_server = await connect_to_server({
+            "server_url": SERVER_URL,
+            "client_id": "binary-provider-ws-test",
+        })
+
+        try:
+            workspace = ws_server.config["workspace"]
+
+            # Service that handles binary data
+            await ws_server.register_service({
+                "id": "binary-service",
+                "name": "Binary Service",
+                "config": {"visibility": "public"},
+                "process_binary": lambda data: {
+                    "length": len(data),
+                    "first_bytes": data[:10],
+                    "reversed": bytes(reversed(data)),
+                },
+                "concat_binary": lambda parts: b"".join(parts),
+            })
+
+            token = await ws_server.generate_token()
+
+            http_server = await connect_to_server({
+                "server_url": SERVER_URL,
+                "workspace": workspace,
+                "client_id": "binary-consumer-http-test",
+                "transport": "http",
+                "token": token,
+            })
+
+            try:
+                service = await http_server.get_service(f"{ws_server.config['client_id']}:binary-service")
+
+                # Test 1: Send binary data
+                test_data = b"Hello, World! This is binary data."
+                result = await service.process_binary(test_data)
+
+                assert result["length"] == len(test_data)
+                assert result["first_bytes"] == test_data[:10]
+                assert result["reversed"] == bytes(reversed(test_data))
+
+                # Test 2: Multiple binary chunks
+                parts = [b"Part1", b"Part2", b"Part3"]
+                concatenated = await service.concat_binary(parts)
+                assert concatenated == b"Part1Part2Part3"
+
+            finally:
+                await http_server.disconnect()
+
+        finally:
+            await ws_server.disconnect()
+
+
+if __name__ == "__main__":
+    # Allow running tests directly
+    pytest.main([__file__, "-v", "-s"])

hypha_rpc-0.20.91/hypha_rpc/VERSION

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

hypha_rpc-0.20.91/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)