fastapi-streams 0.0.1__py3-none-any.whl

fastapi_streams/codegen/typescript.py

@@ -0,0 +1,220 @@
+import json
+import re
+from importlib.resources import files
+
+from fastapi_streams.codegen.ir import (
+    Array,
+    Contract,
+    EnumAlias,
+    EnumValue,
+    Intersection,
+    LiteralType,
+    Object,
+    Operation,
+    Reference,
+    Scalar,
+    StringEnum,
+    Type,
+    Union,
+)
+from fastapi_streams.codegen.names import identifier
+from fastapi_streams.codegen.openapi import ContractError
+from fastapi_streams.codegen.templating import add_filters, environment
+
+_HEADER = "// Generated by fastapi-streams. Do not edit.\n"
+_JSON = (
+    "export type JsonValue = string | number | boolean | null "
+    "| JsonValue[] | { [key: string]: JsonValue };"
+)
+
+
+def render_type(type_: Type, prefix: str = "") -> str:
+    match type_:
+        case Scalar(name="JsonValue"):
+            return prefix + "JsonValue"
+        case Scalar(name="integer"):
+            return "number"
+        case Scalar(name=name):
+            return name
+        case LiteralType(value=value):
+            return json.dumps(value, ensure_ascii=False)
+        case EnumValue(enum=enum, member=member):
+            return f"typeof {prefix}{enum}.{member}"
+        case StringEnum(members=members):
+            return " | ".join(json.dumps(member.value) for member in members)
+        case EnumAlias(target=target):
+            return prefix + target
+        case Reference(name=name):
+            return prefix + name
+        case Array(item=item):
+            return f"Array<{render_type(item, prefix=prefix)}>"
+        case Union(members=members):
+            return (
+                "("
+                + " | ".join(render_type(part, prefix=prefix) for part in members)
+                + ")"
+            )
+        case Intersection(members=members):
+            return (
+                "("
+                + " & ".join(render_type(part, prefix=prefix) for part in members)
+                + ")"
+            )
+        case Object(fields=fields, additional=additional):
+            parts = [
+                f"{json.dumps(field.name)}{'' if field.required else '?'}: "
+                f"{render_type(field.type, prefix=prefix)};"
+                for field in fields
+            ]
+            if additional is not None:
+                values = {render_type(additional, prefix=prefix)}
+                values.update(
+                    render_type(field.type, prefix=prefix) for field in fields
+                )
+                if any(not field.required for field in fields):
+                    values.add("undefined")
+                parts.append(f"[key: string]: {' | '.join(sorted(values))};")
+            # An empty model is a JSON object, not TypeScript's non-nullish {} type.
+            return (
+                "{\n" + "\n".join("  " + part for part in parts) + "\n}"
+                if parts
+                else "{ [key: string]: never }"
+            )
+
+
+def generate_typescript(contract: Contract) -> dict[str, str]:
+    public_names = {
+        "Client",
+        "ClientOptions",
+        "RequestOptions",
+        "HttpError",
+        "StreamParseError",
+        "TransportError",
+    }
+    for declaration in contract.declarations:
+        if declaration.name in public_names:
+            raise ContractError(f"Reserved TypeScript model name: {declaration.name}")
+        public_names.add(declaration.name)
+    for operation in contract.operations:
+        names = (
+            [_input_name(operation)] if operation.parameters or operation.body else []
+        )
+        if operation.errors:
+            names.append(identifier(operation.operation_id, upper=True) + "Error")
+        for name in names:
+            if name in public_names:
+                raise ContractError(f"TypeScript public name collision: {name}")
+            public_names.add(name)
+    env = environment()
+
+    def pascal(value: str) -> str:
+        return identifier(value, upper=True)
+
+    add_filters(
+        env,
+        ts_type=render_type,
+        json=json.dumps,
+        pascal=pascal,
+        input_name=_input_name,
+        required=_required,
+        error_type=_error_type,
+        path=_path,
+    )
+    output: dict[str, str] = {}
+    declarations: list[str] = []
+    for declaration in contract.declarations:
+        name, type_ = declaration.name, declaration.type
+        if isinstance(type_, StringEnum):
+            members = "\n".join(
+                f"  {member.name}: {json.dumps(member.value)},"
+                for member in type_.members
+            )
+            declarations.append(
+                f"export const {name} = {{\n{members}\n}} as const;\n"
+                f"export type {name} = (typeof {name})[keyof typeof {name}];"
+            )
+        elif isinstance(type_, EnumAlias):
+            declarations.append(
+                f"export const {name} = {type_.target};\n"
+                f"export type {name} = {type_.target};"
+            )
+        else:
+            declarations.append(f"export type {name} = {render_type(type_)};")
+    output["types.ts"] = "\n".join([_HEADER, _JSON, "", *declarations]) + "\n"
+    for template in ("sse.ts", "errors.ts"):
+        output[f"transport/{template}"] = (
+            files(__package__)
+            .joinpath(f"templates/{template}")
+            .read_text(encoding="utf-8")
+        )
+    grouped: dict[str, list[Operation]] = {}
+    for operation in contract.operations:
+        grouped.setdefault(operation.group, []).append(operation)
+    groups: list[dict[str, str]] = []
+    exports = [
+        _HEADER,
+        'export { createClient } from "./client.js";',
+        'export type { Client } from "./client.js";',
+        'export * from "./types.js";',
+        'export type { ClientOptions, RequestOptions } from "./transport/sse.js";',
+        "export { HttpError, TransportError, StreamParseError } "
+        'from "./transport/errors.js";',
+    ]
+    for group, operations in sorted(grouped.items()):
+        operations.sort(key=lambda operation: operation.name)
+        directory = operations[0].directory
+        factory = "create" + group[:1].upper() + group[1:] + "Api"
+        groups.append(dict(name=group, factory=factory, directory=directory))
+        functions = ["stream"]
+        if any(
+            param.location == "path" for op in operations for param in op.parameters
+        ):
+            functions.append("encodePath")
+        if any(
+            param.location == "query" for op in operations for param in op.parameters
+        ):
+            functions.append("appendQuery")
+        if any(
+            param.location == "header" for op in operations for param in op.parameters
+        ):
+            functions.append("setHeader")
+        output[f"{directory}/api.ts"] = env.get_template("typescript/api.ts.j2").render(
+            operations=operations,
+            functions=functions,
+            factory=factory,
+        )
+        output[f"{directory}/index.ts"] = _HEADER + 'export * from "./api.js";\n'
+        exports.append(f'export type * from "./{directory}/api.js";')
+    output["client.ts"] = env.get_template("typescript/client.ts.j2").render(
+        groups=groups
+    )
+    output["index.ts"] = "\n".join(exports) + "\n"
+    return output
+
+
+def _input_name(operation: Operation) -> str:
+    return identifier(operation.operation_id, upper=True) + "Params"
+
+
+def _path(operation: Operation) -> str:
+    parts: list[str] = []
+    cursor = 0
+    by_name = {param.name: param.argument for param in operation.parameters}
+    for match in re.finditer(r"\{([^{}]+)\}", operation.path):
+        parts.append(json.dumps(operation.path[cursor : match.start()]))
+        parts.append(f"encodePath(input.{by_name[match[1]]})")
+        cursor = match.end()
+    parts.append(json.dumps(operation.path[cursor:]))
+    return " + ".join(parts)
+
+
+def _required(operation: Operation) -> bool:
+    return any(param.required for param in operation.parameters) or (
+        operation.body is not None and operation.body.required
+    )
+
+
+def _error_type(operation: Operation) -> str:
+    return " | ".join(
+        sorted({render_type(error.type, prefix="Types.") for error in operation.errors})
+    )

