faststream_fastapi 1.0.0__py3-none-any.whl

faststream_fastapi/_internal/wrap_callable_to_fastapi_compatible.py

@@ -0,0 +1,180 @@
+import inspect
+from collections.abc import Awaitable, Callable, Iterable
+from contextlib import AsyncExitStack
+from functools import wraps
+from itertools import dropwhile
+from typing import Any, ParamSpec, TypeVar
+
+from fast_depends.dependencies import Dependant
+from fastapi.dependencies.models import Dependant as FastAPIDependant
+from fastapi.params import Depends
+from fastapi.routing import run_endpoint_function, serialize_response
+from faststream.exceptions import SetupError
+from faststream.message import StreamMessage as NativeMessage
+from faststream.response import Response, ensure_response
+
+from faststream_fastapi._internal.config import Config
+from faststream_fastapi._internal.fastapi_compat import (
+    FASTAPI_V106,
+    FASTAPI_V121,
+    raise_fastapi_validation_error,
+    solve_faststream_dependency,
+)
+from faststream_fastapi._internal.fs_re_exports.context import ContextRepo
+from faststream_fastapi._internal.get_dependant import (
+    get_fastapi_native_dependant,
+    has_forbidden_types,
+    is_faststream_decorated,
+    mark_faststream_decorated,
+)
+from faststream_fastapi._internal.replace_context import replace_context
+from faststream_fastapi.stream_message import StreamMessage
+
+P_HandlerParams = ParamSpec("P_HandlerParams")
+T_HandlerReturn = TypeVar("T_HandlerReturn")
+
+
+def wrap_callable_to_fastapi_compatible(
+    user_callable: Callable[P_HandlerParams, T_HandlerReturn],
+    *,
+    config: Config,
+    context: ContextRepo,
+    dependencies: Iterable[Depends],
+) -> Callable[[NativeMessage[Any]], Awaitable[Any]]:
+    user_callable = replace_context(user_callable)
+
+    if has_forbidden_types(user_callable, (Dependant,)):
+        msg = (
+            f"Incorrect `faststream.Depends` usage at `{user_callable.__name__}`. "
+            "For FastAPI integration use `fastapi.Depends` instead."
+        )
+        raise SetupError(msg)
+
+    if is_faststream_decorated(user_callable):
+        return user_callable  # type: ignore[return-value]
+
+    parsed_callable = build_faststream_to_fastapi_parser(
+        dependent=get_fastapi_native_dependant(user_callable, dependencies),
+        config=config,
+        context=context,
+    )
+
+    mark_faststream_decorated(parsed_callable)
+    return wraps(user_callable)(parsed_callable)
+
+
+def build_faststream_to_fastapi_parser(
+    *,
+    dependent: FastAPIDependant,
+    config: Config,
+    context: ContextRepo,
+) -> Callable[[NativeMessage[Any]], Awaitable[Any]]:
+    if dependent.call is None:  # pragma: no cover
+        raise ValueError("dependent.call is None")  # noqa: TRY003
+
+    consume = make_fastapi_execution(
+        dependent=dependent,
+        config=config,
+    )
+
+    dependencies_names = tuple(i.name for i in dependent.dependencies)
+
+    first_arg = next(
+        dropwhile(
+            lambda i: i in dependencies_names,
+            inspect.signature(dependent.call).parameters,
+        ),
+        None,
+    )
+
+    async def parsed_consumer(message: NativeMessage[Any]) -> Any:
+        body = await message.decode()
+
+        fastapi_body: dict[str, Any] | list[Any]
+        stream_message: StreamMessage
+        if first_arg is not None:
+            if isinstance(body, dict):
+                path = fastapi_body = body or {}
+            elif isinstance(body, list):
+                fastapi_body, path = body, {}
+            else:
+                path = fastapi_body = {first_arg: body}
+
+            stream_message = StreamMessage(
+                body=fastapi_body,
+                headers={"context__": context, **message.headers},
+                path={**path, **message.path},
+            )
+
+        else:
+            stream_message = StreamMessage(
+                body={},
+                headers={"context__": context},
+                path={},
+            )
+        return await consume(stream_message, message)
+
+    return parsed_consumer
+
+
+def make_fastapi_execution(
+    *,
+    dependent: FastAPIDependant,
+    config: Config,
+) -> Callable[
+    [StreamMessage, NativeMessage[Any]],
+    Awaitable[Response],
+]:
+    is_coroutine = inspect.iscoroutinefunction(dependent.call)
+
+    async def app(
+        request: StreamMessage,
+        raw_message: NativeMessage[Any],  # to support BackgroundTasks by middleware
+    ) -> Response:
+        async with AsyncExitStack() as stack:
+            kwargs = {}
+            if FASTAPI_V121:
+                request.scope["fastapi_inner_astack"] = stack
+                function_stack = AsyncExitStack()
+                await stack.enter_async_context(function_stack)
+                request.scope["fastapi_function_astack"] = function_stack
+
+            if FASTAPI_V106:
+                kwargs = {"async_exit_stack": stack}
+
+            else:  # pragma: no cover
+                request.scope["fastapi_astack"] = stack
+
+            request.scope["app"] = config.application
+            request.scope["state"] = config.asgi_state
+
+            solved_result = await solve_faststream_dependency(
+                request=request,
+                dependant=dependent,
+                dependency_overrides_provider=config.dependency_overrides_provider,
+                **kwargs,
+            )
+
+            raw_message.background = solved_result.background_tasks  # type: ignore[attr-defined]
+
+            if solved_result.errors:
+                raise_fastapi_validation_error(solved_result.errors, request._body)  # type: ignore[arg-type]
+
+            function_result = await run_endpoint_function(
+                dependant=dependent,
+                values=solved_result.values,
+                is_coroutine=is_coroutine,
+            )
+
+            response = ensure_response(function_result)
+
+            response.body = await serialize_response(
+                response_content=response.body,
+                is_coroutine=is_coroutine,
+            )
+
+            return response
+
+        raise AssertionError("unreachable")
+
+    return app

