pydantic-takibiapi 0.1.0__tar.gz

pydantic_takibiapi-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 - present, pydantic-takibiapi Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pydantic_takibiapi-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: pydantic-takibiapi
+Version: 0.1.0
+Summary: takibiapi with pydantic models as the schemas, checked strictly
+Keywords: openapi,asgi,pydantic,rest,api,validation
+Author: nakita628
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Typing :: Typed
+Requires-Dist: takibiapi>=0.1.0,<0.2
+Requires-Dist: pydantic>=2.11
+Requires-Python: >=3.12
+Project-URL: Repository, https://github.com/nakita628/takibi
+Project-URL: Issues, https://github.com/nakita628/takibi/issues
+Description-Content-Type: text/markdown
+
+# pydantic-takibiapi
+
+[TakibiAPI](../takibiapi) with [pydantic](https://pydantic.dev/) models as the schemas, checked strictly: constraints, unknown keys and responses included.
+
+```sh
+pip install pydantic-takibiapi
+```
+
+## Quick start
+
+```python
+from pydantic_takibiapi import Context, Model, TakibiAPI, createRoute
+
+
+class Message(Model):
+    message: str
+
+
+class getTakibiRoute(
+    createRoute(
+        {
+            "method": "get",
+            "path": "/takibi",
+            "responses": {200: {"description": "takibi🔥", "content": {"application/json": {"schema": Message}}}},
+        }
+    )
+):
+    """Say takibi🔥."""
+
+
+def getTakibiRouteHandler(c: Context[getTakibiRoute]):
+    return c.json(Message(message="takibi🔥"))
+
+
+app = TakibiAPI()
+app.openapi(getTakibiRoute, getTakibiRouteHandler)
+app.doc("/doc", {"openapi": "3.1.0", "info": {"title": "takibi API", "version": "1.0.0"}})
+```
+
+```bash
+granian --interface rsgi myapp:app   # or: uvicorn myapp:app
+curl localhost:8000/takibi           # {"message":"takibi🔥"}
+```
+
+Import `TakibiAPI` from `pydantic_takibiapi`; everything else works as in Takibi.
+
+## Models
+
+Every model, nested ones included, must be strict: subclass `Model` (a `BaseModel` with `strict=True, extra="forbid"`). `app.openapi` raises `TypeError` otherwise. `Field` constraints, aliases and validators work as in pydantic.
+
+## Checks
+
+- **Requests**: `c.req.valid(...)` gives a checked model instance. Path, query, header and cookie text is converted (`"7"` → `7`); JSON bodies are strict (`"1"` is not an `int`) and reject unknown keys. A failure gets **422** with pydantic's error types as `code`.
+- **Responses**: `c.json(value, status)` checks `value` against the model declared for that status. A mismatch raises `ResponseValidationError` and answers **500** (details in the log, not in the response).
+
+```python
+app.onError(lambda c: c.json({"error": str(c.error)}, 500))  # replaces the 500, ResponseValidationError included
+```
+
+## OpenAPI
+
+Schemas come from pydantic's JSON Schema; every model is a component (`Name-Input` / `Name-Output` when reading and writing differ). `"3.0.x"` documents are converted from it.
+
+## Development
+
+From the repository root: `bazel test //pypi/pydantic-takibiapi:test`. See the root README.
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/takibi/blob/main/pypi/pydantic-takibiapi/LICENSE) for more information.

pydantic_takibiapi-0.1.0/README.md

