chore: make init awaitable

Author: guibeira

packages/python/iii-example/src/iii.py

@@ -7,10 +7,10 @@
 _iii: III | None = None
 
 
-def init_iii() -> III:
+async def init_iii() -> III:
     global _iii
     if _iii is None:
-        _iii = init(
+        _iii = await init(
             address=engine_ws_url,
             options=InitOptions(
                 worker_name="iii-example",

packages/python/iii-example/src/main.py

@@ -187,7 +187,7 @@ async def _post_example(req: ApiRequest, ctx) -> ApiResponse:
 async def _async_main() -> None:
     from .iii import init_iii
 
-    init_iii()
+    await init_iii()
     _setup()
 
     while True:

packages/python/iii-example/uv.lock

@@ -1,6 +1,5 @@
 """III SDK for Python."""
 
-import asyncio
 import logging
 
 from .context import Context, get_context, with_context
@@ -32,19 +31,10 @@
 from .types import ApiRequest, ApiResponse, FunctionsAvailableCallback, RemoteFunctionHandler
 
 
-def init(address: str, options: InitOptions | None = None) -> III:
-    """Create an III client and auto-start its connection task."""
+async def init(address: str, options: InitOptions | None = None) -> III:
+    """Create an III client and connect to the server."""
     client = III(address, options)
-
-    try:
-        loop = asyncio.get_running_loop()
-    except RuntimeError as exc:
-        raise RuntimeError(
-            "iii.init() requires an active asyncio event loop. "
-            "Call it inside async code or use `client = III(...); await client.connect()`"
-        ) from exc
-
-    loop.create_task(client.connect())
+    await client.connect()
     return client
 
 

packages/python/iii/src/iii/__init__.py

@@ -10,33 +10,17 @@
 
 
 @pytest.fixture(autouse=True)
-def reset_otel():
-    yield
-    # III.connect() calls init_otel() which sets global providers;
-    # reset them so subsequent test files start with a clean slate.
-    try:
-        from iii.telemetry import shutdown_otel
-        shutdown_otel()
-    except Exception:
-        pass
-    try:
-        import opentelemetry._logs._internal as _li
-        _li._LOGGER_PROVIDER = None
-        _li._LOGGER_PROVIDER_SET_ONCE._done = False
-    except Exception:
-        pass
-    try:
-        import opentelemetry.trace._internal as _ti
-        _ti._TRACER_PROVIDER = None
-        _ti._TRACER_PROVIDER_SET_ONCE._done = False
-    except Exception:
-        pass
-    try:
-        import opentelemetry.metrics._internal as _mi
-        _mi._METER_PROVIDER = None
-        _mi._METER_PROVIDER_SET_ONCE._done = False
-    except Exception:
-        pass
+def disable_otel(monkeypatch: pytest.MonkeyPatch):
+    """Prevent OTel from starting a SharedEngineConnection during these tests.
+
+    The monkeypatched websockets.connect returns a plain coroutine, not an
+    async-context-manager, so SharedEngineConnection._run() would produce
+    'coroutine was never awaited' warnings.
+    """
+    import iii.telemetry as telemetry_mod
+
+    monkeypatch.setattr(telemetry_mod, "init_otel", lambda config=None, loop=None: None)
+    monkeypatch.setattr(telemetry_mod, "attach_event_loop", lambda loop: None)
 
 
 class FakeWebSocket:

packages/python/iii/tests/test_iii_registration_dedup.py

@@ -11,23 +11,18 @@ def anyio_backend() -> str:
 
 
 @pytest.mark.anyio
-async def test_init_schedules_connect(monkeypatch: pytest.MonkeyPatch) -> None:
-    called = asyncio.Event()
+async def test_init_awaits_connect(monkeypatch: pytest.MonkeyPatch) -> None:
+    called = False
 
     async def fake_connect(self: III) -> None:
-        called.set()
+        nonlocal called
+        called = True
 
     monkeypatch.setattr(III, "connect", fake_connect)
 
-    client = init("ws://fake")
+    client = await init("ws://fake")
     assert isinstance(client, III)
-
-    await asyncio.wait_for(called.wait(), timeout=0.2)
-
-
-def test_init_requires_running_loop() -> None:
-    with pytest.raises(RuntimeError, match="active asyncio event loop"):
-        init("ws://fake")
+    assert called
 
 
 @pytest.mark.anyio
@@ -49,14 +44,11 @@ async def fake_do_connect(self: III) -> None:
     monkeypatch.setattr(telemetry, "attach_event_loop", fake_attach_event_loop)
     monkeypatch.setattr(III, "_do_connect", fake_do_connect)
 
-    client = init(
+    client = await init(
         "ws://fake",
         InitOptions(otel={"enabled": True, "service_name": "iii-python-init-test"}),
     )
 
-    # let scheduled connect task run
-    await asyncio.sleep(0)
-
     assert isinstance(client, III)
     assert captured["config"] is not None
     assert getattr(captured["config"], "service_name", None) == "iii-python-init-test"

packages/python/iii/tests/test_init_api.py

@@ -14,7 +14,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             otel: Some(OtelConfig::default()),
             ..Default::default()
         },
-    )?;
+    )
+    .await?;
 
     // Register HTTP fetch API handlers (GET & POST http-fetch with OTel instrumentation)
     http_example::setup(&iii);

packages/rust/iii-example/src/main.rs

@@ -32,7 +32,7 @@ pub struct InitOptions {
     pub otel: Option<crate::telemetry::types::OtelConfig>,
 }
 
-pub fn init(address: &str, options: InitOptions) -> Result<III, IIIError> {
+pub async fn init(address: &str, options: InitOptions) -> Result<III, IIIError> {
     let InitOptions {
         metadata,
         #[cfg(feature = "otel")]
@@ -50,15 +50,7 @@ pub fn init(address: &str, options: InitOptions) -> Result<III, IIIError> {
         iii.set_otel_config(cfg);
     }
 
-    let handle = tokio::runtime::Handle::try_current()
-        .map_err(|_| IIIError::Runtime("iii_sdk::init requires an active Tokio runtime".into()))?;
-
-    let client = iii.clone();
-    handle.spawn(async move {
-        if let Err(err) = client.connect().await {
-            tracing::warn!(error = %err, "iii_sdk::init auto-connect failed");
-        }
-    });
+    iii.connect().await?;
 
     Ok(iii)
 }

packages/rust/iii/src/lib.rs

@@ -1,17 +1,9 @@
-use iii_sdk::{IIIError, InitOptions, init};
-
-#[test]
-fn init_without_runtime_returns_runtime_error() {
-    match init("ws://127.0.0.1:49134", InitOptions::default()) {
-        Err(IIIError::Runtime(_)) => {}
-        Err(other) => panic!("expected Runtime error, got {other:?}"),
-        Ok(_) => panic!("expected init to fail without Tokio runtime"),
-    }
-}
+use iii_sdk::{InitOptions, init};
 
 #[tokio::test]
 async fn init_with_runtime_returns_sdk_instance() {
     let client = init("ws://127.0.0.1:49134", InitOptions::default())
+        .await
         .expect("init should succeed inside Tokio runtime");
 
     // API should remain usable immediately after init()
@@ -33,6 +25,7 @@ async fn init_applies_otel_config_before_auto_connect() {
             ..Default::default()
         },
     )
+    .await
     .expect("init should succeed");
 
     client.register_function("test.echo.otel", |input| async move { Ok(input) });