takibiapi 0.1.0__tar.gz → 0.2.0__tar.gz

{takibiapi-0.1.0 → takibiapi-0.2.0}/Cargo.toml

@@ -1,17 +1,16 @@
-# Cargo workspace. The Rust extension crate lives next to its pyproject.toml in pypi/takibiapi,
+# Cargo workspace. The Rust extension crate lives next to its pyproject.toml in packages/takibiapi,
 # so that directory is both a uv and a Cargo workspace member. The crate has no version of its own:
-# maturin takes the package version from pyproject.toml. Bazel reads this workspace and Cargo.lock
-# too (MODULE.bazel), so the crates are pinned once. The lint levels are crate attributes in
-# pypi/takibiapi/src/lib.rs, where both build systems see them.
+# maturin takes the package version from pyproject.toml. The lint levels are crate attributes in
+# packages/takibiapi/src/lib.rs.
 [workspace]
 resolver = "2"
-members = ["pypi/takibiapi"]
+members = ["packages/takibiapi"]
 
 [workspace.package]
 edition = "2021"
 rust-version = "1.83"
 license = "MIT"
-repository = "https://github.com/nakita628/takibi"
+repository = "https://github.com/nakita628/takibiapi"
 
 [workspace.dependencies]
 pyo3 = "0.29"

{takibiapi-0.1.0 → takibiapi-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: takibiapi
-Version: 0.1.0
+Version: 0.2.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
@@ -18,8 +18,9 @@ Author: nakita628
 License-Expression: MIT
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-Project-URL: Issues, https://github.com/nakita628/takibi/issues
-Project-URL: Repository, https://github.com/nakita628/takibi
+Project-URL: Funding, https://github.com/sponsors/nakita628
+Project-URL: Issues, https://github.com/nakita628/takibiapi/issues
+Project-URL: Repository, https://github.com/nakita628/takibiapi
 
 # TakibiAPI
 
@@ -72,6 +73,19 @@ curl localhost:8000/takibi           # {"message":"takibi🔥"}
 
 A route is a class made with `createRoute`, and its handler takes `c: Context[thatRoute]`. `app.openapi(route, handler)` raises `TypeError` for anything else, and the type checker sees the route's types: `c.req.valid(...)` is the declared request type and `c.json(...)` takes only the declared responses.
 
+The response's status is typed too. `c.json`, `c.text` and `c.body` take only a status the route declares (200 when none is given, so a route without 200 must name its status), and the handler must return what they build (a `TypedResponse`):
+
+```python
+"responses": {201: {...Todo}, 404: {...Problem}}
+
+return c.json(Todo(...), 201)      # ok
+return c.json(Todo(...), 200)      # type error: 200 is not declared
+return c.body(status=204)          # type error: nor 204
+return Response(b"...")            # type error at app.openapi: not a declared response
+```
+
+A `"default"` response allows any status. The statuses are inferred from the literal keys, so annotate shared responses with theirs: `errors: Mapping[Literal[400, 404], ResponseConfig[Problem]]`, spread as `{**errors, 200: ...}` (a `dict[int, ...]` is a type error). Which body goes with which status is not checked: `c.json(Todo(...), 404)` passes when both are declared.
+
 ## Requests
 
 The request parts in `request` (`params`, `query`, `headers`, `cookies`, a JSON `body`) are checked against their **types** before the handler runs and read with `c.req.valid("param" | "query" | "header" | "cookie" | "json")`:
@@ -144,9 +158,9 @@ def getProfileRouteHandler(c: Context[getProfileRoute]):
 
 ## Development
 
-From the repository root: `bazel test //pypi/takibiapi:test` runs this package's tests (on both the Rust engine and the pure-Python reference); `uv sync` builds the extension into the virtualenv for the editor. See the root README.
+From the repository root: `uv sync` builds the extension into the virtualenv, and `uv run pytest packages/takibiapi` runs this package's tests (on both the Rust engine and the pure-Python reference). See the root README.
 
 ## License
 
-Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/takibi/blob/main/pypi/takibiapi/LICENSE) for more information.
+Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/takibiapi/blob/main/packages/takibiapi/LICENSE) for more information.
 

{takibiapi-0.1.0 → takibiapi-0.2.0}/README.md

@@ -49,6 +49,19 @@ curl localhost:8000/takibi           # {"message":"takibi🔥"}
 
 A route is a class made with `createRoute`, and its handler takes `c: Context[thatRoute]`. `app.openapi(route, handler)` raises `TypeError` for anything else, and the type checker sees the route's types: `c.req.valid(...)` is the declared request type and `c.json(...)` takes only the declared responses.
 
+The response's status is typed too. `c.json`, `c.text` and `c.body` take only a status the route declares (200 when none is given, so a route without 200 must name its status), and the handler must return what they build (a `TypedResponse`):
+
+```python
+"responses": {201: {...Todo}, 404: {...Problem}}
+
+return c.json(Todo(...), 201)      # ok
+return c.json(Todo(...), 200)      # type error: 200 is not declared
+return c.body(status=204)          # type error: nor 204
+return Response(b"...")            # type error at app.openapi: not a declared response
+```
+
+A `"default"` response allows any status. The statuses are inferred from the literal keys, so annotate shared responses with theirs: `errors: Mapping[Literal[400, 404], ResponseConfig[Problem]]`, spread as `{**errors, 200: ...}` (a `dict[int, ...]` is a type error). Which body goes with which status is not checked: `c.json(Todo(...), 404)` passes when both are declared.
+
 ## Requests
 
 The request parts in `request` (`params`, `query`, `headers`, `cookies`, a JSON `body`) are checked against their **types** before the handler runs and read with `c.req.valid("param" | "query" | "header" | "cookie" | "json")`:
@@ -121,8 +134,8 @@ def getProfileRouteHandler(c: Context[getProfileRoute]):
 
 ## Development
 
-From the repository root: `bazel test //pypi/takibiapi:test` runs this package's tests (on both the Rust engine and the pure-Python reference); `uv sync` builds the extension into the virtualenv for the editor. See the root README.
+From the repository root: `uv sync` builds the extension into the virtualenv, and `uv run pytest packages/takibiapi` runs this package's tests (on both the Rust engine and the pure-Python reference). See the root README.
 
 ## License
 
-Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/takibi/blob/main/pypi/takibiapi/LICENSE) for more information.
+Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/takibiapi/blob/main/packages/takibiapi/LICENSE) for more information.

takibiapi-0.2.0/packages/takibiapi/CHANGELOG.md

@@ -0,0 +1,21 @@
+# takibiapi
+
+## 0.2.0
+
+### Minor Changes
+
+- Typed response statuses: `c.json`, `c.text` and `c.body` take only a status the route declares (200 when none is given; any status when the route declares `"default"`), and a handler registered with `app.openapi` must return what they build, a `TypedResponse`. A `Response` built by hand, or a status the route does not declare, is a type error
+- **Breaking (types only)**: the statuses are inferred from the literal keys of `responses`, so a status passed as an `int` variable, or shared responses typed `dict[int, ResponseConfig[...]]`, are type errors; annotate them with their codes, `Mapping[Literal[400, 404], ResponseConfig[Problem]]`. `Route` takes a sixth type parameter, the statuses. Nothing changes at run time
+- Export `StatusCode` and `TypedResponse`
+
+## 0.1.1
+
+### Patch Changes
+
+- Move to the takibiapi repository (https://github.com/nakita628/takibiapi); the project URLs point there
+
+## 0.1.0
+
+### Minor Changes
+
+- Initial release

{takibiapi-0.1.0/pypi → takibiapi-0.2.0/packages}/takibiapi/README.md

@@ -49,6 +49,19 @@ curl localhost:8000/takibi           # {"message":"takibi🔥"}
 
 A route is a class made with `createRoute`, and its handler takes `c: Context[thatRoute]`. `app.openapi(route, handler)` raises `TypeError` for anything else, and the type checker sees the route's types: `c.req.valid(...)` is the declared request type and `c.json(...)` takes only the declared responses.
 
+The response's status is typed too. `c.json`, `c.text` and `c.body` take only a status the route declares (200 when none is given, so a route without 200 must name its status), and the handler must return what they build (a `TypedResponse`):
+
+```python
+"responses": {201: {...Todo}, 404: {...Problem}}
+
+return c.json(Todo(...), 201)      # ok
+return c.json(Todo(...), 200)      # type error: 200 is not declared
+return c.body(status=204)          # type error: nor 204
+return Response(b"...")            # type error at app.openapi: not a declared response
+```
+
+A `"default"` response allows any status. The statuses are inferred from the literal keys, so annotate shared responses with theirs: `errors: Mapping[Literal[400, 404], ResponseConfig[Problem]]`, spread as `{**errors, 200: ...}` (a `dict[int, ...]` is a type error). Which body goes with which status is not checked: `c.json(Todo(...), 404)` passes when both are declared.
+
 ## Requests
 
 The request parts in `request` (`params`, `query`, `headers`, `cookies`, a JSON `body`) are checked against their **types** before the handler runs and read with `c.req.valid("param" | "query" | "header" | "cookie" | "json")`:
@@ -121,8 +134,8 @@ def getProfileRouteHandler(c: Context[getProfileRoute]):
 
 ## Development
 
-From the repository root: `bazel test //pypi/takibiapi:test` runs this package's tests (on both the Rust engine and the pure-Python reference); `uv sync` builds the extension into the virtualenv for the editor. See the root README.
+From the repository root: `uv sync` builds the extension into the virtualenv, and `uv run pytest packages/takibiapi` runs this package's tests (on both the Rust engine and the pure-Python reference). See the root README.
 
 ## License
 
-Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/takibi/blob/main/pypi/takibiapi/LICENSE) for more information.
+Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/takibiapi/blob/main/packages/takibiapi/LICENSE) for more information.

{takibiapi-0.1.0/pypi → takibiapi-0.2.0/packages}/takibiapi/src/lib.rs

@@ -2,8 +2,7 @@
 //! parsing in Rust, with exactly the results of ``takibiapi.schema``'s Python checker and of Python's
 //! ``json`` and ``urllib.parse`` (input it cannot match is left to them: ``None``).
 
-// Lint levels live here rather than in Cargo.toml so that cargo and Bazel (rules_rust's clippy
-// aspect, which does not read Cargo manifests) apply the same set.
+// Lint levels live here rather than in Cargo.toml, next to the code they apply to.
 #![warn(missing_debug_implementations, unused_qualifications)]
 #![warn(clippy::all, clippy::pedantic)]
 #![warn(

takibiapi-0.2.0/packages/takibiapi/tests/typing/routes.py

