faststream_fastapi 1.0.0__py3-none-any.whl

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/__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/_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/_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/_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

faststream_fastapi/_internal/fastapi_compat.py

@@ -0,0 +1,152 @@
+from dataclasses import dataclass
+from typing import Any
+
+from fastapi import __version__ as FASTAPI_VERSION  # noqa: N812
+from fastapi.dependencies.models import Dependant
+from fastapi.dependencies.utils import solve_dependencies
+from fastapi.requests import Request
+from starlette.background import BackgroundTasks
+from typing_extensions import Never
+
+major, minor, patch, *_ = FASTAPI_VERSION.split(".")
+
+_FASTAPI_MAJOR, _FASTAPI_MINOR = int(major), int(minor)
+
+FASTAPI_V2 = _FASTAPI_MAJOR > 0 or _FASTAPI_MINOR > 100
+FASTAPI_V106 = _FASTAPI_MAJOR > 0 or _FASTAPI_MINOR >= 106
+FASTAPI_V121 = _FASTAPI_MAJOR > 0 or _FASTAPI_MINOR >= 121
+FASTAPI_V128 = _FASTAPI_MAJOR > 0 or _FASTAPI_MINOR >= 128
+
+try:
+    _FASTAPI_PATCH = int(patch)
+except ValueError:
+    FASTAPI_v102_3 = True
+    FASTAPI_v102_4 = True
+else:
+    FASTAPI_v102_3 = (
+        _FASTAPI_MAJOR > 0
+        or _FASTAPI_MINOR > 112
+        or (_FASTAPI_MINOR == 112 and _FASTAPI_PATCH > 2)
+    )
+    FASTAPI_v102_4 = (
+        _FASTAPI_MAJOR > 0
+        or _FASTAPI_MINOR > 112
+        or (_FASTAPI_MINOR == 112 and _FASTAPI_PATCH > 3)
+    )
+
+__all__ = (
+    "RequestValidationError",
+    "create_response_field",
+    "raise_fastapi_validation_error",
+    "solve_faststream_dependency",
+)
+
+
+@dataclass
+class SolvedDependency:
+    values: dict[str, Any]
+    errors: list[Any]
+    background_tasks: BackgroundTasks | None
+
+
+if FASTAPI_V128:
+    from fastapi.exceptions import RequestValidationError
+
+    def raise_fastapi_validation_error(
+        errors: list[Any],
+        body: dict[str, Any],
+    ) -> Never:
+        raise RequestValidationError(errors, body=body)
+
+elif FASTAPI_V2:
+    from fastapi._compat import _normalize_errors  # type: ignore[attr-defined]
+    from fastapi.exceptions import RequestValidationError
+
+    def raise_fastapi_validation_error(
+        errors: list[Any],
+        body: dict[str, Any],
+    ) -> Never:
+        raise RequestValidationError(_normalize_errors(errors), body=body)
+
+else:
+    from pydantic import (  # type: ignore[assignment]
+        ValidationError as RequestValidationError,
+    )
+    from pydantic import (
+        create_model,
+    )
+
+    ROUTER_VALIDATION_ERROR_MODEL = create_model("StreamRoute")
+
+    def raise_fastapi_validation_error(
+        errors: list[Any],
+        body: dict[str, Any],
+    ) -> Never:
+        raise RequestValidationError(errors, ROUTER_VALIDATION_ERROR_MODEL)  # type: ignore[misc]
+
+
+if FASTAPI_v102_3:
+    from fastapi.utils import (
+        create_model_field as create_response_field,
+    )
+
+    extra = {"embed_body_fields": False} if FASTAPI_v102_4 else {}
+
+    async def solve_faststream_dependency(
+        request: Request,
+        dependant: Dependant,
+        dependency_overrides_provider: Any | None,
+        **kwargs: Any,
+    ) -> SolvedDependency:
+        solved_result = await solve_dependencies(
+            request=request,
+            body=request._body,
+            dependant=dependant,
+            dependency_overrides_provider=dependency_overrides_provider,
+            **extra,  # type: ignore[arg-type]
+            **kwargs,
+        )
+        values, errors, background = (
+            solved_result.values,
+            solved_result.errors,
+            solved_result.background_tasks,
+        )
+
+        return SolvedDependency(
+            values=values,
+            errors=errors,
+            background_tasks=background,
+        )
+
+else:
+    from fastapi.utils import (  # type: ignore[attr-defined,no-redef]
+        create_response_field,
+    )
+
+    async def solve_faststream_dependency(
+        request: Request,
+        dependant: Dependant,
+        dependency_overrides_provider: Any | None,
+        **kwargs: Any,
+    ) -> SolvedDependency:
+        solved_result = await solve_dependencies(
+            request=request,
+            body=request._body,
+            dependant=dependant,
+            dependency_overrides_provider=dependency_overrides_provider,
+            **kwargs,
+        )
+
+        (
+            values,
+            errors,
+            background,
+            _response,
+            _dependency_cache,
+        ) = solved_result  # type: ignore[misc]
+
+        return SolvedDependency(
+            values=values,  # type: ignore[has-type]
+            errors=errors,  # type: ignore[has-type]
+            background_tasks=background,  # type: ignore[has-type]
+        )