fastapi_streams/codegen/writer.py

@@ -0,0 +1,64 @@
+import json
+import tempfile
+from collections.abc import Mapping
+from pathlib import Path, PurePosixPath
+from typing import Any, cast
+
+MANIFEST = ".fastapi-streams.json"
+
+
+def write_files(
+    output: Path, files: Mapping[str, str], *, check: bool = False
+) -> tuple[Path, ...]:
+    """Write deterministic output; only remove stale files owned by the manifest.
+
+    Check mode is read-only, including when output does not yet exist.
+    """
+    expected = dict(files)
+    if MANIFEST in expected:
+        raise ValueError(f"{MANIFEST} is reserved")
+    expected[MANIFEST] = json.dumps({"files": sorted(files)}, indent=2) + "\n"
+    manifest = _owned_path(output, MANIFEST)
+    previous: set[str] = set()
+    if manifest.exists():
+        value = json.loads(manifest.read_text(encoding="utf-8"))
+        names = value.get("files")
+        if not isinstance(names, list) or not all(
+            isinstance(name, str) for name in cast(list[Any], names)
+        ):
+            raise ValueError(f"Invalid generated manifest: {manifest}")
+        previous = set(cast(list[str], names))
+    # Preflight every target, including stale paths, before modifying anything.
+    paths = {name: _owned_path(output, name) for name in set(expected) | previous}
+    changed: list[Path] = []
+    for name, content in sorted(expected.items()):
+        path = paths[name]
+        if path.is_file() and path.read_bytes() == content.encode("utf-8"):
+            continue
+        changed.append(path)
+        if not check:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            with tempfile.NamedTemporaryFile(dir=path.parent, delete=False) as handle:
+                temporary = Path(handle.name)
+                handle.write(content.encode("utf-8"))
+            try:
+                temporary.replace(path)
+            finally:
+                temporary.unlink(missing_ok=True)
+    for name in sorted(previous - set(expected)):
+        path = paths[name]
+        if path.is_file():
+            changed.append(path)
+            if not check:
+                path.unlink()
+    return tuple(changed)
+
+
+def _owned_path(root: Path, relative: str) -> Path:
+    path = PurePosixPath(relative)
+    if path.is_absolute() or ".." in path.parts or "\\" in relative or ":" in relative:
+        raise ValueError(f"Unsafe generated path: {relative!r}")
+    resolved = (root / relative).resolve()
+    if not resolved.is_relative_to(root.resolve()) or resolved == root.resolve():
+        raise ValueError(f"Generated path escapes output directory: {relative!r}")
+    return resolved

