From 8c2b6c873eb49479506fc024b6a118a1c6655fdf Mon Sep 17 00:00:00 2001 From: Saurabh Date: Sun, 5 Jul 2026 15:44:32 +0530 Subject: [PATCH 1/6] =?UTF-8?q?=F0=9F=90=9B=20Fix=20status=5Fcode=20being?= =?UTF-8?q?=20ignored=20for=20SSE=20and=20JSONL=20streaming=20endpoints?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- fastapi/routing.py | 10 ++- tests/test_stream_status_code.py | 138 +++++++++++++++++++++++++++++++ 2 files changed, 146 insertions(+), 2 deletions(-) create mode 100644 tests/test_stream_status_code.py diff --git a/fastapi/routing.py b/fastapi/routing.py index c442b122b..8a4819b29 100644 --- a/fastapi/routing.py +++ b/fastapi/routing.py @@ -624,10 +624,13 @@ def get_request_handler( _sse_with_checkpoints(sse_receive_stream) ) + response_args = _build_response_args( + status_code=status_code, solved_result=solved_result + ) response = StreamingResponse( sse_stream_content, media_type="text/event-stream", - background=solved_result.background_tasks, + **response_args, ) response.headers["Cache-Control"] = "no-cache" # For Nginx proxies to not buffer server sent events @@ -660,10 +663,13 @@ def get_request_handler( jsonl_stream_content = _sync_stream_jsonl() + response_args = _build_response_args( + status_code=status_code, solved_result=solved_result + ) response = StreamingResponse( jsonl_stream_content, media_type="application/jsonl", - background=solved_result.background_tasks, + **response_args, ) response.headers.raw.extend(solved_result.response.headers.raw) elif dependant.is_async_gen_callable or dependant.is_gen_callable: diff --git a/tests/test_stream_status_code.py b/tests/test_stream_status_code.py new file mode 100644 index 000000000..76b2bf4dc --- /dev/null +++ b/tests/test_stream_status_code.py @@ -0,0 +1,138 @@ +import json +from collections.abc import AsyncIterable +from typing import Any, cast + +from fastapi import Depends, FastAPI, Response +from fastapi.responses import EventSourceResponse, StreamingResponse +from fastapi.testclient import TestClient + +app = FastAPI() + + +def set_accepted(response: Response) -> None: + response.status_code = 202 + + +@app.post("/sse-created", response_class=EventSourceResponse, status_code=201) +async def sse_created() -> AsyncIterable[dict[str, str]]: + yield {"message": "created"} + + +@app.post("/jsonl-created", status_code=201) +async def jsonl_created() -> AsyncIterable[dict[str, str]]: + yield {"message": "created"} + + +@app.get("/sse-dependency", response_class=EventSourceResponse) +async def sse_dependency( + accepted: None = Depends(set_accepted), +) -> AsyncIterable[dict[str, str]]: + yield {"message": "accepted"} + + +@app.get("/jsonl-dependency") +async def jsonl_dependency( + accepted: None = Depends(set_accepted), +) -> AsyncIterable[dict[str, str]]: + yield {"message": "accepted"} + + +@app.get("/raw-dependency", response_class=StreamingResponse) +async def raw_dependency( + accepted: None = Depends(set_accepted), +) -> AsyncIterable[str]: + yield "accepted" + + +@app.get("/sse-default", response_class=EventSourceResponse) +async def sse_default() -> AsyncIterable[dict[str, str]]: + yield {"message": "ok"} + + +@app.get("/jsonl-default") +async def jsonl_default() -> AsyncIterable[dict[str, str]]: + yield {"message": "ok"} + + +client = TestClient(app) + + +def get_sse_data(response_text: str) -> list[dict[str, str]]: + data_lines = [ + line.removeprefix("data: ") + for line in response_text.splitlines() + if line.startswith("data: ") + ] + return [json.loads(line) for line in data_lines] + + +def get_jsonl_data(response_text: str) -> list[dict[str, str]]: + return [json.loads(line) for line in response_text.splitlines()] + + +def test_sse_stream_honors_declared_status_code() -> None: + response = client.post("/sse-created") + + assert response.status_code == 201 + assert response.headers["content-type"] == "text/event-stream; charset=utf-8" + assert get_sse_data(response.text) == [{"message": "created"}] + + +def test_jsonl_stream_honors_declared_status_code() -> None: + response = client.post("/jsonl-created") + + assert response.status_code == 201 + assert response.headers["content-type"] == "application/jsonl" + assert get_jsonl_data(response.text) == [{"message": "created"}] + + +def test_sse_stream_honors_dependency_status_code() -> None: + response = client.get("/sse-dependency") + + assert response.status_code == 202 + assert get_sse_data(response.text) == [{"message": "accepted"}] + + +def test_jsonl_stream_honors_dependency_status_code() -> None: + response = client.get("/jsonl-dependency") + + assert response.status_code == 202 + assert get_jsonl_data(response.text) == [{"message": "accepted"}] + + +def test_raw_stream_still_honors_dependency_status_code() -> None: + response = client.get("/raw-dependency") + + assert response.status_code == 202 + assert response.text == "accepted" + + +def test_sse_stream_default_status_code_stays_200() -> None: + response = client.get("/sse-default") + + assert response.status_code == 200 + assert get_sse_data(response.text) == [{"message": "ok"}] + + +def test_jsonl_stream_default_status_code_stays_200() -> None: + response = client.get("/jsonl-default") + + assert response.status_code == 200 + assert get_jsonl_data(response.text) == [{"message": "ok"}] + + +def test_stream_status_codes_match_openapi() -> None: + schema = client.get("/openapi.json").json() + + assert response_status_codes(schema, "/sse-created", "post") == ["201"] + assert response_status_codes(schema, "/jsonl-created", "post") == ["201"] + assert response_status_codes(schema, "/sse-default", "get") == ["200"] + assert response_status_codes(schema, "/jsonl-default", "get") == ["200"] + + +def response_status_codes(schema: dict[str, Any], path: str, method: str) -> list[str]: + paths = cast(dict[str, Any], schema["paths"]) + route = cast(dict[str, Any], paths[path]) + operation = cast(dict[str, Any], route[method]) + responses = cast(dict[str, Any], operation["responses"]) + return sorted(responses) From 11f2f207aff37ecedd35c6003136c0308f17f0f5 Mon Sep 17 00:00:00 2001 From: Saurabh Date: Mon, 6 Jul 2026 16:23:31 +0530 Subject: [PATCH 2/6] test: add coverage for dependency overridden status codes in streams --- tests/test_stream_status_code.py | 54 +++++++++++++++++++++++++++++++- 1 file changed, 53 insertions(+), 1 deletion(-) diff --git a/tests/test_stream_status_code.py b/tests/test_stream_status_code.py index 76b2bf4dc..4e78dae0f 100644 --- a/tests/test_stream_status_code.py +++ b/tests/test_stream_status_code.py @@ -54,6 +54,29 @@ async def jsonl_default() -> AsyncIterable[dict[str, str]]: yield {"message": "ok"} +# --- NEW OVERRIDE ENDPOINTS --- + +@app.post("/sse-created-override", response_class=EventSourceResponse, status_code=201) +async def sse_created_override( + accepted: None = Depends(set_accepted), +) -> AsyncIterable[dict[str, str]]: + yield {"message": "overridden"} + + +@app.post("/jsonl-created-override", status_code=201) +async def jsonl_created_override( + accepted: None = Depends(set_accepted), +) -> AsyncIterable[dict[str, str]]: + yield {"message": "overridden"} + + +@app.post("/raw-created-override", response_class=StreamingResponse, status_code=201) +async def raw_created_override( + accepted: None = Depends(set_accepted), +) -> AsyncIterable[str]: + yield "overridden" + + client = TestClient(app) @@ -121,6 +144,29 @@ def test_jsonl_stream_default_status_code_stays_200() -> None: assert get_jsonl_data(response.text) == [{"message": "ok"}] +# --- NEW OVERRIDE TESTS --- + +def test_sse_stream_dependency_overrides_declared_status_code() -> None: + response = client.post("/sse-created-override") + + assert response.status_code == 202 + assert get_sse_data(response.text) == [{"message": "overridden"}] + + +def test_jsonl_stream_dependency_overrides_declared_status_code() -> None: + response = client.post("/jsonl-created-override") + + assert response.status_code == 202 + assert get_jsonl_data(response.text) == [{"message": "overridden"}] + + +def test_raw_stream_dependency_overrides_declared_status_code() -> None: + response = client.post("/raw-created-override") + + assert response.status_code == 202 + assert response.text == "overridden" + + def test_stream_status_codes_match_openapi() -> None: schema = client.get("/openapi.json").json() @@ -128,6 +174,12 @@ def test_stream_status_codes_match_openapi() -> None: assert response_status_codes(schema, "/jsonl-created", "post") == ["201"] assert response_status_codes(schema, "/sse-default", "get") == ["200"] assert response_status_codes(schema, "/jsonl-default", "get") == ["200"] + + # Asserting that OpenAPI still documents the declared status code (201), + # even though the dependency sets it to 202 at runtime. + assert response_status_codes(schema, "/sse-created-override", "post") == ["201"] + assert response_status_codes(schema, "/jsonl-created-override", "post") == ["201"] + assert response_status_codes(schema, "/raw-created-override", "post") == ["201"] def response_status_codes(schema: dict[str, Any], path: str, method: str) -> list[str]: @@ -135,4 +187,4 @@ def response_status_codes(schema: dict[str, Any], path: str, method: str) -> lis route = cast(dict[str, Any], paths[path]) operation = cast(dict[str, Any], route[method]) responses = cast(dict[str, Any], operation["responses"]) - return sorted(responses) + return sorted(responses) \ No newline at end of file From de62aadd965f7938305d141331e1fd411eda79a3 Mon Sep 17 00:00:00 2001 From: Saurabh Date: Mon, 6 Jul 2026 16:52:19 +0530 Subject: [PATCH 3/6] chore: remove accidental inline comments from tests --- tests/test_stream_status_code.py | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/tests/test_stream_status_code.py b/tests/test_stream_status_code.py index 4e78dae0f..7015e842e 100644 --- a/tests/test_stream_status_code.py +++ b/tests/test_stream_status_code.py @@ -54,7 +54,7 @@ async def jsonl_default() -> AsyncIterable[dict[str, str]]: yield {"message": "ok"} -# --- NEW OVERRIDE ENDPOINTS --- + @app.post("/sse-created-override", response_class=EventSourceResponse, status_code=201) async def sse_created_override( @@ -144,7 +144,7 @@ def test_jsonl_stream_default_status_code_stays_200() -> None: assert get_jsonl_data(response.text) == [{"message": "ok"}] -# --- NEW OVERRIDE TESTS --- + def test_sse_stream_dependency_overrides_declared_status_code() -> None: response = client.post("/sse-created-override") @@ -175,8 +175,7 @@ def test_stream_status_codes_match_openapi() -> None: assert response_status_codes(schema, "/sse-default", "get") == ["200"] assert response_status_codes(schema, "/jsonl-default", "get") == ["200"] - # Asserting that OpenAPI still documents the declared status code (201), - # even though the dependency sets it to 202 at runtime. + assert response_status_codes(schema, "/sse-created-override", "post") == ["201"] assert response_status_codes(schema, "/jsonl-created-override", "post") == ["201"] assert response_status_codes(schema, "/raw-created-override", "post") == ["201"] From 7ab5435f466054b216fb5b0fee3ab52cd313199d Mon Sep 17 00:00:00 2001 From: "pre-commit-ci-lite[bot]" <117423508+pre-commit-ci-lite[bot]@users.noreply.github.com> Date: Mon, 6 Jul 2026 11:41:43 +0000 Subject: [PATCH 4/6] =?UTF-8?q?=F0=9F=8E=A8=20Auto=20format?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- tests/test_stream_status_code.py | 15 +++++---------- 1 file changed, 5 insertions(+), 10 deletions(-) diff --git a/tests/test_stream_status_code.py b/tests/test_stream_status_code.py index 7015e842e..c2a91fae3 100644 --- a/tests/test_stream_status_code.py +++ b/tests/test_stream_status_code.py @@ -54,8 +54,6 @@ async def jsonl_default() -> AsyncIterable[dict[str, str]]: yield {"message": "ok"} - - @app.post("/sse-created-override", response_class=EventSourceResponse, status_code=201) async def sse_created_override( accepted: None = Depends(set_accepted), @@ -144,25 +142,23 @@ def test_jsonl_stream_default_status_code_stays_200() -> None: assert get_jsonl_data(response.text) == [{"message": "ok"}] - - def test_sse_stream_dependency_overrides_declared_status_code() -> None: response = client.post("/sse-created-override") - + assert response.status_code == 202 assert get_sse_data(response.text) == [{"message": "overridden"}] def test_jsonl_stream_dependency_overrides_declared_status_code() -> None: response = client.post("/jsonl-created-override") - + assert response.status_code == 202 assert get_jsonl_data(response.text) == [{"message": "overridden"}] def test_raw_stream_dependency_overrides_declared_status_code() -> None: response = client.post("/raw-created-override") - + assert response.status_code == 202 assert response.text == "overridden" @@ -174,8 +170,7 @@ def test_stream_status_codes_match_openapi() -> None: assert response_status_codes(schema, "/jsonl-created", "post") == ["201"] assert response_status_codes(schema, "/sse-default", "get") == ["200"] assert response_status_codes(schema, "/jsonl-default", "get") == ["200"] - - + assert response_status_codes(schema, "/sse-created-override", "post") == ["201"] assert response_status_codes(schema, "/jsonl-created-override", "post") == ["201"] assert response_status_codes(schema, "/raw-created-override", "post") == ["201"] @@ -186,4 +181,4 @@ def response_status_codes(schema: dict[str, Any], path: str, method: str) -> lis route = cast(dict[str, Any], paths[path]) operation = cast(dict[str, Any], route[method]) responses = cast(dict[str, Any], operation["responses"]) - return sorted(responses) \ No newline at end of file + return sorted(responses) From ca53c0998e3913a237b31402a1be4ec27fff3abd Mon Sep 17 00:00:00 2001 From: Yurii Motov Date: Mon, 13 Jul 2026 19:06:27 +0200 Subject: [PATCH 5/6] Remove tests for `default` --- tests/test_stream_status_code.py | 26 -------------------------- 1 file changed, 26 deletions(-) diff --git a/tests/test_stream_status_code.py b/tests/test_stream_status_code.py index c2a91fae3..8a2e058a0 100644 --- a/tests/test_stream_status_code.py +++ b/tests/test_stream_status_code.py @@ -44,16 +44,6 @@ async def raw_dependency( yield "accepted" -@app.get("/sse-default", response_class=EventSourceResponse) -async def sse_default() -> AsyncIterable[dict[str, str]]: - yield {"message": "ok"} - - -@app.get("/jsonl-default") -async def jsonl_default() -> AsyncIterable[dict[str, str]]: - yield {"message": "ok"} - - @app.post("/sse-created-override", response_class=EventSourceResponse, status_code=201) async def sse_created_override( accepted: None = Depends(set_accepted), @@ -128,20 +118,6 @@ def test_raw_stream_still_honors_dependency_status_code() -> None: assert response.text == "accepted" -def test_sse_stream_default_status_code_stays_200() -> None: - response = client.get("/sse-default") - - assert response.status_code == 200 - assert get_sse_data(response.text) == [{"message": "ok"}] - - -def test_jsonl_stream_default_status_code_stays_200() -> None: - response = client.get("/jsonl-default") - - assert response.status_code == 200 - assert get_jsonl_data(response.text) == [{"message": "ok"}] - - def test_sse_stream_dependency_overrides_declared_status_code() -> None: response = client.post("/sse-created-override") @@ -168,8 +144,6 @@ def test_stream_status_codes_match_openapi() -> None: assert response_status_codes(schema, "/sse-created", "post") == ["201"] assert response_status_codes(schema, "/jsonl-created", "post") == ["201"] - assert response_status_codes(schema, "/sse-default", "get") == ["200"] - assert response_status_codes(schema, "/jsonl-default", "get") == ["200"] assert response_status_codes(schema, "/sse-created-override", "post") == ["201"] assert response_status_codes(schema, "/jsonl-created-override", "post") == ["201"] From 8938eda5e9841ea460c8447cfb6759fef3b4fc30 Mon Sep 17 00:00:00 2001 From: Yurii Motov Date: Mon, 13 Jul 2026 19:46:17 +0200 Subject: [PATCH 6/6] Update tests --- tests/test_stream_status_code.py | 500 ++++++++++++++++++++++++------- 1 file changed, 397 insertions(+), 103 deletions(-) diff --git a/tests/test_stream_status_code.py b/tests/test_stream_status_code.py index 8a2e058a0..15b6d1053 100644 --- a/tests/test_stream_status_code.py +++ b/tests/test_stream_status_code.py @@ -1,10 +1,50 @@ -import json from collections.abc import AsyncIterable -from typing import Any, cast +import pytest from fastapi import Depends, FastAPI, Response from fastapi.responses import EventSourceResponse, StreamingResponse from fastapi.testclient import TestClient +from inline_snapshot import snapshot + +SSE_RESPONSE = { + "description": "Successful Response", + "content": { + "text/event-stream": { + "itemSchema": { + "type": "object", + "properties": { + "data": { + "type": "string", + "contentMediaType": "application/json", + "contentSchema": { + "type": "object", + "additionalProperties": {"type": "string"}, + "title": "SSE stream item", + }, + }, + "event": {"type": "string"}, + "id": {"type": "string"}, + "retry": {"type": "integer", "minimum": 0}, + }, + "required": ["data"], + } + } + }, +} + +JSONL_RESPONSE = { + "description": "Successful Response", + "content": { + "application/jsonl": { + "itemSchema": { + "type": "object", + "additionalProperties": {"type": "string"}, + "title": "JSONL stream item", + } + } + }, +} + app = FastAPI() @@ -13,53 +53,80 @@ def set_accepted(response: Response) -> None: response.status_code = 202 -@app.post("/sse-created", response_class=EventSourceResponse, status_code=201) -async def sse_created() -> AsyncIterable[dict[str, str]]: +@app.post("/sse", response_class=EventSourceResponse, status_code=201) +async def sse() -> AsyncIterable[dict[str, str]]: yield {"message": "created"} -@app.post("/jsonl-created", status_code=201) -async def jsonl_created() -> AsyncIterable[dict[str, str]]: +@app.post("/jsonl", status_code=201) +async def jsonl() -> AsyncIterable[dict[str, str]]: yield {"message": "created"} -@app.get("/sse-dependency", response_class=EventSourceResponse) +@app.post("/raw", response_class=StreamingResponse, status_code=201) +async def raw() -> AsyncIterable[str]: + yield "accepted" + + +@app.post( + "/sse-dependency", + response_class=EventSourceResponse, + responses={202: SSE_RESPONSE}, +) async def sse_dependency( accepted: None = Depends(set_accepted), ) -> AsyncIterable[dict[str, str]]: yield {"message": "accepted"} -@app.get("/jsonl-dependency") +@app.post("/jsonl-dependency", responses={202: JSONL_RESPONSE}) async def jsonl_dependency( accepted: None = Depends(set_accepted), ) -> AsyncIterable[dict[str, str]]: yield {"message": "accepted"} -@app.get("/raw-dependency", response_class=StreamingResponse) +@app.post( + "/raw-dependency", + response_class=StreamingResponse, + responses={202: {"description": "Accepted"}}, +) async def raw_dependency( accepted: None = Depends(set_accepted), ) -> AsyncIterable[str]: yield "accepted" -@app.post("/sse-created-override", response_class=EventSourceResponse, status_code=201) -async def sse_created_override( +@app.post( + "/sse-dependency-override", + response_class=EventSourceResponse, + status_code=201, + responses={202: SSE_RESPONSE}, +) +async def sse_dependency_override( accepted: None = Depends(set_accepted), ) -> AsyncIterable[dict[str, str]]: yield {"message": "overridden"} -@app.post("/jsonl-created-override", status_code=201) -async def jsonl_created_override( +@app.post( + "/jsonl-dependency-override", + status_code=201, + responses={202: JSONL_RESPONSE}, +) +async def jsonl_dependency_override( accepted: None = Depends(set_accepted), ) -> AsyncIterable[dict[str, str]]: yield {"message": "overridden"} -@app.post("/raw-created-override", response_class=StreamingResponse, status_code=201) -async def raw_created_override( +@app.post( + "/raw-dependency-override", + response_class=StreamingResponse, + status_code=201, + responses={202: {"description": "Accepted"}}, +) +async def raw_dependency_override( accepted: None = Depends(set_accepted), ) -> AsyncIterable[str]: yield "overridden" @@ -68,91 +135,318 @@ async def raw_created_override( client = TestClient(app) -def get_sse_data(response_text: str) -> list[dict[str, str]]: - data_lines = [ - line.removeprefix("data: ") - for line in response_text.splitlines() - if line.startswith("data: ") - ] - return [json.loads(line) for line in data_lines] - - -def get_jsonl_data(response_text: str) -> list[dict[str, str]]: - return [json.loads(line) for line in response_text.splitlines()] - - -def test_sse_stream_honors_declared_status_code() -> None: - response = client.post("/sse-created") - - assert response.status_code == 201 - assert response.headers["content-type"] == "text/event-stream; charset=utf-8" - assert get_sse_data(response.text) == [{"message": "created"}] - - -def test_jsonl_stream_honors_declared_status_code() -> None: - response = client.post("/jsonl-created") - - assert response.status_code == 201 - assert response.headers["content-type"] == "application/jsonl" - assert get_jsonl_data(response.text) == [{"message": "created"}] - - -def test_sse_stream_honors_dependency_status_code() -> None: - response = client.get("/sse-dependency") - - assert response.status_code == 202 - assert get_sse_data(response.text) == [{"message": "accepted"}] - - -def test_jsonl_stream_honors_dependency_status_code() -> None: - response = client.get("/jsonl-dependency") - - assert response.status_code == 202 - assert get_jsonl_data(response.text) == [{"message": "accepted"}] - - -def test_raw_stream_still_honors_dependency_status_code() -> None: - response = client.get("/raw-dependency") - - assert response.status_code == 202 - assert response.text == "accepted" - - -def test_sse_stream_dependency_overrides_declared_status_code() -> None: - response = client.post("/sse-created-override") - - assert response.status_code == 202 - assert get_sse_data(response.text) == [{"message": "overridden"}] - - -def test_jsonl_stream_dependency_overrides_declared_status_code() -> None: - response = client.post("/jsonl-created-override") - - assert response.status_code == 202 - assert get_jsonl_data(response.text) == [{"message": "overridden"}] - - -def test_raw_stream_dependency_overrides_declared_status_code() -> None: - response = client.post("/raw-created-override") - - assert response.status_code == 202 - assert response.text == "overridden" - - -def test_stream_status_codes_match_openapi() -> None: - schema = client.get("/openapi.json").json() - - assert response_status_codes(schema, "/sse-created", "post") == ["201"] - assert response_status_codes(schema, "/jsonl-created", "post") == ["201"] - - assert response_status_codes(schema, "/sse-created-override", "post") == ["201"] - assert response_status_codes(schema, "/jsonl-created-override", "post") == ["201"] - assert response_status_codes(schema, "/raw-created-override", "post") == ["201"] - - -def response_status_codes(schema: dict[str, Any], path: str, method: str) -> list[str]: - paths = cast(dict[str, Any], schema["paths"]) - route = cast(dict[str, Any], paths[path]) - operation = cast(dict[str, Any], route[method]) - responses = cast(dict[str, Any], operation["responses"]) - return sorted(responses) +@pytest.mark.parametrize( + "path,expected_status_code", + [ + ("/sse", 201), + ("/jsonl", 201), + ("/raw", 201), + ("/sse-dependency", 202), + ("/jsonl-dependency", 202), + ("/raw-dependency", 202), + ("/sse-dependency-override", 202), + ("/jsonl-dependency-override", 202), + ("/raw-dependency-override", 202), + ], +) +def test_status_code(path: str, expected_status_code: int) -> None: + response = client.post(path) + assert response.status_code == expected_status_code + + +def test_openapi() -> None: + openapi = app.openapi() + + assert openapi == snapshot( + { + "openapi": "3.1.0", + "info": {"title": "FastAPI", "version": "0.1.0"}, + "paths": { + "/sse": { + "post": { + "summary": "Sse", + "operationId": "sse_sse_post", + "responses": { + "201": { + "description": "Successful Response", + "content": { + "text/event-stream": { + "itemSchema": { + "type": "object", + "properties": { + "data": { + "type": "string", + "contentMediaType": "application/json", + "contentSchema": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "title": "Streamitem Sse Sse Post", + }, + }, + "event": {"type": "string"}, + "id": {"type": "string"}, + "retry": { + "type": "integer", + "minimum": 0, + }, + }, + "required": ["data"], + } + } + }, + } + }, + } + }, + "/jsonl": { + "post": { + "summary": "Jsonl", + "operationId": "jsonl_jsonl_post", + "responses": { + "201": { + "description": "Successful Response", + "content": { + "application/jsonl": { + "itemSchema": { + "type": "object", + "additionalProperties": {"type": "string"}, + "title": "Streamitem Jsonl Jsonl Post", + } + } + }, + } + }, + } + }, + "/raw": { + "post": { + "summary": "Raw", + "operationId": "raw_raw_post", + "responses": {"201": {"description": "Successful Response"}}, + } + }, + "/sse-dependency": { + "post": { + "summary": "Sse Dependency", + "operationId": "sse_dependency_sse_dependency_post", + "responses": { + "200": { + "description": "Successful Response", + "content": { + "text/event-stream": { + "itemSchema": { + "type": "object", + "properties": { + "data": { + "type": "string", + "contentMediaType": "application/json", + "contentSchema": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "title": "Streamitem Sse Dependency Sse Dependency Post", + }, + }, + "event": {"type": "string"}, + "id": {"type": "string"}, + "retry": { + "type": "integer", + "minimum": 0, + }, + }, + "required": ["data"], + } + } + }, + }, + "202": { + "description": "Successful Response", + "content": { + "text/event-stream": { + "itemSchema": { + "type": "object", + "properties": { + "data": { + "type": "string", + "contentMediaType": "application/json", + "contentSchema": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "title": "SSE stream item", + }, + }, + "event": {"type": "string"}, + "id": {"type": "string"}, + "retry": { + "type": "integer", + "minimum": 0, + }, + }, + "required": ["data"], + } + } + }, + }, + }, + } + }, + "/jsonl-dependency": { + "post": { + "summary": "Jsonl Dependency", + "operationId": "jsonl_dependency_jsonl_dependency_post", + "responses": { + "200": { + "description": "Successful Response", + "content": { + "application/jsonl": { + "itemSchema": { + "type": "object", + "additionalProperties": {"type": "string"}, + "title": "Streamitem Jsonl Dependency Jsonl Dependency Post", + } + } + }, + }, + "202": { + "description": "Successful Response", + "content": { + "application/jsonl": { + "itemSchema": { + "type": "object", + "additionalProperties": {"type": "string"}, + "title": "JSONL stream item", + } + } + }, + }, + }, + } + }, + "/raw-dependency": { + "post": { + "summary": "Raw Dependency", + "operationId": "raw_dependency_raw_dependency_post", + "responses": { + "200": {"description": "Successful Response"}, + "202": {"description": "Accepted"}, + }, + } + }, + "/sse-dependency-override": { + "post": { + "summary": "Sse Dependency Override", + "operationId": "sse_dependency_override_sse_dependency_override_post", + "responses": { + "201": { + "description": "Successful Response", + "content": { + "text/event-stream": { + "itemSchema": { + "type": "object", + "properties": { + "data": { + "type": "string", + "contentMediaType": "application/json", + "contentSchema": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "title": "Streamitem Sse Dependency Override Sse Dependency Override Post", + }, + }, + "event": {"type": "string"}, + "id": {"type": "string"}, + "retry": { + "type": "integer", + "minimum": 0, + }, + }, + "required": ["data"], + } + } + }, + }, + "202": { + "description": "Successful Response", + "content": { + "text/event-stream": { + "itemSchema": { + "type": "object", + "properties": { + "data": { + "type": "string", + "contentMediaType": "application/json", + "contentSchema": { + "type": "object", + "additionalProperties": { + "type": "string" + }, + "title": "SSE stream item", + }, + }, + "event": {"type": "string"}, + "id": {"type": "string"}, + "retry": { + "type": "integer", + "minimum": 0, + }, + }, + "required": ["data"], + } + } + }, + }, + }, + } + }, + "/jsonl-dependency-override": { + "post": { + "summary": "Jsonl Dependency Override", + "operationId": "jsonl_dependency_override_jsonl_dependency_override_post", + "responses": { + "201": { + "description": "Successful Response", + "content": { + "application/jsonl": { + "itemSchema": { + "type": "object", + "additionalProperties": {"type": "string"}, + "title": "Streamitem Jsonl Dependency Override Jsonl Dependency Override Post", + } + } + }, + }, + "202": { + "description": "Successful Response", + "content": { + "application/jsonl": { + "itemSchema": { + "type": "object", + "additionalProperties": {"type": "string"}, + "title": "JSONL stream item", + } + } + }, + }, + }, + } + }, + "/raw-dependency-override": { + "post": { + "summary": "Raw Dependency Override", + "operationId": "raw_dependency_override_raw_dependency_override_post", + "responses": { + "201": {"description": "Successful Response"}, + "202": {"description": "Accepted"}, + }, + } + }, + }, + } + )