faststream_fastapi/asyncapi_config.py

@@ -0,0 +1,71 @@
+from collections.abc import Sequence
+from typing import Any
+
+from faststream.specification.asyncapi.site import (
+    ASYNCAPI_CSS_DEFAULT_URL,
+    ASYNCAPI_JS_DEFAULT_URL,
+    ASYNCAPI_TRY_IT_PLUGIN_URL,
+)
+from faststream.specification.schema import Tag, TagDict
+
+
+class _Empty: ...
+
+
+_EMPTY = _Empty()
+
+
+class AsyncAPIConfig:
+    def __init__(
+        self,
+        path: str,
+        *,
+        description: str | None = None,
+        tags: Sequence[Tag | TagDict | dict[str, Any]] | None = None,
+        unique_id: str | None = None,
+        include_in_schema: bool = False,
+        asyncapi_json_path: str | None | _Empty = _EMPTY,
+        asyncapi_yaml_path: str | None | _Empty = _EMPTY,
+        try_it_out_path: str | None | _Empty = _EMPTY,
+        sidebar: bool = True,
+        info: bool = True,
+        servers: bool = True,
+        operations: bool = True,
+        messages: bool = True,
+        schemas: bool = True,
+        errors: bool = True,
+        expand_message_examples: bool = True,
+        asyncapi_js_url: str = ASYNCAPI_JS_DEFAULT_URL,
+        asyncapi_css_url: str = ASYNCAPI_CSS_DEFAULT_URL,
+        try_it_out_plugin_url: str = ASYNCAPI_TRY_IT_PLUGIN_URL,
+    ) -> None:
+        self.path = path
+
+        if isinstance(asyncapi_json_path, _Empty):
+            asyncapi_json_path = path.rstrip("/") + ".json"
+        self.asyncapi_json_path = asyncapi_json_path
+
+        if isinstance(asyncapi_yaml_path, _Empty):
+            asyncapi_yaml_path = path.rstrip("/") + ".yaml"
+        self.asyncapi_yaml_path = asyncapi_yaml_path
+
+        if isinstance(try_it_out_path, _Empty):
+            try_it_out_path = path.rstrip("/") + "/try"
+        self.try_it_out_path = try_it_out_path
+
+        self.description = description
+        self.tags = tags
+        self.unique_id = unique_id
+        self.include_in_schema = include_in_schema
+
+        self.sidebar = sidebar
+        self.info = info
+        self.servers = servers
+        self.operations = operations
+        self.messages = messages
+        self.schemas = schemas
+        self.errors = errors
+        self.expand_message_examples = expand_message_examples
+        self.asyncapi_js_url = asyncapi_js_url
+        self.asyncapi_css_url = asyncapi_css_url
+        self.try_it_out_plugin_url = try_it_out_plugin_url