fastapi_streams/router.py

@@ -0,0 +1,133 @@
+import inspect
+from collections.abc import (
+    AsyncGenerator,
+    AsyncIterable,
+    AsyncIterator,
+    Callable,
+    Generator,
+    Iterable,
+    Iterator,
+)
+from typing import Any, TypeAliasType, get_args, get_origin, get_type_hints
+
+from fastapi import APIRouter
+from fastapi.sse import EventSourceResponse, ServerSentEvent
+from pydantic import TypeAdapter
+
+_ASYNC = (AsyncIterator, AsyncIterable, AsyncGenerator)
+_SYNC = (Iterator, Iterable, Generator)
+
+
+class StreamRouter(APIRouter):
+    """An APIRouter with typed SSE routes; normal FastAPI routes work unchanged."""
+
+    def stream[Endpoint: Callable[..., Any]](
+        self,
+        path: str,
+        *,
+        methods: list[str] | None = None,
+        **options: Any,
+    ) -> Callable[[Endpoint], Endpoint]:
+        """Register a GET (default) or POST JSON-data SSE generator.
+
+        Other options are forwarded to ``APIRouter.api_route``, including tags,
+        dependencies, responses and operation_id. Serialization must preserve
+        the exported event schema: include must be None, exclude must be empty,
+        by_alias must be True, and exclude_none/unset/defaults must be False.
+        Put HTTP precondition checks in dependencies: a generator's body executes
+        after the response has started, following native FastAPI behavior.
+        """
+        selected = [
+            method.upper() for method in (methods if methods is not None else ["GET"])
+        ]
+        if not selected or not set(selected) <= {"GET", "POST"}:
+            raise ValueError("Streams support GET and POST only")
+        if "response_class" in options or "response_model" in options:
+            raise TypeError(
+                "Streams infer their response model and use EventSourceResponse"
+            )
+        for option, changes_contract in (
+            (
+                "response_model_include",
+                options.get("response_model_include") is not None,
+            ),
+            ("response_model_exclude", bool(options.get("response_model_exclude"))),
+            (
+                "response_model_by_alias",
+                options.get("response_model_by_alias", True) is not True,
+            ),
+            (
+                "response_model_exclude_none",
+                bool(options.get("response_model_exclude_none")),
+            ),
+            (
+                "response_model_exclude_unset",
+                bool(options.get("response_model_exclude_unset")),
+            ),
+            (
+                "response_model_exclude_defaults",
+                bool(options.get("response_model_exclude_defaults")),
+            ),
+        ):
+            if changes_contract:
+                raise TypeError(
+                    f"{option} would change the stream's exported event contract"
+                )
+        status = options.get("status_code", 200)
+        if status is not None and (not 200 <= status < 300 or status in (204, 205)):
+            raise ValueError("A stream must use a successful status code with a body")
+        options.setdefault("response_description", "Stream of JSON events")
+
+        def decorator(endpoint: Endpoint) -> Endpoint:
+            _validate_endpoint(endpoint)
+            self.api_route(
+                path,
+                methods=selected,
+                response_class=EventSourceResponse,
+                **options,
+            )(endpoint)
+            return endpoint
+
+        return decorator
+
+
+def _has_any(annotation: Any, seen: frozenset[int] = frozenset()) -> bool:
+    if annotation is Any or any(
+        annotation is item for item in (object, dict, list, tuple, set)
+    ):
+        return True
+    if id(annotation) in seen:
+        return False
+    seen = seen | {id(annotation)}
+    if isinstance(annotation, TypeAliasType):
+        return _has_any(annotation.__value__, seen)
+    return any(_has_any(arg, seen) for arg in get_args(annotation))
+
+
+def _validate_endpoint(endpoint: Callable[..., Any]) -> None:
+    try:
+        annotation = get_type_hints(endpoint, include_extras=True).get("return")
+    except (NameError, TypeError) as exc:
+        raise TypeError(
+            f"Cannot resolve stream annotation for {endpoint.__name__}"
+        ) from exc
+    if inspect.isasyncgenfunction(endpoint):
+        origins = _ASYNC
+    elif inspect.isgeneratorfunction(endpoint):
+        origins = _SYNC
+    else:
+        raise TypeError("A stream endpoint must be a generator function using yield")
+    args = get_args(annotation)
+    if get_origin(annotation) not in origins or not args:
+        raise TypeError(
+            "A stream must declare AsyncIterator[Event] (or Iterable[Event] for def)"
+        )
+    item = args[0]
+    if _has_any(item) or item is ServerSentEvent:
+        raise TypeError(
+            "Declare a concrete JSON event type, not Any or ServerSentEvent"
+        )
+    try:
+        TypeAdapter(item).json_schema(mode="serialization")
+    except Exception as exc:
+        raise TypeError(f"Unsupported stream item type: {item!r}") from exc