@@ -0,0 +1,177 @@
+# pyright: reportUnnecessaryTypeIgnoreComment=true
+"""Static types of routes and handlers (checked by pyright; see typing_test.py)."""
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Literal, TypedDict, reveal_type
+
+from takibiapi import Context, Response, ResponseConfig, TakibiAPI, TypedResponse, createRoute
+
+
+class TodoParams(TypedDict):
+    todoId: int
+
+
+class Search(TypedDict):
+    q: str
+
+
+@dataclass
+class NewTodo:
+    title: str
+
+
+@dataclass
+class Todo:
+    id: int
+    title: str
+
+
+@dataclass
+class Problem:
+    detail: str
+
+
+@dataclass
+class Other:
+    x: int
+
+
+class putTodoRoute(
+    createRoute(
+        {
+            "method": "put",
+            "path": "/todos/{todoId}",
+            "request": {
+                "params": TodoParams,
+                "query": Search,
+                "body": {"content": {"application/json": {"schema": NewTodo}}},
+            },
+            "responses": {
+                200: {"description": "ok", "content": {"application/json": {"schema": Todo}}},
+                404: {"description": "missing", "content": {"application/problem+json": {"schema": Problem}}},
+            },
+        }
+    )
+):
+    """Update a todo."""
+
+
+async def putTodoRouteHandler(c: Context[putTodoRoute]):
+    body = c.req.valid("json")
+    reveal_type(body, expected_text="NewTodo")
+    reveal_type(c.req.valid("param")["todoId"], expected_text="int")
+    reveal_type(c.req.valid("query"), expected_text="Search")
+    c.req.valid("header")  # no headers type: Any
+    reveal_type(await c.req.json(), expected_text="Any")  # the raw, unchecked body
+    reveal_type(c.req.param("todoId"), expected_text="str")  # the raw text
+    reveal_type(c.req.query("q"), expected_text="str | None")
+    reveal_type(c.req.queries("tag"), expected_text="list[str]")
+    c.json(Other(x=1))  # pyright: ignore[reportArgumentType]  # not a declared response body
+    c.json({"id": 1, "title": "x"})  # pyright: ignore[reportArgumentType]  # a dict is not a Todo
+    reveal_type(c.json(Problem(detail="x"), 404), expected_text="TypedResponse")
+    c.json(Problem(detail="x"), 500)  # pyright: ignore[reportArgumentType]  # 500 is not declared
+    c.text("x", 500)  # pyright: ignore[reportArgumentType]  # nor for text
+    c.body(status=204)  # pyright: ignore[reportArgumentType]  # nor 204 without content
+    params = c.req.valid("param")
+    return c.json(Todo(id=params["todoId"], title=body.title), 200)
+
+
+class getOtherRoute(
+    createRoute(
+        {
+            "method": "get",
+            "path": "/other",
+            "responses": {200: {"description": "ok", "content": {"application/json": {"schema": list[Search]}}}},
+        }
+    )
+):
+    pass
+
+
+def getOtherRouteHandler(c: Context[getOtherRoute]):
+    c.json([{"q": "x"}])
+    c.json([{"name": "x"}])  # pyright: ignore[reportArgumentType]  # wrong TypedDict key
+    return c.json([])
+
+
+app = TakibiAPI()
+app.openapi(putTodoRoute, putTodoRouteHandler)
+app.openapi(getOtherRoute, getOtherRouteHandler)
+app.openapi(putTodoRoute, getOtherRouteHandler)  # pyright: ignore[reportArgumentType]  # another route's handler
+
+
+# -- statuses ---------------------------------------------------------------------------------- #
+
+errors: Mapping[Literal[400, 404], ResponseConfig[Problem]] = {
+    400: {"description": "bad", "content": {"application/json": {"schema": Problem}}},
+    404: {"description": "missing", "content": {"application/json": {"schema": Problem}}},
+}
+
+
+class createTodoRoute(
+    createRoute(
+        {
+            "method": "post",
+            "path": "/todos",
+            "responses": {
+                **errors,
+                201: {"description": "created", "content": {"application/json": {"schema": Todo}}},
+                204: {"description": "nothing to create"},
+            },
+        }
+    )
+):
+    pass
+
+
+def createTodoRouteHandler(c: Context[createTodoRoute]):
+    if c.req.query("dry"):
+        return c.body(status=204)
+    if c.req.query("bad"):
+        return c.json(Problem(detail="bad"), 400)
+    c.json(Todo(id=1, title="x"))  # pyright: ignore[reportArgumentType]  # 200 (the default) is not declared
+    return c.json(Todo(id=1, title="x"), 201)
+
+
+reveal_type(createTodoRouteHandler, expected_text="(c: Context[createTodoRoute]) -> TypedResponse")
+
+
+class withDefaultRoute(
+    createRoute(
+        {
+            "method": "get",
+            "path": "/default",
+            "responses": {
+                200: {"description": "ok", "content": {"application/json": {"schema": Todo}}},
+                "default": {"description": "error", "content": {"application/json": {"schema": Problem}}},
+            },
+        }
+    )
+):
+    pass
+
+
+def withDefaultRouteHandler(c: Context[withDefaultRoute]):
+    if c.req.query("x"):
+        return c.text("teapot", 418)  # "default" covers any status
+    return c.json(Problem(detail="x"), 503)
+
+
+# Keys typed `int` are not statuses (pyright reports it as either rule, depending on what it checks first).
+untyped: dict[int, ResponseConfig[Problem]] = {}
+createRoute({"method": "get", "path": "/u", "responses": {**untyped}})  # pyright: ignore[reportCallIssue, reportArgumentType]
+
+
+def returnsResponse(c: Context[getOtherRoute]) -> Response:
+    return c.json([])
+
+
+def returnsTyped(c: Context[getOtherRoute]) -> TypedResponse:
+    return c.json([])
+
+
+app.openapi(createTodoRoute, createTodoRouteHandler)
+app.openapi(withDefaultRoute, withDefaultRouteHandler)
+app.openapi(getOtherRoute, returnsTyped)
+app.openapi(getOtherRoute, returnsResponse)  # pyright: ignore[reportArgumentType]  # a plain Response is not a declared one

