pyfect-dev 0.1.0__py3-none-any.whl

pyfect/http_api/security.py

@@ -0,0 +1,91 @@
+"""Where a request carries its credentials (Effect's ``HttpApiSecurity``):
+an ``Authorization`` scheme (``bearer``, ``http(scheme=...)``), HTTP Basic
+(``basic``) or an API key in a header, query parameter or cookie
+(``api_key``). A security middleware decodes them with
+``HttpApiBuilder.security_decode``; OpenAPI documents them."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field, replace
+from typing import Any, Literal, Self
+
+from pyfect.context import Context, TagLike
+from pyfect.redacted import Redacted
+
+
+@dataclass(frozen=True, slots=True)
+class Credentials:
+    """HTTP Basic credentials."""
+
+    username: str
+    password: Redacted[str]
+
+
+@dataclass(frozen=True, slots=True)
+class _Security:
+    annotations: Context[Any] = field(default_factory=Context.empty, kw_only=True)
+
+    def annotate[S, T](self, tag: TagLike[S, T], value: S) -> Self:
+        """This security with an annotation (``OpenApi.Description``, ...)."""
+        return replace(self, annotations=self.annotations.add(tag, value))
+
+    def annotate_merge(self, annotations: Context[Any]) -> Self:
+        return replace(self, annotations=self.annotations.merge(annotations))
+
+    def pipe[B](self, f: Callable[[Self], B], /) -> B:
+        return f(self)
+
+
+@dataclass(frozen=True, slots=True)
+class Http(_Security):
+    """An ``Authorization: <scheme> <credential>`` header; the credential
+    is a ``Redacted`` string (empty when absent)."""
+
+    scheme: str
+
+
+@dataclass(frozen=True, slots=True)
+class ApiKey(_Security):
+    """An API key named ``key`` in a header (case-insensitive), query
+    parameter or cookie; the credential is a ``Redacted`` string."""
+
+    key: str
+    in_: Literal["header", "query", "cookie"] = "header"
+
+
+@dataclass(frozen=True, slots=True)
+class Basic(_Security):
+    """HTTP Basic: the credential is ``Credentials`` (empty when absent)."""
+
+
+type HttpApiSecurity = Http | ApiKey | Basic
+type Credential = Redacted[str] | Credentials
+"""What decoding a security gives: ``Credentials`` for ``Basic``, else a
+``Redacted`` string."""
+
+
+def http(*, scheme: str) -> Http:
+    return Http(scheme)
+
+
+bearer: Http = http(scheme="Bearer")
+basic: Basic = Basic()
+
+
+def api_key(*, key: str, in_: Literal["header", "query", "cookie"] = "header") -> ApiKey:
+    return ApiKey(key, in_)
+
+
+__all__ = [
+    "ApiKey",
+    "Basic",
+    "Credential",
+    "Credentials",
+    "Http",
+    "HttpApiSecurity",
+    "api_key",
+    "basic",
+    "bearer",
+    "http",
+]

pyfect/http_api/swagger.py

@@ -0,0 +1,69 @@
+"""Swagger UI for an ``HttpApi`` (Effect's ``HttpApiSwagger``)::
+
+    app = builder.layer(api).pipe(layer.merge(swagger.layer(api)))
+
+serves the API's OpenAPI document in Swagger UI at ``GET /docs``. The page
+bundles Swagger UI, so it needs no network; it is made on the first
+request and kept.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Never
+
+from pyfect._core import Effect
+from pyfect.effect import sync
+from pyfect.http.router import HttpRouter, HttpRouterService, use
+from pyfect.http.server_response import HttpServerResponse, html
+from pyfect.http_api import _html
+from pyfect.http_api.api import HttpApi
+from pyfect.layer import Layer
+
+
+def _page(api: HttpApi[Any], javascript: str, css: str) -> HttpServerResponse:
+    from pyfect.http_api import openapi
+
+    spec = openapi.from_api(api)
+    return html(f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>{_html.escape(spec["info"]["title"])} Documentation</title>
+  <style>{css}</style>
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script id="swagger-spec" type="application/json">
+    {_html.escape_json(spec)}
+  </script>
+  <script>
+    {javascript}
+    window.onload = () => {{
+      window.ui = SwaggerUIBundle({{
+        spec: JSON.parse(document.getElementById("swagger-spec").textContent),
+        dom_id: "#swagger-ui",
+      }});
+    }};
+  </script>
+</body>
+</html>""")
+
+
+def layer(api: HttpApi[Any], *, path: str = "/docs") -> Layer[Never, Never, HttpRouter]:
+    """``GET path`` answering with Swagger UI for ``api``."""
+
+    def add(router: HttpRouterService) -> Effect[None]:
+        def with_assets(assets: tuple[str, str]) -> Effect[None]:
+            javascript, css = assets
+            page = _html.memoize_success(lambda: _page(api, javascript, css))
+            return router.add("GET", path, sync(page))
+
+        return sync(lambda: (_html.asset("swagger-ui.js"), _html.asset("swagger-ui.css"))).flat_map(
+            with_assets
+        )
+
+    return use(add)
+
+
+__all__ = ["layer"]

pyfect/http_api/test.py

@@ -0,0 +1,105 @@
+"""A client of an API served in memory (Effect's ``HttpApiTest``).
+
+``groups(api, (Users,), layer=UsersLive)`` serves the handlers of the
+listed groups without a server, and gives a client of the whole API; an
+endpoint of another group dies when called::
+
+    api_client = yield from http_api.test.groups(api, (Users,), layer=UsersLive)
+    users = http_api.get_group(api_client, Users)
+
+The client, and the layer, are valid until the caller's ``Scope`` closes.
+Without ``layer`` the groups' layers come from the context, which must
+then outlive the client: a layer provided to ``groups(...)`` alone is
+released once the client is made, as in Effect.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any, Never, overload
+
+from pyfect._core import Effect
+from pyfect._layer_for_life import with_layer
+from pyfect.context import Context
+from pyfect.effect import context, die, gen
+from pyfect.http._in_memory import client as in_memory_client
+from pyfect.http.router import to_http_effect
+from pyfect.http.server_response import HttpServerResponse
+from pyfect.http_api._handlers import HandlerEntry
+from pyfect.http_api.api import ApiServing, HttpApi, api_of
+from pyfect.http_api.builder import handler_to_route
+from pyfect.http_api.builder import layer as api_layer
+from pyfect.http_api.client import Client, make_with
+from pyfect.http_api.group import AnyGroup, GroupService, HttpApiGroup
+from pyfect.layer import Layer, succeed_context
+from pyfect.layer import provide as layer_provide
+from pyfect.scope import CloseableScope, Scope
+
+
+@overload
+def groups[G, S: HttpApiGroup[Any, Any]](
+    api: ApiServing[G, S],
+    served: Sequence[type[S]],
+    *,
+    base_url: str = "http://localhost:3000",
+) -> Effect[Client[G], Never, S | Scope]: ...
+@overload
+def groups[G, S: HttpApiGroup[Any, Any], E, R](
+    api: ApiServing[G, S],
+    served: Sequence[type[S]],
+    *,
+    layer: Layer[S, E, R],
+    base_url: str = "http://localhost:3000",
+) -> Effect[Client[G], E, R | Scope]: ...
+def groups(
+    api: ApiServing[Any, Any],
+    served: Sequence[AnyGroup],
+    *,
+    layer: Layer[Any, Any, Any] | None = None,
+    base_url: str = "http://localhost:3000",
+) -> Effect[Client[Any], Any, Any]:
+    """A client of ``api`` whose requests are handled in memory by the
+    handlers of ``served`` (a group ``api`` lacks is a type error). The
+    groups' layers are ``layer``, built into the caller's ``Scope``, or
+    else come from the context; the client is valid until that scope
+    closes."""
+    return with_layer(lambda: _groups(api_of(api), served, base_url), layer)
+
+
+def _groups(
+    api: HttpApi[Any], served: Sequence[AnyGroup], base_url: str
+) -> Effect[Client[Any], Never, Any]:
+    served_ids = {group.identifier for group in served}
+
+    def run() -> Any:
+        services: Context[Any] = yield from context()
+        for group in api.groups.values():
+            if group.identifier in served_ids:
+                continue
+            services = services.add(group.origin, _unhandled(api, group, services))
+        app = api_layer(api).pipe(layer_provide(succeed_context(services)))
+        handler: Effect[HttpServerResponse, Any, Any] = yield from to_http_effect(app)
+        scope: CloseableScope = yield from Scope()
+        http_client = in_memory_client(handler, scope)
+        return (yield from make_with(api, http_client=http_client, base_url=base_url))
+
+    return gen(run)
+
+
+def _unhandled(api: HttpApi[Any], group: AnyGroup, services: Context[Any]) -> GroupService:
+    entries = {
+        identifier: HandlerEntry(
+            endpoint,
+            lambda _request, identifier=identifier: die(
+                RuntimeError(f"Unhandled endpoint: {identifier}")
+            ),
+            is_raw=False,
+            uninterruptible=False,
+        )
+        for identifier, endpoint in group.endpoints.items()
+    }
+    routes = tuple(handler_to_route(api, group, entry, services) for entry in entries.values())
+    return GroupService(routes, entries)
+
+
+__all__ = ["groups"]

pyfect/json_patch.py

@@ -0,0 +1,255 @@
+"""JSON Patch (RFC 6902) restricted to ``add``, ``remove`` and ``replace``
+(Effect's ``JsonPatch``): ``get`` computes a patch between two JSON values,
+``apply`` runs one without mutating its input::
+
+    patch = json_patch.get({"a": 1}, {"a": 2, "b": [1]})
+    # [{"op": "replace", "path": "/a", "value": 2}, {"op": "add", "path": "/b", "value": [1]}]
+    json_patch.apply(patch, {"a": 1})  # {"a": 2, "b": [1]}
+
+Arrays are lists or tuples and objects string-keyed mappings on the way in;
+``apply`` builds new lists and dicts along the path it changes and keeps
+every other value as it is. An operation that cannot be applied raises
+``ValueError`` with Effect's message.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping, Sequence
+from typing import Literal, NotRequired, TypedDict, cast
+
+from pyfect import _json_text
+from pyfect._digits import parse_digits
+from pyfect._js import js_sort_key
+from pyfect._json_value import JsonValue
+from pyfect.json_pointer import escape_token, unescape_token
+
+
+class AddOperation(TypedDict):
+    op: Literal["add"]
+    path: str
+    value: JsonValue
+    description: NotRequired[str]
+
+
+class RemoveOperation(TypedDict):
+    op: Literal["remove"]
+    path: str
+    description: NotRequired[str]
+
+
+class ReplaceOperation(TypedDict):
+    op: Literal["replace"]
+    path: str
+    value: JsonValue
+    description: NotRequired[str]
+
+
+type JsonPatchOperation = AddOperation | RemoveOperation | ReplaceOperation
+type JsonPatch = Sequence[JsonPatchOperation]
+
+type _Array = Sequence[JsonValue]
+type _Object = Mapping[str, JsonValue]
+
+
+def _is_array(value: object) -> bool:
+    return isinstance(value, list | tuple)
+
+
+def _is_object(value: object) -> bool:
+    return isinstance(value, Mapping)
+
+
+def _same(a: JsonValue, b: JsonValue) -> bool:
+    """JavaScript's ``Object.is`` on JSON values: the same container, or
+    leaves of one JSON type with one value (``True`` is not ``1``, ``-0.0``
+    is not ``0``)."""
+    if a is b:
+        return True
+    if isinstance(a, bool) or isinstance(b, bool):
+        return type(a) is type(b) and a == b
+    if isinstance(a, int | float) and isinstance(b, int | float):
+        return a == b and math.copysign(1, a) == math.copysign(1, b)
+    if isinstance(a, str) and isinstance(b, str):
+        return a == b
+    return False
+
+
+def get(old_value: JsonValue, new_value: JsonValue) -> list[JsonPatchOperation]:
+    """The operations turning ``old_value`` into ``new_value``: array
+    elements compared by index (removals from the end first, then
+    additions), object keys in JavaScript's sorted order, anything else a ``replace``."""
+    patches: list[JsonPatchOperation] = []
+    _get_loop(old_value, new_value, "", patches)
+    return patches
+
+
+def _get_loop(
+    old_value: JsonValue, new_value: JsonValue, path: str, patches: list[JsonPatchOperation]
+) -> None:
+    if _same(old_value, new_value):
+        return
+    if _is_array(old_value) and _is_array(new_value):
+        old = cast("_Array", old_value)
+        new = cast("_Array", new_value)
+        for i in range(min(len(old), len(new))):
+            _get_loop(old[i], new[i], f"{path}/{i}", patches)
+        patches.extend(
+            RemoveOperation(op="remove", path=f"{path}/{i}")
+            for i in range(len(old) - 1, len(new) - 1, -1)
+        )
+        patches.extend(
+            AddOperation(op="add", path=f"{path}/{i}", value=new[i])
+            for i in range(len(old), len(new))
+        )
+        return
+    if _is_object(old_value) and _is_object(new_value):
+        old_object = cast("_Object", old_value)
+        new_object = cast("_Object", new_value)
+        for key in sorted({*old_object, *new_object}, key=js_sort_key):
+            key_path = f"{path}/{escape_token(key)}"
+            if key in old_object and key in new_object:
+                _get_loop(old_object[key], new_object[key], key_path, patches)
+            elif key in new_object:
+                patches.append(AddOperation(op="add", path=key_path, value=new_object[key]))
+            else:
+                patches.append(RemoveOperation(op="remove", path=key_path))
+        return
+    patches.append(ReplaceOperation(op="replace", path=path, value=new_value))
+
+
+def apply(patch: JsonPatch, old_value: JsonValue) -> JsonValue:
+    """``old_value`` with each operation applied in order. An empty patch
+    returns ``old_value`` itself."""
+    doc = old_value
+    for operation in patch:
+        doc = _apply_operation(doc, operation)
+    return doc
+
+
+def _tokenize(pointer: str) -> list[str]:
+    if not pointer:
+        return []
+    if not pointer.startswith("/"):
+        raise ValueError(
+            f'Invalid JSON Pointer, it must start with "/": {_json_text.stringify(pointer)}'
+        )
+    return [unescape_token(token) for token in pointer.split("/")[1:]]
+
+
+def _array_index(token: str) -> int:
+    index = parse_digits(token, unpadded=True)
+    if index is None:
+        raise ValueError(f'Invalid array index: "{token}"')
+    return index
+
+
+def _not_a_container(operation: JsonPatchOperation) -> ValueError:
+    return ValueError(
+        f'Cannot {operation["op"]} at "{operation["path"]}" (parent not found or not a container).'
+    )
+
+
+def _apply_operation(doc: JsonValue, operation: JsonPatchOperation) -> JsonValue:
+    path = operation["path"]
+    if not path:
+        if operation["op"] == "remove":
+            raise ValueError("Unsupported operation at the root")
+        return operation["value"]
+    resolved = _resolve_parent(doc, path)
+    if resolved is None:
+        raise _not_a_container(operation)
+    stack, parent, last_token = resolved
+    if _is_array(parent):
+        return _rebuild(stack, _apply_to_array(cast("_Array", parent), last_token, operation))
+    if _is_object(parent):
+        return _rebuild(stack, _apply_to_object(cast("_Object", parent), last_token, operation))
+    raise _not_a_container(operation)
+
+
+def _apply_to_array(
+    parent: _Array, last_token: str, operation: JsonPatchOperation
+) -> list[JsonValue]:
+    if last_token == "-" and operation["op"] != "add":
+        raise ValueError(f'"-" is not valid for {operation["op"]} at "{operation["path"]}".')
+    index = len(parent) if last_token == "-" else _array_index(last_token)
+    max_index = len(parent) if operation["op"] == "add" else len(parent) - 1
+    if index > max_index:
+        raise ValueError(f'Array index out of bounds at "{operation["path"]}".')
+    updated = list(parent)
+    if operation["op"] == "add":
+        updated.insert(index, operation["value"])
+    elif operation["op"] == "remove":
+        del updated[index]
+    else:
+        updated[index] = operation["value"]
+    return updated
+
+
+def _apply_to_object(
+    parent: _Object, last_token: str, operation: JsonPatchOperation
+) -> dict[str, JsonValue]:
+    if operation["op"] != "add" and last_token not in parent:
+        raise ValueError(f'Property "{last_token}" does not exist at "{operation["path"]}".')
+    updated = dict(parent)
+    if operation["op"] == "remove":
+        del updated[last_token]
+    else:
+        updated[last_token] = operation["value"]
+    return updated
+
+
+type _Stack = list[tuple[JsonValue, int | str]]
+
+
+def _resolve_parent(doc: JsonValue, pointer: str) -> tuple[_Stack, JsonValue, str] | None:
+    """The containers on the way to the parent of ``pointer``, the parent and
+    the last token; ``None`` when a container on the way is missing."""
+    tokens = _tokenize(pointer)
+    stack: _Stack = []
+    current = doc
+    for token in tokens[:-1]:
+        if _is_array(current):
+            array = cast("_Array", current)
+            index = _array_index(token)
+            if index >= len(array):
+                return None
+            stack.append((current, index))
+            current = array[index]
+        elif _is_object(current):
+            mapping = cast("_Object", current)
+            if token not in mapping:
+                return None
+            stack.append((current, token))
+            current = mapping[token]
+        else:
+            return None
+    return stack, current, tokens[-1]
+
+
+def _rebuild(stack: _Stack, new_parent: JsonValue) -> JsonValue:
+    """The document with ``new_parent`` written back through ``stack``,
+    copying each container on the way."""
+    acc = new_parent
+    for container, token in reversed(stack):
+        if isinstance(token, int):
+            array = list(cast("_Array", container))
+            array[token] = acc
+            acc = array
+        else:
+            mapping = dict(cast("_Object", container))
+            mapping[token] = acc
+            acc = mapping
+    return acc
+
+
+__all__ = [
+    "AddOperation",
+    "JsonPatch",
+    "JsonPatchOperation",
+    "JsonValue",
+    "RemoveOperation",
+    "ReplaceOperation",
+    "apply",
+    "get",
+]

pyfect/json_pointer.py

@@ -0,0 +1,100 @@
+"""JSON Pointer tokens and URI fragments (RFC 6901, Effect's ``JsonPointer``).
+
+A JSON Pointer separates tokens with ``/``, so a token escapes ``~`` as
+``~0`` and ``/`` as ``~1``. A URI fragment percent-encodes the escaped
+pointer as JavaScript's ``encodeURI`` does, with ``#`` encoded too::
+
+    json_pointer.escape_token("a/b")                   # "a~1b"
+    json_pointer.parse_uri_fragment("#/users/a~1b")    # ["users", "a/b"]
+    json_pointer.format_uri_fragment(["a b", "Rate%"]) # "#/a%20b/Rate%25"
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Sequence
+from urllib.parse import quote
+
+# What JavaScript's ``encodeURI`` leaves alone, besides letters and digits.
+_URI_SAFE = ";,/?:@&=+$-_.!~*'()#"
+_INVALID_ESCAPE = re.compile(r"~(?:[^01]|$)")
+_PERCENT = re.compile(r"%([0-9A-Fa-f]{2})")
+
+
+def escape_token(token: str) -> str:
+    """``token`` with ``~`` as ``~0`` and ``/`` as ``~1`` (``~`` first, so
+    nothing is escaped twice)."""
+    return token.replace("~", "~0").replace("/", "~1")
+
+
+def unescape_token(token: str) -> str:
+    """The inverse of ``escape_token``: ``~1`` to ``/``, then ``~0`` to ``~``."""
+    return token.replace("~1", "/").replace("~0", "~")
+
+
+def _encode_uri(text: str) -> str:
+    """JavaScript's ``encodeURI``. A lone surrogate raises ``ValueError``
+    (Effect's ``URIError``)."""
+    try:
+        return quote(text, safe=_URI_SAFE, errors="strict")
+    except UnicodeEncodeError as error:
+        raise ValueError("URI malformed") from error
+
+
+def _decode_uri_component(text: str) -> str:
+    """JavaScript's ``decodeURIComponent``: a stray ``%`` or invalid UTF-8
+    raises ``ValueError``."""
+    if "%" in _PERCENT.sub("", text):
+        raise ValueError("URI malformed")
+    data = bytearray()
+    position = 0
+    for match in _PERCENT.finditer(text):
+        data += text[position : match.start()].encode()
+        data.append(int(match.group(1), 16))
+        position = match.end()
+    data += text[position:].encode()
+    return data.decode()
+
+
+def _format_uri_fragment_token(token: str) -> str:
+    return _encode_uri(escape_token(token)).replace("#", "%23")
+
+
+def _decode_uri_fragment(fragment: str) -> str | None:
+    if fragment in ("", "#"):
+        return ""
+    if not fragment.startswith("#"):
+        return None
+    encoded = fragment[1:]
+    try:
+        if _encode_uri(encoded).replace("%25", "%").replace("#", "%23") != encoded:
+            return None
+        pointer = _decode_uri_component(encoded)
+    except ValueError:
+        return None
+    if pointer.startswith("/") and not _INVALID_ESCAPE.search(pointer):
+        return pointer
+    return None
+
+
+def parse_uri_fragment(fragment: str) -> list[str] | None:
+    """The tokens of a JSON Pointer URI fragment (``""`` and ``"#"`` are the
+    root, ``[]``), percent-decoded and then unescaped. ``None`` for anything
+    that is not a fragment, holds a character needing percent-encoding, or
+    has an invalid ``~`` escape."""
+    pointer = _decode_uri_fragment(fragment)
+    if pointer is None:
+        return None
+    if not pointer:
+        return []
+    return [unescape_token(token) for token in pointer[1:].split("/")]
+
+
+def format_uri_fragment(path: Sequence[str]) -> str:
+    """``path`` as a URI fragment: each token escaped, then percent-encoded;
+    the empty path is ``"#"``. A token with a lone surrogate raises
+    ``ValueError``."""
+    return "#" + "".join(f"/{_format_uri_fragment_token(token)}" for token in path)
+
+
+__all__ = ["escape_token", "format_uri_fragment", "parse_uri_fragment", "unescape_token"]

pyfect/json_schema/__init__.py

@@ -0,0 +1,66 @@
+"""JSON Schema documents across dialects (Effect's ``JsonSchema``).
+
+Every conversion goes through Draft 2020-12: read a schema with one of the
+``from_schema_*`` functions into a ``Document`` (the root schema and its
+definitions, kept apart), then write it out with ``to_document_draft_07``,
+``to_document_draft_04`` or ``to_multi_document_open_api_3_1``::
+
+    from pyfect import json_schema
+
+    doc = json_schema.from_schema_draft_07({"type": "array", "items": [{"type": "string"}]})
+    doc.schema  # {"type": "array", "prefixItems": [{"type": "string"}]}
+    json_schema.to_document_draft_07(doc).schema  # back to Draft-07
+
+References (``$ref``) are relocated to where their targets land, schema
+resources (``$id``) included. A keyword that cannot be carried over without
+changing what the schema accepts raises ``ValueError`` with Effect's message.
+Schemas are plain dicts; inputs are never mutated.
+"""
+
+from pyfect.json_schema._api import (
+    from_schema_draft_07,
+    from_schema_draft_2020_12,
+    from_schema_open_api_3_0,
+    from_schema_open_api_3_1,
+    to_document_draft_04,
+    to_document_draft_07,
+    to_multi_document_open_api_3_1,
+)
+from pyfect.json_schema._model import (
+    META_SCHEMA_URI_DRAFT_04,
+    META_SCHEMA_URI_DRAFT_07,
+    META_SCHEMA_URI_DRAFT_2020_12,
+    VALID_OPEN_API_COMPONENTS_SCHEMAS_KEY_REGEXP,
+    Definitions,
+    Dialect,
+    Document,
+    JsonSchema,
+    MultiDocument,
+    Type,
+    get_reference_key,
+    rewrite_refs,
+    sanitize_open_api_components_schemas_key,
+)
+
+__all__ = [
+    "META_SCHEMA_URI_DRAFT_04",
+    "META_SCHEMA_URI_DRAFT_07",
+    "META_SCHEMA_URI_DRAFT_2020_12",
+    "VALID_OPEN_API_COMPONENTS_SCHEMAS_KEY_REGEXP",
+    "Definitions",
+    "Dialect",
+    "Document",
+    "JsonSchema",
+    "MultiDocument",
+    "Type",
+    "from_schema_draft_07",
+    "from_schema_draft_2020_12",
+    "from_schema_open_api_3_0",
+    "from_schema_open_api_3_1",
+    "get_reference_key",
+    "rewrite_refs",
+    "sanitize_open_api_components_schemas_key",
+    "to_document_draft_04",
+    "to_document_draft_07",
+    "to_multi_document_open_api_3_1",
+]