faststream_fastapi/_internal/fs_re_exports/_compat.py

@@ -0,0 +1,6 @@
+from faststream._internal._compat import PYDANTIC_V2, PydanticUndefined
+
+__all__ = (
+    "PYDANTIC_V2",
+    "PydanticUndefined",
+)

faststream_fastapi/_internal/fs_re_exports/application.py

@@ -0,0 +1,3 @@
+from faststream._internal.application import StartAbleApplication
+
+__all__ = ("StartAbleApplication",)

faststream_fastapi/_internal/fs_re_exports/broker.py

@@ -0,0 +1,4 @@
+from faststream._internal.broker import BrokerUsecase
+from faststream._internal.broker.router import BrokerRouter
+
+__all__ = ("BrokerRouter", "BrokerUsecase")

faststream_fastapi/_internal/fs_re_exports/constants.py

@@ -0,0 +1,3 @@
+from faststream._internal.constants import EMPTY
+
+__all__ = ("EMPTY",)

faststream_fastapi/_internal/fs_re_exports/context.py

@@ -0,0 +1,8 @@
+from faststream._internal.context import Context, ContextRepo
+from faststream._internal.context.resolve import resolve_context_by_name
+
+__all__ = (
+    "Context",
+    "ContextRepo",
+    "resolve_context_by_name",
+)

faststream_fastapi/_internal/fs_re_exports/di.py

@@ -0,0 +1,3 @@
+from faststream._internal.di import FastDependsConfig
+
+__all__ = ("FastDependsConfig",)

faststream_fastapi/_internal/fs_re_exports/logger.py

@@ -0,0 +1,3 @@
+from faststream._internal.logger.logging import get_logger
+
+__all__ = ("get_logger",)

faststream_fastapi/_internal/get_dependant.py