@@ -0,0 +1,70 @@
+# pydantic-takibiapi
+
+[TakibiAPI](../takibiapi) with [pydantic](https://pydantic.dev/) models as the schemas, checked strictly: constraints, unknown keys and responses included.
+
+```sh
+pip install pydantic-takibiapi
+```
+
+## Quick start
+
+```python
+from pydantic_takibiapi import Context, Model, TakibiAPI, createRoute
+
+
+class Message(Model):
+    message: str
+
+
+class getTakibiRoute(
+    createRoute(
+        {
+            "method": "get",
+            "path": "/takibi",
+            "responses": {200: {"description": "takibi🔥", "content": {"application/json": {"schema": Message}}}},
+        }
+    )
+):
+    """Say takibi🔥."""
+
+
+def getTakibiRouteHandler(c: Context[getTakibiRoute]):
+    return c.json(Message(message="takibi🔥"))
+
+
+app = TakibiAPI()
+app.openapi(getTakibiRoute, getTakibiRouteHandler)
+app.doc("/doc", {"openapi": "3.1.0", "info": {"title": "takibi API", "version": "1.0.0"}})
+```
+
+```bash
+granian --interface rsgi myapp:app   # or: uvicorn myapp:app
+curl localhost:8000/takibi           # {"message":"takibi🔥"}
+```
+
+Import `TakibiAPI` from `pydantic_takibiapi`; everything else works as in Takibi.
+
+## Models
+
+Every model, nested ones included, must be strict: subclass `Model` (a `BaseModel` with `strict=True, extra="forbid"`). `app.openapi` raises `TypeError` otherwise. `Field` constraints, aliases and validators work as in pydantic.
+
+## Checks
+
+- **Requests**: `c.req.valid(...)` gives a checked model instance. Path, query, header and cookie text is converted (`"7"` → `7`); JSON bodies are strict (`"1"` is not an `int`) and reject unknown keys. A failure gets **422** with pydantic's error types as `code`.
+- **Responses**: `c.json(value, status)` checks `value` against the model declared for that status. A mismatch raises `ResponseValidationError` and answers **500** (details in the log, not in the response).
+
+```python
+app.onError(lambda c: c.json({"error": str(c.error)}, 500))  # replaces the 500, ResponseValidationError included
+```
+
+## OpenAPI
+
+Schemas come from pydantic's JSON Schema; every model is a component (`Name-Input` / `Name-Output` when reading and writing differ). `"3.0.x"` documents are converted from it.
+
+## Development
+
+From the repository root: `bazel test //pypi/pydantic-takibiapi:test`. See the root README.
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/nakita628/takibi/blob/main/pypi/pydantic-takibiapi/LICENSE) for more information.

