converse-framework 0.2.0__py3-none-any.whl

converse_framework/examples/text_chat.py

@@ -0,0 +1,308 @@
+"""Text-only chat example showing the framework as a second consumer.
+
+This example runs a real conversation against :class:`SpeechPipeline`
+using only the framework's public API. No harness modules, FastAPI,
+WebSocket, profile files, or browser UI are involved. It is intended
+as a quick smoke test that the extracted package can drive a complete
+turn loop on its own.
+
+The example exposes two surfaces:
+
+* :func:`run_text_chat` — async driver that runs a list of scripted
+  inputs through the pipeline. Used by the test suite.
+* ``__main__`` — a small CLI that reads lines from stdin, prints LLM
+  tokens as they stream, and summarizes each turn's events.
+
+The CLI uses mock providers by default. To try a real provider, pass
+``--asr``, ``--llm``, ``--tts`` with a registered provider name and
+install the matching extra. If the extra is missing, the framework
+falls back to :class:`UnavailableProvider` and the status message
+will tell the user which extra to install.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import sys
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from typing import Any
+
+from converse_framework.events import EventSink, QueueEventSink
+from converse_framework.pipeline import PipelineConfig, SpeechPipeline
+from converse_framework.registry import build_provider_bundle
+
+
+@dataclass
+class TextChatExampleConfig:
+    """User-facing configuration for the text chat example."""
+
+    providers: dict[str, str] = field(
+        default_factory=lambda: {
+            "vad": "mock",
+            "asr": "mock",
+            "llm": "mock",
+            "tts": "mock",
+        }
+    )
+    tts_chunk_chars: int = 80
+    min_tts_chars: int = 0
+    mode: str = "chat"
+    system_prompt: str = "You are a helpful assistant. Be concise."
+
+
+def build_example_bundle(config: TextChatExampleConfig) -> Any:
+    """Build a provider bundle from the example config.
+
+    Each section is forwarded to the framework registry. Real provider
+    names are honored when the matching optional dependency is
+    installed; otherwise the registry returns an unavailable provider
+    whose status message tells the user which extra to install.
+    """
+    nested: dict[str, dict[str, Any]] = {}
+    for kind, name in config.providers.items():
+        nested[kind] = {"provider": name}
+    return build_provider_bundle(nested)
+
+
+def build_example_pipeline(
+    config: TextChatExampleConfig | None = None,
+    *,
+    sink: EventSink | None = None,
+) -> tuple[SpeechPipeline, Any]:
+    """Construct a :class:`SpeechPipeline` ready for the example.
+
+    Returns the pipeline and the provider bundle it was built with so
+    callers can inspect ``bundle.statuses()`` if they want to.
+    """
+    config = config or TextChatExampleConfig()
+    bundle = build_example_bundle(config)
+    sink = sink or QueueEventSink(asyncio.Queue())
+    pipeline = SpeechPipeline(
+        providers=bundle,
+        sink=sink,
+        config=PipelineConfig(
+            tts_chunk_chars=config.tts_chunk_chars,
+            min_tts_chars=config.min_tts_chars,
+            default_mode=config.mode,
+        ),
+    )
+    if config.system_prompt:
+        pipeline.set_system_prompt(config.system_prompt, mode=config.mode)
+    return pipeline, bundle
+
+
+async def run_text_chat(
+    inputs: Iterable[str],
+    config: TextChatExampleConfig | None = None,
+) -> dict[str, Any]:
+    """Drive the example end-to-end and return a structured summary.
+
+    The summary contains the per-turn event types, the LLM text per
+    turn, and the number of TTS audio chunks produced per turn. It is
+    designed to be assertion-friendly for the framework test suite.
+    """
+    config = config or TextChatExampleConfig()
+    queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
+    pipeline, _ = build_example_pipeline(config, sink=QueueEventSink(queue))
+
+    turns: list[dict[str, Any]] = []
+    for text in inputs:
+        await pipeline.handle_text_turn(text, mode=config.mode)
+        # Drain events emitted during the turn before recording them so
+        # concurrent TTS tasks finish flushing.
+        await _drain_in_flight_tts(pipeline)
+        events = await _drain_queue(queue)
+        turns.append(
+            {
+                "input": text,
+                "events": [event["type"] for event in events],
+                "llm_text": _joined_llm_text(events),
+                "tts_audio_chunks": sum(
+                    1 for event in events if event["type"] == "tts.audio"
+                ),
+            }
+        )
+    return {
+        "mode": config.mode,
+        "providers": config.providers,
+        "turns": turns,
+        "messages": pipeline.messages_for_mode(config.mode),
+    }
+
+
+async def _drain_in_flight_tts(pipeline: SpeechPipeline) -> None:
+    """Wait for any pending TTS tasks to finish so events are settled."""
+    active = list(pipeline.state.active_tts_tasks)
+    if not active:
+        return
+    await asyncio.gather(*active, return_exceptions=True)
+
+
+async def _drain_queue(queue: asyncio.Queue[dict[str, Any]]) -> list[dict[str, Any]]:
+    events: list[dict[str, Any]] = []
+    while not queue.empty():
+        events.append(queue.get_nowait())
+    return events
+
+
+def _joined_llm_text(events: list[dict[str, Any]]) -> str:
+    pieces: list[str] = []
+    for event in events:
+        if event["type"] == "llm.token":
+            payload = event.get("payload", {})
+            token = payload.get("text")
+            if isinstance(token, str):
+                pieces.append(token)
+    return "".join(pieces).strip()
+
+
+def _format_audio_summary(audio_b64: str, mime_type: str) -> str:
+    """Best-effort one-line summary for a TTS audio payload."""
+    try:
+        decoded = base64.b64decode(audio_b64.encode("ascii"))
+    except Exception:
+        return f"[tts.audio] {mime_type} (decode-error)"
+    return f"[tts.audio] {mime_type} {len(decoded)} bytes"
+
+
+def _format_event_for_cli(event: dict[str, Any]) -> str:
+    event_type = event.get("type", "")
+    payload = event.get("payload", {}) or {}
+    if event_type == "llm.token":
+        return f"  token: {payload.get('text', '')!r}"
+    if event_type == "asr.transcript":
+        marker = "final" if payload.get("final") else "partial"
+        return f"  asr({marker}): {payload.get('text', '')!r}"
+    if event_type == "tts.audio":
+        return "  " + _format_audio_summary(
+            str(payload.get("data", "")), str(payload.get("mime_type", "audio/wav"))
+        )
+    if event_type == "turn.finished":
+        return "  turn.finished"
+    if event_type == "turn.error":
+        return f"  turn.error: {payload.get('message', '')}"
+    return f"  {event_type}"
+
+
+_DEFAULT_PROVIDER_NAMES: dict[str, str] = {
+    "vad": "mock",
+    "asr": "mock",
+    "llm": "mock",
+    "tts": "mock",
+}
+
+
+def _parse_provider_args(values: Iterable[str]) -> dict[str, str]:
+    """Parse ``--provider KIND=NAME`` style CLI arguments.
+
+    Returns a complete provider name map (vad/asr/llm/tts) with each
+    kind defaulting to ``mock`` when no override is supplied. The
+    text-only example does not exercise voice activity detection, so
+    callers typically leave the VAD default alone.
+    """
+    parsed: dict[str, str] = dict(_DEFAULT_PROVIDER_NAMES)
+    for entry in values:
+        if "=" not in entry:
+            raise SystemExit(
+                f"Expected --provider-style argument of the form KIND=NAME, got {entry!r}"
+            )
+        kind, name = entry.split("=", 1)
+        kind = kind.strip()
+        name = name.strip()
+        if kind not in {"vad", "asr", "llm", "tts"}:
+            raise SystemExit(f"Unknown provider kind: {kind}")
+        if not name:
+            raise SystemExit(f"Provider name is empty for kind {kind}")
+        parsed[kind] = name
+    return parsed
+
+
+def _build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="python -m converse_framework.examples.text_chat",
+        description=(
+            "Run a text conversation against Converse Framework with mock "
+            "providers by default. Use KIND=NAME overrides to select a real "
+            "provider when the matching extra is installed."
+        ),
+    )
+    parser.add_argument(
+        "--provider",
+        action="append",
+        default=[],
+        metavar="KIND=NAME",
+        help="Override a provider, e.g. --provider asr=faster-whisper",
+    )
+    parser.add_argument(
+        "--tts-chunk-chars",
+        type=int,
+        default=80,
+        help="Flush TTS once the LLM has produced this many characters.",
+    )
+    parser.add_argument(
+        "--system-prompt",
+        type=str,
+        default="You are a helpful assistant. Be concise.",
+        help="Initial system prompt.",
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        default="chat",
+        help="Conversation mode key (default: chat).",
+    )
+    return parser
+
+
+async def _run_cli(args: argparse.Namespace) -> int:
+    config = TextChatExampleConfig(
+        providers=_parse_provider_args(args.provider),
+        tts_chunk_chars=args.tts_chunk_chars,
+        min_tts_chars=0,
+        mode=args.mode,
+        system_prompt=args.system_prompt,
+    )
+    queue: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
+    pipeline, bundle = build_example_pipeline(config, sink=QueueEventSink(queue))
+
+    print(f"providers: {config.providers}")
+    for status in bundle.statuses():
+        print(f"  - {status['kind']}/{status['name']}: {status['message']}")
+    print("type 'quit' to exit, 'clear' to reset history")
+    print("-" * 60)
+
+    loop = asyncio.get_running_loop()
+    while True:
+        try:
+            line = await loop.run_in_executor(None, lambda: input("you> "))
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return 0
+        text = line.strip()
+        if not text:
+            continue
+        if text in {"quit", "exit"}:
+            return 0
+        if text == "clear":
+            await pipeline.clear_conversation(mode=config.mode)
+            print("(conversation cleared)")
+            continue
+        await pipeline.handle_text_turn(text, mode=config.mode)
+        await _drain_in_flight_tts(pipeline)
+        events = await _drain_queue(queue)
+        for event in events:
+            print(_format_event_for_cli(event))
+        print("-" * 60)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_arg_parser()
+    args = parser.parse_args(argv)
+    return asyncio.run(_run_cli(args))
+
+
+if __name__ == "__main__":  # pragma: no cover - exercised by the CLI smoke test
+    sys.exit(main())

converse_framework/examples/voice_chat.py

@@ -0,0 +1,223 @@
+"""Voice chat example (manual).
+
+This example shows the framework's voice flow: a :class:`AudioUtteranceCollector`
+feeds PCM frames into the :class:`SpeechPipeline` after detecting speech
+end. It is the recommended starting point for any consumer that wants
+to build a voice assistant on top of the framework.
+
+The example is **manual** by design — it reads a WAV file supplied with
+``--input`` and is not exercised by the
+automated test suite. The text-only example in
+:mod:`converse_framework.examples.text_chat` is the one covered by
+tests.
+
+Usage
+-----
+
+Run the voice example from the repository root after installing the
+optional ``silero`` and ``faster-whisper`` extras::
+
+    python -m converse_framework.examples.voice_chat --input path/to/16k_mono.wav
+
+The example will:
+
+1. Build a provider bundle (``silero`` VAD, ``faster-whisper`` ASR,
+   ``llamacpp`` LLM, ``kokoro`` TTS by default).
+2. Read 16 kHz mono PCM frames from the WAV file passed with
+   ``--input path/to/file.wav``.
+3. Feed 30 ms PCM frames into the utterance collector.
+4. For each completed utterance, hand the PCM bytes to
+   :meth:`SpeechPipeline.handle_audio_turn`.
+5. Emit pipeline events, including any ``tts.audio`` chunks, through the
+   configured event sink. Consumer apps own playback.
+
+Implementation notes
+--------------------
+
+* The collector's :attr:`cancel_callback` is wired to
+  :meth:`SpeechPipeline.cancel_tts` so VAD-driven speech starts cancel
+  any in-flight TTS (barge-in).
+* The collector's ``pre_speech_start_hook`` is a no-op here, but it
+  is where a real consumer would update a per-frame system prompt
+  before the utterance is finalized.
+* ``--mock`` swaps the VAD/ASR providers for the in-process mock
+  providers so the example can run without any heavy model
+  dependencies.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import base64
+import sys
+
+from converse_framework.audio_utils import AudioFrame, AudioFrameStats, parse_audio_frame
+from converse_framework.events import QueueEventSink
+from converse_framework.pipeline import PipelineConfig, SpeechPipeline
+from converse_framework.registry import build_provider_bundle
+from converse_framework.utterance_collector import (
+    AudioUtteranceCollector,
+    UtteranceCollectorConfig,
+)
+
+
+def _parse_provider_args(values: list[str]) -> dict[str, str]:
+    parsed: dict[str, str] = {"vad": "silero", "asr": "faster-whisper", "llm": "llamacpp", "tts": "kokoro"}
+    for entry in values:
+        if "=" not in entry:
+            raise SystemExit(f"Expected KIND=NAME, got {entry!r}")
+        kind, name = entry.split("=", 1)
+        if kind not in parsed:
+            raise SystemExit(f"Unknown provider kind: {kind}")
+        parsed[kind] = name.strip()
+    return parsed
+
+
+def _build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="python -m converse_framework.examples.voice_chat",
+        description=(
+            "Manual voice example. Streams WAV-file frames "
+            "through the framework's utterance collector and pipeline. "
+            "Run --mock to avoid heavy provider dependencies."
+        ),
+    )
+    parser.add_argument(
+        "--provider",
+        action="append",
+        default=[],
+        metavar="KIND=NAME",
+        help="Override a provider, e.g. --provider tts=pocket-tts",
+    )
+    parser.add_argument(
+        "--mock",
+        action="store_true",
+        help="Use mock VAD/ASR providers so the example runs without extras.",
+    )
+    parser.add_argument(
+        "--input",
+        type=str,
+        default=None,
+        help="Read PCM frames from a 16 kHz mono WAV file instead of the mic.",
+    )
+    parser.add_argument(
+        "--frame-ms",
+        type=int,
+        default=30,
+        help="Frame size in milliseconds (default 30).",
+    )
+    parser.add_argument(
+        "--pre-speech-ms",
+        type=int,
+        default=450,
+        help="Pre-speech buffer size in milliseconds (default 450).",
+    )
+    return parser
+
+
+async def _drive_collector(
+    collector: AudioUtteranceCollector,
+    pipeline: SpeechPipeline,
+    config: UtteranceCollectorConfig,
+    *,
+    input_path: str | None = None,
+) -> None:
+    """Read PCM frames from the mic or a file and feed the collector.
+
+    Real deployments should plug a microphone capture coroutine in
+    here. The framework only cares that ``parse_audio_frame`` succeeds
+    and that the resulting :class:`AudioFrame` is passed to
+    :meth:`AudioUtteranceCollector.ingest_frame`.
+    """
+    if input_path is None:
+        raise SystemExit(
+            "No --input file provided. Pass a 16 kHz mono WAV file to drive the "
+            "collector. (Live microphone capture is intentionally out of scope "
+            "for the example; the framework is platform-agnostic.)"
+        )
+
+    stats = AudioFrameStats(
+        expected_sample_rate=config.sample_rate,
+        expected_channels=config.channels,
+        expected_frame_ms=config.frame_ms,
+    )
+    expected_frame_bytes = config.bytes_per_ms * config.frame_ms
+
+    with open(input_path, "rb") as handle:
+        # Skip the 44-byte WAV header. The example assumes a bare
+        # PCM_s16le body; production code should use ``wave`` instead.
+        handle.read(44)
+        sequence = 0
+        while True:
+            chunk = handle.read(expected_frame_bytes)
+            if not chunk:
+                break
+            frame = parse_audio_frame(
+                {
+                    # The wire format is base64-encoded PCM bytes (see
+                    # ``parse_audio_frame``); encode the raw chunk so
+                    # the parser can decode it back to bytes.
+                    "data": base64.b64encode(chunk).decode("ascii"),
+                    "sample_rate": config.sample_rate,
+                    "channels": config.channels,
+                    "frame_ms": config.frame_ms,
+                    "encoding": "pcm_s16le",
+                    "sequence": sequence,
+                },
+                stats,
+            )
+            await collector.ingest_frame(frame)
+            sequence += 1
+
+
+async def _main_async(args: argparse.Namespace) -> int:
+    providers = _parse_provider_args(args.provider)
+    if args.mock:
+        providers = {"vad": "mock", "asr": "mock", "llm": "mock", "tts": "mock"}
+
+    queue: asyncio.Queue = asyncio.Queue()
+    sink = QueueEventSink(queue)
+    bundle = build_provider_bundle({kind: {"provider": name} for kind, name in providers.items()})
+    pipeline = SpeechPipeline(
+        providers=bundle,
+        sink=sink,
+        config=PipelineConfig(tts_chunk_chars=80),
+    )
+    collector_config = UtteranceCollectorConfig(
+        sample_rate=16000,
+        channels=1,
+        frame_ms=args.frame_ms,
+        pre_speech_ms=args.pre_speech_ms,
+    )
+
+    async def utterance_callback(pcm: bytes, sample_rate: int, mode: str) -> None:
+        await pipeline.handle_audio_turn(pcm, sample_rate, mode=mode)
+
+    async def cancel_callback(reason: str) -> None:
+        await pipeline.cancel_tts(reason)
+
+    collector = AudioUtteranceCollector(
+        vad_provider=bundle.vad,
+        event_sink=sink,
+        utterance_callback=utterance_callback,
+        config=collector_config,
+        cancel_callback=cancel_callback,
+    )
+
+    print(f"providers: {providers}")
+    print(f"frame_ms={args.frame_ms}  pre_speech_ms={args.pre_speech_ms}")
+    print("-" * 60)
+
+    await _drive_collector(collector, pipeline, collector_config, input_path=args.input)
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_arg_parser()
+    args = parser.parse_args(argv)
+    return asyncio.run(_main_async(args))
+
+
+if __name__ == "__main__":  # pragma: no cover - manual example
+    sys.exit(main())

