swarmauri_transport_httpx 0.1.0.dev4__tar.gz

swarmauri_transport_httpx-0.1.0.dev4/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_httpx-0.1.0.dev4/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: swarmauri_transport_httpx
+Version: 0.1.0.dev4
+Summary: Synchronous, asynchronous, buffered, and streaming HTTPX transport 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,httpx,http,streaming,async
+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: httpx (>=0.27)
+Requires-Dist: swarmauri_base (>=0.11.0.dev5)
+Requires-Dist: swarmauri_core (>=0.11.0.dev5)
+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_httpx.svg)](https://pypi.org/project/swarmauri_transport_httpx/) [![Python](https://img.shields.io/pypi/pyversions/swarmauri_transport_httpx.svg)](https://pypi.org/project/swarmauri_transport_httpx/) [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE) [![Downloads](https://static.pepy.tech/badge/swarmauri_transport_httpx)](https://pepy.tech/project/swarmauri_transport_httpx) [![Hits](https://hits.sh/github.com/swarmauri/swarmauri-sdk.svg)](https://hits.sh/github.com/swarmauri/swarmauri-sdk/)
+
+# swarmauri_transport_httpx
+
+## Features
+
+- Synchronous and asynchronous buffered requests.
+- Genuine synchronous and asynchronous streaming contexts.
+- Persistent connection pooling with explicit ownership and cleanup.
+- Caller-supplied HTTPX clients for testing and custom network stacks.
+- Provider-neutral Swarmauri HTTP interfaces.
+
+## Installation
+
+```bash
+uv add swarmauri_transport_httpx
+pip install swarmauri_transport_httpx
+```
+
+## Usage
+
+Use `HttpxClient.request`/`arequest` for buffered responses and `stream`/`astream` for incremental response processing.
+
+```python
+from swarmauri_transport_httpx import HttpxClient
+
+with HttpxClient(base_url="https://api.example.com") as client:
+    response = client.request("GET", "/models")
+    response.raise_for_status()
+```
+
+Injected `httpx.Client` and `httpx.AsyncClient` instances remain caller-owned and are never closed by the adapter.
+

swarmauri_transport_httpx-0.1.0.dev4/README.md

@@ -0,0 +1,34 @@
+![Swarmauri](https://github.com/swarmauri/swarmauri-sdk/blob/3d4d1cfa949399d7019ae9d8f296afba773dfb7f/assets/swarmauri.brand.theme.svg)
+
+[![PyPI version](https://img.shields.io/pypi/v/swarmauri_transport_httpx.svg)](https://pypi.org/project/swarmauri_transport_httpx/) [![Python](https://img.shields.io/pypi/pyversions/swarmauri_transport_httpx.svg)](https://pypi.org/project/swarmauri_transport_httpx/) [![License](https://img.shields.io/badge/license-Apache--2.0-blue)](LICENSE) [![Downloads](https://static.pepy.tech/badge/swarmauri_transport_httpx)](https://pepy.tech/project/swarmauri_transport_httpx) [![Hits](https://hits.sh/github.com/swarmauri/swarmauri-sdk.svg)](https://hits.sh/github.com/swarmauri/swarmauri-sdk/)
+
+# swarmauri_transport_httpx
+
+## Features
+
+- Synchronous and asynchronous buffered requests.
+- Genuine synchronous and asynchronous streaming contexts.
+- Persistent connection pooling with explicit ownership and cleanup.
+- Caller-supplied HTTPX clients for testing and custom network stacks.
+- Provider-neutral Swarmauri HTTP interfaces.
+
+## Installation
+
+```bash
+uv add swarmauri_transport_httpx
+pip install swarmauri_transport_httpx
+```
+
+## Usage
+
+Use `HttpxClient.request`/`arequest` for buffered responses and `stream`/`astream` for incremental response processing.
+
+```python
+from swarmauri_transport_httpx import HttpxClient
+
+with HttpxClient(base_url="https://api.example.com") as client:
+    response = client.request("GET", "/models")
+    response.raise_for_status()
+```
+
+Injected `httpx.Client` and `httpx.AsyncClient` instances remain caller-owned and are never closed by the adapter.

swarmauri_transport_httpx-0.1.0.dev4/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "swarmauri_transport_httpx"
+version = "0.1.0.dev4"
+description = "Synchronous, asynchronous, buffered, and streaming HTTPX transport for Swarmauri."
+readme = "README.md"
+requires-python = ">=3.10,<3.13"
+authors = [{ name = "Jacob Stewart", email = "jacob@swarmauri.com" }]
+license = { file = "LICENSE" }
+dependencies = ["httpx>=0.27", "swarmauri_core>=0.11.0.dev5", "swarmauri_base>=0.11.0.dev5"]
+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", "httpx", "http", "streaming", "async"]
+
+[tool.uv.sources]
+swarmauri_core = { workspace = true }
+swarmauri_base = { workspace = true }
+
+[project.entry-points."swarmauri.transports"]
+HttpxClient = "swarmauri_transport_httpx:HttpxClient"
+
+[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"]
+
+[tool.ruff]
+extend = "../../pyproject.toml"
+
+[tool.ruff.lint]
+ignore = ["N999", "SIM117"]

swarmauri_transport_httpx-0.1.0.dev4/swarmauri_transport_httpx/AsyncHttpxStreamResponse.py

@@ -0,0 +1,42 @@
+from collections.abc import AsyncIterator
+from typing import Any
+
+import httpx
+from pydantic import PrivateAttr
+from swarmauri_base.transports.http.AsyncHttpStreamResponseBase import (
+    AsyncHttpStreamResponseBase,
+)
+from swarmauri_core.transports.http_errors import HttpStatusError
+
+
+class AsyncHttpxStreamResponse(AsyncHttpStreamResponseBase):
+    _response: Any = PrivateAttr(default=None)
+
+    @classmethod
+    def from_response(cls, response: Any) -> "AsyncHttpxStreamResponse":
+        result = cls(
+            status_code=response.status_code,
+            headers=dict(response.headers),
+        )
+        result._response = response
+        return result
+
+    async def aiter_bytes(self) -> AsyncIterator[bytes]:
+        async for chunk in self._response.aiter_bytes():
+            yield chunk
+
+    async def aread(self) -> bytes:
+        return await self._response.aread()
+
+    def json(self) -> Any:
+        return self._response.json()
+
+    def raise_for_status(self) -> None:
+        try:
+            self._response.raise_for_status()
+        except httpx.HTTPStatusError as error:
+            raise HttpStatusError(
+                str(error),
+                status_code=self.status_code,
+                response=self,
+            ) from error

swarmauri_transport_httpx-0.1.0.dev4/swarmauri_transport_httpx/HttpxClient.py

@@ -0,0 +1,171 @@
+from collections.abc import AsyncIterator, Iterator, Mapping
+from contextlib import asynccontextmanager, contextmanager
+from typing import Any
+
+import httpx
+from pydantic import Field, PrivateAttr
+from swarmauri_base.transports.http.HttpClientBase import HttpClientBase
+from swarmauri_core.transports.http_errors import HttpRequestError
+from swarmauri_core.transports.i_managed_http_client import IManagedHttpClient
+
+from .AsyncHttpxStreamResponse import AsyncHttpxStreamResponse
+from .HttpxResponse import HttpxResponse
+from .HttpxStreamResponse import HttpxStreamResponse
+
+
+class HttpxClient(HttpClientBase, IManagedHttpClient):
+    """Persistent HTTPX adapter for the Swarmauri HTTP client contracts."""
+
+    client_options: dict[str, Any] = Field(default_factory=dict)
+    _sync_client: httpx.Client | None = PrivateAttr(default=None)
+    _async_client: httpx.AsyncClient | None = PrivateAttr(default=None)
+    _owns_sync_client: bool = PrivateAttr(default=False)
+    _owns_async_client: bool = PrivateAttr(default=False)
+
+    def __init__(
+        self,
+        *,
+        client: httpx.Client | None = None,
+        async_client: httpx.AsyncClient | None = None,
+        **data: Any,
+    ) -> None:
+        super().__init__(**data)
+        self._sync_client = client
+        self._async_client = async_client
+
+    def _sync(self) -> httpx.Client:
+        if self._sync_client is None:
+            options = dict(self.client_options)
+            options.setdefault("timeout", self.timeout)
+            self._sync_client = httpx.Client(**options)
+            self._owns_sync_client = True
+        return self._sync_client
+
+    def _async(self) -> httpx.AsyncClient:
+        if self._async_client is None:
+            options = dict(self.client_options)
+            options.setdefault("timeout", self.timeout)
+            self._async_client = httpx.AsyncClient(**options)
+            self._owns_async_client = True
+        return self._async_client
+
+    @staticmethod
+    def _request_kwargs(body: bytes, kwargs: dict[str, Any]) -> dict[str, Any]:
+        request_kwargs = dict(kwargs)
+        if body:
+            if any(
+                key in request_kwargs
+                for key in ("content", "data", "files", "json")
+            ):
+                raise ValueError(
+                    "body cannot be combined with content, data, files, "
+                    "or json"
+                )
+            request_kwargs["content"] = body
+        return request_kwargs
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        body: bytes = b"",
+        **kwargs: Any,
+    ) -> HttpxResponse:
+        try:
+            response = self._sync().request(
+                method,
+                self.resolve_url(path),
+                headers=self.merge_headers(dict(headers or {})),
+                **self._request_kwargs(body, kwargs),
+            )
+            return HttpxResponse.from_response(response)
+        except httpx.RequestError as error:
+            raise HttpRequestError(str(error)) from error
+
+    async def arequest(
+        self,
+        method: str,
+        path: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        body: bytes = b"",
+        **kwargs: Any,
+    ) -> HttpxResponse:
+        try:
+            response = await self._async().request(
+                method,
+                self.resolve_url(path),
+                headers=self.merge_headers(dict(headers or {})),
+                **self._request_kwargs(body, kwargs),
+            )
+            return HttpxResponse.from_response(response)
+        except httpx.RequestError as error:
+            raise HttpRequestError(str(error)) from error
+
+    @contextmanager
+    def stream(
+        self,
+        method: str,
+        path: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        body: bytes = b"",
+        **kwargs: Any,
+    ) -> Iterator[HttpxStreamResponse]:
+        try:
+            with self._sync().stream(
+                method,
+                self.resolve_url(path),
+                headers=self.merge_headers(dict(headers or {})),
+                **self._request_kwargs(body, kwargs),
+            ) as response:
+                yield HttpxStreamResponse.from_response(response)
+        except httpx.RequestError as error:
+            raise HttpRequestError(str(error)) from error
+
+    @asynccontextmanager
+    async def astream(
+        self,
+        method: str,
+        path: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        body: bytes = b"",
+        **kwargs: Any,
+    ) -> AsyncIterator[AsyncHttpxStreamResponse]:
+        try:
+            async with self._async().stream(
+                method,
+                self.resolve_url(path),
+                headers=self.merge_headers(dict(headers or {})),
+                **self._request_kwargs(body, kwargs),
+            ) as response:
+                yield AsyncHttpxStreamResponse.from_response(response)
+        except httpx.RequestError as error:
+            raise HttpRequestError(str(error)) from error
+
+    def close(self) -> None:
+        if self._sync_client is not None and self._owns_sync_client:
+            self._sync_client.close()
+        self._sync_client = None
+        self._owns_sync_client = False
+
+    async def aclose(self) -> None:
+        if self._async_client is not None and self._owns_async_client:
+            await self._async_client.aclose()
+        self._async_client = None
+        self._owns_async_client = False
+
+    def __enter__(self) -> "HttpxClient":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    async def __aenter__(self) -> "HttpxClient":
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self.aclose()

swarmauri_transport_httpx-0.1.0.dev4/swarmauri_transport_httpx/HttpxResponse.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+from pydantic import PrivateAttr
+from swarmauri_base.transports.http.HttpResponseBase import HttpResponseBase
+from swarmauri_core.transports.http_errors import HttpStatusError
+
+
+class HttpxResponse(HttpResponseBase):
+    _response: Any = PrivateAttr(default=None)
+
+    @classmethod
+    def from_response(cls, response: Any) -> HttpxResponse:
+        result = cls(
+            status_code=response.status_code,
+            headers=dict(response.headers),
+        )
+        result._response = response
+        result.set_content(response.content)
+        return result
+
+    def raise_for_status(self) -> None:
+        try:
+            self._response.raise_for_status()
+        except httpx.HTTPStatusError as error:
+            raise HttpStatusError(
+                str(error),
+                status_code=self.status_code,
+                response=self,
+            ) from error

swarmauri_transport_httpx-0.1.0.dev4/swarmauri_transport_httpx/HttpxStreamResponse.py

@@ -0,0 +1,41 @@
+from collections.abc import Iterator
+from typing import Any
+
+import httpx
+from pydantic import PrivateAttr
+from swarmauri_base.transports.http.HttpStreamResponseBase import (
+    HttpStreamResponseBase,
+)
+from swarmauri_core.transports.http_errors import HttpStatusError
+
+
+class HttpxStreamResponse(HttpStreamResponseBase):
+    _response: Any = PrivateAttr(default=None)
+
+    @classmethod
+    def from_response(cls, response: Any) -> "HttpxStreamResponse":
+        result = cls(
+            status_code=response.status_code,
+            headers=dict(response.headers),
+        )
+        result._response = response
+        return result
+
+    def iter_bytes(self) -> Iterator[bytes]:
+        yield from self._response.iter_bytes()
+
+    def read(self) -> bytes:
+        return self._response.read()
+
+    def json(self) -> Any:
+        return self._response.json()
+
+    def raise_for_status(self) -> None:
+        try:
+            self._response.raise_for_status()
+        except httpx.HTTPStatusError as error:
+            raise HttpStatusError(
+                str(error),
+                status_code=self.status_code,
+                response=self,
+            ) from error

swarmauri_transport_httpx-0.1.0.dev4/swarmauri_transport_httpx/__init__.py

@@ -0,0 +1,11 @@
+from .AsyncHttpxStreamResponse import AsyncHttpxStreamResponse
+from .HttpxClient import HttpxClient
+from .HttpxResponse import HttpxResponse
+from .HttpxStreamResponse import HttpxStreamResponse
+
+__all__ = [
+    "AsyncHttpxStreamResponse",
+    "HttpxClient",
+    "HttpxResponse",
+    "HttpxStreamResponse",
+]