pydantic_takibiapi-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[project]
+name = "pydantic-takibiapi"
+version = "0.1.0"
+description = "takibiapi with pydantic models as the schemas, checked strictly"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+    "openapi",
+    "asgi",
+    "pydantic",
+    "rest",
+    "api",
+    "validation",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    "Typing :: Typed",
+]
+dependencies = [
+    "takibiapi>=0.1.0,<0.2",
+    "pydantic>=2.11",
+]
+
+[[project.authors]]
+name = "nakita628"
+
+[project.urls]
+Repository = "https://github.com/nakita628/takibi"
+Issues = "https://github.com/nakita628/takibi/issues"
+
+[build-system]
+requires = ["uv_build>=0.8,<0.14"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = "python"
+module-name = "pydantic_takibiapi"
+
+[tool.uv.sources.takibiapi]
+workspace = true

pydantic_takibiapi-0.1.0/pyproject.toml.orig

@@ -0,0 +1,37 @@
+[project]
+name = "pydantic-takibiapi"
+version = "0.1.0"
+description = "takibiapi with pydantic models as the schemas, checked strictly"
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "nakita628" }]
+keywords = ["openapi", "asgi", "pydantic", "rest", "api", "validation"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    "Typing :: Typed",
+]
+dependencies = ["takibiapi>=0.1.0,<0.2", "pydantic>=2.11"]
+
+[project.urls]
+Repository = "https://github.com/nakita628/takibi"
+Issues = "https://github.com/nakita628/takibi/issues"
+
+[build-system]
+requires = ["uv_build>=0.8,<0.14"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = "python"
+module-name = "pydantic_takibiapi"
+
+[tool.uv.sources]
+takibiapi = { workspace = true }

pydantic_takibiapi-0.1.0/python/pydantic_takibiapi/__init__.py

@@ -0,0 +1,52 @@
+"""pydantic-takibiapi: takibi with pydantic models as the schemas, checked strictly.
+
+    from pydantic_takibiapi import Context, Model, Response, TakibiAPI, createRoute
+
+Schemas are :class:`Model` subclasses (pydantic models with ``strict=True`` and
+``extra="forbid"``). Requests are checked with pydantic before the handler runs, ``Field``
+constraints included; responses are checked against the declared model; the OpenAPI document
+comes from pydantic's JSON Schema.
+"""
+
+from pydantic_takibiapi.app import TakibiAPI
+from pydantic_takibiapi.model import Model, ValidationErrorItem, ValidationProblem
+from pydantic_takibiapi.schemas import PydanticSchemas
+from takibiapi import (
+    Context,
+    Middleware,
+    Next,
+    OpenAPIConfig,
+    Request,
+    RequestConfig,
+    Response,
+    ResponseConfig,
+    ResponseValidationError,
+    Route,
+    RouteConfig,
+    ValidationError,
+    createRoute,
+    problem,
+)
+
+__all__ = [
+    "Context",
+    "Middleware",
+    "Model",
+    "Next",
+    "OpenAPIConfig",
+    "PydanticSchemas",
+    "Request",
+    "RequestConfig",
+    "Response",
+    "ResponseConfig",
+    "ResponseValidationError",
+    "Route",
+    "RouteConfig",
+    "TakibiAPI",
+    "ValidationError",
+    "ValidationErrorItem",
+    "ValidationProblem",
+    "createRoute",
+    "problem",
+]
+__version__ = "0.1.0"

pydantic_takibiapi-0.1.0/python/pydantic_takibiapi/app.py

@@ -0,0 +1,22 @@
+"""``TakibiAPI``: takibi with pydantic models as its schemas."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import takibiapi
+
+from .schemas import PydanticSchemas
+
+
+class TakibiAPI(takibiapi.TakibiAPI):
+    """``takibiapi.TakibiAPI`` whose routes are described with pydantic models (``Model``): requests
+    are checked with pydantic, constraints included, before the handler runs (422 when they do
+    not match), and ``c.json(...)`` checks the response against the declared model (500 when the
+    handler breaks its own contract). Everything else (routing, middleware, ASGI / RSGI, the
+    OpenAPI document) is takibi's."""
+
+    schemas: Any = PydanticSchemas()
+
+
+__all__ = ["TakibiAPI"]

pydantic_takibiapi-0.1.0/python/pydantic_takibiapi/model.py

@@ -0,0 +1,41 @@
+"""``Model``: the base of every schema, a pydantic model with the strict settings takibi requires."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Model(BaseModel):
+    """A strict pydantic model: no type conversion in JSON (``"1"`` is not an ``int``; parameters
+    from the path, query, headers and cookies are still read from their text), and no keys the
+    model does not declare.
+
+        class Todo(Model):
+            id: int = Field(ge=1)
+            title: str = Field(min_length=1, max_length=100)
+    """
+
+    model_config = ConfigDict(strict=True, extra="forbid")
+
+
+class ValidationErrorItem(Model):
+    in_: Annotated[str, Field(alias="in", description="Where the value was sent: path, query, header, cookie or body")]
+    path: Annotated[str, Field(description="Dot-separated path inside that part", examples=["title"])]
+    code: Annotated[str, Field(description="The pydantic error type", examples=["string_too_short"])]
+    message: Annotated[str, Field(examples=["String should have at least 1 character"])]
+
+
+class ValidationProblem(Model):
+    """RFC 9457 Problem Details for a request part that does not match its schema."""
+
+    type: Annotated[str, Field(examples=["/problems/validation-error"])]
+    title: Annotated[str, Field(examples=["Unprocessable Content"])]
+    status: Annotated[int, Field(examples=[422])]
+    detail: str
+    instance: Annotated[str, Field(description="The request path")]
+    errors: list[ValidationErrorItem]
+
+
+__all__ = ["Model", "ValidationErrorItem", "ValidationProblem"]

pydantic_takibiapi-0.1.0/python/pydantic_takibiapi/schemas.py

@@ -0,0 +1,241 @@
+"""``PydanticSchemas``: pydantic models as takibi's schemas (see ``takibiapi.schemas``).
+
+Requests are checked with pydantic, constraints included (``Field(ge=1, min_length=1)``):
+parameters from the path, query, headers and cookies are read from their text, JSON bodies
+strictly (``"1"`` is not an ``int``) and without undeclared keys. Responses are checked against
+the model the route declares for the status before they are written. Every model must be strict
+(``Model``, or ``strict=True`` and ``extra="forbid"``).
+"""
+
+from __future__ import annotations
+
+import enum
+import functools
+import types
+import typing
+from collections.abc import Iterator
+from typing import Any, Literal, Union, get_args, get_origin
+
+import pydantic
+from pydantic import BaseModel, TypeAdapter
+from pydantic.fields import FieldInfo
+from pydantic.json_schema import JsonSchemaMode
+
+from takibiapi import ValidationError
+
+from .model import ValidationProblem
+
+REF_TEMPLATE = "#/components/schemas/{model}"
+
+
+def _issues(exc: pydantic.ValidationError) -> list[dict[str, Any]]:
+    return [{"path": list(e["loc"]), "code": e["type"], "message": e["msg"]} for e in exc.errors(include_url=False)]
+
+
+def _strict_error(tp: Any) -> str | None:
+    """Why ``tp`` is not strict enough, or None: every model must be strict and forbid extra keys,
+    and plain dataclasses / TypedDicts (whose settings cannot say so) are not allowed."""
+    seen: set[int] = set()
+
+    def walk(tp: Any) -> Iterator[str]:
+        origin = get_origin(tp)
+        if origin is typing.Annotated:
+            yield from walk(get_args(tp)[0])
+            return
+        if isinstance(tp, type) and issubclass(tp, BaseModel):
+            if id(tp) in seen:
+                return
+            seen.add(id(tp))
+            config = tp.model_config
+            if config.get("strict") is not True or config.get("extra") != "forbid":
+                yield f"{tp.__name__} is not strict (subclass pydantic_takibiapi.Model)"
+            for field in tp.model_fields.values():
+                yield from walk(field.annotation)
+            return
+        if typing.is_typeddict(tp) or (isinstance(tp, type) and hasattr(tp, "__dataclass_fields__")):
+            yield f"{tp.__name__} is a {'TypedDict' if typing.is_typeddict(tp) else 'dataclass'} (use a Model)"
+            return
+        for arg in get_args(tp):
+            if not isinstance(arg, (str, int, float, bool, enum.Enum)) and arg is not Ellipsis and arg is not None:
+                yield from walk(arg)
+
+    return next(walk(tp), None)
+
+
+def _strict_adapter(tp: Any) -> TypeAdapter[Any]:
+    error = _strict_error(tp)
+    if error is not None:
+        raise TypeError(error)
+    return TypeAdapter(tp)
+
+
+def _repeats(annotation: Any) -> bool:
+    """Whether a query field collects every value of its key (``list[str]``, ``list[int] | None``)."""
+    args = get_args(annotation) if get_origin(annotation) in (Union, types.UnionType) else (annotation,)
+    return any(a in (list, tuple, set, frozenset) or get_origin(a) in (list, tuple, set, frozenset) for a in args)
+
+
+class _Checker:
+    __slots__ = ("_adapter", "names")
+
+    def __init__(self, tp: Any, target: str) -> None:
+        self._adapter = _strict_adapter(tp)
+        if target == "json":
+            self.names: list[tuple[str, bool]] = []
+            return
+        if not (isinstance(tp, type) and issubclass(tp, BaseModel)):
+            raise TypeError(f"request {target} parts must be a Model, got {tp!r}")
+        self.names = [(f.alias or name, _repeats(f.annotation)) for name, f in tp.model_fields.items()]
+
+    def decode(self, value: Any, *, coerce: bool) -> Any:
+        try:  # parameters arrive as text: convert ("7" -> 7) even though the model is strict
+            return self._adapter.validate_python(value, strict=False if coerce else None)
+        except pydantic.ValidationError as exc:
+            raise ValidationError(_issues(exc)) from None
+
+    def decode_json(self, data: bytes) -> Any:
+        try:
+            return self._adapter.validate_json(data)
+        except pydantic.ValidationError as exc:
+            errors = exc.errors(include_url=False)
+            if errors and errors[0]["type"] == "json_invalid":
+                raise ValueError(errors[0]["msg"]) from None
+            raise ValidationError(_issues(exc)) from None
+
+
+class _Encoder:
+    __slots__ = ("_adapter",)
+
+    def __init__(self, tp: Any) -> None:
+        self._adapter = _strict_adapter(tp)
+
+    def encode_json(self, value: Any) -> bytes:
+        try:
+            checked = self._adapter.validate_python(value)
+        except pydantic.ValidationError as exc:
+            raise ValidationError(_issues(exc)) from None
+        return self._adapter.dump_json(checked)
+
+
+class _DocBuilder:
+    """Collects every schema the document needs and generates them in one pydantic pass, so named
+    models are written once to ``components.schemas`` (with ``-Input`` / ``-Output`` variants when
+    a model reads and writes differently). ``of`` returns a placeholder dict, filled in place when
+    ``components`` is read (``build_document`` reads it last)."""
+
+    def __init__(self, openapi31: bool) -> None:
+        self.openapi31 = openapi31
+        self._pending: list[tuple[dict[str, Any], JsonSchemaMode, TypeAdapter[Any]]] = []
+        self._components: dict[str, Any] | None = None
+
+    def of(self, tp: Any, io: Literal["input", "output"] = "input") -> dict[str, Any]:
+        placeholder: dict[str, Any] = {}
+        mode: JsonSchemaMode = "validation" if io == "input" else "serialization"
+        self._pending.append((placeholder, mode, _adapter_for_doc(tp)))
+        return placeholder
+
+    def parameters(self, tp: Any, location: str) -> list[dict[str, Any]]:
+        if not (isinstance(tp, type) and issubclass(tp, BaseModel)):
+            raise TypeError(f"{location} parameters must be a Model, got {tp!r}")
+        out: list[dict[str, Any]] = []
+        for name, field in tp.model_fields.items():
+            param: dict[str, Any] = {
+                "name": field.alias or name,
+                "in": location,
+                "required": location == "path" or field.is_required(),
+                "schema": self.of(typing.Annotated[field.annotation, _without_alias(field)]),
+            }
+            if field.description:
+                param["description"] = field.description
+            out.append(param)
+        return out
+
+    @property
+    def components(self) -> dict[str, Any]:
+        if self._components is None:
+            inputs: list[tuple[int, JsonSchemaMode, TypeAdapter[Any]]] = [
+                (i, mode, adapter) for i, (_, mode, adapter) in enumerate(self._pending)
+            ]
+            schemas, definitions = TypeAdapter.json_schemas(inputs, ref_template=REF_TEMPLATE)
+            for i, (placeholder, mode, _) in enumerate(self._pending):
+                placeholder.update(self._convert(_untitled(schemas[(i, mode)])))
+            defs = definitions.get("$defs", {})
+            self._components = {name: self._convert(schema) for name, schema in defs.items()}
+        return self._components
+
+    def _convert(self, schema: Any) -> Any:
+        return schema if self.openapi31 else to_openapi30(schema)
+
+
+@functools.cache
+def _adapter_for_doc(tp: Any) -> TypeAdapter[Any]:
+    return TypeAdapter(tp)
+
+
+def _without_alias(field: FieldInfo) -> FieldInfo:
+    """The field's constraints and description, for a parameter's own schema."""
+    return FieldInfo.merge_field_infos(field, alias=None, validation_alias=None, serialization_alias=None, title=None)
+
+
+def _untitled(schema: dict[str, Any]) -> dict[str, Any]:
+    return {k: v for k, v in schema.items() if k != "title"}
+
+
+def to_openapi30(schema: Any) -> Any:
+    """pydantic's JSON Schema (2020-12, as OpenAPI 3.1 uses) written for OpenAPI 3.0: ``null`` in
+    unions becomes ``nullable``, ``const`` an ``enum``, ``examples`` an ``example``, numeric
+    ``exclusiveMinimum`` / ``exclusiveMaximum`` the boolean form, and ``$ref`` siblings ``allOf``."""
+    if isinstance(schema, list):
+        return [to_openapi30(s) for s in schema]
+    if not isinstance(schema, dict):
+        return schema
+    out = {k: to_openapi30(v) if isinstance(v, (dict, list)) else v for k, v in schema.items()}
+    for key in ("anyOf", "oneOf"):
+        members = out.get(key)
+        if isinstance(members, list) and {"type": "null"} in members:
+            rest = [m for m in members if m != {"type": "null"}]
+            del out[key]
+            if len(rest) == 1 and "$ref" not in rest[0]:
+                out = {**rest[0], **out}
+            elif len(rest) == 1:
+                out["allOf"] = rest
+            else:
+                out[key] = rest
+            out["nullable"] = True
+    if isinstance(out.get("type"), list):
+        kinds = [t for t in out["type"] if t != "null"]
+        if len(kinds) < len(out["type"]):
+            out["nullable"] = True
+        out["type"] = kinds[0] if len(kinds) == 1 else kinds
+    if "const" in out:
+        out["enum"] = [out.pop("const")]
+    if isinstance(out.get("examples"), list):
+        examples = out.pop("examples")
+        if examples:
+            out["example"] = examples[0]
+    for exclusive, bound in (("exclusiveMinimum", "minimum"), ("exclusiveMaximum", "maximum")):
+        if isinstance(out.get(exclusive), (int, float)) and not isinstance(out.get(exclusive), bool):
+            out[bound] = out.pop(exclusive)
+            out[exclusive] = True
+    if "$ref" in out and len(out) > 1:
+        ref = out.pop("$ref")
+        out["allOf"] = [{"$ref": ref}, *out.get("allOf", [])]
+    return out
+
+
+class PydanticSchemas:
+    """pydantic models as takibi's schemas: request and response checks, constraints included."""
+
+    validation_problem: Any = ValidationProblem
+
+    def checker(self, tp: Any, target: str) -> _Checker:
+        return _Checker(tp, target)
+
+    def response_encoder(self, tp: Any) -> _Encoder:
+        return _Encoder(tp)
+
+    def builder(self, openapi31: bool) -> _DocBuilder:
+        return _DocBuilder(openapi31)
+
+
+__all__ = ["PydanticSchemas", "to_openapi30"]