@@ -0,0 +1,182 @@
+import inspect
+from collections.abc import Callable, Iterable
+from typing import Annotated, Any, Final, cast, get_args, get_origin
+
+from fast_depends.library.serializer import OptionItem
+from fast_depends.utils import get_typed_annotation
+from fastapi.dependencies.models import Dependant
+from fastapi.dependencies.utils import (
+    get_dependant,
+    get_parameterless_sub_dependant,
+    get_typed_signature,
+)
+from fastapi.params import Depends
+from pydantic import Field, create_model
+
+from faststream_fastapi._internal.fs_re_exports._compat import PYDANTIC_V2, PydanticUndefined
+
+
+def get_fastapi_dependant(
+    orig_call: Callable[..., Any],
+    dependencies: Iterable[Depends],
+) -> Dependant:
+    dependent = get_fastapi_native_dependant(orig_call=orig_call, dependencies=dependencies)
+    return _patch_fastapi_dependent(dependent)
+
+
+def get_fastapi_native_dependant(
+    orig_call: Callable[..., Any],
+    dependencies: Iterable[Depends],
+) -> Dependant:
+    dependent = get_dependant(
+        path="",
+        call=orig_call,
+    )
+
+    for depends in list(dependencies)[::-1]:
+        dependent.dependencies.insert(
+            0,
+            get_parameterless_sub_dependant(depends=depends, path=""),
+        )
+
+    return dependent
+
+
+def _patch_fastapi_dependent(dependant: Dependant) -> Dependant:
+    params = dependant.query_params + dependant.body_params
+
+    for d in dependant.dependencies:
+        params.extend(d.query_params + d.body_params)
+
+    params_unique = {}
+
+    call = dependant.call
+    if is_faststream_decorated(call):
+        call = getattr(call, "__wrapped__", call)
+    globalns = getattr(call, "__globals__", {})
+
+    for p in params:
+        if p.name not in params_unique:
+            info: Any = p.field_info if PYDANTIC_V2 else p
+
+            field_data = {
+                "default": ... if info.default is PydanticUndefined else info.default,
+                "default_factory": info.default_factory,
+                "alias": info.alias,
+            }
+
+            if PYDANTIC_V2:
+                from pydantic.fields import FieldInfo  # noqa: PLC0415
+
+                info = cast("FieldInfo", info)
+
+                field_data.update(
+                    {
+                        "title": info.title,
+                        "alias_priority": info.alias_priority,
+                        "validation_alias": info.validation_alias,
+                        "serialization_alias": info.serialization_alias,
+                        "description": info.description,
+                        "discriminator": info.discriminator,
+                        "examples": info.examples,
+                        "exclude": info.exclude,
+                        "json_schema_extra": info.json_schema_extra,
+                    },
+                )
+
+                f = next(
+                    filter(
+                        lambda x: isinstance(x, FieldInfo),
+                        p.field_info.metadata or (),
+                    ),
+                    Field(**field_data),  # type: ignore[pydantic-field,unused-ignore]
+                )
+
+            else:
+                from pydantic.fields import (  # type: ignore[attr-defined] # noqa: PLC0415 # pragma: no cover
+                    ModelField,
+                )
+
+                info = cast("ModelField", info)
+
+                field_data.update(
+                    {
+                        "title": info.field_info.title,
+                        "description": info.field_info.description,
+                        "discriminator": info.field_info.discriminator,
+                        "exclude": info.field_info.exclude,
+                        "gt": info.field_info.gt,
+                        "ge": info.field_info.ge,
+                        "lt": info.field_info.lt,
+                        "le": info.field_info.le,
+                    },
+                )
+                f = Field(**field_data)  # type: ignore[pydantic-field,unused-ignore]
+
+            params_unique[p.name] = (
+                get_typed_annotation(info.annotation, globalns, {}),
+                f,
+            )
+
+    dependant.model = create_model(  # type: ignore[attr-defined]
+        getattr(call, "__name__", type(call).__name__),
+    )
+
+    dependant.custom_fields = {}  # type: ignore[attr-defined]
+    dependant.flat_params = [  # type: ignore[attr-defined]
+        OptionItem(field_name=name, field_type=type_, default_value=default)
+        for name, (type_, default) in params_unique.items()
+    ]
+
+    return dependant
+
+
+def has_forbidden_types(  # noqa: C901
+    orig_call: Callable[..., Any],
+    forbidden_types: tuple[Any, ...],
+) -> set[Any]:
+    endpoint_signature = get_typed_signature(orig_call)
+    signature_params = endpoint_signature.parameters
+
+    founded_types = set()
+
+    for param in signature_params.values():
+        ann = param.annotation
+
+        founded_buffer = set()
+        has_fastapi_depends = False
+        if ann is not inspect.Signature.empty and get_origin(ann) is Annotated:
+            annotated_args = get_args(ann)
+
+            for arg in annotated_args[1:]:
+                if isinstance(arg, Depends):
+                    has_fastapi_depends = True
+                    continue
+
+                for t in forbidden_types:
+                    if isinstance(arg, t):
+                        founded_buffer.add(t)
+
+        if isinstance(param.default, Depends):
+            has_fastapi_depends = True
+            continue
+
+        for t in forbidden_types:
+            if isinstance(param.default, t):
+                founded_buffer.add(t)
+
+        if not has_fastapi_depends:
+            founded_types |= founded_buffer
+
+    return founded_types
+
+
+FASTSTREAM_FASTAPI_PLUGIN_DECORATOR_MARKER: Final = "__faststream_consumer__"
+
+
+def is_faststream_decorated(func: object) -> bool:
+    return getattr(func, FASTSTREAM_FASTAPI_PLUGIN_DECORATOR_MARKER, False)
+
+
+def mark_faststream_decorated(func: object) -> None:
+    setattr(func, FASTSTREAM_FASTAPI_PLUGIN_DECORATOR_MARKER, True)