faststream_fastapi/context.py

@@ -0,0 +1,31 @@
+from collections.abc import Callable
+from typing import Annotated, Any
+
+from fastapi import params
+
+from faststream_fastapi._internal.fs_re_exports.constants import EMPTY
+from faststream_fastapi._internal.fs_re_exports.context import (
+    resolve_context_by_name,
+)
+
+
+def Context(  # noqa: N802
+    name: str = "",
+    *,
+    default: Any = EMPTY,
+    initial: Callable[..., Any] | None = None,
+) -> Any:
+    def solve_context(
+        context: Annotated[
+            Any,
+            params.Header(alias="context__", include_in_schema=False),
+        ],
+    ) -> Any:
+        return resolve_context_by_name(
+            name=name,
+            default=default,
+            initial=initial,
+            context=context,
+        )
+
+    return params.Depends(solve_context, use_cache=True)

faststream_fastapi/faststream_api.py

@@ -0,0 +1,165 @@
+import traceback
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
+from contextlib import asynccontextmanager
+from typing import Any
+
+from fastapi import FastAPI
+from fastapi.params import Depends
+from faststream.message import StreamMessage
+from faststream.specification.base import SpecificationFactory
+from starlette.types import Receive, Scope, Send
+
+from faststream_fastapi._internal.asyncapi_router import AsyncAPIRouter
+from faststream_fastapi._internal.background_middleware import _BackgroundMiddleware
+from faststream_fastapi._internal.config import Config
+from faststream_fastapi._internal.fs_re_exports.application import StartAbleApplication
+from faststream_fastapi._internal.fs_re_exports.broker import BrokerUsecase
+from faststream_fastapi._internal.fs_re_exports.context import ContextRepo
+from faststream_fastapi._internal.fs_re_exports.di import FastDependsConfig
+from faststream_fastapi._internal.get_dependant import get_fastapi_dependant
+from faststream_fastapi._internal.wrap_callable_to_fastapi_compatible import (
+    wrap_callable_to_fastapi_compatible,
+)
+from faststream_fastapi.asyncapi_config import AsyncAPIConfig
+
+
+def _subscriber_compatibility_wrapper(
+    config: Config,
+    context: ContextRepo,
+    dependencies: Iterable[Depends],
+) -> Callable[[Callable[..., Any]], Callable[["StreamMessage[Any]"], Awaitable[Any]]]:
+    def subscriber_compatibility_wrapper(
+        endpoint: Callable[..., Any],
+    ) -> Callable[["StreamMessage[Any]"], Awaitable[Any]]:
+        return wrap_callable_to_fastapi_compatible(
+            user_callable=endpoint,
+            config=config,
+            context=context,
+            dependencies=dependencies,
+        )
+
+    return subscriber_compatibility_wrapper
+
+
+class FastStreamAPI:
+    def __init__(
+        self,
+        *brokers: BrokerUsecase[Any, Any],
+        application: FastAPI,
+        context: ContextRepo | None = None,
+        # AsyncAPI
+        specification: SpecificationFactory | None = None,
+        asyncapi_path: str | AsyncAPIConfig | None = None,
+    ) -> None:
+        self._application = application
+
+        self._brokers = brokers
+
+        self._startable_application = StartAbleApplication(
+            *brokers,
+            specification=specification,
+            config=FastDependsConfig(
+                get_dependent=get_fastapi_dependant,
+                context=context or ContextRepo(),
+            ),
+        )
+
+        self._config = Config(
+            application=application,
+            dependency_overrides_provider=self._application,
+        )
+
+        if asyncapi_path is not None:
+            if isinstance(asyncapi_path, str):
+                asyncapi_config = AsyncAPIConfig(asyncapi_path)
+            else:
+                asyncapi_config = asyncapi_path
+
+        else:
+            asyncapi_config = None
+
+        self._asyncapi_config = asyncapi_config
+
+        for broker in self._brokers:
+            broker.config.add_middleware(_BackgroundMiddleware)
+
+            for subscriber in broker.subscribers:
+                dependencies = (
+                    *broker.config.broker_dependencies,
+                    *subscriber._call_options.dependencies,
+                )
+                subscriber._call_decorators = (
+                    _subscriber_compatibility_wrapper(
+                        config=self._config,
+                        context=self._startable_application.context,
+                        dependencies=dependencies,  # type: ignore[arg-type]
+                    ),
+                    *subscriber._call_decorators,
+                )
+
+    # For FastStream docs gen
+    @property
+    def schema(self) -> SpecificationFactory:
+        return self._startable_application.schema
+
+    @property
+    def context(self) -> ContextRepo:
+        return self._startable_application.context
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] == "lifespan":
+            await self.lifespan(scope, receive, send)
+            return None
+
+        return await self._application(scope, receive, send)
+
+    async def lifespan(self, scope: Scope, receive: Receive, send: Send) -> None:
+        started = False
+        app: Any = scope.get("app")
+        await receive()
+        try:
+            async with (
+                self._lifespan_context(app),
+                self._application.router.lifespan_context(app) as maybe_state,
+            ):
+                if maybe_state is not None:
+                    if "state" not in scope:
+                        msg = 'The server does not support "state" in the lifespan scope.'
+                        raise RuntimeError(msg)  # noqa: TRY301
+
+                    scope["state"].update(maybe_state)
+
+                await send({"type": "lifespan.startup.complete"})
+                started = True
+                await receive()
+        except BaseException:
+            exc_text = traceback.format_exc()
+            if started:
+                await send({"type": "lifespan.shutdown.failed", "message": exc_text})
+            else:
+                await send({"type": "lifespan.startup.failed", "message": exc_text})
+            raise
+        else:
+            await send({"type": "lifespan.shutdown.complete"})
+
+    @asynccontextmanager
+    async def _lifespan_context(self, application: Any) -> AsyncIterator[None]:
+        if self._asyncapi_config is not None:
+            asyncapi_router = AsyncAPIRouter(
+                brokers=self._brokers,
+                config=self._asyncapi_config,
+                schema=self._startable_application.schema,
+            )
+            self._application.include_router(asyncapi_router)
+
+        started_brokers: list[BrokerUsecase[Any, Any]] = []
+
+        try:
+            for broker in self._brokers:
+                await broker.start()
+                started_brokers.append(broker)
+
+            yield None
+        finally:
+            for started_broker in started_brokers:
+                await started_broker.stop()