converse_framework/examples/websocket_voice_chat.py

@@ -0,0 +1,174 @@
+"""FastAPI WebSocket voice-chat recipe.
+
+This example shows the browser-oriented wire shape: clients send JSON
+messages containing ``audio.frame`` payloads, the framework validates
+them with :func:`parse_audio_frame`, and all framework events are sent
+back over the same WebSocket.
+
+FastAPI is imported only by :func:`create_app`, so importing this module
+does not add a dependency to the base framework package. To run it::
+
+    pip install fastapi uvicorn
+    uvicorn converse_framework.examples.websocket_voice_chat:create_app --factory
+
+The mock providers are used by default. Pass a provider config to
+:func:`build_websocket_voice_runtime` when embedding this recipe in a
+real app.
+
+.. seealso::
+
+   :class:`converse_framework.session.WebSocketSession` provides a
+   reusable message-dispatch loop that replaces the per-endpoint
+   routing in this recipe.  See the WebSocket Session Helper section
+   in the README.
+
+.. note::
+
+   Mobile browser microphone access (``getUserMedia``) requires a
+   **secure context** — HTTPS, ``localhost``, or ``127.0.0.1``.
+   Over a plain ``http://<lan-ip>`` page, ``getUserMedia`` will be
+   rejected on mobile browsers.  See the "Mobile Browser Microphone
+   Testing" section in the README for tunnel and HTTPS recipes.
+   The WebSocket URL for tunneled setups changes from
+   ``ws://<host>/ws`` to ``wss://<tunnel-host>/ws``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import Any
+
+from converse_framework.audio_utils import AudioFrameStats, parse_audio_frame
+from converse_framework.events import FrameworkEvent, TransportEventSink
+from converse_framework.pipeline import PipelineConfig, SpeechPipeline
+from converse_framework.registry import build_provider_bundle
+from converse_framework.transport import Transport
+from converse_framework.utterance_collector import (
+    AudioUtteranceCollector,
+    UtteranceCollectorConfig,
+)
+
+
+@dataclass
+class WebSocketVoiceRuntime:
+    """Objects needed to drive voice frames from a WebSocket."""
+
+    pipeline: SpeechPipeline
+    collector: AudioUtteranceCollector
+    frame_stats: AudioFrameStats
+
+
+class WebSocketTransport(Transport):
+    """Minimal transport adapter for FastAPI-compatible WebSockets."""
+
+    def __init__(self, websocket) -> None:
+        self.websocket = websocket
+
+    async def send_event(self, event: FrameworkEvent) -> None:
+        await self.websocket.send_json(event.to_json())
+
+    async def receive_event(self) -> FrameworkEvent:
+        message = await self.websocket.receive_json()
+        return FrameworkEvent(
+            type=str(message.get("type", "")),
+            payload=dict(message.get("payload", {}) or {}),
+            ts=float(message.get("ts", 0.0)),
+        )
+
+
+def build_websocket_voice_runtime(
+    transport: Transport,
+    *,
+    provider_config: dict[str, dict[str, Any]] | None = None,
+    collector_config: UtteranceCollectorConfig | None = None,
+    pipeline_config: PipelineConfig | None = None,
+) -> WebSocketVoiceRuntime:
+    """Build the pipeline and collector used by the WebSocket handler."""
+    provider_config = provider_config or {
+        "vad": {"provider": "mock"},
+        "asr": {"provider": "mock"},
+        "llm": {"provider": "mock"},
+        "tts": {"provider": "mock"},
+    }
+    collector_config = collector_config or UtteranceCollectorConfig()
+    sink = TransportEventSink(transport)
+    bundle = build_provider_bundle(provider_config)
+    pipeline = SpeechPipeline(bundle, sink, pipeline_config or PipelineConfig())
+
+    async def utterance_callback(pcm: bytes, sample_rate: int, mode: str) -> None:
+        await pipeline.handle_audio_turn(pcm, sample_rate, mode=mode)
+
+    async def cancel_callback(reason: str) -> None:
+        await pipeline.cancel_tts(reason)
+
+    collector = AudioUtteranceCollector(
+        vad_provider=bundle.vad,
+        event_sink=sink,
+        utterance_callback=utterance_callback,
+        config=collector_config,
+        cancel_callback=cancel_callback,
+    )
+    frame_stats = AudioFrameStats(
+        expected_sample_rate=collector_config.sample_rate,
+        expected_channels=collector_config.channels,
+        expected_frame_ms=collector_config.frame_ms,
+    )
+    return WebSocketVoiceRuntime(pipeline, collector, frame_stats)
+
+
+async def handle_websocket_message(
+    runtime: WebSocketVoiceRuntime,
+    transport: Transport,
+    message: dict[str, Any],
+) -> None:
+    """Handle one client message from the WebSocket recipe."""
+    message_type = str(message.get("type", ""))
+    payload = dict(message.get("payload", {}) or {})
+    mode = str(payload.pop("mode", "chat"))
+
+    if message_type == "audio.frame":
+        try:
+            frame = parse_audio_frame(payload, runtime.frame_stats)
+        except ValueError as exc:
+            await transport.send_event(
+                FrameworkEvent("audio.frame_error", {"message": str(exc)})
+            )
+            return
+        await runtime.collector.ingest_frame(frame, mode=mode)
+        return
+
+    if message_type == "text.turn":
+        text = str(payload.get("text", ""))
+        if text:
+            await runtime.pipeline.handle_text_turn(text, mode=mode)
+        return
+
+    if message_type == "conversation.clear":
+        await runtime.pipeline.clear_conversation(mode=mode)
+        return
+
+    await transport.send_event(
+        FrameworkEvent(
+            "turn.error", {"message": f"unknown message type: {message_type}"}
+        )
+    )
+
+
+def create_app():
+    """Create a tiny FastAPI app exposing ``/ws`` for voice chat."""
+    from fastapi import FastAPI, WebSocket
+
+    app = FastAPI()
+
+    @app.websocket("/ws")
+    async def websocket_endpoint(websocket: WebSocket) -> None:
+        await websocket.accept()
+        transport = WebSocketTransport(websocket)
+        runtime = build_websocket_voice_runtime(transport)
+        while True:
+            message = await websocket.receive_json()
+            await handle_websocket_message(runtime, transport, message)
+            await asyncio.sleep(0)
+
+    return app