faststream_fastapi 1.0.0__tar.gz

faststream_fastapi-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivan Kirpichnikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

faststream_fastapi-1.0.0/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: faststream_fastapi
+Version: 1.0.0
+Summary: FastAPI integration for FastStream
+Keywords: rabbitmq,kafka,nats,redis,mqtt,asyncapi,framework,message brokers,fastapi
+Author: Ivan Kirpichnikov
+Author-email: Ivan Kirpichnikov <mmssvvvv570@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Typing :: Typed
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Pydantic
+Classifier: Framework :: Pydantic :: 1
+Classifier: Framework :: Pydantic :: 2
+Requires-Dist: fastapi<1.0.0
+Requires-Dist: faststream>=0.7.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# FastAPI Plugin for FastStream
+
+A plugin that allows you to use **Depends** and **FastAPI** other objects in the **FastStream**
+
+# Features
+
+### Use FastAPI Dependency Injection
+In **FastStream** handlers, it will be possible to use the familiar DI from **FastAPI**
+```py
+from fastapi import Path, Body, Header, Depends
+
+class BodyModel(BaseModel):
+    field: int
+
+@broker.subscriber("subject.{num}")
+async def subscriber_handler(
+    num: Annotated[int, Path()],
+    body: Annotated[BodyModel, Body()],
+    x_user_id: Annotated[int, Header()],
+    my_dep: Annotated[int, Depends(int)],
+) -> None:
+    ...
+```
+
+### Сan use FastAPI dependency overrides
+```py
+fastapi = FastAPI()
+fastapi.dependency_overrides[Dep] = lambda: "Dep"
+
+@broker.subscriber("subject")
+async def subscriber(dep: Annotated[str, De[]]) -> None:
+    assert dep == "Dep"
+```
+
+### Using the FastStream Context
+```py
+from faststream import Context
+
+@broker.subscriber("subject")
+async def subscriber_handler(context_data: Annotated[int, Context("data")]) -> Response: ...
+```
+
+### Use FastAPI Request and Response
+```py
+from fastapi import Request, Response
+from fastapi.responses import JSONResponse
+
+@broker.subscriber("subject")
+async def subscriber_handler(request: Request) -> Response:
+    return JSONResponse({"data": 1})
+```
+
+### Minimalistic plugin connection to your application
+
+All you need to do is wrap the **FastAPI** with the **FastStreamAPI** object from the **plugin**
+
+```py
+application = FastStreamAPI(
+    NatsBroker(),
+    application=FastAPI(),
+)
+uvicorn.run(application)
+```
+
+### Managing a lifespan state
+Now the **lifespan state** is also available in **FastStream handlers**
+
+```py
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    yield {"lifespan_data": "LIFESPAN DATA"}
+
+@broker.subscriber("subject")
+async def subscriber(request: Request) -> None:
+    assert request.state.lifespan_data == "LIFESPAN DATA"
+```
+
+### The ability to configure AsyncAPI
+
+The ability to configure **AsyncAPI** using **SpecificationFactory** from **FastStream** and **AsyncAPIConfig** from the **plugin**
+
+```py
+FastStreamAPI(
+    ...,
+    specification=AsyncAPI(
+        title="My app",
+        version="1.0.0",
+        description="...",
+        ...,
+    ),
+    asyncapi_path="/fs_docs",
+    # or
+    asyncapi_path=AsyncAPIRouter(
+        "/fs_docs",
+        description="...",
+        ...
+    ),
+)
+```
+
+### Backgrounds tasks
+
+You can use **BackgroundTasks** from **FastAPI** in **FastStream handlers**
+
+```py
+@broker.subscriber("subject")
+async def handler1(
+    tasks: BackgroundTasks,
+) -> None:
+    tasks.add_task(...)
+```

faststream_fastapi-1.0.0/README.md