fastapi_streams-0.0.1.dist-info/METADATA

@@ -0,0 +1,238 @@
+Metadata-Version: 2.5
+Name: fastapi-streams
+Version: 0.0.1
+Summary: Typed FastAPI streams with generated TypeScript and Python clients.
+Project-URL: Documentation, https://github.com/mathisarends/fastapi-streams/tree/main/docs
+Project-URL: Source, https://github.com/mathisarends/fastapi-streams
+Project-URL: Issues, https://github.com/mathisarends/fastapi-streams/issues
+Author: Mathis Arends
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: fastapi<1.0,>=0.143.3
+Requires-Dist: pydantic<3,>=2.11.2
+Provides-Extra: codegen
+Requires-Dist: jinja2<4,>=3.1; extra == 'codegen'
+Requires-Dist: jsonschema<5,>=4.23; extra == 'codegen'
+Description-Content-Type: text/markdown
+
+# fastapi-streams
+
+[![CI](https://github.com/mathisarends/fastapi-streams/actions/workflows/ci.yml/badge.svg)](https://github.com/mathisarends/fastapi-streams/actions/workflows/ci.yml)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12%2B-blue)](pyproject.toml)
+[![MIT License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+**Decorate a FastAPI endpoint. Get typed streaming clients in TypeScript and Python.**
+
+Define your events with Pydantic and add `@router.stream()`. `fastapi-streams`
+turns that definition into an OpenAPI 3.2 stream contract and generated SDKs with
+named event values, typed async iteration, and shared SSE transport code.
+
+```text
+FastAPI decorator → OpenAPI 3.2 → shared HTTP IR → TypeScript + Python clients
+```
+
+## Why this exists
+
+An endpoint labeled `text/event-stream` does not give consumers a typed SDK.
+They still need to know which JSON events arrive, how to parse a fragmented
+stream, and how to stop it cleanly.
+
+OpenAPI 3.2 can describe each SSE event with `itemSchema` and its JSON payload
+with `contentSchema`. `fastapi-streams` connects that contract to both clients,
+so event models, endpoint parameters, and client types come from one definition.
+A CI check catches drift between the Python app, the contract, and generated code.
+
+## 1. Decorate your FastAPI endpoint
+
+Install from GitHub with the optional codegen extra:
+
+```sh
+uv add 'fastapi-streams[codegen] @ git+https://github.com/mathisarends/fastapi-streams.git'
+```
+
+Save this as `app.py`:
+
+```python
+from collections.abc import AsyncIterator
+from typing import Annotated, Literal
+
+from fastapi import FastAPI
+from pydantic import BaseModel, Field
+
+from fastapi_streams import StreamRouter
+
+
+class TokenDelta(BaseModel):
+    type: Literal["token.delta"]
+    text: str
+
+
+class RunCompleted(BaseModel):
+    type: Literal["run.completed"]
+    run_id: str
+
+
+type RunEvent = Annotated[TokenDelta | RunCompleted, Field(discriminator="type")]
+
+router = StreamRouter(prefix="/runs", tags=["agentRuns"])
+
+
+@router.stream("/{run_id}/events", operation_id="stream_run_events")
+async def stream_run_events(run_id: str) -> AsyncIterator[RunEvent]:
+    yield TokenDelta(type="token.delta", text="Hello")
+    yield RunCompleted(type="run.completed", run_id=run_id)
+
+
+app = FastAPI()
+app.include_router(router, prefix="/v1")
+```
+
+The result is `GET /v1/runs/{run_id}/events`. `StreamRouter` extends `APIRouter`:
+normal `Depends`, security dependencies, validation, middleware, and nested
+routers keep working. FastAPI handles SSE framing, serialization, and heartbeats.
+Use `methods=["POST"]` for request-body-driven streams.
+
+## 2. Export once, generate both clients
+
+```sh
+uv run fastapi-streams schema \
+  --app app:app --output openapi.json
+
+uv run fastapi-streams generate \
+  --schema openapi.json --language typescript --output generated/typescript
+
+uv run fastapi-streams generate \
+  --schema openapi.json --language python --output generated/python
+```
+
+These commands import the app and read its contract; no running server is needed.
+The exporter validates OpenAPI 3.2 and the event schemas. Both generators consume
+one HTTP intermediate representation (IR), carrying operations, parameters, and
+event types into the generated SDKs.
+
+## 3. Consume typed events
+
+The `RunEvent` union produces `RunEventType`, with the same named values in both
+languages. The discriminator narrows each event to its matching model.
+
+**TypeScript — Fetch, `AsyncIterable<RunEvent>`, no runtime dependencies:**
+
+```typescript
+import { createClient, RunEventType } from "./generated/typescript/index.js";
+
+const client = createClient({ baseUrl: "http://localhost:8000" });
+
+for await (const event of client.agentRuns.streamRunEvents({ runId: "demo" })) {
+  switch (event.type) {
+    case RunEventType.TOKEN_DELTA:
+      console.log(event.text); // TokenDelta
+      break;
+    case RunEventType.RUN_COMPLETED:
+      console.log(event.run_id); // RunCompleted
+      break;
+    default: {
+      const exhaustive: never = event;
+      throw new Error(`Unexpected event: ${exhaustive}`);
+    }
+  }
+}
+```
+
+**Python — HTTPX, Pydantic models, and `StrEnum` values:**
+
+```python
+import asyncio
+from typing import assert_never
+
+from generated.python import Client, RunEventType
+
+
+async def main() -> None:
+    async with Client("http://localhost:8000") as client:
+        async for event in client.agent_runs.stream_run_events(run_id="demo"):
+            match event.type:
+                case RunEventType.TOKEN_DELTA:
+                    print(event.text)
+                case RunEventType.RUN_COMPLETED:
+                    print(event.run_id)
+                case _:
+                    assert_never(event)
+
+
+asyncio.run(main())
+```
+
+Install `httpx` and `pydantic` in a Python consumer (`uv add httpx pydantic`).
+HTTPX remains the default; opt in to HTTPX2 at generation time with
+`--python-http-client httpx2` and install `httpx2` instead. See
+[Python HTTP library selection](docs/clients.md#python-http-library).
+Both SDKs handle fragmented SSE frames, UTF-8 decoding, HTTP errors, and resource
+cleanup. TypeScript supports `AbortSignal`; Python supports task cancellation and
+explicit async-generator closure. See [client usage](docs/clients.md).
+
+## 4. Catch contract drift in CI
+
+Commit the exported schema and generated clients. Then check the complete chain:
+
+```sh
+uv run fastapi-streams check \
+  --app app:app --schema openapi.json \
+  --language typescript --output generated/typescript
+
+uv run fastapi-streams check \
+  --app app:app --schema openapi.json \
+  --language python --output generated/python
+```
+
+`check` fails if the app's contract changed or generated files are stale. It
+writes nothing and needs no running server. Pair it with TypeScript's compiler
+and Pyright to catch invalid parameters and event access in consumer code.
+
+| Check | What it verifies |
+| --- | --- |
+| Contract validation | OpenAPI structure, JSON Schemas, and local references. |
+| `fastapi-streams check` | App → committed contract → generated client consistency. |
+| TypeScript / Pyright | Parameter types, event fields, and exhaustive narrowing. |
+
+[Codegen and CI reference →](docs/codegen.md)
+
+## Run the complete example
+
+```sh
+git clone https://github.com/mathisarends/fastapi-streams.git
+cd fastapi-streams
+uv sync --all-extras
+npm ci
+uv run uvicorn examples.agent_runs:app --reload
+```
+
+In another terminal:
+
+```sh
+# TypeScript
+npx tsc -p tests/typescript/tsconfig.json
+node tests/typescript/dist/examples/agent_runs/consume.js
+
+# Python
+uv run python -m examples.agent_runs.consume
+```
+
+The example includes GET and authenticated POST streams, both generated SDKs,
+and committed OpenAPI regression fixtures in `tests/fixtures/`. Verify all generated artifacts with
+`uv run python scripts/codegen.py --check`.
+
+## Documentation
+
+| Guide | Topics |
+| --- | --- |
+| [Quickstart](docs/quickstart.md) | Setup, event models, and FastAPI integration. |
+| [Contracts and codegen](docs/codegen.md) | OpenAPI 3.2, both generators, and drift checks. |
+| [Client usage](docs/clients.md) | Enums, authentication, cancellation, and errors. |
+| [Architecture](docs/architecture.md) | Native SSE, shared IR, templates, and transports. |
+| [Development](docs/development.md) | Tests, supported scope, and roadmap. |
+
+v0.0.1 supports GET/POST JSON SSE streams. Ordinary REST endpoints stay in the
+contract for your existing REST SDK. See the [supported scope](docs/development.md#supported-scope-and-roadmap).
+
+Python 3.12+ · FastAPI 0.143.3+ · Pydantic v2 · [MIT](LICENSE)

fastapi_streams-0.0.1.dist-info/RECORD

@@ -0,0 +1,28 @@
+fastapi_streams/__init__.py,sha256=Cx2hFW54h2SV9F8cNGqb_tEgpxBKn0wGx-Gi46q9Zq8,98
+fastapi_streams/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_streams/router.py,sha256=u9rq1KTJhJpDpngPi-51Fh4ej_CggisgqGfYvMXYhaY,5011
+fastapi_streams/codegen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fastapi_streams/codegen/cli.py,sha256=Zj6bxudZnRV6lej3lAoG6PiHqldhOlisgBCUNTT6HDk,4926
+fastapi_streams/codegen/enums.py,sha256=Fw-eUyvYGm-R6_2siYFmZRfsv0akE5yOXLQKe1vcqIE,6804
+fastapi_streams/codegen/ir.py,sha256=MCUtejThPhmGzWmAD-pbUFfO_DHkLCXihD8NJNTezdY,18297
+fastapi_streams/codegen/names.py,sha256=hApsdr0RFjlaT6ufoZakVlajMVDDityoBvq47a59MbU,1765
+fastapi_streams/codegen/openapi.py,sha256=Y9JLKHySX2QYH7Mk5OC0PcYDWMlbPEbsUtgj9fSP_pE,5797
+fastapi_streams/codegen/python.py,sha256=IMsazyN1nzSVAL7haz99c5zy2kjcXqe0epLOO2OjlYI,20170
+fastapi_streams/codegen/templating.py,sha256=g5tVd4ch-kEnitpzTwo_Rsc5BFe9x51ZCWXJ0Qkx68Q,562
+fastapi_streams/codegen/typescript.py,sha256=11aMysC13bVz3ruvSpH-sDuxKC6upEBRAE-ziwV5LRk,8071
+fastapi_streams/codegen/writer.py,sha256=2C1z4VzP67WKEX0XuUUNQIA8cGl2tH2rNNNnY4iSAfI,2560
+fastapi_streams/codegen/schemas/LICENSE,sha256=SUg2fGXhzgZpDiytxuhvzhpqbbVe-HTOS3jA9HLOXxM,11345
+fastapi_streams/codegen/schemas/README.md,sha256=v-U902pyRk_S_qG8clMC2rhBMZl19jCyRXKBbx1EwyM,399
+fastapi_streams/codegen/schemas/openapi-3.2.json,sha256=7FPbbhFLdo_y0nOyMr2iEPUbcMXlfVesja9-hJam4HM,41089
+fastapi_streams/codegen/templates/errors.ts,sha256=a7EVMCMpt4yXNciBegOWffeIlxAdBW4g-xFpzNFwtPE,690
+fastapi_streams/codegen/templates/sse.ts,sha256=v3CikQUUu9YB3W7FFZw9xwm_ZHjo4G1CluYZIL5vgQA,7996
+fastapi_streams/codegen/templates/python/api.py.j2,sha256=06IekC4WwAhvFqk5K4c9M10c085UQZJ25tiwbBPcQkk,2083
+fastapi_streams/codegen/templates/python/client.py.j2,sha256=M2TwtO_L-myMxQJL2d-4nPnfNmrXi3fgxwMFlZ_9inU,1045
+fastapi_streams/codegen/templates/python/runtime.py,sha256=lA6s-eII8cm1Lat0CY5QMLqAxN3xzPfedAALCwi5JFk,7013
+fastapi_streams/codegen/templates/typescript/api.ts.j2,sha256=IpYFDpS2KQBGRYwm6n9fJQpKb0DeS4eCFo0xmse-L9Y,2031
+fastapi_streams/codegen/templates/typescript/client.ts.j2,sha256=G85wKsfcZjRtKC84JrK4hPmh-gpzgFB2bFG6fI-Air4,432
+fastapi_streams-0.0.1.dist-info/METADATA,sha256=BSvnCR0QuxtQSrXkZKpxH5OVFffnHiNRPHp61ZMB6gM,8279
+fastapi_streams-0.0.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+fastapi_streams-0.0.1.dist-info/entry_points.txt,sha256=fnJJEzaZB-8o3hjMMa-oww9fzN_xFi0CTHRaGmZIchU,69
+fastapi_streams-0.0.1.dist-info/licenses/LICENSE,sha256=H0UaMIIkGhEKOyOZdL2EJFxiMJw3mhtXvQ7ZgrYn-Y8,1070
+fastapi_streams-0.0.1.dist-info/RECORD,,

fastapi_streams-0.0.1.dist-info/WHEEL

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