iii-sdk 0.17.0.dev1__tar.gz → 0.18.0.dev1__tar.gz

{iii_sdk-0.17.0.dev1 → iii_sdk-0.18.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iii-sdk
-Version: 0.17.0.dev1
+Version: 0.18.0.dev1
 Summary: III SDK for Python
 Project-URL: Homepage, https://github.com/iii-hq/iii
 Project-URL: Repository, https://github.com/iii-hq/iii
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
-Requires-Dist: iii-observability==0.17.0.dev1
+Requires-Dist: iii-observability==0.18.0.dev1
 Requires-Dist: opentelemetry-api>=1.25
 Requires-Dist: pydantic>=2.0
 Requires-Dist: websockets>=12.0

{iii_sdk-0.17.0.dev1 → iii_sdk-0.18.0.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "iii-sdk"
-version = "0.17.0.dev1"
+version = "0.18.0.dev1"
 description = "III SDK for Python"
 authors = [{ name = "III" }]
 license = { text = "Apache-2.0" }
@@ -23,7 +23,7 @@ dependencies = [
     "websockets>=12.0",
     "pydantic>=2.0",
     "opentelemetry-api>=1.25",
-    "iii-observability==0.17.0.dev1",
+    "iii-observability==0.18.0.dev1",
 ]
 
 [project.urls]

{iii_sdk-0.17.0.dev1 → iii_sdk-0.18.0.dev1}/src/iii/channels.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import asyncio
 import logging
+from dataclasses import dataclass
+from enum import Enum
 from typing import Any, AsyncIterator, Callable
 from urllib.parse import quote
 
@@ -17,6 +19,51 @@ log = logging.getLogger("iii.channels")
 MAX_FRAME_SIZE = 64 * 1024
 
 
+class ChannelDirection(str, Enum):
+    """Direction of a streaming channel reference.
+
+    Mirrors the Rust SDK's ``ChannelDirection`` enum. The string values
+    (``"read"`` / ``"write"``) match the wire format used by
+    :class:`StreamChannelRef.direction`.
+    """
+
+    READ = "read"
+    WRITE = "write"
+
+
+@dataclass
+class ChannelItem:
+    """A single frame transferred over a channel.
+
+    Mirrors the Rust SDK's ``ChannelItem`` enum. Exactly one of ``text`` or
+    ``binary`` is set; use :meth:`text_item` / :meth:`binary_item` to
+    construct instances.
+    """
+
+    text: str | None = None
+    binary: bytes | None = None
+
+    def __post_init__(self) -> None:
+        if (self.text is None) == (self.binary is None):
+            raise ValueError("ChannelItem requires exactly one of `text` or `binary`")
+
+    @classmethod
+    def text_item(cls, value: str) -> "ChannelItem":
+        return cls(text=value, binary=None)
+
+    @classmethod
+    def binary_item(cls, value: bytes) -> "ChannelItem":
+        return cls(text=None, binary=value)
+
+    @property
+    def is_text(self) -> bool:
+        return self.text is not None
+
+    @property
+    def is_binary(self) -> bool:
+        return self.binary is not None
+
+
 def build_channel_url(
     engine_ws_base: str,
     channel_id: str,

iii_sdk-0.18.0.dev1/src/iii/helpers.py

@@ -0,0 +1,80 @@
+"""Helper free functions that operate on an :class:`III` client instance.
+
+These were previously instance methods on the SDK client. They take the
+``iii`` client as the first argument so the public surface of the client
+stays focused on the core lifecycle and registration methods.
+
+Mirrors the Rust ``iii_sdk::helpers`` module and the Node
+``iii-sdk/helpers`` subpath export.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Protocol, TypeVar
+
+from .channels import ChannelDirection, ChannelItem
+from .stream import IStream
+from .types import Channel, IIIClient, extract_channel_refs, is_channel_ref
+
+TData = TypeVar("TData")
+
+__all__ = [
+    "ChannelDirection",
+    "ChannelItem",
+    "create_channel",
+    "create_channel_async",
+    "create_stream",
+    "extract_channel_refs",
+    "is_channel_ref",
+]
+
+
+class _IIIWithHelperShims(IIIClient, Protocol):
+    """Internal Protocol that adds the ``_helpers_*`` shim methods.
+
+    The free functions below delegate to these private methods on the
+    concrete :class:`III` instance. Defining the Protocol here mirrors the
+    Node SDK's ``IIIWithHelperShims`` intersection type — callers see the
+    public :class:`IIIClient` Protocol; helpers see the shims internally.
+    """
+
+    def _helpers_create_channel(self, buffer_size: int | None = None) -> Channel: ...
+
+    async def _helpers_create_channel_async(
+        self, buffer_size: int | None = None
+    ) -> Channel: ...
+
+    def _helpers_create_stream(
+        self, stream_name: str, stream: IStream[Any]
+    ) -> None: ...  # noqa: D401 — internal shim, generic erased at the boundary
+
+
+def create_channel(iii: IIIClient, buffer_size: int | None = None) -> Channel:
+    """Create a streaming channel pair (sync wrapper).
+
+    Free-function form of the former ``III.create_channel`` instance method.
+    """
+    shim: _IIIWithHelperShims = iii  # type: ignore[assignment]
+    return shim._helpers_create_channel(buffer_size)
+
+
+async def create_channel_async(
+    iii: IIIClient, buffer_size: int | None = None
+) -> Channel:
+    """Create a streaming channel pair (async).
+
+    Free-function form of the former ``III.create_channel_async`` method.
+    """
+    shim: _IIIWithHelperShims = iii  # type: ignore[assignment]
+    return await shim._helpers_create_channel_async(buffer_size)
+
+
+def create_stream(iii: IIIClient, stream_name: str, stream: IStream[TData]) -> None:
+    """Register a custom stream implementation.
+
+    Free-function form of the former ``III.create_stream`` instance method.
+    The ``IStream`` generic ``TData`` is preserved so type checkers can
+    validate the implementor's get/set/delete/list signatures.
+    """
+    shim: _IIIWithHelperShims = iii  # type: ignore[assignment]
+    shim._helpers_create_stream(stream_name, stream)

{iii_sdk-0.17.0.dev1 → iii_sdk-0.18.0.dev1}/src/iii/iii.py

@@ -1142,49 +1142,20 @@ class III:
                 invocation_id=invocation_id,
             )
 
-    def create_channel(self, buffer_size: int | None = None) -> Channel:
-        """Create a streaming channel pair for worker-to-worker data transfer.
+    # Internal: backing methods for items in the `iii.helpers` submodule.
+    # These are renamed with a leading underscore so they don't appear on the
+    # public `IIIClient` Protocol; callers use `iii.helpers.<name>(iii, ...)`.
+    def _helpers_create_channel(self, buffer_size: int | None = None) -> Channel:
+        """Internal shim backing :func:`iii.helpers.create_channel`.
 
-        The returned ``Channel`` contains a local ``writer`` / ``reader``
-        and their serializable refs (``writer_ref``, ``reader_ref``) that
-        can be passed as fields in invocation data to other functions.
-
-        Args:
-            buffer_size: Buffer capacity for the channel. Defaults to ``64``.
-
-        Returns:
-            A ``Channel`` object with ``writer``, ``reader``,
-            ``writer_ref``, and ``reader_ref`` attributes.  Pass
-            ``writer_ref`` or ``reader_ref`` in trigger payloads to
-            share channels across functions -- the receiving function
-            can reconstruct a ``ChannelWriter`` or ``ChannelReader``
-            from the ref.
-
-        Examples:
-            >>> ch = iii.create_channel()
-            >>> fn = iii.register_function("producer", producer_handler)
-            >>> iii.trigger({"function_id": "producer", "payload": {"output": ch.writer_ref}})
+        Public callers must use the free function from ``iii.helpers``.
         """
-        return self._run_on_loop(self.create_channel_async(buffer_size))
-
-    async def create_channel_async(self, buffer_size: int | None = None) -> Channel:
-        """Create a streaming channel pair for worker-to-worker data transfer.
-
-        The returned ``Channel`` contains a local ``writer`` / ``reader``
-        and their serializable refs (``writer_ref``, ``reader_ref``) that
-        can be passed as fields in invocation data to other functions.
+        return self._run_on_loop(self._helpers_create_channel_async(buffer_size))
 
-        Args:
-            buffer_size: Buffer capacity for the channel. Defaults to ``64``.
-
-        Returns:
-            A ``Channel`` with ``writer``, ``reader``, ``writer_ref``, and
-            ``reader_ref`` attributes.
+    async def _helpers_create_channel_async(self, buffer_size: int | None = None) -> Channel:
+        """Internal shim backing :func:`iii.helpers.create_channel_async`.
 
-        Examples:
-            >>> ch = await iii.create_channel_async()
-            >>> fn = iii.register_function("producer", producer_handler)
-            >>> await iii.trigger_async({"function_id": "producer", "payload": {"output": ch.writer_ref}})
+        Public callers must use the free function from ``iii.helpers``.
         """
         result = await self.trigger_async(
             {
@@ -1248,27 +1219,14 @@ class III:
         )
         asyncio.run_coroutine_threadsafe(self._send(msg), self._loop)
 
-    def create_stream(self, stream_name: str, stream: IStream[Any]) -> None:
-        """Register a custom stream implementation, overriding the engine default.
+    def _helpers_create_stream(self, stream_name: str, stream: IStream[Any]) -> None:
+        """Internal shim backing :func:`iii.helpers.create_stream`.
 
+        Public callers must use the free function from ``iii.helpers``.
         Registers 5 of the 6 ``IStream`` methods (``get``, ``set``, ``delete``,
-        ``list``, ``list_groups``).  The ``update`` method is **not** registered
-        -- atomic updates are handled by the engine's built-in stream update logic.
-
-        Args:
-            stream_name: Unique name for the stream.
-            stream: An object implementing the ``IStream`` interface.
-
-        Examples:
-            >>> from iii.stream import IStream
-            >>> class MyStream(IStream):
-            ...     async def get(self, input): ...
-            ...     async def set(self, input): ...
-            ...     async def delete(self, input): ...
-            ...     async def list(self, input): ...
-            ...     async def list_groups(self, input): ...
-            ...     async def update(self, input): ...
-            >>> iii.create_stream("my-stream", MyStream())
+        ``list``, ``list_groups``). The ``update`` method is **not** registered
+        -- atomic updates are handled by the engine's built-in stream update
+        logic.
         """
 
         async def get_handler(data: Any) -> Any:

{iii_sdk-0.17.0.dev1 → iii_sdk-0.18.0.dev1}/src/iii/triggers.py

@@ -52,7 +52,7 @@ class Trigger:
 
 
 class TriggerTypeRef(Generic[C, R]):
-    """Typed handle returned by :meth:`III.register_trigger_type`.
+    """Typed handle returned by :meth:`iii.III.register_trigger_type`.
 
     Type parameters:
 

{iii_sdk-0.17.0.dev1 → iii_sdk-0.18.0.dev1}/src/iii/types.py

@@ -5,7 +5,18 @@ from __future__ import annotations
 import asyncio
 import json
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Awaitable, Callable, Generic, Protocol, TypeVar
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Awaitable,
+    Callable,
+    Generic,
+    Literal,
+    Protocol,
+    TypedDict,
+    TypeGuard,
+    TypeVar,
+)
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -18,7 +29,6 @@ from .iii_types import (
     StreamChannelRef,
     TriggerRequest,
 )
-from .stream import IStream
 from .triggers import Trigger, TriggerHandler
 
 if TYPE_CHECKING:
@@ -77,7 +87,11 @@ class RemoteServiceFunctionData(BaseModel):
 
 
 class IIIClient(Protocol):
-    """Protocol for III client implementations."""
+    """Protocol for III client implementations.
+
+    Helper free functions live in :mod:`iii.helpers`. See
+    :func:`iii.helpers.create_channel` and :func:`iii.helpers.create_stream`.
+    """
 
     def register_trigger(self, trigger: RegisterTriggerInput | dict[str, Any]) -> Trigger: ...
 
@@ -97,10 +111,6 @@ class IIIClient(Protocol):
 
     def unregister_trigger_type(self, trigger_type: RegisterTriggerTypeInput | dict[str, Any]) -> None: ...
 
-    def create_channel(self, buffer_size: int | None = None) -> Channel: ...
-
-    def create_stream(self, stream_name: str, stream: IStream[Any]) -> None: ...
-
     def shutdown(self) -> None: ...
 
 
@@ -183,11 +193,59 @@ class HttpRequest:
     request_body: ChannelReader
 
 
-def is_channel_ref(value: Any) -> bool:
-    """Check if a value looks like a StreamChannelRef."""
+class StreamChannelRefDict(TypedDict):
+    """Wire-shape of a :class:`StreamChannelRef` as it appears in raw payloads.
+
+    Used as the narrowed type for :func:`is_channel_ref` so type checkers can
+    validate ``value["channel_id"]`` style access after the guard passes.
+    """
+
+    channel_id: str
+    access_key: str
+    direction: Literal["read", "write"]
+
+
+def is_channel_ref(value: Any) -> TypeGuard[StreamChannelRefDict]:
+    """Check if a value looks like a StreamChannelRef.
+
+    Returns a :class:`typing.TypeGuard` that narrows ``value`` to
+    :class:`StreamChannelRefDict`, mirroring the TypeScript SDK's
+    ``value is StreamChannelRef`` predicate.
+    """
     return (
         isinstance(value, dict)
         and isinstance(value.get("channel_id"), str)
         and isinstance(value.get("access_key"), str)
         and value.get("direction") in {"read", "write"}
     )
+
+
+def extract_channel_refs(data: Any) -> list[tuple[str, StreamChannelRef]]:
+    """Extract all channel references from a nested value, returning ``(path, ref)`` tuples.
+
+    Recursively walks ``dict`` and ``list`` structures. Dotted paths are
+    used for object fields, bracketed indices for list elements (e.g.
+    ``items[0].writer``). Mirrors the Rust SDK's ``extract_channel_refs``.
+    """
+    refs: list[tuple[str, StreamChannelRef]] = []
+    _extract_refs_recursive(data, "", refs)
+    return refs
+
+
+def _extract_refs_recursive(
+    data: Any, prefix: str, refs: list[tuple[str, StreamChannelRef]]
+) -> None:
+    if is_channel_ref(data):
+        try:
+            refs.append((prefix, StreamChannelRef(**data)))
+        except Exception:
+            pass
+        return
+    if isinstance(data, dict):
+        for key, value in data.items():
+            path = key if not prefix else f"{prefix}.{key}"
+            _extract_refs_recursive(value, path, refs)
+    elif isinstance(data, list):
+        for idx, item in enumerate(data):
+            path = f"[{idx}]" if not prefix else f"{prefix}[{idx}]"
+            _extract_refs_recursive(item, path, refs)

{iii_sdk-0.17.0.dev1 → iii_sdk-0.18.0.dev1}/tests/test_async_api.py

@@ -2,6 +2,7 @@
 
 import inspect
 
+from iii import helpers
 from iii.iii import III
 
 
@@ -10,9 +11,8 @@ def test_trigger_async_is_coroutine_function():
     assert inspect.iscoroutinefunction(III.trigger_async)
 
 
-def test_create_channel_async_is_coroutine_function():
-    assert hasattr(III, "create_channel_async")
-    assert inspect.iscoroutinefunction(III.create_channel_async)
+def test_create_channel_async_helper_is_coroutine_function():
+    assert inspect.iscoroutinefunction(helpers.create_channel_async)
 
 
 def test_connect_async_is_coroutine_function():
@@ -29,7 +29,6 @@ def test_async_methods_have_docstrings():
     """All public async methods must have docstrings."""
     async_methods = [
         "trigger_async",
-        "create_channel_async",
         "connect_async",
         "shutdown_async",
     ]

{iii_sdk-0.17.0.dev1 → iii_sdk-0.18.0.dev1}/tests/test_data_channels.py

@@ -4,8 +4,9 @@ import asyncio
 import json
 import time
 
-from iii.iii import III
 from iii.channels import ChannelReader, ChannelWriter
+from iii.helpers import create_channel_async
+from iii.iii import III
 
 
 def test_stream_data_from_sender_to_processor(iii_client: III):
@@ -35,7 +36,7 @@ def test_stream_data_from_sender_to_processor(iii_client: III):
 
     async def sender_handler(input_data):
         records = input_data["records"]
-        channel = await iii_client.create_channel_async()
+        channel = await create_channel_async(iii_client)
 
         payload = json.dumps(records).encode("utf-8")
         await channel.writer.write(payload)
@@ -137,8 +138,8 @@ def test_bidirectional_streaming(iii_client: III):
         text = input_data["text"]
         chunk_size = input_data["chunkSize"]
 
-        input_channel = await iii_client.create_channel_async()
-        output_channel = await iii_client.create_channel_async()
+        input_channel = await create_channel_async(iii_client)
+        output_channel = await create_channel_async(iii_client)
 
         messages = []
         output_channel.reader.on_message(lambda msg: messages.append(json.loads(msg)))

iii_sdk-0.18.0.dev1/tests/test_helpers.py

@@ -0,0 +1,196 @@
+"""Tests for the public helpers submodule (mirrors Rust/Node helpers parity)."""
+
+from __future__ import annotations
+
+import inspect
+import json
+from types import SimpleNamespace
+from typing import Any
+
+import pytest
+
+import iii.iii as iii_module
+from iii import InitOptions
+from iii.iii import III
+
+
+class FakeWebSocket:
+    def __init__(self) -> None:
+        self.sent: list[dict[str, Any]] = []
+        self.state = SimpleNamespace(name="OPEN")
+
+    async def send(self, payload: str) -> None:
+        self.sent.append(json.loads(payload))
+
+    async def close(self) -> None:
+        self.state = SimpleNamespace(name="CLOSED")
+
+    def __aiter__(self) -> "FakeWebSocket":
+        return self
+
+    async def __anext__(self) -> Any:
+        raise StopAsyncIteration
+
+
+def _patch_ws(monkeypatch: pytest.MonkeyPatch) -> FakeWebSocket:
+    ws = FakeWebSocket()
+
+    async def fake_connect(_: str, **kwargs: object) -> FakeWebSocket:
+        return ws
+
+    monkeypatch.setattr(iii_module.websockets, "connect", fake_connect)
+    monkeypatch.setattr("iii_observability.telemetry.init_otel", lambda **kwargs: None)
+    monkeypatch.setattr("iii_observability.telemetry.attach_event_loop", lambda loop: None)
+    monkeypatch.setattr(iii_module.III, "_register_worker_metadata", lambda self: None)
+    return ws
+
+
+def test_helpers_module_exports_expected_names() -> None:
+    from iii import helpers
+
+    expected = {
+        "ChannelDirection",
+        "ChannelItem",
+        "create_channel",
+        "create_channel_async",
+        "create_stream",
+        "extract_channel_refs",
+        "is_channel_ref",
+    }
+    actual = set(helpers.__all__)
+    missing = expected - actual
+    assert not missing, f"missing from helpers.__all__: {missing}"
+    for name in expected:
+        assert hasattr(helpers, name), f"helpers module missing attribute: {name}"
+
+
+def test_helpers_free_functions_take_iii_first() -> None:
+    from iii import helpers
+
+    for name in (
+        "create_channel",
+        "create_channel_async",
+        "create_stream",
+    ):
+        sig = inspect.signature(getattr(helpers, name))
+        params = list(sig.parameters)
+        assert params and params[0] == "iii", f"{name} signature: {sig}"
+
+
+def test_is_channel_ref_works_via_helpers() -> None:
+    from iii import helpers
+
+    assert helpers.is_channel_ref({}) is False
+    assert helpers.is_channel_ref(
+        {"channel_id": "c", "access_key": "k", "direction": "read"}
+    ) is True
+    assert helpers.is_channel_ref(
+        {"channel_id": "c", "access_key": "k", "direction": "garbage"}
+    ) is False
+
+
+def test_extract_channel_refs_walks_nested_structures() -> None:
+    from iii import helpers
+
+    assert helpers.extract_channel_refs({}) == []
+
+    ref = {"channel_id": "c1", "access_key": "k1", "direction": "read"}
+    refs = helpers.extract_channel_refs({"input": ref})
+    assert len(refs) == 1
+    path, channel_ref = refs[0]
+    assert path == "input"
+    assert channel_ref.channel_id == "c1"
+
+    nested = helpers.extract_channel_refs(
+        {"items": [{"writer": ref}, {"writer": ref}]}
+    )
+    assert {p for p, _ in nested} == {"items[0].writer", "items[1].writer"}
+
+
+def test_channel_direction_string_values() -> None:
+    from iii.helpers import ChannelDirection
+
+    assert ChannelDirection.READ.value == "read"
+    assert ChannelDirection.WRITE.value == "write"
+
+
+def test_channel_item_constructors() -> None:
+    from iii.helpers import ChannelItem
+
+    text = ChannelItem.text_item("hi")
+    assert text.is_text and not text.is_binary
+    assert text.text == "hi"
+
+    binary = ChannelItem.binary_item(b"\x00\x01")
+    assert binary.is_binary and not binary.is_text
+    assert binary.binary == b"\x00\x01"
+
+
+def test_iii_no_longer_exposes_relocated_methods(monkeypatch: pytest.MonkeyPatch) -> None:
+    _patch_ws(monkeypatch)
+    client = III("ws://fake", InitOptions())
+
+    try:
+        for name in (
+            "create_channel",
+            "create_channel_async",
+            "create_stream",
+        ):
+            assert not hasattr(client, name), f"client still has {name}"
+    finally:
+        client.shutdown()
+
+
+def test_iii_client_protocol_no_longer_declares_relocated_methods() -> None:
+    """The :class:`iii.IIIClient` Protocol must not declare the relocated methods."""
+    from iii import IIIClient
+
+    for name in (
+        "create_channel",
+        "create_stream",
+    ):
+        assert name not in IIIClient.__dict__, (
+            f"IIIClient Protocol still declares {name}"
+        )
+
+
+def test_init_no_longer_exports_relocated_channel_items() -> None:
+    import iii
+
+    for name in (
+        "extract_channel_refs",
+        "is_channel_ref",
+        "ChannelDirection",
+        "ChannelItem",
+    ):
+        assert name not in iii.__all__, f"{name} still in iii.__all__"
+
+
+def test_iii_register_and_unregister_trigger_type_round_trip(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    from iii import RegisterTriggerTypeInput
+    from iii.triggers import TriggerConfig, TriggerHandler
+
+    class DummyHandler(TriggerHandler[Any]):
+        async def register_trigger(self, config: TriggerConfig[Any]) -> None:
+            return None
+
+        async def unregister_trigger(self, config: TriggerConfig[Any]) -> None:
+            return None
+
+    _patch_ws(monkeypatch)
+    client = III("ws://fake", InitOptions())
+    try:
+        trigger_type = RegisterTriggerTypeInput(
+            id="helpers.test", description="from helpers"
+        )
+
+        ref = client.register_trigger_type(trigger_type, DummyHandler())
+        assert "helpers.test" in client._trigger_types
+        assert ref is not None
+
+        client.unregister_trigger_type(trigger_type)
+        assert "helpers.test" not in client._trigger_types
+    finally:
+        client.shutdown()

{iii_sdk-0.17.0.dev1 → iii_sdk-0.18.0.dev1}/tests/test_streams.py

@@ -6,6 +6,7 @@ from typing import Any
 
 import pytest
 
+from iii.helpers import create_stream
 from iii.iii import III
 from iii.stream import (
     IStream,
@@ -353,7 +354,7 @@ async def test_stream_custom_operations(iii_client: III):
         async def update(self, input: StreamUpdateInput) -> StreamUpdateResult | None:
             raise NotImplementedError
 
-    iii_client.create_stream(stream_name, InMemoryStream())
+    create_stream(iii_client, stream_name, InMemoryStream())
     await asyncio.sleep(1.0)
 
     test_data = {"name": "Test", "value": 100}

{iii_sdk-0.17.0.dev1 → iii_sdk-0.18.0.dev1}/tests/test_sync_api.py

@@ -9,6 +9,7 @@ import pytest
 
 import iii.iii as iii_module
 from iii import InitOptions, RegisterTriggerTypeInput
+from iii.helpers import create_channel
 from iii.iii import III
 from iii.triggers import TriggerConfig, TriggerHandler
 
@@ -179,7 +180,7 @@ def test_register_and_unregister_trigger_type_accept_input_object(monkeypatch: p
 
 
 def test_public_methods_are_sync(monkeypatch: pytest.MonkeyPatch) -> None:
-    """trigger and create_channel should be sync."""
+    """trigger and the helpers.create_channel free function should be sync."""
     _patch_ws(monkeypatch)
     client = III("ws://fake", InitOptions())
     time.sleep(0.05)
@@ -187,7 +188,7 @@ def test_public_methods_are_sync(monkeypatch: pytest.MonkeyPatch) -> None:
     import inspect
 
     assert not inspect.iscoroutinefunction(client.trigger)
-    assert not inspect.iscoroutinefunction(client.create_channel)
+    assert not inspect.iscoroutinefunction(create_channel)
 
     client.shutdown()
 

{iii_sdk-0.17.0.dev1 → iii_sdk-0.18.0.dev1}/uv.lock

@@ -546,7 +546,7 @@ wheels = [
 
 [[package]]
 name = "iii-observability"
-version = "0.13.0.dev1"
+version = "0.16.0.dev3"
 source = { editable = "../observability" }
 dependencies = [
     { name = "httpx" },
@@ -572,7 +572,7 @@ provides-extras = ["dev"]
 
 [[package]]
 name = "iii-sdk"
-version = "0.13.0.dev1"
+version = "0.16.0.dev3"
 source = { editable = "." }
 dependencies = [
     { name = "iii-observability" },