@@ -0,0 +1,111 @@
+# FastAPI Plugin for FastStream
+
+A plugin that allows you to use **Depends** and **FastAPI** other objects in the **FastStream**
+
+# Features
+
+### Use FastAPI Dependency Injection
+In **FastStream** handlers, it will be possible to use the familiar DI from **FastAPI**
+```py
+from fastapi import Path, Body, Header, Depends
+
+class BodyModel(BaseModel):
+    field: int
+
+@broker.subscriber("subject.{num}")
+async def subscriber_handler(
+    num: Annotated[int, Path()],
+    body: Annotated[BodyModel, Body()],
+    x_user_id: Annotated[int, Header()],
+    my_dep: Annotated[int, Depends(int)],
+) -> None:
+    ...
+```
+
+### Сan use FastAPI dependency overrides
+```py
+fastapi = FastAPI()
+fastapi.dependency_overrides[Dep] = lambda: "Dep"
+
+@broker.subscriber("subject")
+async def subscriber(dep: Annotated[str, De[]]) -> None:
+    assert dep == "Dep"
+```
+
+### Using the FastStream Context
+```py
+from faststream import Context
+
+@broker.subscriber("subject")
+async def subscriber_handler(context_data: Annotated[int, Context("data")]) -> Response: ...
+```
+
+### Use FastAPI Request and Response
+```py
+from fastapi import Request, Response
+from fastapi.responses import JSONResponse
+
+@broker.subscriber("subject")
+async def subscriber_handler(request: Request) -> Response:
+    return JSONResponse({"data": 1})
+```
+
+### Minimalistic plugin connection to your application
+
+All you need to do is wrap the **FastAPI** with the **FastStreamAPI** object from the **plugin**
+
+```py
+application = FastStreamAPI(
+    NatsBroker(),
+    application=FastAPI(),
+)
+uvicorn.run(application)
+```
+
+### Managing a lifespan state
+Now the **lifespan state** is also available in **FastStream handlers**
+
+```py
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    yield {"lifespan_data": "LIFESPAN DATA"}
+
+@broker.subscriber("subject")
+async def subscriber(request: Request) -> None:
+    assert request.state.lifespan_data == "LIFESPAN DATA"
+```
+
+### The ability to configure AsyncAPI
+
+The ability to configure **AsyncAPI** using **SpecificationFactory** from **FastStream** and **AsyncAPIConfig** from the **plugin**
+
+```py
+FastStreamAPI(
+    ...,
+    specification=AsyncAPI(
+        title="My app",
+        version="1.0.0",
+        description="...",
+        ...,
+    ),
+    asyncapi_path="/fs_docs",
+    # or
+    asyncapi_path=AsyncAPIRouter(
+        "/fs_docs",
+        description="...",
+        ...
+    ),
+)
+```
+
+### Backgrounds tasks
+
+You can use **BackgroundTasks** from **FastAPI** in **FastStream handlers**
+
+```py
+@broker.subscriber("subject")
+async def handler1(
+    tasks: BackgroundTasks,
+) -> None:
+    tasks.add_task(...)
+```

faststream_fastapi-1.0.0/pyproject.toml