faststream_fastapi/stream_message.py

@@ -0,0 +1,25 @@
+from typing import Any
+
+from fastapi import Request
+
+
+class StreamMessage(Request):
+    scope: dict[str, Any]
+    _cookies: dict[str, Any]
+    _headers: dict[str, Any]  # type: ignore[assignment]
+    _body: dict[str, Any] | list[Any]  # type: ignore[assignment]
+    _query_params: dict[str, Any]  # type: ignore[assignment]
+
+    def __init__(
+        self,
+        *,
+        body: dict[str, Any] | list[Any],
+        headers: dict[str, Any],
+        path: dict[str, Any],
+    ) -> None:
+        self._headers = headers
+        self._body = body
+        self._query_params = path
+
+        self.scope = {"path_params": self._query_params}
+        self._cookies = {}

faststream_fastapi-1.0.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,27 @@
+faststream_fastapi/__about__.py,sha256=oYISj9X_HBZogY0KMHgJ8v3EPboAd_XANLfWjFBtwMc,136
+faststream_fastapi/__init__.py,sha256=Trs7HiP8zCim_vz7lyzN-7jDbLFNL2Vmes0lKmHsjGI,323
+faststream_fastapi/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faststream_fastapi/_internal/asyncapi_router.py,sha256=BIwHuAby1mhTQuoTRMWY2X2oa7_GGORB329Lj6ouXtc,4299
+faststream_fastapi/_internal/background_middleware.py,sha256=3IvdDQ1ZBIzgIzeFamc2B4Z2YJMEAzdI7M96Ndvl7y0,717
+faststream_fastapi/_internal/config.py,sha256=YmFNnpk6FpOTM_JGJgSbSE-MbT-pMh5SxBD-1yKEOvc,571
+faststream_fastapi/_internal/fastapi_compat.py,sha256=0ChnQV7FbB2OsEWPwb74rDqwfeFMjXf8FN7qEkYjqnk,4362
+faststream_fastapi/_internal/fs_re_exports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faststream_fastapi/_internal/fs_re_exports/_compat.py,sha256=h7xdEqvop1FfFzKB4kZBsHtRSdNNXIRQNt7BYJQPHms,131
+faststream_fastapi/_internal/fs_re_exports/application.py,sha256=ocziVIpGpB0IgOw_kimZAVdCF0OzBdTLCts3e5QlpOE,103
+faststream_fastapi/_internal/fs_re_exports/broker.py,sha256=6mZ08_R_Z9e3qbDSYx_UdB8mQY1M_jJlU9ZrPT7EXW4,159
+faststream_fastapi/_internal/fs_re_exports/constants.py,sha256=mJ8kiBNoF2VstW6sZ4LZY44Bwx1AUKJhb5mbd5DJMEE,71
+faststream_fastapi/_internal/fs_re_exports/context.py,sha256=ep53p8_UYAgUVxFw7QAvqiZjbNfQ1QMLahriUraB_ZU,215
+faststream_fastapi/_internal/fs_re_exports/di.py,sha256=x38rHqtwmrOduz7W31_Hke_7vXlKIGVtAQh-ej52w_0,88
+faststream_fastapi/_internal/fs_re_exports/logger.py,sha256=SMxqu9YwIwLBa9hvzSFM-qYW_B48AsdhP1uL3LV1vEo,86
+faststream_fastapi/_internal/get_dependant.py,sha256=ObQvRmywHTNM7c7zQM6VAtirCBtJhxH2f7-6DMxfcSk,5997
+faststream_fastapi/_internal/logger.py,sha256=qaa8lXlQxtrp9hzDZHOijTBH0cKiV-2ZpUEbnjjdrUc,258
+faststream_fastapi/_internal/replace_context.py,sha256=nCLVn8kTV9SuGS_whbyzXYi-pq96x8Vft5cll9vCpMo,3697
+faststream_fastapi/_internal/wrap_callable_to_fastapi_compatible.py,sha256=LTotExCxEeqLEI7KAx82JSyzmz1PoXV8fpbvVqGPkfQ,5889
+faststream_fastapi/asyncapi_config.py,sha256=2D5Jc8ByUztmMn12a2fcNWtvfHZPeIhffbW6bhUO9lM,2294
+faststream_fastapi/context.py,sha256=bcE0DB8lQMPtCO3eTP3bNu1i_YL8uIOViwmk8IMiSGs,788
+faststream_fastapi/faststream_api.py,sha256=RLXcwA5hqyp6Q90siNg_LGpXs3r_kYqnwtaqzH2Ptmw,6021
+faststream_fastapi/stream_message.py,sha256=1k2vzUGL76wSJjbpPwL03LTBctRtD0syBlLqUuK5MpQ,665
+faststream_fastapi-1.0.0.dist-info/licenses/LICENSE,sha256=ZDtF8IsAs002GXg_yHpuS_RLkXDOOjKFuGFSTYUiTY4,1074
+faststream_fastapi-1.0.0.dist-info/WHEEL,sha256=8ZlpUMJ7mlDirmlHRhDirEx_nPnARrwDjeE92mlk68E,81
+faststream_fastapi-1.0.0.dist-info/METADATA,sha256=UrIblBJ44uDZuCgiuNtzCkTFSTTlg6L6al3nNvmqNCM,4354
+faststream_fastapi-1.0.0.dist-info/RECORD,,

faststream_fastapi-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.11.21
+Root-Is-Purelib: true
+Tag: py3-none-any

faststream_fastapi-1.0.0.dist-info/licenses/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.