faststream_fastapi/_internal/logger.py

@@ -0,0 +1,11 @@
+import logging
+import sys
+
+from faststream_fastapi._internal.fs_re_exports.logger import get_logger
+
+logger = get_logger(
+    name="faststream_fastapi",
+    log_level=logging.INFO,
+    stream=sys.stderr,
+    fmt="%(asctime)s %(levelname)8s - %(message)s",
+)

faststream_fastapi/_internal/replace_context.py

@@ -0,0 +1,119 @@
+import functools
+import inspect
+from collections.abc import Callable, Mapping
+from typing import (
+    Annotated,
+    Any,
+    ParamSpec,
+    TypeVar,
+    cast,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
+
+from fastapi.dependencies.utils import get_typed_signature
+from faststream._internal.context import Context as ContextCls
+
+from faststream_fastapi import Context as PluginContext
+
+P_HandlerParams = ParamSpec("P_HandlerParams")
+T_HandlerReturn = TypeVar("T_HandlerReturn")
+
+
+def replace_context(
+    func: Callable[P_HandlerParams, T_HandlerReturn],
+) -> Callable[P_HandlerParams, T_HandlerReturn]:
+    if inspect.iscoroutinefunction(func):
+
+        @functools.wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            return await func(*args, **kwargs)
+    else:
+
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            return func(*args, **kwargs)
+
+    endpoint_signature = get_typed_signature(func)
+    new_params = get_new_parameters(endpoint_signature.parameters)
+    new_annotations = get_new_annotations(get_type_hints(func, include_extras=True))
+
+    wrapper.__name__ = func.__name__
+    wrapper.__qualname__ = func.__qualname__
+    wrapper.__doc__ = func.__doc__
+    wrapper.__module__ = func.__module__
+    wrapper.__annotations__ = new_annotations
+    wrapper.__signature__ = inspect.Signature(  # type: ignore[attr-defined]
+        parameters=new_params,
+        return_annotation=endpoint_signature.return_annotation,
+    )
+
+    return cast(Callable[P_HandlerParams, T_HandlerReturn], wrapper)
+
+
+def get_new_parameters(
+    signature_params: Mapping[str, inspect.Parameter],
+) -> list[inspect.Parameter]:
+    new_params = []
+
+    for param in signature_params.values():
+        if (
+            param.annotation is not inspect.Signature.empty
+            and get_origin(param.annotation) is Annotated
+        ):
+            new_params.append(
+                inspect.Parameter(
+                    name=param.name,
+                    default=param.default,
+                    kind=param.kind,
+                    annotation=replace_annotated(param.annotation, param.name),
+                ),
+            )
+        elif isinstance(param.default, ContextCls):
+            new_param = inspect.Parameter(
+                name=param.name,
+                default=create_plugin_context(param.default, param.name),
+                kind=param.kind,
+                annotation=param.annotation,
+            )
+            new_params.append(new_param)
+        else:
+            new_params.append(param)
+
+    return new_params
+
+
+def get_new_annotations(type_hints: Mapping[str, Any]) -> dict[str, Any]:
+    new_annotations = {}
+
+    for param_name, type_hint in type_hints.items():
+        if get_origin(type_hint) is Annotated:
+            new_annotations[param_name] = replace_annotated(type_hint, param_name)
+        else:
+            new_annotations[param_name] = type_hint
+
+    return new_annotations
+
+
+def replace_annotated(type_hint: Any, parameter_name: str) -> Any:
+    annotated_args = get_args(type_hint)
+
+    new_annotated_args = [annotated_args[0]]
+    for arg in annotated_args[1:]:
+        if isinstance(arg, ContextCls):
+            new_annotated_args.append(create_plugin_context(arg, parameter_name))
+        else:
+            new_annotated_args.append(arg)
+
+    return Annotated[tuple(new_annotated_args)]
+
+
+def create_plugin_context(fs_context: ContextCls, parameter_name: str) -> Any:
+    fs_context.set_param_name(parameter_name)
+
+    return PluginContext(
+        name=fs_context.name or fs_context.param_name,
+        default=fs_context.default,
+        initial=fs_context.initial,
+    )