@@ -0,0 +1,139 @@
+[build-system]
+requires = ["uv_build==0.11.21"]
+build-backend = "uv_build"
+
+[project]
+name = "faststream_fastapi"
+description = "FastAPI integration for FastStream"
+readme = "README.md"
+authors = [
+    { name = "Ivan Kirpichnikov", email = "mmssvvvv570@gmail.com" },
+]
+license = "MIT"
+license-files = ["LICENSE"]
+
+requires-python = ">=3.10"
+version = "1.0.0"
+
+keywords = [
+    "rabbitmq",
+    "kafka",
+    "nats",
+    "redis",
+    "mqtt",
+    "asyncapi",
+    "framework",
+    "message brokers",
+    "fastapi",
+]
+
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Application Frameworks",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development",
+    "Topic :: System :: Networking",
+    "Topic :: System :: Distributed Computing",
+    "Typing :: Typed",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: System Administrators",
+    "Environment :: Web Environment",
+    "Framework :: AsyncIO",
+    "Framework :: Pydantic",
+    "Framework :: Pydantic :: 1",
+    "Framework :: Pydantic :: 2",
+]
+
+dependencies = [
+    "fastapi<1.0.0",
+    "faststream>=0.7.0",
+]
+
+[dependency-groups]
+linters = [
+    "ruff==0.15.20",
+    "typos==1.48.0",
+    "codespell==2.4.3",
+]
+static_analysis = [
+    "mypy==2.1.0",
+    "bandit==1.9.4",
+    "semgrep==1.169.0",
+    "zizmor==1.27.0",
+]
+docs = [
+    "zensical==0.0.50",
+    "mkdocstrings[python]==1.0.6",
+]
+
+testing = [
+    "pytest==9.0.3",
+    "pytest-asyncio==1.3.0",
+    "pytest-xdist>=3.8.0",
+    "pytest-timeout==2.4.0",
+    "pytest-cov>=6.2.1",
+    "covdefaults>=2.3.0",
+    { include-group = "testing-dependencies" },
+]
+testing-dependencies = [
+    "httpx2==2.5.0",
+    "asgi-lifespan==2.1.0",
+    "faststream[rabbit,kafka,confluent,nats,redis,mqtt]>=0.7.0",
+]
+
+dev = [
+    { include-group = "docs"},
+    { include-group = "testing" },
+    { include-group = "linters" },
+    { include-group = "static_analysis" },
+]
+
+[tool.uv.build-backend]
+module-root = "src"
+module-name = "faststream_fastapi"
+
+[tool.pytest.ini_options]
+minversion = "7.0"
+timeout = 30
+addopts = "--strict-markers --strict-config -q -m 'not slow'"
+testpaths = ["tests"]
+markers = [
+    "rabbit",
+    "kafka",
+    "confluent",
+    "nats",
+    "redis",
+    "redis_cluster",
+    "mqtt",
+    "slow",
+    "connected",
+    "all",
+]
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.coverage.run]
+source = ["src/"]
+relative_files = true
+
+[tool.coverage.paths]
+source = ["src/", "/app/src/"]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pass",
+    "def __str__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+]

faststream_fastapi-1.0.0/src/faststream_fastapi/__about__.py

@@ -0,0 +1,5 @@
+from importlib.metadata import version
+
+__version__ = version("faststream_fastapi")
+
+SERVICE_NAME = f"faststream_fastapi-{__version__}"

faststream_fastapi-1.0.0/src/faststream_fastapi/__init__.py

@@ -0,0 +1,11 @@
+from faststream_fastapi.asyncapi_config import AsyncAPIConfig
+from faststream_fastapi.context import Context
+from faststream_fastapi.faststream_api import FastStreamAPI
+from faststream_fastapi.stream_message import StreamMessage
+
+__all__ = (
+    "AsyncAPIConfig",
+    "Context",
+    "FastStreamAPI",
+    "StreamMessage",
+)

faststream_fastapi-1.0.0/src/faststream_fastapi/_internal/asyncapi_router.py

