aiohttp-asgi-connector 0.1.0__tar.gz

aiohttp_asgi_connector-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Elias Gabriel
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

aiohttp_asgi_connector-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.1
+Name: aiohttp-asgi-connector
+Version: 0.1.0
+Summary: AIOHTTP Connector for running ASGI applications
+Author-Email: thearchitector <me@eliasfgabriel.com>
+License: BSD-3-Clause
+Requires-Python: >=3.8
+Requires-Dist: aiohttp>=3
+Description-Content-Type: text/markdown
+
+# aiohttp-asgi
+
+![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/thearchitector/aiohttp-asgi-connector/CI.yaml?label=tests&style=flat-square)
+![PyPI - Downloads](https://img.shields.io/pypi/dw/aiohttp-asgi-connector?style=flat-square)
+![GitHub](https://img.shields.io/github/license/thearchitector/aiohttp-asgi-connector?style=flat-square)
+
+AIOHTTP Connector for running ASGI applications.
+
+This library intends to increase the parity between AIOHTTP and HTTPX, specifically with HTTPX's `AsyncClient`. It is primarily intended to be used in test suite scenarios, or other situations where one would want to interface with an ASGI application directly instead of through a web server.
+
+Supports Python 3.8+ and AIOHTTP 3+.
+
+## Installation
+
+```sh
+$ pdm add aiohttp-asgi-connector
+# or
+$ python -m pip install --user aiohttp-asgi-connector
+```
+
+## Usage
+
+This library replaces the entire connection stack and pool underlying HTTP transport. AIOHTTP exposes custom connectors via the `connector` argument supplied when creating a `ClientSession` instance.
+
+To use the `ASGIApplicationConnector`:
+
+```py
+import asyncio
+from typing import Annotated  # or from typing_extensions
+
+from aiohttp_asgi_connector import ASGIApplicationConnector
+from aiohttp import ClientSession
+from fastapi import FastAPI, Body
+
+app = FastAPI()
+
+@app.post("/ping")
+async def pong(message: Annotated[str, Body(embed=True)]):
+    return {"broadcast": f"Application says '{message}'!"}
+
+async def main():
+    connector = ASGIApplicationConnector(app)
+    async with ClientSession(base_url="http://localhost", connector=connector) as session:
+        async with session.post("/ping", json={"message": "hello"}) as resp:
+            print(await resp.json())
+            # ==> {'broadcast': "Application says 'hello'!"}
+
+asyncio.run(main())
+```
+
+This library does not handle ASGI lifespan events. If you want to run those events, use this library in conjunction with something like [asgi-lifespan](https://pypi.org/project/asgi-lifespan/).
+
+## License
+
+This software is licensed under the [BSD 3-Clause License](LICENSE).

aiohttp_asgi_connector-0.1.0/README.md

@@ -0,0 +1,55 @@
+# aiohttp-asgi
+
+![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/thearchitector/aiohttp-asgi-connector/CI.yaml?label=tests&style=flat-square)
+![PyPI - Downloads](https://img.shields.io/pypi/dw/aiohttp-asgi-connector?style=flat-square)
+![GitHub](https://img.shields.io/github/license/thearchitector/aiohttp-asgi-connector?style=flat-square)
+
+AIOHTTP Connector for running ASGI applications.
+
+This library intends to increase the parity between AIOHTTP and HTTPX, specifically with HTTPX's `AsyncClient`. It is primarily intended to be used in test suite scenarios, or other situations where one would want to interface with an ASGI application directly instead of through a web server.
+
+Supports Python 3.8+ and AIOHTTP 3+.
+
+## Installation
+
+```sh
+$ pdm add aiohttp-asgi-connector
+# or
+$ python -m pip install --user aiohttp-asgi-connector
+```
+
+## Usage
+
+This library replaces the entire connection stack and pool underlying HTTP transport. AIOHTTP exposes custom connectors via the `connector` argument supplied when creating a `ClientSession` instance.
+
+To use the `ASGIApplicationConnector`:
+
+```py
+import asyncio
+from typing import Annotated  # or from typing_extensions
+
+from aiohttp_asgi_connector import ASGIApplicationConnector
+from aiohttp import ClientSession
+from fastapi import FastAPI, Body
+
+app = FastAPI()
+
+@app.post("/ping")
+async def pong(message: Annotated[str, Body(embed=True)]):
+    return {"broadcast": f"Application says '{message}'!"}
+
+async def main():
+    connector = ASGIApplicationConnector(app)
+    async with ClientSession(base_url="http://localhost", connector=connector) as session:
+        async with session.post("/ping", json={"message": "hello"}) as resp:
+            print(await resp.json())
+            # ==> {'broadcast': "Application says 'hello'!"}
+
+asyncio.run(main())
+```
+
+This library does not handle ASGI lifespan events. If you want to run those events, use this library in conjunction with something like [asgi-lifespan](https://pypi.org/project/asgi-lifespan/).
+
+## License
+
+This software is licensed under the [BSD 3-Clause License](LICENSE).

aiohttp_asgi_connector-0.1.0/aiohttp_asgi_connector/__init__.py

@@ -0,0 +1,3 @@
+from .connector import ASGIApplicationConnector
+
+__all__ = ["ASGIApplicationConnector"]

aiohttp_asgi_connector-0.1.0/aiohttp_asgi_connector/connector.py

@@ -0,0 +1,59 @@
+from typing import TYPE_CHECKING
+
+from aiohttp import BaseConnector
+
+from .transport import ASGITransport
+
+if TYPE_CHECKING:  # pragma: no cover
+    from asyncio import AbstractEventLoop
+    from typing import List, Optional
+
+    from aiohttp import ClientRequest, ClientTimeout
+    from aiohttp.client_proto import ResponseHandler
+    from aiohttp.client_reqrep import ConnectionKey
+    from aiohttp.tracing import Trace
+
+    from .transport import Application
+
+
+class ASGIApplicationConnector(BaseConnector):
+    """
+    A Connector that replaces the underlying connection transport with one that
+    intercepts and runs the provided ASGI application.
+
+    Since requests are handled by the ASGI application directly, there is no concept of
+    connection pooling with this connector; every request is processed immediately.
+
+    @param 'root_path' [""]:  alters the root path of the constructed ASGI request
+        scope.
+    @param 'raise_app_exceptions' [True]:  will cause the transport to propagate any
+        exceptions produced and not handled by the ASGI application.
+    """
+
+    def __init__(
+        self,
+        application: "Application",
+        root_path: str = "",
+        raise_app_exceptions: bool = True,
+        loop: "Optional[AbstractEventLoop]" = None,
+    ) -> None:
+        super().__init__(loop=loop)
+        self.app = application
+        self.root_path = root_path
+        self.raise_app_exceptions = raise_app_exceptions
+
+    async def _create_connection(
+        self, req: "ClientRequest", traces: "List[Trace]", timeout: "ClientTimeout"
+    ) -> "ResponseHandler":
+        protocol = self._factory()
+        transport = ASGITransport(
+            protocol, self.app, req, self.root_path, self.raise_app_exceptions
+        )
+        protocol.connection_made(transport)
+        return protocol
+
+    def _available_connections(self, key: "ConnectionKey") -> int:
+        return 1
+
+    def _get(self, key: "ConnectionKey") -> None:
+        return None

aiohttp_asgi_connector-0.1.0/aiohttp_asgi_connector/transport.py

@@ -0,0 +1,175 @@
+from asyncio import Transport
+from io import BytesIO
+from typing import TYPE_CHECKING
+
+from aiohttp import Payload
+
+if TYPE_CHECKING:  # pragma: no cover
+    from asyncio import Task
+    from typing import (
+        Any,
+        Awaitable,
+        Callable,
+        Dict,
+        Iterator,
+        List,
+        MutableMapping,
+        Optional,
+        Tuple,
+    )
+
+    from aiohttp import ClientRequest
+    from aiohttp.client_proto import ResponseHandler
+
+    Application = Callable[
+        [
+            Dict[str, Any],
+            Callable[[], Awaitable[Dict[str, Any]]],
+            Callable[[MutableMapping[str, Any]], Awaitable[None]],
+        ],
+        Awaitable[None],
+    ]
+
+STATUS_CODE_TO_REASON: "Dict[int, str]" = {
+    200: "OK",
+    201: "Created",
+    202: "Accepted",
+    204: "No Content",
+    301: "Moved Permanently",
+    302: "Found",
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+}
+
+
+class ASGITransport(Transport):
+    def __init__(
+        self,
+        protocol: "ResponseHandler",
+        app: "Application",
+        request: "ClientRequest",
+        root_path: str,
+        raise_app_exceptions: bool,
+    ):
+        super().__init__()
+        self.protocol = protocol
+        self.app = app
+        self.root_path = root_path
+        self.raise_app_exceptions = raise_app_exceptions
+
+        self.request = request
+        self.request_size = -1
+        self.request_handler: "Optional[Task[None]]" = None
+
+        self._closing = False
+
+    async def _handle_request(self) -> None:
+        scope: "Dict[str, Any]" = {
+            "type": "http",
+            "asgi": {"version": "3.0"},
+            "http_version": "1.1",
+            "method": self.request.method,
+            "headers": [(k.lower(), v) for (k, v) in self.request.headers.items()],
+            "scheme": self.request.url.scheme,
+            "path": self.request.url.path,
+            "raw_path": self.request.url.raw_path.split("?")[0],
+            "query_string": self.request.url.query,
+            "server": (self.request.url.host, self.request.url.port),
+            "client": ("127.0.0.1", 123),
+            "root_path": self.root_path,
+        }
+
+        payload = BytesIO()
+
+        if isinstance(self.request.body, Payload):
+
+            class FalseWriter:
+                async def write(self, chunk: bytes) -> None:
+                    payload.write(chunk)
+
+            await self.request.body.write(FalseWriter())  # type: ignore
+        elif isinstance(self.request.body, tuple):
+            for chunk in self.request.body:
+                payload.write(chunk)
+        else:
+            payload.write(self.request.body)
+
+        request_body_chunks: "Iterator[bytes]" = iter([payload.getvalue()])
+        status_code: "Optional[int]" = None
+        response_headers: "Optional[List[Tuple[bytes, bytes]]]" = None
+        response_body: bytearray = bytearray()
+
+        async def receive() -> "Dict[str, Any]":
+            try:
+                body = next(request_body_chunks)
+            except StopIteration:
+                return {"type": "http.request", "body": b"", "more_body": False}
+            return {"type": "http.request", "body": body, "more_body": True}
+
+        async def send(message: "MutableMapping[str, Any]") -> None:
+            nonlocal status_code, response_headers
+
+            if message["type"] == "http.response.start":
+                status_code = message["status"]
+                response_headers = message.get("headers", [])
+            elif message["type"] == "http.response.body":
+                body = message.get("body", b"")
+                if body and self.request.method != "HEAD":
+                    response_body.extend(body)
+
+        try:
+            await self.app(scope, receive, send)
+        except Exception:
+            if self.raise_app_exceptions:
+                raise
+
+        if status_code is None:
+            status_code = 500
+        if response_headers is None:
+            response_headers = []
+
+        response_payload = self._encode_response(
+            status_code, response_headers, response_body
+        )
+        self.protocol.data_received(response_payload)
+
+    def _encode_response(
+        self, status: int, headers: "List[Tuple[bytes, bytes]]", body: bytearray
+    ) -> bytes:
+        status_line = (
+            f"HTTP/1.1 {status} {STATUS_CODE_TO_REASON.get(status, 'Unknown')}"
+        )
+        header_line = "\r\n".join(
+            f"{name.decode()}: {value.decode()}" for name, value in headers
+        )
+        response = f"{status_line}\r\n{header_line}\r\n\r\n{body.decode()}"
+        return response.encode()
+
+    def write(self, data: bytes) -> None:
+        if self.request_size == -1:
+            self.request_size = 0
+            if size := getattr(self.request.body, "size", None):
+                self.max_request_size = size
+            else:
+                self.max_request_size = len(self.request.body)
+        else:
+            self.request_size += len(data)
+
+        if self.request_size == self.max_request_size:
+            # we've hit EOF. schedule the request for processing. we have to save this
+            # to a task since the event loop only holds weak refs and we don't want to
+            # GC in the middle of an execution
+            task = self.protocol._loop.create_task(self._handle_request())
+            self.request_handler = task
+
+    def close(self) -> None:
+        self._closing = True
+        del self.request_handler
+
+    def is_closing(self) -> bool:
+        return self._closing

aiohttp_asgi_connector-0.1.0/pyproject.toml

@@ -0,0 +1,55 @@
+[project]
+name = "aiohttp-asgi-connector"
+version = "0.1.0"
+description = "AIOHTTP Connector for running ASGI applications"
+authors = [
+    { name = "thearchitector", email = "me@eliasfgabriel.com" },
+]
+dependencies = [
+    "aiohttp>=3",
+]
+requires-python = ">=3.8"
+readme = "README.md"
+
+[project.license]
+text = "BSD-3-Clause"
+
+[tool.pdm.dev-dependencies]
+dev = [
+    "fastapi-slim>=0.111.0",
+    "pytest>=8.2.2",
+    "pytest-asyncio>=0.23.7",
+    "mypy>=1.10.1",
+    "typing-extensions>=4.12.2",
+]
+
+[tool.pytest.ini_options]
+addopts = "-ra -vv"
+testpaths = [
+    "tests",
+]
+asyncio_mode = "auto"
+
+[tool.mypy]
+strict = true
+
+[tool.pyright]
+ignore = [
+    "tests",
+]
+
+[tool.ruff]
+target-version = "py310"
+
+[tool.ruff.lint]
+extend-select = [
+    "B",
+    "I",
+    "ASYNC",
+]
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"

aiohttp_asgi_connector-0.1.0/tests/conftest.py

@@ -0,0 +1,41 @@
+import pytest
+from aiohttp import ClientSession
+from fastapi import Body, FastAPI
+from fastapi.responses import JSONResponse
+from pytest_asyncio import is_async_test
+from typing_extensions import Annotated
+
+from aiohttp_asgi_connector import ASGIApplicationConnector
+
+
+def pytest_collection_modifyitems(items):
+    pytest_asyncio_tests = (item for item in items if is_async_test(item))
+    session_scope_marker = pytest.mark.asyncio(scope="session")
+    for async_test in pytest_asyncio_tests:
+        async_test.add_marker(session_scope_marker, append=False)
+
+
+app = FastAPI(default_response_class=JSONResponse)
+
+
+@app.get("/ping")
+async def pong():
+    return True
+
+
+@app.post("/post_ping")
+async def post_ping(message: Annotated[str, Body(embed=True)]):
+    return {"broadcast": message}
+
+
+@pytest.fixture(scope="session")
+async def asgi_connector():
+    return ASGIApplicationConnector(app)
+
+
+@pytest.fixture(scope="session")
+async def session(asgi_connector):
+    async with ClientSession(
+        base_url="http://localhost", connector=asgi_connector
+    ) as session:
+        yield session

aiohttp_asgi_connector-0.1.0/tests/test_connector.py

@@ -0,0 +1,13 @@
+async def test_bad_method(session):
+    async with session.post("/ping") as resp:
+        assert (await resp.json()) == {"detail": "Method Not Allowed"}
+
+
+async def test_simple_get(session):
+    async with session.get("/ping") as resp:
+        assert (await resp.json()) is True
+
+
+async def test_simple_post(session):
+    async with session.post("/post_ping", json={"message": "hello world"}) as resp:
+        assert (await resp.json()) == {"broadcast": "hello world"}