swarmauri_transport_aws_eventstream 0.1.0.dev1__tar.gz

swarmauri_transport_aws_eventstream-0.1.0.dev1/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_transport_aws_eventstream-0.1.0.dev1/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: swarmauri_transport_aws_eventstream
+Version: 0.1.0.dev1
+Summary: Amazon Bedrock bidirectional EventStream transport for Swarmauri live models.
+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,transport,aws,amazon bedrock,eventstream,bidirectional,nova sonic,smithy,http2
+Author: Jacob Stewart
+Author-email: jacob@swarmauri.com
+Requires-Python: >=3.10,<3.13
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: aws-sdk-bedrock-runtime (>=0.2.0,<0.3.0) ; python_version >= "3.12"
+Requires-Dist: botocore (>=1.35)
+Requires-Dist: swarmauri_base (>=0.11.0.dev5)
+Requires-Dist: swarmauri_core (>=0.11.0.dev5)
+Project-URL: Documentation, https://github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/standards/swarmauri_transport_aws_eventstream#readme
+Project-URL: Homepage, https://github.com/swarmauri/swarmauri-sdk
+Project-URL: Repository, https://github.com/swarmauri/swarmauri-sdk
+Project-URL: Source, https://github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/standards/swarmauri_transport_aws_eventstream
+Description-Content-Type: text/markdown
+
+![Swarmauri](https://github.com/swarmauri/swarmauri-sdk/blob/3d4d1cfa949399d7019ae9d8f296afba773dfb7f/assets/swarmauri.brand.theme.svg)
+
+[![PyPI version](https://img.shields.io/pypi/v/swarmauri_transport_aws_eventstream.svg)](https://pypi.org/project/swarmauri_transport_aws_eventstream/) [![Python](https://img.shields.io/pypi/pyversions/swarmauri_transport_aws_eventstream.svg)](https://pypi.org/project/swarmauri_transport_aws_eventstream/) [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE) [![Downloads](https://static.pepy.tech/badge/swarmauri_transport_aws_eventstream)](https://pepy.tech/project/swarmauri_transport_aws_eventstream) [![Hits](https://hits.sh/github.com/swarmauri/swarmauri-sdk.svg?path=pkgs%2Fstandards%2Fswarmauri_transport_aws_eventstream)](https://hits.sh/github.com/swarmauri/swarmauri-sdk/)
+
+# swarmauri_transport_aws_eventstream
+
+`swarmauri_transport_aws_eventstream` adapts Amazon Bedrock's Smithy
+bidirectional EventStream operation to Swarmauri's
+`IBidirectionalStreamClient` and `IBidirectionalStreamConnection` contracts.
+The AWS SDK owns HTTP/2 framing, credential-chain resolution, and SigV4 request
+and message signing; this package owns the Swarmauri lifecycle and JSON event
+mapping.
+
+## Features
+
+- Sends and receives JSON events over `InvokeModelWithBidirectionalStream`.
+- Supports explicit temporary credentials, the default AWS credential chain,
+  and named profiles.
+- Exposes synchronous and asynchronous Swarmauri connection APIs.
+- Converts AWS stream exception events into `AwsEventStreamError`.
+- Keeps credentials out of serialized component state.
+
+The codec and package metadata support Python 3.10 through 3.12. Amazon's
+official `aws-sdk-bedrock-runtime` currently requires Python 3.12, so opening a
+live Bedrock connection requires Python 3.12.
+
+## Installation
+
+```bash
+uv add swarmauri_transport_aws_eventstream
+```
+
+```bash
+pip install swarmauri_transport_aws_eventstream
+```
+
+## Usage
+
+Use the client directly when you already have a Bedrock model ID:
+
+```python
+from swarmauri_transport_aws_eventstream import AwsEventStreamClient
+
+client = AwsEventStreamClient(region="us-east-1")
+connection = await client.aconnect(
+    "https://bedrock-runtime.us-east-1.amazonaws.com",
+    model_id="amazon.nova-sonic-v1:0",
+)
+
+await connection.asend({"event": {"sessionStart": {}}})
+async for event in connection.aiter_events():
+    print(event)
+await connection.aclose()
+```
+
+`NovaSonicLiveModel` configures this transport automatically. Pass an
+`AmazonNovaProvider` when you need a named profile, explicit temporary
+credentials, a different region, or a custom Bedrock runtime endpoint.
+

swarmauri_transport_aws_eventstream-0.1.0.dev1/README.md

@@ -0,0 +1,58 @@
+![Swarmauri](https://github.com/swarmauri/swarmauri-sdk/blob/3d4d1cfa949399d7019ae9d8f296afba773dfb7f/assets/swarmauri.brand.theme.svg)
+
+[![PyPI version](https://img.shields.io/pypi/v/swarmauri_transport_aws_eventstream.svg)](https://pypi.org/project/swarmauri_transport_aws_eventstream/) [![Python](https://img.shields.io/pypi/pyversions/swarmauri_transport_aws_eventstream.svg)](https://pypi.org/project/swarmauri_transport_aws_eventstream/) [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE) [![Downloads](https://static.pepy.tech/badge/swarmauri_transport_aws_eventstream)](https://pepy.tech/project/swarmauri_transport_aws_eventstream) [![Hits](https://hits.sh/github.com/swarmauri/swarmauri-sdk.svg?path=pkgs%2Fstandards%2Fswarmauri_transport_aws_eventstream)](https://hits.sh/github.com/swarmauri/swarmauri-sdk/)
+
+# swarmauri_transport_aws_eventstream
+
+`swarmauri_transport_aws_eventstream` adapts Amazon Bedrock's Smithy
+bidirectional EventStream operation to Swarmauri's
+`IBidirectionalStreamClient` and `IBidirectionalStreamConnection` contracts.
+The AWS SDK owns HTTP/2 framing, credential-chain resolution, and SigV4 request
+and message signing; this package owns the Swarmauri lifecycle and JSON event
+mapping.
+
+## Features
+
+- Sends and receives JSON events over `InvokeModelWithBidirectionalStream`.
+- Supports explicit temporary credentials, the default AWS credential chain,
+  and named profiles.
+- Exposes synchronous and asynchronous Swarmauri connection APIs.
+- Converts AWS stream exception events into `AwsEventStreamError`.
+- Keeps credentials out of serialized component state.
+
+The codec and package metadata support Python 3.10 through 3.12. Amazon's
+official `aws-sdk-bedrock-runtime` currently requires Python 3.12, so opening a
+live Bedrock connection requires Python 3.12.
+
+## Installation
+
+```bash
+uv add swarmauri_transport_aws_eventstream
+```
+
+```bash
+pip install swarmauri_transport_aws_eventstream
+```
+
+## Usage
+
+Use the client directly when you already have a Bedrock model ID:
+
+```python
+from swarmauri_transport_aws_eventstream import AwsEventStreamClient
+
+client = AwsEventStreamClient(region="us-east-1")
+connection = await client.aconnect(
+    "https://bedrock-runtime.us-east-1.amazonaws.com",
+    model_id="amazon.nova-sonic-v1:0",
+)
+
+await connection.asend({"event": {"sessionStart": {}}})
+async for event in connection.aiter_events():
+    print(event)
+await connection.aclose()
+```
+
+`NovaSonicLiveModel` configures this transport automatically. Pass an
+`AmazonNovaProvider` when you need a named profile, explicit temporary
+credentials, a different region, or a custom Bedrock runtime endpoint.

swarmauri_transport_aws_eventstream-0.1.0.dev1/pyproject.toml

@@ -0,0 +1,62 @@
+[project]
+name = "swarmauri_transport_aws_eventstream"
+version = "0.1.0.dev1"
+description = "Amazon Bedrock bidirectional EventStream transport for Swarmauri live models."
+readme = "README.md"
+requires-python = ">=3.10,<3.13"
+authors = [{ name = "Jacob Stewart", email = "jacob@swarmauri.com" }]
+license = { file = "LICENSE" }
+dependencies = [
+  "botocore>=1.35",
+  "swarmauri_base>=0.11.0.dev5",
+  "swarmauri_core>=0.11.0.dev5",
+  "aws-sdk-bedrock-runtime~=0.2.0; python_version >= '3.12'",
+]
+keywords = [
+  "swarmauri",
+  "transport",
+  "aws",
+  "amazon bedrock",
+  "eventstream",
+  "bidirectional",
+  "nova sonic",
+  "smithy",
+  "http2",
+]
+classifiers = [
+  "Development Status :: 1 - Planning",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Internet :: WWW/HTTP",
+  "Topic :: Software Development :: Libraries",
+]
+
+[tool.uv.sources]
+swarmauri_base = { workspace = true }
+swarmauri_core = { workspace = true }
+
+[project.urls]
+Homepage = "https://github.com/swarmauri/swarmauri-sdk"
+Repository = "https://github.com/swarmauri/swarmauri-sdk"
+Source = "https://github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/standards/swarmauri_transport_aws_eventstream"
+Documentation = "https://github.com/swarmauri/swarmauri-sdk/tree/master/pkgs/standards/swarmauri_transport_aws_eventstream#readme"
+
+[project.entry-points."swarmauri.transports"]
+AwsEventStreamClient = "swarmauri_transport_aws_eventstream:AwsEventStreamClient"
+
+[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 = ["N999"]

swarmauri_transport_aws_eventstream-0.1.0.dev1/swarmauri_transport_aws_eventstream/AwsEventStreamClient.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import asyncio
+import warnings
+from collections.abc import Mapping
+from typing import Any, Literal
+from urllib.parse import unquote, urlsplit
+
+from pydantic import Field
+from swarmauri_base.ComponentBase import ComponentBase, ResourceTypes
+from swarmauri_base.transports.bidirectional.BidirectionalStreamClientBase import (  # noqa: E501
+    BidirectionalStreamClientBase,
+)
+
+from .AwsEventStreamConnection import AwsEventStreamConnection
+
+
+@ComponentBase.register_type(
+    BidirectionalStreamClientBase, "AwsEventStreamClient"
+)
+class AwsEventStreamClient(BidirectionalStreamClientBase):
+    """Open Bedrock bidirectional streams through AWS's Smithy SDK."""
+
+    region: str = "us-east-1"
+    sdk_client_factory: Any = Field(default=None, exclude=True)
+    type: Literal["AwsEventStreamClient"] = "AwsEventStreamClient"
+    resource: str = Field(default=ResourceTypes.TRANSPORT.value, frozen=True)
+
+    @staticmethod
+    def _run_sync(awaitable: Any) -> Any:
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            return asyncio.run(awaitable)
+        close = getattr(awaitable, "close", None)
+        if close is not None:
+            close()
+        raise RuntimeError("Use aconnect() inside an event loop")
+
+    @staticmethod
+    def _model_from_endpoint(endpoint: str) -> str | None:
+        path = urlsplit(endpoint).path
+        prefix = "/model/"
+        suffix = "/invoke-with-bidirectional-stream"
+        if path.startswith(prefix) and path.endswith(suffix):
+            return unquote(path[len(prefix) : -len(suffix)])
+        return None
+
+    @staticmethod
+    def _profile_credentials(profile: str) -> dict[str, str]:
+        from botocore.session import Session
+
+        credentials = Session(profile=profile).get_credentials()
+        if credentials is None:
+            raise ValueError(f"AWS profile {profile!r} has no credentials")
+        frozen = credentials.get_frozen_credentials()
+        result = {
+            "aws_access_key_id": frozen.access_key,
+            "aws_secret_access_key": frozen.secret_key,
+        }
+        if frozen.token:
+            result["aws_session_token"] = frozen.token
+        return result
+
+    @staticmethod
+    def _default_sdk():
+        try:
+            from aws_sdk_bedrock_runtime.config import Config
+            from aws_sdk_bedrock_runtime.models import (
+                InvokeModelWithBidirectionalStreamOperationInput,
+            )
+        except ImportError as exc:  # pragma: no cover - Python < 3.12
+            raise RuntimeError(
+                "AWS Bedrock bidirectional transport requires Python 3.12 "
+                "and aws-sdk-bedrock-runtime"
+            ) from exc
+        try:
+            from aws_sdk_bedrock_runtime.client import (
+                AsyncBedrockRuntimeClient,
+            )
+
+            client_type = AsyncBedrockRuntimeClient
+        except ImportError:
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", DeprecationWarning)
+                from aws_sdk_bedrock_runtime.client import (
+                    BedrockRuntimeClient,
+                )
+
+            client_type = BedrockRuntimeClient
+        return (
+            client_type,
+            Config,
+            (InvokeModelWithBidirectionalStreamOperationInput),
+        )
+
+    def connect(
+        self,
+        endpoint: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        **kwargs: Any,
+    ) -> AwsEventStreamConnection:
+        return self._run_sync(
+            self.aconnect(endpoint, headers=headers, **kwargs)
+        )
+
+    async def aconnect(
+        self,
+        endpoint: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        **kwargs: Any,
+    ) -> AwsEventStreamConnection:
+        if headers:
+            raise ValueError(
+                "Custom headers are unsupported; the AWS SDK owns "
+                "SigV4 headers"
+            )
+
+        model_id = kwargs.pop("model_id", None) or self._model_from_endpoint(
+            endpoint
+        )
+        if not model_id:
+            raise ValueError("model_id is required for a Bedrock event stream")
+
+        region = str(kwargs.pop("region", None) or self.region)
+        profile = kwargs.pop("profile", None)
+        credential_options = {
+            key: kwargs.pop(key)
+            for key in (
+                "aws_access_key_id",
+                "aws_secret_access_key",
+                "aws_session_token",
+            )
+            if kwargs.get(key) is not None
+        }
+        if ("aws_access_key_id" in credential_options) != (
+            "aws_secret_access_key" in credential_options
+        ):
+            raise ValueError(
+                "aws_access_key_id and aws_secret_access_key must be "
+                "provided together"
+            )
+        if profile and not credential_options:
+            credential_options = await asyncio.to_thread(
+                self._profile_credentials, str(profile)
+            )
+        if kwargs:
+            names = ", ".join(sorted(kwargs))
+            raise TypeError(f"Unsupported AWS event stream options: {names}")
+
+        client_type, config_type, input_type = self._default_sdk()
+        split = urlsplit(endpoint)
+        if split.scheme not in {"http", "https"} or not split.netloc:
+            raise ValueError("endpoint must be an absolute HTTP or HTTPS URL")
+        endpoint_uri = f"{split.scheme}://{split.netloc}"
+        config = config_type(
+            region=region,
+            endpoint_uri=endpoint_uri,
+            **credential_options,
+        )
+        factory = self.sdk_client_factory or client_type
+        client = factory(config)
+        stream = client.invoke_model_with_bidirectional_stream(
+            input_type(model_id=str(model_id))
+        )
+        return AwsEventStreamConnection.from_stream(stream)

swarmauri_transport_aws_eventstream-0.1.0.dev1/swarmauri_transport_aws_eventstream/AwsEventStreamCodec.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .AwsEventStreamError import AwsEventStreamError
+
+
+class AwsEventStreamCodec:
+    """Translate Python payloads to and from Bedrock Smithy events."""
+
+    @staticmethod
+    def _models():
+        try:
+            from aws_sdk_bedrock_runtime import models
+        except ImportError as exc:  # pragma: no cover - Python < 3.12
+            raise RuntimeError(
+                "AWS Bedrock bidirectional transport requires Python 3.12 "
+                "and aws-sdk-bedrock-runtime"
+            ) from exc
+        return models
+
+    def encode(self, event: Any) -> Any:
+        models = self._models()
+        payload = (
+            event
+            if isinstance(event, bytes)
+            else json.dumps(event, separators=(",", ":")).encode("utf-8")
+        )
+        return models.InvokeModelWithBidirectionalStreamInputChunk(
+            models.BidirectionalInputPayloadPart(bytes_=payload)
+        )
+
+    def decode(self, event: Any) -> Any:
+        if event.__class__.__name__ == (
+            "InvokeModelWithBidirectionalStreamOutputChunk"
+        ):
+            payload = event.value.bytes_ or b""
+            return json.loads(payload.decode("utf-8"))
+
+        value = getattr(event, "value", None)
+        message = getattr(value, "message", None)
+        if message is None:
+            message = f"Unexpected AWS event stream event: {event!r}"
+        raise AwsEventStreamError(str(message))

swarmauri_transport_aws_eventstream-0.1.0.dev1/swarmauri_transport_aws_eventstream/AwsEventStreamConnection.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Iterator
+from typing import Any
+
+from pydantic import PrivateAttr
+from swarmauri_base.transports.bidirectional.BidirectionalStreamConnectionBase import (  # noqa: E501
+    BidirectionalStreamConnectionBase,
+)
+from swarmauri_base.transports.bidirectional.BidirectionalStreamState import (
+    BidirectionalStreamState,
+)
+
+from .AwsEventStreamCodec import AwsEventStreamCodec
+
+
+class AwsEventStreamConnection(BidirectionalStreamConnectionBase):
+    """Swarmauri connection adapter for a Smithy duplex event stream."""
+
+    _stream: Any = PrivateAttr()
+    _receiver: Any = PrivateAttr(default=None)
+    _stream_closed: bool = PrivateAttr(default=False)
+    _codec: AwsEventStreamCodec = PrivateAttr(
+        default_factory=AwsEventStreamCodec
+    )
+
+    @classmethod
+    def from_stream(cls, stream: Any) -> "AwsEventStreamConnection":
+        connection = cls(state=BidirectionalStreamState.OPEN.value)
+        connection._stream = stream
+        return connection
+
+    async def _output_receiver(self) -> Any:
+        if self._receiver is None:
+            _, self._receiver = await self._stream.await_output()
+        return self._receiver
+
+    async def asend(self, event: Any) -> None:
+        if self.state != BidirectionalStreamState.OPEN.value:
+            raise RuntimeError("AWS event stream is not open")
+        await self._stream.input_stream.send(self._codec.encode(event))
+
+    async def areceive(self) -> Any:
+        if self.state != BidirectionalStreamState.OPEN.value:
+            raise EOFError("AWS event stream is closed")
+        receiver = await self._output_receiver()
+        event = await receiver.receive()
+        if event is None:
+            await self._close_stream()
+            raise EOFError("AWS event stream ended")
+        return self._codec.decode(event)
+
+    def iter_events(self) -> Iterator[Any]:
+        while self.state == BidirectionalStreamState.OPEN.value:
+            try:
+                yield self.receive()
+            except EOFError:
+                return
+
+    async def aiter_events(self) -> AsyncIterator[Any]:
+        while self.state == BidirectionalStreamState.OPEN.value:
+            try:
+                yield await self.areceive()
+            except EOFError:
+                return
+
+    async def _close_stream(self) -> None:
+        if self._stream_closed:
+            self.state = BidirectionalStreamState.CLOSED.value
+            return
+        self.state = BidirectionalStreamState.CLOSING.value
+        try:
+            await self._stream.close()
+        finally:
+            self._stream_closed = True
+            self.state = BidirectionalStreamState.CLOSED.value
+
+    async def aclose(self) -> None:
+        await self._close_stream()

swarmauri_transport_aws_eventstream-0.1.0.dev1/swarmauri_transport_aws_eventstream/AwsEventStreamError.py

@@ -0,0 +1,2 @@
+class AwsEventStreamError(RuntimeError):
+    """Raised when an AWS bidirectional event stream returns an error event."""

swarmauri_transport_aws_eventstream-0.1.0.dev1/swarmauri_transport_aws_eventstream/__init__.py

@@ -0,0 +1,11 @@
+from .AwsEventStreamClient import AwsEventStreamClient
+from .AwsEventStreamCodec import AwsEventStreamCodec
+from .AwsEventStreamConnection import AwsEventStreamConnection
+from .AwsEventStreamError import AwsEventStreamError
+
+__all__ = [
+    "AwsEventStreamClient",
+    "AwsEventStreamCodec",
+    "AwsEventStreamConnection",
+    "AwsEventStreamError",
+]