@@ -0,0 +1,115 @@
+import json
+from collections.abc import Awaitable, Callable, Sequence
+from typing import Any
+
+from fastapi import APIRouter, Request, Response
+from fastapi.responses import HTMLResponse, JSONResponse
+from faststream.asgi.factories.asyncapi.try_it_out import TryItOutProcessor
+from faststream.specification.asyncapi.site import get_asyncapi_html
+from faststream.specification.base import SpecificationFactory
+
+from faststream_fastapi._internal.fs_re_exports.broker import BrokerUsecase
+from faststream_fastapi.asyncapi_config import AsyncAPIConfig
+
+
+class AsyncAPIRouter(APIRouter):
+    def __init__(
+        self,
+        brokers: Sequence[BrokerUsecase[Any, Any]],
+        config: AsyncAPIConfig,
+        schema: SpecificationFactory,
+    ) -> None:
+        super().__init__(include_in_schema=config.include_in_schema)
+
+        self._config = config
+
+        try:
+            try_processor = TryItOutProcessor(*brokers)
+        except ValueError:
+            try_processor = None
+
+        self.get(self._config.path)(self.make_serve_asyncapi_schema(schema))
+
+        if self._config.asyncapi_json_path is not None:
+            self.get(self._config.asyncapi_json_path)(self.make_download_app_json_schema(schema))
+
+        if self._config.asyncapi_yaml_path is not None:
+            self.get(self._config.asyncapi_yaml_path)(self.make_download_app_yaml_schema(schema))
+
+        if try_processor is not None and self._config.try_it_out_path is not None:
+            self.post(self._config.try_it_out_path, include_in_schema=False)(
+                self.make_try_asyncapi_schema(try_processor),
+            )
+
+    def make_download_app_json_schema(
+        self,
+        schema: SpecificationFactory,
+    ) -> Callable[[], Awaitable[Response]]:
+        async def download_app_json_schema() -> Response:
+            return Response(
+                content=json.dumps(
+                    schema.to_specification().to_jsonable(),
+                    indent=2,
+                ),
+                headers={"Content-Type": "application/json"},
+            )
+
+        return download_app_json_schema
+
+    def make_download_app_yaml_schema(
+        self,
+        schema: SpecificationFactory,
+    ) -> Callable[[], Awaitable[Response]]:
+        async def download_app_yaml_schema() -> Response:
+            return Response(
+                content=schema.to_specification().to_yaml(),
+                headers={
+                    "Content-Type": "application/octet-stream",
+                },
+            )
+
+        return download_app_yaml_schema
+
+    def make_serve_asyncapi_schema(
+        self,
+        schema: SpecificationFactory,
+    ) -> Callable[[], Awaitable[Response]]:
+        async def serve_asyncapi_schema() -> Response:
+            return HTMLResponse(
+                content=get_asyncapi_html(
+                    schema.to_specification(),
+                    sidebar=self._config.sidebar,
+                    info=self._config.info,
+                    servers=self._config.servers,
+                    operations=self._config.operations,
+                    messages=self._config.messages,
+                    schemas=self._config.schemas,
+                    errors=self._config.errors,
+                    expand_message_examples=self._config.expand_message_examples,
+                    asyncapi_js_url=self._config.asyncapi_js_url,
+                    asyncapi_css_url=self._config.asyncapi_css_url,
+                    try_it_out_plugin_url=self._config.try_it_out_plugin_url,
+                    try_it_out_path=self._config.try_it_out_path,
+                ),
+            )
+
+        return serve_asyncapi_schema
+
+    def make_try_asyncapi_schema(
+        self,
+        try_processor: TryItOutProcessor,
+    ) -> Callable[[Request], Awaitable[Response]]:
+        async def try_asyncapi_schema(request: Request) -> Response:
+            try:
+                body = await request.json()
+            except Exception as e:  # noqa: BLE001
+                return JSONResponse({"details": f"Invalid JSON: {e}"}, 400)
+
+            result = await try_processor.process(body)
+            return Response(
+                content=result.body,
+                status_code=result.status_code,
+                media_type="application/json",
+            )
+
+        return try_asyncapi_schema

faststream_fastapi-1.0.0/src/faststream_fastapi/_internal/background_middleware.py

@@ -0,0 +1,22 @@
+from types import TracebackType
+from typing import cast
+
+from fastapi.background import BackgroundTasks
+from faststream.middlewares import BaseMiddleware
+
+
+class _BackgroundMiddleware(BaseMiddleware):
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_val: BaseException | None = None,
+        exc_tb: TracebackType | None = None,
+    ) -> bool | None:
+        background = cast(
+            "BackgroundTasks | None",
+            getattr(self.context.get_local("message"), "background", None),
+        )
+        if exc_type is None and background is not None:
+            await background()
+
+        return await super().after_processed(exc_type, exc_val, exc_tb)

faststream_fastapi-1.0.0/src/faststream_fastapi/_internal/config.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Any
+
+from fastapi import FastAPI
+from fastapi.datastructures import State
+
+
+class ConfigAsgiStateError(ValueError):
+    def __str__(self) -> str:
+        return "ASGI state already is set"
+
+
+@dataclass
+class Config:
+    application: FastAPI
+    dependency_overrides_provider: Any | None
+    asgi_state: State | None = None
+
+    def set_asgi_state(self, asgi_state: State) -> None:
+        if self.asgi_state is not None:
+            raise ConfigAsgiStateError  # pragma: no cover
+
+        self.asgi_state = asgi_state