swarmauri_live_model_qwen 0.1.0.dev3__tar.gz

swarmauri_live_model_qwen-0.1.0.dev3/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2024 Jacob Stewart
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

swarmauri_live_model_qwen-0.1.0.dev3/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: swarmauri_live_model_qwen
+Version: 0.1.0.dev3
+Summary: Qwen Omni Realtime multimodal model adapter for Swarmauri.
+License: Copyright 2024 Jacob Stewart
+         
+         Licensed under the Apache License, Version 2.0 (the "License");
+         you may not use this file except in compliance with the License.
+         You may obtain a copy of the License at
+         
+             http://www.apache.org/licenses/LICENSE-2.0
+         
+         Unless required by applicable law or agreed to in writing, software
+         distributed under the License is distributed on an "AS IS" BASIS,
+         WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+         See the License for the specific language governing permissions and
+         limitations under the License.
+License-File: LICENSE
+Keywords: swarmauri,qwen omni,realtime,multimodal,websocket
+Author: Jacob Stewart
+Author-email: jacob@swarmauri.com
+Requires-Python: >=3.10,<3.13
+Classifier: Development Status :: 1 - Planning
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: swarmauri_base (>=0.11.0.dev5)
+Requires-Dist: swarmauri_core (>=0.11.0.dev5)
+Requires-Dist: swarmauri_provider_qwen (>=0.1.0.dev3)
+Requires-Dist: swarmauri_transport_websocket (>=0.1.0.dev4)
+Description-Content-Type: text/markdown
+
+![Swarmauri](https://github.com/swarmauri/swarmauri-sdk/blob/3d4d1cfa949399d7019ae9d8f296afba773dfb7f/assets/swarmauri.brand.theme.svg)
+
+[![PyPI](https://img.shields.io/pypi/v/swarmauri_live_model_qwen.svg)](https://pypi.org/project/swarmauri_live_model_qwen/) [![Python](https://img.shields.io/pypi/pyversions/swarmauri_live_model_qwen.svg)](https://pypi.org/project/swarmauri_live_model_qwen/) [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE) [![Downloads](https://static.pepy.tech/badge/swarmauri_live_model_qwen)](https://pepy.tech/project/swarmauri_live_model_qwen) [![Hits](https://hits.sh/github.com/swarmauri/swarmauri-sdk.svg)](https://hits.sh/github.com/swarmauri/swarmauri-sdk/)
+
+# swarmauri_live_model_qwen
+
+## Features
+
+- Qwen Omni realtime text, audio, image, transcript, and tool events.
+- Provider-neutral Swarmauri live-session contract.
+
+## Installation
+
+`uv add swarmauri_live_model_qwen` or `pip install swarmauri_live_model_qwen`.
+
+## Usage
+
+Inject `QwenProvider` into `QwenOmniRealtimeModel` and consume typed events.
+

swarmauri_live_model_qwen-0.1.0.dev3/README.md

@@ -0,0 +1,18 @@
+![Swarmauri](https://github.com/swarmauri/swarmauri-sdk/blob/3d4d1cfa949399d7019ae9d8f296afba773dfb7f/assets/swarmauri.brand.theme.svg)
+
+[![PyPI](https://img.shields.io/pypi/v/swarmauri_live_model_qwen.svg)](https://pypi.org/project/swarmauri_live_model_qwen/) [![Python](https://img.shields.io/pypi/pyversions/swarmauri_live_model_qwen.svg)](https://pypi.org/project/swarmauri_live_model_qwen/) [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE) [![Downloads](https://static.pepy.tech/badge/swarmauri_live_model_qwen)](https://pepy.tech/project/swarmauri_live_model_qwen) [![Hits](https://hits.sh/github.com/swarmauri/swarmauri-sdk.svg)](https://hits.sh/github.com/swarmauri/swarmauri-sdk/)
+
+# swarmauri_live_model_qwen
+
+## Features
+
+- Qwen Omni realtime text, audio, image, transcript, and tool events.
+- Provider-neutral Swarmauri live-session contract.
+
+## Installation
+
+`uv add swarmauri_live_model_qwen` or `pip install swarmauri_live_model_qwen`.
+
+## Usage
+
+Inject `QwenProvider` into `QwenOmniRealtimeModel` and consume typed events.

swarmauri_live_model_qwen-0.1.0.dev3/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "swarmauri_live_model_qwen"
+version = "0.1.0.dev3"
+description = "Qwen Omni Realtime multimodal model adapter for Swarmauri."
+readme = "README.md"
+requires-python = ">=3.10,<3.13"
+authors = [{ name = "Jacob Stewart", email = "jacob@swarmauri.com" }]
+license = { file = "LICENSE" }
+dependencies = ["swarmauri_core>=0.11.0.dev5", "swarmauri_base>=0.11.0.dev5", "swarmauri_provider_qwen>=0.1.0.dev3", "swarmauri_transport_websocket>=0.1.0.dev4"]
+classifiers = ["Development Status :: 1 - Planning", "License :: OSI Approved :: Apache Software License", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12"]
+keywords = ["swarmauri", "qwen omni", "realtime", "multimodal", "websocket"]
+[tool.uv.sources]
+swarmauri_core = { workspace = true }
+swarmauri_base = { workspace = true }
+swarmauri_provider_qwen = { workspace = true }
+swarmauri_transport_websocket = { workspace = true }
+[project.entry-points."swarmauri.live_models"]
+QwenOmniRealtimeModel = "swarmauri_live_model_qwen:QwenOmniRealtimeModel"
+[build-system]
+requires = ["poetry-core>=1.8.0"]
+build-backend = "poetry.core.masonry.api"
+[dependency-groups]
+dev = ["pytest>=8.0", "pytest-asyncio>=0.24", "ruff>=0.9.9", "swarmauri_tests_component"]
+
+[tool.ruff]
+extend = "../../pyproject.toml"
+
+[tool.ruff.lint]
+ignore = ["BLE001", "N999"]

swarmauri_live_model_qwen-0.1.0.dev3/swarmauri_live_model_qwen/QwenOmniRealtimeCodec.py

@@ -0,0 +1,99 @@
+import base64
+import json
+
+from swarmauri_base.live_models.events.AudioDeltaEvent import AudioDeltaEvent
+from swarmauri_base.live_models.events.OutputTranscriptDeltaEvent import (
+    OutputTranscriptDeltaEvent,
+)
+from swarmauri_base.live_models.events.SessionErrorEvent import (
+    SessionErrorEvent,
+)
+from swarmauri_base.live_models.events.TextDeltaEvent import TextDeltaEvent
+from swarmauri_base.live_models.events.ToolCallEvent import ToolCallEvent
+from swarmauri_base.live_models.events.TurnCompleteEvent import (
+    TurnCompleteEvent,
+)
+
+
+class QwenOmniRealtimeCodec:
+    def encode(self, input_data):
+        if input_data.kind == "text":
+            return json.dumps(
+                {
+                    "type": "conversation.item.create",
+                    "item": {
+                        "role": "user",
+                        "content": [
+                            {"type": "input_text", "text": input_data.payload}
+                        ],
+                    },
+                }
+            )
+        if input_data.kind == "audio":
+            return json.dumps(
+                {
+                    "type": "input_audio_buffer.append",
+                    "audio": base64.b64encode(input_data.payload).decode(),
+                }
+            )
+        if input_data.kind == "tool_result":
+            return json.dumps(
+                {
+                    "type": "conversation.item.create",
+                    "item": {
+                        "type": "function_call_output",
+                        "call_id": input_data.call_id,
+                        "output": json.dumps(input_data.payload),
+                    },
+                }
+            )
+        return json.dumps({"type": "response.create"})
+
+    def decode(self, message):
+        data = json.loads(message)
+        kind = data.get("type", "")
+        correlation = {
+            "provider_event_id": data.get("event_id"),
+            "call_id": data.get("call_id"),
+        }
+        if kind.endswith("text.delta"):
+            return [
+                TextDeltaEvent(
+                    payload=data.get("delta", ""), correlation=correlation
+                )
+            ]
+        if kind.endswith("audio.delta"):
+            return [
+                AudioDeltaEvent(
+                    payload=base64.b64decode(data.get("delta", "")),
+                    correlation=correlation,
+                )
+            ]
+        if "transcript.delta" in kind:
+            return [
+                OutputTranscriptDeltaEvent(
+                    payload=data.get("delta", ""), correlation=correlation
+                )
+            ]
+        if kind.endswith("function_call_arguments.done"):
+            args = data.get("arguments", {})
+            return [
+                ToolCallEvent(
+                    call_id=data.get("call_id", ""),
+                    tool_name=data.get("name", ""),
+                    arguments=json.loads(args)
+                    if isinstance(args, str)
+                    else args,
+                    correlation=correlation,
+                )
+            ]
+        if kind == "response.done":
+            return [TurnCompleteEvent(correlation=correlation)]
+        if kind == "error":
+            return [
+                SessionErrorEvent(
+                    message=str(data.get("error", data)),
+                    correlation=correlation,
+                )
+            ]
+        return []

swarmauri_live_model_qwen-0.1.0.dev3/swarmauri_live_model_qwen/QwenOmniRealtimeConfigMapper.py

@@ -0,0 +1,13 @@
+from swarmauri_base.live_models.LiveConfigBase import LiveConfigBase
+
+
+class QwenOmniRealtimeConfigMapper:
+    def map(self, config: LiveConfigBase) -> dict:
+        return {
+            "event_id": "swarmauri-setup",
+            "type": "session.update",
+            "session": {
+                "modalities": config.requested_modalities,
+                **config.provider_options.get("session", {}),
+            },
+        }

swarmauri_live_model_qwen-0.1.0.dev3/swarmauri_live_model_qwen/QwenOmniRealtimeModel.py

@@ -0,0 +1,43 @@
+from typing import Any, Literal
+
+from pydantic import ConfigDict, Field
+from swarmauri_base.ComponentBase import ComponentBase
+from swarmauri_base.live_models.LiveCapabilitiesBase import (
+    LiveCapabilitiesBase,
+)
+from swarmauri_base.live_models.LiveConfigBase import LiveConfigBase
+from swarmauri_base.live_models.LiveModelBase import LiveModelBase
+from swarmauri_provider_qwen import QwenProvider
+from swarmauri_transport_websocket import WebSocketClient
+
+from .QwenOmniRealtimeConfigMapper import QwenOmniRealtimeConfigMapper
+from .QwenOmniRealtimeSession import QwenOmniRealtimeSession
+
+
+@ComponentBase.register_type(LiveModelBase, "QwenOmniRealtimeModel")
+class QwenOmniRealtimeModel(LiveModelBase):
+    name: str = "qwen-omni-turbo-realtime"
+    provider: QwenProvider = Field(default_factory=QwenProvider)
+    transport: Any = Field(default_factory=WebSocketClient, exclude=True)
+    capabilities: LiveCapabilitiesBase = Field(
+        default_factory=lambda: LiveCapabilitiesBase(
+            input_modalities=frozenset({"text", "audio", "image"}),
+            output_modalities=frozenset({"text", "audio"}),
+            features=frozenset({"tools", "transcription"}),
+            session_features=frozenset({"realtime"}),
+        )
+    )
+    type: Literal["QwenOmniRealtimeModel"] = "QwenOmniRealtimeModel"
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
+
+    async def aconnect(self, config: LiveConfigBase):
+        connection_config = self.provider.prepare_connection(
+            "realtime.connect", model=self.name
+        )
+        connection = await self.transport.aconnect(
+            connection_config.resolved_url(),
+            headers=connection_config.headers,
+        )
+        return await QwenOmniRealtimeSession.create(
+            connection, QwenOmniRealtimeConfigMapper().map(config)
+        )

swarmauri_live_model_qwen-0.1.0.dev3/swarmauri_live_model_qwen/QwenOmniRealtimeSession.py

@@ -0,0 +1,53 @@
+import asyncio
+import json
+from contextlib import suppress
+from typing import Literal
+
+from pydantic import PrivateAttr
+from swarmauri_base.live_models.events.SessionErrorEvent import (
+    SessionErrorEvent,
+)
+from swarmauri_base.live_models.LiveSessionBase import LiveSessionBase
+from swarmauri_base.ComponentBase import ComponentBase
+
+from .QwenOmniRealtimeCodec import QwenOmniRealtimeCodec
+
+
+@ComponentBase.register_type(LiveSessionBase, "QwenOmniRealtimeSession")
+class QwenOmniRealtimeSession(LiveSessionBase):
+    type: Literal["QwenOmniRealtimeSession"] = "QwenOmniRealtimeSession"
+    _connection = PrivateAttr()
+    _codec = PrivateAttr(default_factory=QwenOmniRealtimeCodec)
+    _receiver = PrivateAttr(default=None)
+
+    @classmethod
+    async def create(cls, connection, setup):
+        session = cls()
+        session._connection = connection
+        await connection.asend(json.dumps(setup))
+        session.mark_open()
+        session._receiver = asyncio.create_task(session._receive_loop())
+        return session
+
+    async def _receive_loop(self) -> None:
+        try:
+            async for message in self._connection.aiter_messages():
+                for event in self._codec.decode(message):
+                    await self.emit(event)
+        except asyncio.CancelledError:
+            raise
+        except Exception as exc:
+            await self.emit(SessionErrorEvent(message=str(exc)))
+            await self.fail(exc)
+        else:
+            await self.finish()
+
+    async def _asend_impl(self, input_data):
+        await self._connection.asend(self._codec.encode(input_data))
+
+    async def _aclose_impl(self):
+        if self._receiver and self._receiver is not asyncio.current_task():
+            self._receiver.cancel()
+            with suppress(asyncio.CancelledError):
+                await self._receiver
+        await self._connection.aclose()

swarmauri_live_model_qwen-0.1.0.dev3/swarmauri_live_model_qwen/QwenOmniRealtimeToolAdapter.py

@@ -0,0 +1,6 @@
+from swarmauri_base.live_models.inputs.ToolResultInput import ToolResultInput
+
+
+class QwenOmniRealtimeToolAdapter:
+    def result(self, call_id, value):
+        return ToolResultInput(call_id=call_id, payload=value)

swarmauri_live_model_qwen-0.1.0.dev3/swarmauri_live_model_qwen/__init__.py

@@ -0,0 +1,13 @@
+from .QwenOmniRealtimeCodec import QwenOmniRealtimeCodec
+from .QwenOmniRealtimeConfigMapper import QwenOmniRealtimeConfigMapper
+from .QwenOmniRealtimeModel import QwenOmniRealtimeModel
+from .QwenOmniRealtimeSession import QwenOmniRealtimeSession
+from .QwenOmniRealtimeToolAdapter import QwenOmniRealtimeToolAdapter
+
+__all__ = [
+    "QwenOmniRealtimeCodec",
+    "QwenOmniRealtimeConfigMapper",
+    "QwenOmniRealtimeModel",
+    "QwenOmniRealtimeSession",
+    "QwenOmniRealtimeToolAdapter",
+]