{takibiapi-0.1.0 → takibiapi-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "takibiapi"
-version = "0.1.0"
+version = "0.2.0"
 description = "REST APIs whose OpenAPI document, request checks and handler types come from Python's own types"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -23,8 +23,9 @@ classifiers = [
 dependencies = []
 
 [project.urls]
-Repository = "https://github.com/nakita628/takibi"
-Issues = "https://github.com/nakita628/takibi/issues"
+Repository = "https://github.com/nakita628/takibiapi"
+Issues = "https://github.com/nakita628/takibiapi/issues"
+Funding = "https://github.com/sponsors/nakita628"
 
 [build-system]
 requires = ["maturin>=1.8,<2"]
@@ -33,5 +34,5 @@ build-backend = "maturin"
 [tool.maturin]
 module-name = "takibiapi._core"
 features = ["pyo3/extension-module"]
-manifest-path = "pypi/takibiapi/Cargo.toml"
+manifest-path = "packages/takibiapi/Cargo.toml"
 python-source = "python"

{takibiapi-0.1.0 → takibiapi-0.2.0}/python/takibiapi/__init__.py

@@ -10,10 +10,10 @@ serves the OpenAPI document. Request parts are checked against their types only
 """
 
 from takibiapi.app import Fallback, FallbackHandler, FallbackMiddleware, FallbackNext, Middleware, Next, TakibiAPI
-from takibiapi.context import Context, Request, Response, ResponseValidationError, problem
+from takibiapi.context import Context, Request, Response, ResponseValidationError, TypedResponse, problem
 from takibiapi.openapi import OpenAPIConfig
 from takibiapi.problems import ValidationProblem
-from takibiapi.route import RequestConfig, ResponseConfig, Route, RouteConfig, createRoute
+from takibiapi.route import RequestConfig, ResponseConfig, Route, RouteConfig, StatusCode, createRoute
 from takibiapi.schema import ValidationError
 
 __all__ = [
@@ -32,10 +32,12 @@ __all__ = [
     "ResponseValidationError",
     "Route",
     "RouteConfig",
+    "StatusCode",
     "TakibiAPI",
+    "TypedResponse",
     "ValidationError",
     "ValidationProblem",
     "createRoute",
     "problem",
 ]
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{takibiapi-0.1.0 → takibiapi-0.2.0}/python/takibiapi/app.py

@@ -14,7 +14,7 @@ import typing
 from collections.abc import Awaitable, Callable, Mapping
 from typing import Any, Self, TypeVar, get_args, get_origin
 
-from .context import Context, MalformedJSONError, RawHeaders, Request, Response, problem
+from .context import Context, MalformedJSONError, RawHeaders, Request, Response, TypedResponse, problem
 from .openapi import OpenAPIConfig, build_document, check_config
 from .route import AnyRoute, route_class
 from .router import new_router
@@ -90,11 +90,15 @@ class TakibiAPI:
         self._documents: dict[int, bytes] = {}
 
     # -- routes ------------------------------------------------------------------------------- #
-    def openapi(self, route: type[_TR], handler: Callable[[Context[_TR]], Response | Awaitable[Response]]) -> Self:
+    def openapi(
+        self, route: type[_TR], handler: Callable[[Context[_TR]], TypedResponse | Awaitable[TypedResponse]]
+    ) -> Self:
         """Register ``route`` with its handler.
 
         The route must be declared as a class (``class getTodoRoute(createRoute({...}))``) and
         the handler must take it as ``c: Context[getTodoRoute]``; anything else is a ``TypeError``.
+        For the type checker, the handler returns what ``c.json`` / ``c.text`` / ``c.body`` build,
+        with a status the route declares.
         The request parts the route declares are checked against their types before the handler
         runs (422 when they do not match) and read with ``c.req.valid(...)``.
         """

{takibiapi-0.1.0 → takibiapi-0.2.0}/python/takibiapi/context.py

@@ -24,6 +24,7 @@ _Q = TypeVar("_Q")
 _J = TypeVar("_J")
 _H = TypeVar("_H")
 _B = TypeVar("_B")
+_S = TypeVar("_S")
 
 JSON_TYPE = "application/json"
 PROBLEM_JSON = "application/problem+json"
@@ -52,7 +53,15 @@ class Response:
         return self.body.decode()
 
     def __repr__(self) -> str:
-        return f"Response({self.status}, {self.body[:60]!r})"
+        return f"{type(self).__name__}({self.status}, {self.body[:60]!r})"
+
+
+class TypedResponse(Response):
+    """A response built by ``c.json`` / ``c.text`` / ``c.body``, whose status the type checker has
+    matched against the route's responses. A handler registered with ``app.openapi`` must return
+    one, so a ``Response`` built by hand is a type error there."""
+
+    __slots__ = ()
 
 
 def problem(status: int, title: str, detail: str, instance: str, type_: str = "about:blank", **extra: Any) -> Response:
@@ -118,13 +127,13 @@ class Request(Generic[TR]):
 
     # The checked part's type comes from the route: Route[params, query, json, headers, ...].
     @overload
-    def valid(self: Request[Route[_P, Any, Any, Any, Any]], target: Literal["param"]) -> _P: ...
+    def valid(self: Request[Route[_P, Any, Any, Any, Any, Any]], target: Literal["param"]) -> _P: ...
     @overload
-    def valid(self: Request[Route[Any, _Q, Any, Any, Any]], target: Literal["query"]) -> _Q: ...
+    def valid(self: Request[Route[Any, _Q, Any, Any, Any, Any]], target: Literal["query"]) -> _Q: ...
     @overload
-    def valid(self: Request[Route[Any, Any, _J, Any, Any]], target: Literal["json"]) -> _J: ...
+    def valid(self: Request[Route[Any, Any, _J, Any, Any, Any]], target: Literal["json"]) -> _J: ...
     @overload
-    def valid(self: Request[Route[Any, Any, Any, _H, Any]], target: Literal["header"]) -> _H: ...
+    def valid(self: Request[Route[Any, Any, Any, _H, Any, Any]], target: Literal["header"]) -> _H: ...
     @overload
     def valid(self, target: Literal["cookie"]) -> Any: ...
 
@@ -245,15 +254,30 @@ class Context(Generic[TR]):
         self._vars: dict[str, Any] | None = None
         self._responses = responses  # {status: {media type: encoder}}: checked responses
 
+    # ``value`` is one of the route's response bodies, and ``status`` one of its statuses (any status
+    # when the route declares "default"). A status left out is 200, so it must be declared too.
+    @overload
     def json(
-        self: Context[Route[Any, Any, Any, Any, _B]],
+        self: Context[Route[Any, Any, Any, Any, _B, Literal["default"]]],
         value: _B,
         status: int = 200,
         headers: Mapping[str, str] | None = None,
-    ) -> Response:
-        """A JSON response. ``value`` is typed by the route's responses (for the type checker).
-        With takibi's own schemas it is written as it is; schemas that check responses
-        (``pydantic-takibiapi``) raise :class:`ResponseValidationError` when it does not match."""
+    ) -> TypedResponse: ...
+    @overload
+    def json(
+        self: Context[Route[Any, Any, Any, Any, _B, _S]],
+        value: _B,
+        status: _S = 200,
+        headers: Mapping[str, str] | None = None,
+    ) -> TypedResponse: ...
+
+    def json(
+        self: Context[Any], value: Any, status: Any = 200, headers: Mapping[str, str] | None = None
+    ) -> TypedResponse:
+        """A JSON response. ``value`` and ``status`` are typed by the route's responses (for the
+        type checker). With takibi's own schemas it is written as it is; schemas that check
+        responses (``pydantic-takibiapi``) raise :class:`ResponseValidationError` when it does not
+        match."""
         if self._responses is not None:
             encoders = self._responses.get(status)
             if encoders:
@@ -271,11 +295,47 @@ class Context(Generic[TR]):
                     return self._respond(body, status, headers, JSON_TYPE)
         return self._respond(dumps(value), status, headers, JSON_TYPE)
 
-    def text(self, text: str, status: int = 200, headers: Mapping[str, str] | None = None) -> Response:
+    @overload
+    def text(
+        self: Context[Route[Any, Any, Any, Any, Any, Literal["default"]]],
+        text: str,
+        status: int = 200,
+        headers: Mapping[str, str] | None = None,
+    ) -> TypedResponse: ...
+    @overload
+    def text(
+        self: Context[Route[Any, Any, Any, Any, Any, _S]],
+        text: str,
+        status: _S = 200,
+        headers: Mapping[str, str] | None = None,
+    ) -> TypedResponse: ...
+
+    def text(
+        self: Context[Any], text: str, status: Any = 200, headers: Mapping[str, str] | None = None
+    ) -> TypedResponse:
+        """A ``text/plain`` response, with a status the route declares."""
         return self._respond(text.encode(), status, headers, "text/plain; charset=utf-8")
 
-    def body(self, data: bytes = b"", status: int = 200, headers: Mapping[str, str] | None = None) -> Response:
-        """Raw bytes (``c.body(status=204)`` for no content); set the content type in ``headers``."""
+    @overload
+    def body(
+        self: Context[Route[Any, Any, Any, Any, Any, Literal["default"]]],
+        data: bytes = b"",
+        status: int = 200,
+        headers: Mapping[str, str] | None = None,
+    ) -> TypedResponse: ...
+    @overload
+    def body(
+        self: Context[Route[Any, Any, Any, Any, Any, _S]],
+        data: bytes = b"",
+        status: _S = 200,
+        headers: Mapping[str, str] | None = None,
+    ) -> TypedResponse: ...
+
+    def body(
+        self: Context[Any], data: bytes = b"", status: Any = 200, headers: Mapping[str, str] | None = None
+    ) -> TypedResponse:
+        """Raw bytes (``c.body(status=204)`` for no content), with a status the route declares; set
+        the content type in ``headers``."""
         return self._respond(data, status, headers, None)
 
     def header(self, name: str, value: str | None, *, append: bool = False) -> None:
@@ -308,10 +368,10 @@ class Context(Generic[TR]):
 
     def _respond(
         self, payload: bytes, status: int, headers: Mapping[str, str] | None, content_type: str | None
-    ) -> Response:
+    ) -> TypedResponse:
         merged: dict[str, HeaderValue] = {} if content_type is None else {"content-type": content_type}
         if self._headers:
             merged.update(self._headers)
         if headers:
             merged.update({k.lower(): v for k, v in headers.items()})
-        return Response(payload, status, merged)
+        return TypedResponse(payload, status, merged)

{takibiapi-0.1.0 → takibiapi-0.2.0}/python/takibiapi/route.py

@@ -2,9 +2,10 @@
 
 The types are written to the OpenAPI document, request parts are checked against them (types
 only: ``c.req.valid(...)``), and they type the handler: ``createRoute`` returns
-``type[Route[P, Q, J, H, R]]`` (path params, query, JSON body, headers, response bodies), and a
-handler for the route takes ``c: Context[thatRoute]``, so ``c.req.valid("param")`` is ``P`` and
-``c.json(...)`` takes ``R``. Responses are not checked at run time.
+``type[Route[P, Q, J, H, R, S]]`` (path params, query, JSON body, headers, response bodies, response
+statuses), and a handler for the route takes ``c: Context[thatRoute]``, so ``c.req.valid("param")``
+is ``P``, ``c.json(...)`` takes ``R`` with a status in ``S``, and the handler must return what
+``c.json`` / ``c.text`` / ``c.body`` build. Responses are not checked at run time.
 """
 
 from __future__ import annotations
@@ -25,9 +26,27 @@ H = TypeVar("H")
 # Response bodies the route declares (a union over its ``responses``) -> ``c.json(...)``. Covariant
 # (with ReadOnly fields below) so several responses infer ``Todo | Problem``.
 R = TypeVar("R", covariant=True)
+# Response statuses the route declares: ``Literal[200, 404]`` (with ``"default"`` when declared). The
+# responses' keys are inferred as this union when they are literals of ``StatusCode``; ``Route``
+# takes it contravariantly, so ``c.json(..., status)`` accepts a status only when the route declares
+# it (and any status when the route declares ``"default"``).
+K = TypeVar("K")
+S = TypeVar("S", contravariant=True)
 
 Method = Literal["get", "post", "put", "patch", "delete", "head", "options", "trace"]
 
+# The HTTP status codes of the IANA registry (and 418). A response key outside them, or one typed
+# ``int``, is a type error: annotate shared responses with their codes,
+# ``errors: Mapping[Literal[400, 404], ResponseConfig[Problem]]``.
+StatusCode = Literal[
+    100, 101, 102, 103,
+    200, 201, 202, 203, 204, 205, 206, 207, 208, 226,
+    300, 301, 302, 303, 304, 305, 307, 308,
+    400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418,
+    421, 422, 423, 424, 425, 426, 428, 429, 431, 451,
+    500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511,
+]  # fmt: skip
+
 _T_co = TypeVar("_T_co", covariant=True)
 
 
@@ -68,18 +87,19 @@ class ResponseMediaType(TypedDict, Generic[R], total=False):
 
 
 class ResponseConfig(TypedDict, Generic[R], total=False):
-    """One entry of ``responses``. Annotate shared ones with their body type, e.g.
-    ``errors: dict[int, ResponseConfig[Problem]]``."""
+    """One entry of ``responses``. Annotate shared ones with their statuses and body type, e.g.
+    ``errors: Mapping[Literal[400, 404], ResponseConfig[Problem]]``, and spread them:
+    ``"responses": {**errors, 200: {...}}``."""
 
     description: ReadOnly[str]
     content: ReadOnly[Mapping[str, ResponseMediaType[R]]]
     headers: ReadOnly[Mapping[str, Any]]
 
 
-class _OperationConfig(TypedDict, Generic[R]):
+class _OperationConfig(TypedDict, Generic[R, K]):
     method: Method
     path: str  # "/todos/{todoId}"
-    responses: Mapping[Any, ResponseConfig[R]]  # status code (or "default") -> response
+    responses: Mapping[K, ResponseConfig[R]]  # status code (or "default") -> response
     summary: NotRequired[str]
     description: NotRequired[str]
     tags: NotRequired[list[str]]
@@ -89,7 +109,7 @@ class _OperationConfig(TypedDict, Generic[R]):
     hide: NotRequired[bool]  # served, but left out of the OpenAPI document
 
 
-class RouteConfig(_OperationConfig[R], Generic[P, Q, J, H, R]):
+class RouteConfig(_OperationConfig[R, K], Generic[P, Q, J, H, R, K]):
     request: NotRequired[RequestConfig[P, Q, J, H]]
 
 
@@ -103,7 +123,7 @@ class _RequestP(TypedDict, Generic[P]):
     cookies: NotRequired[type]
 
 
-class _RouteP(_OperationConfig[R], Generic[P, R]):
+class _RouteP(_OperationConfig[R, K], Generic[P, R, K]):
     request: _RequestP[P]
 
 
@@ -112,7 +132,7 @@ class _RequestQ(TypedDict, Generic[Q]):
     cookies: NotRequired[type]
 
 
-class _RouteQ(_OperationConfig[R], Generic[Q, R]):
+class _RouteQ(_OperationConfig[R, K], Generic[Q, R, K]):
     request: _RequestQ[Q]
 
 
@@ -121,7 +141,7 @@ class _RequestH(TypedDict, Generic[H]):
     cookies: NotRequired[type]
 
 
-class _RouteH(_OperationConfig[R], Generic[H, R]):
+class _RouteH(_OperationConfig[R, K], Generic[H, R, K]):
     request: _RequestH[H]
 
 
@@ -130,7 +150,7 @@ class _RequestB(TypedDict, Generic[J]):
     cookies: NotRequired[type]
 
 
-class _RouteB(_OperationConfig[R], Generic[J, R]):
+class _RouteB(_OperationConfig[R, K], Generic[J, R, K]):
     request: _RequestB[J]
 
 
@@ -140,7 +160,7 @@ class _RequestPQ(TypedDict, Generic[P, Q]):
     cookies: NotRequired[type]
 
 
-class _RoutePQ(_OperationConfig[R], Generic[P, Q, R]):
+class _RoutePQ(_OperationConfig[R, K], Generic[P, Q, R, K]):
     request: _RequestPQ[P, Q]
 
 
@@ -150,7 +170,7 @@ class _RequestPH(TypedDict, Generic[P, H]):
     cookies: NotRequired[type]
 
 
-class _RoutePH(_OperationConfig[R], Generic[P, H, R]):
+class _RoutePH(_OperationConfig[R, K], Generic[P, H, R, K]):
     request: _RequestPH[P, H]
 
 
@@ -160,7 +180,7 @@ class _RequestPB(TypedDict, Generic[P, J]):
     cookies: NotRequired[type]
 
 
-class _RoutePB(_OperationConfig[R], Generic[P, J, R]):
+class _RoutePB(_OperationConfig[R, K], Generic[P, J, R, K]):
     request: _RequestPB[P, J]
 
 
@@ -170,7 +190,7 @@ class _RequestQH(TypedDict, Generic[Q, H]):
     cookies: NotRequired[type]
 
 
-class _RouteQH(_OperationConfig[R], Generic[Q, H, R]):
+class _RouteQH(_OperationConfig[R, K], Generic[Q, H, R, K]):
     request: _RequestQH[Q, H]
 
 
@@ -180,7 +200,7 @@ class _RequestQB(TypedDict, Generic[Q, J]):
     cookies: NotRequired[type]
 
 
-class _RouteQB(_OperationConfig[R], Generic[Q, J, R]):
+class _RouteQB(_OperationConfig[R, K], Generic[Q, J, R, K]):
     request: _RequestQB[Q, J]
 
 
@@ -190,7 +210,7 @@ class _RequestHB(TypedDict, Generic[J, H]):
     cookies: NotRequired[type]
 
 
-class _RouteHB(_OperationConfig[R], Generic[J, H, R]):
+class _RouteHB(_OperationConfig[R, K], Generic[J, H, R, K]):
     request: _RequestHB[J, H]
 
 
@@ -201,7 +221,7 @@ class _RequestPQH(TypedDict, Generic[P, Q, H]):
     cookies: NotRequired[type]
 
 
-class _RoutePQH(_OperationConfig[R], Generic[P, Q, H, R]):
+class _RoutePQH(_OperationConfig[R, K], Generic[P, Q, H, R, K]):
     request: _RequestPQH[P, Q, H]
 
 
@@ -212,7 +232,7 @@ class _RequestPQB(TypedDict, Generic[P, Q, J]):
     cookies: NotRequired[type]
 
 
-class _RoutePQB(_OperationConfig[R], Generic[P, Q, J, R]):
+class _RoutePQB(_OperationConfig[R, K], Generic[P, Q, J, R, K]):
     request: _RequestPQB[P, Q, J]
 
 
@@ -223,7 +243,7 @@ class _RequestPHB(TypedDict, Generic[P, J, H]):
     cookies: NotRequired[type]
 
 
-class _RoutePHB(_OperationConfig[R], Generic[P, J, H, R]):
+class _RoutePHB(_OperationConfig[R, K], Generic[P, J, H, R, K]):
     request: _RequestPHB[P, J, H]
 
 
@@ -234,7 +254,7 @@ class _RequestQHB(TypedDict, Generic[Q, J, H]):
     cookies: NotRequired[type]
 
 
-class _RouteQHB(_OperationConfig[R], Generic[Q, J, H, R]):
+class _RouteQHB(_OperationConfig[R, K], Generic[Q, J, H, R, K]):
     request: _RequestQHB[Q, J, H]
 
 
@@ -246,11 +266,11 @@ class _RequestPQHB(TypedDict, Generic[P, Q, J, H]):
     cookies: NotRequired[type]
 
 
-class _RoutePQHB(_OperationConfig[R], Generic[P, Q, J, H, R]):
+class _RoutePQHB(_OperationConfig[R, K], Generic[P, Q, J, H, R, K]):
     request: _RequestPQHB[P, Q, J, H]
 
 
-class Route(Generic[P, Q, J, H, R]):
+class Route(Generic[P, Q, J, H, R, S]):
     """An operation made by :func:`createRoute`. Declare it as a class, so that handlers can name
     it::
 
@@ -279,7 +299,7 @@ class Route(Generic[P, Q, J, H, R]):
         raise TypeError("routes are classes: use the route itself (app.openapi(route, handler))")
 
 
-AnyRoute = Route[Any, Any, Any, Any, Any]
+AnyRoute = Route[Any, Any, Any, Any, Any, Any]
 
 
 def route_class(config: Mapping[str, Any], *, generated: bool = True) -> type[AnyRoute]:
@@ -294,109 +314,110 @@ _Q = TypeVar("_Q")
 _J = TypeVar("_J")
 _H = TypeVar("_H")
 _R = TypeVar("_R")
+_K = TypeVar("_K", bound=StatusCode | Literal["default"])
 
 
 @overload
-def createRoute(config: _OperationConfig[_R]) -> type[Route[Any, Any, Any, Any, _R]]: ...
+def createRoute(config: _OperationConfig[_R, _K]) -> type[Route[Any, Any, Any, Any, _R, _K]]: ...
 
 
 # A dict literal with a "request" key cannot match the overload above (TypedDicts reject extra
 # keys), although pyright's overlap check treats the shapes below as its structural subtypes.
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RouteP[_P, _R],
-) -> type[Route[_P, Any, Any, Any, _R]]: ...
+    config: _RouteP[_P, _R, _K],
+) -> type[Route[_P, Any, Any, Any, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RouteQ[_Q, _R],
-) -> type[Route[Any, _Q, Any, Any, _R]]: ...
+    config: _RouteQ[_Q, _R, _K],
+) -> type[Route[Any, _Q, Any, Any, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RouteH[_H, _R],
-) -> type[Route[Any, Any, Any, _H, _R]]: ...
+    config: _RouteH[_H, _R, _K],
+) -> type[Route[Any, Any, Any, _H, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RouteB[_J, _R],
-) -> type[Route[Any, Any, _J, Any, _R]]: ...
+    config: _RouteB[_J, _R, _K],
+) -> type[Route[Any, Any, _J, Any, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RoutePQ[_P, _Q, _R],
-) -> type[Route[_P, _Q, Any, Any, _R]]: ...
+    config: _RoutePQ[_P, _Q, _R, _K],
+) -> type[Route[_P, _Q, Any, Any, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RoutePH[_P, _H, _R],
-) -> type[Route[_P, Any, Any, _H, _R]]: ...
+    config: _RoutePH[_P, _H, _R, _K],
+) -> type[Route[_P, Any, Any, _H, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RoutePB[_P, _J, _R],
-) -> type[Route[_P, Any, _J, Any, _R]]: ...
+    config: _RoutePB[_P, _J, _R, _K],
+) -> type[Route[_P, Any, _J, Any, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RouteQH[_Q, _H, _R],
-) -> type[Route[Any, _Q, Any, _H, _R]]: ...
+    config: _RouteQH[_Q, _H, _R, _K],
+) -> type[Route[Any, _Q, Any, _H, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RouteQB[_Q, _J, _R],
-) -> type[Route[Any, _Q, _J, Any, _R]]: ...
+    config: _RouteQB[_Q, _J, _R, _K],
+) -> type[Route[Any, _Q, _J, Any, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RouteHB[_J, _H, _R],
-) -> type[Route[Any, Any, _J, _H, _R]]: ...
+    config: _RouteHB[_J, _H, _R, _K],
+) -> type[Route[Any, Any, _J, _H, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RoutePQH[_P, _Q, _H, _R],
-) -> type[Route[_P, _Q, Any, _H, _R]]: ...
+    config: _RoutePQH[_P, _Q, _H, _R, _K],
+) -> type[Route[_P, _Q, Any, _H, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RoutePQB[_P, _Q, _J, _R],
-) -> type[Route[_P, _Q, _J, Any, _R]]: ...
+    config: _RoutePQB[_P, _Q, _J, _R, _K],
+) -> type[Route[_P, _Q, _J, Any, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RoutePHB[_P, _J, _H, _R],
-) -> type[Route[_P, Any, _J, _H, _R]]: ...
+    config: _RoutePHB[_P, _J, _H, _R, _K],
+) -> type[Route[_P, Any, _J, _H, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RouteQHB[_Q, _J, _H, _R],
-) -> type[Route[Any, _Q, _J, _H, _R]]: ...
+    config: _RouteQHB[_Q, _J, _H, _R, _K],
+) -> type[Route[Any, _Q, _J, _H, _R, _K]]: ...
 
 
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: _RoutePQHB[_P, _Q, _J, _H, _R],
-) -> type[Route[_P, _Q, _J, _H, _R]]: ...
+    config: _RoutePQHB[_P, _Q, _J, _H, _R, _K],
+) -> type[Route[_P, _Q, _J, _H, _R, _K]]: ...
 
 
 # Anything else (cookies only, a dict built at run time).
 @overload
 def createRoute(  # pyright: ignore[reportOverlappingOverload]
-    config: RouteConfig[_P, _Q, _J, _H, _R],
-) -> type[Route[_P, _Q, _J, _H, _R]]: ...
+    config: RouteConfig[_P, _Q, _J, _H, _R, _K],
+) -> type[Route[_P, _Q, _J, _H, _R, _K]]: ...
 
 
 def createRoute(config: Any) -> Any:  # noqa: N802 (the conventional name)
@@ -405,4 +426,13 @@ def createRoute(config: Any) -> Any:  # noqa: N802 (the conventional name)
     return route_class(config)
 
 
-__all__ = ["AnyRoute", "RequestConfig", "ResponseConfig", "Route", "RouteConfig", "SchemaLike", "createRoute"]
+__all__ = [
+    "AnyRoute",
+    "RequestConfig",
+    "ResponseConfig",
+    "Route",
+    "RouteConfig",
+    "SchemaLike",
+    "StatusCode",
+    "createRoute",
+]

takibiapi-0.1.0/pypi/takibiapi/BUILD.bazel

@@ -1,25 +0,0 @@
-load("//tools/pytest:defs.bzl", "pytest_test")
-
-# The Rust engine's sources, built into takibiapi._core by //pypi/takibiapi/python:core.
-filegroup(
-    name = "core_srcs",
-    srcs = glob(["src/**/*.rs"]),
-    visibility = ["//pypi/takibiapi/python:__pkg__"],
-)
-
-exports_files(
-    ["src/lib.rs"],
-    visibility = ["//pypi/takibiapi/python:__pkg__"],
-)
-
-# tests/test_typing.py is not here: it shells out to pyright, which `just typecheck` runs over
-# tests/typing directly.
-pytest_test(
-    name = "test",
-    size = "small",
-    tests = glob(
-        ["tests/test_*.py"],
-        exclude = ["tests/test_typing.py"],
-    ),
-    deps = ["//pypi/takibiapi/python:takibiapi"],
-)

takibiapi-0.1.0/pypi/takibiapi/CHANGELOG.md

@@ -1,7 +0,0 @@
-# takibiapi
-
-## 0.1.0
-
-### Minor Changes
-
-- Initial release

takibiapi-0.1.0/pypi/takibiapi/python/BUILD.bazel

@@ -1,29 +0,0 @@
-load("@rules_python//python:defs.bzl", "py_library")
-load("@rules_rust_pyo3//:defs.bzl", "pyo3_extension")
-
-# takibiapi (`import takibiapi`): the framework. `imports = ["."]` makes the import resolve from
-# this directory, as when the wheel is installed.
-py_library(
-    name = "takibiapi",
-    srcs = glob(["takibiapi/*.py"]),
-    data = [
-        "takibiapi/_core.pyi",
-        "takibiapi/py.typed",
-    ],
-    imports = ["."],
-    visibility = ["//visibility:public"],
-    deps = [":core"],
-)
-
-# takibiapi._core: the Rust engine (request checks, JSON, routing), placed next to the Python
-# sources as takibiapi/_core.so. takibiapi.schema falls back to its Python checker without it.
-pyo3_extension(
-    name = "core",
-    srcs = ["//pypi/takibiapi:core_srcs"],
-    crate_name = "_core",
-    crate_root = "//pypi/takibiapi:src/lib.rs",
-    edition = "2021",
-    imports = ["."],
-    module_name = "takibiapi._core",
-    stubs = False,
-)

takibiapi-0.1.0/pypi/takibiapi/tests/typing/routes.py

@@ -1,97 +0,0 @@
-# pyright: reportUnnecessaryTypeIgnoreComment=true
-"""Static types of routes and handlers (checked by pyright; see typing_test.py)."""
-
-from dataclasses import dataclass
-from typing import TypedDict, reveal_type
-
-from takibiapi import Context, TakibiAPI, createRoute
-
-
-class TodoParams(TypedDict):
-    todoId: int
-
-
-class Search(TypedDict):
-    q: str
-
-
-@dataclass
-class NewTodo:
-    title: str
-
-
-@dataclass
-class Todo:
-    id: int
-    title: str
-
-
-@dataclass
-class Problem:
-    detail: str
-
-
-@dataclass
-class Other:
-    x: int
-
-
-class putTodoRoute(
-    createRoute(
-        {
-            "method": "put",
-            "path": "/todos/{todoId}",
-            "request": {
-                "params": TodoParams,
-                "query": Search,
-                "body": {"content": {"application/json": {"schema": NewTodo}}},
-            },
-            "responses": {
-                200: {"description": "ok", "content": {"application/json": {"schema": Todo}}},
-                404: {"description": "missing", "content": {"application/problem+json": {"schema": Problem}}},
-            },
-        }
-    )
-):
-    """Update a todo."""
-
-
-async def putTodoRouteHandler(c: Context[putTodoRoute]):
-    body = c.req.valid("json")
-    reveal_type(body, expected_text="NewTodo")
-    reveal_type(c.req.valid("param")["todoId"], expected_text="int")
-    reveal_type(c.req.valid("query"), expected_text="Search")
-    c.req.valid("header")  # no headers type: Any
-    reveal_type(await c.req.json(), expected_text="Any")  # the raw, unchecked body
-    reveal_type(c.req.param("todoId"), expected_text="str")  # the raw text
-    reveal_type(c.req.query("q"), expected_text="str | None")
-    reveal_type(c.req.queries("tag"), expected_text="list[str]")
-    c.json(Other(x=1))  # pyright: ignore[reportArgumentType]  # not a declared response body
-    c.json({"id": 1, "title": "x"})  # pyright: ignore[reportArgumentType]  # a dict is not a Todo
-    c.json(Problem(detail="x"), 404)
-    params = c.req.valid("param")
-    return c.json(Todo(id=params["todoId"], title=body.title), 200)
-
-
-class getOtherRoute(
-    createRoute(
-        {
-            "method": "get",
-            "path": "/other",
-            "responses": {200: {"description": "ok", "content": {"application/json": {"schema": list[Search]}}}},
-        }
-    )
-):
-    pass
-
-
-def getOtherRouteHandler(c: Context[getOtherRoute]):
-    c.json([{"q": "x"}])
-    c.json([{"name": "x"}])  # pyright: ignore[reportArgumentType]  # wrong TypedDict key
-    return c.json([])
-
-
-app = TakibiAPI()
-app.openapi(putTodoRoute, putTodoRouteHandler)
-app.openapi(getOtherRoute, getOtherRouteHandler)
-app.openapi(putTodoRoute, getOtherRouteHandler)  # pyright: ignore[reportArgumentType]  # another route's handler