alt-stack-openapi-pydantic 1.6.2__py3-none-any.whl

alt_stack_openapi_pydantic/lowering.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from .rendering import needs_named_model
+from .types import AnySchema
+from .utils import to_pascal_case
+
+
+@dataclass(slots=True)
+class NamedSchema:
+    name: str
+    schema: AnySchema
+
+
+@dataclass(slots=True)
+class LoweringContext:
+    used_names: set[str] = field(default_factory=set)
+
+    def reserve_name(self, base_name: str) -> str:
+        if base_name not in self.used_names:
+            self.used_names.add(base_name)
+            return base_name
+
+        index = 2
+        while f"{base_name}_{index}" in self.used_names:
+            index += 1
+
+        reserved = f"{base_name}_{index}"
+        self.used_names.add(reserved)
+        return reserved
+
+
+def lower_named_schema(
+    context: LoweringContext,
+    name: str,
+    schema: AnySchema,
+) -> list[NamedSchema]:
+    lowered, hoisted = _lower_schema(context, name, schema)
+    return [*hoisted, NamedSchema(name=name, schema=lowered)]
+
+
+def _lower_schema(
+    context: LoweringContext,
+    parent_name: str,
+    schema: AnySchema,
+) -> tuple[AnySchema, list[NamedSchema]]:
+    if not isinstance(schema, dict):
+        return schema, []
+
+    lowered = dict(schema)
+    hoisted: list[NamedSchema] = []
+
+    properties = lowered.get("properties")
+    if isinstance(properties, dict):
+        lowered_properties: dict[str, AnySchema] = {}
+        for prop_name, prop_schema in properties.items():
+            child_name = f"{parent_name}{to_pascal_case(prop_name)}"
+            lowered_child, child_hoisted = _lower_child_schema(context, child_name, prop_schema)
+            lowered_properties[prop_name] = lowered_child
+            hoisted.extend(child_hoisted)
+        lowered["properties"] = lowered_properties
+
+    items = lowered.get("items")
+    if isinstance(items, dict):
+        lowered_items, item_hoisted = _lower_child_schema(
+            context,
+            f"{parent_name}Item",
+            items,
+        )
+        lowered["items"] = lowered_items
+        hoisted.extend(item_hoisted)
+
+    additional = lowered.get("additionalProperties")
+    if isinstance(additional, dict):
+        lowered_additional, additional_hoisted = _lower_child_schema(
+            context,
+            f"{parent_name}Value",
+            additional,
+        )
+        lowered["additionalProperties"] = lowered_additional
+        hoisted.extend(additional_hoisted)
+
+    for keyword, suffix in (("oneOf", "Option"), ("anyOf", "Option"), ("allOf", "Part")):
+        value = lowered.get(keyword)
+        if not isinstance(value, list):
+            continue
+        lowered_items_list: list[AnySchema] = []
+        for index, item in enumerate(value, start=1):
+            child_name = f"{parent_name}{suffix}{index}"
+            lowered_item, item_hoisted = _lower_child_schema(context, child_name, item)
+            lowered_items_list.append(lowered_item)
+            hoisted.extend(item_hoisted)
+        lowered[keyword] = lowered_items_list
+
+    return lowered, hoisted
+
+
+def _lower_child_schema(
+    context: LoweringContext,
+    child_name: str,
+    schema: AnySchema,
+) -> tuple[AnySchema, list[NamedSchema]]:
+    if not isinstance(schema, dict):
+        return schema, []
+
+    if needs_named_model(schema):
+        reserved_name = context.reserve_name(child_name)
+        lowered_schema, hoisted = _lower_schema(context, reserved_name, schema)
+        ref_schema: dict[str, Any] = {"$ref": f"#/components/schemas/{reserved_name}"}
+        if schema.get("nullable") is True:
+            ref_schema["nullable"] = True
+        return ref_schema, [*hoisted, NamedSchema(name=reserved_name, schema=lowered_schema)]
+
+    return _lower_schema(context, child_name, schema)

alt_stack_openapi_pydantic/py.typed

@@ -0,0 +1 @@
+

alt_stack_openapi_pydantic/registry.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal, TypeAlias, TypedDict, cast
+
+SUPPORTED_STRING_FORMATS = [
+    "color-hex",
+    "date",
+    "date-time",
+    "email",
+    "iso-date",
+    "iso-date-time",
+    "objectid",
+    "uri",
+    "url",
+    "uuid",
+]
+
+SupportedStringFormat = Literal[
+    "color-hex",
+    "date",
+    "date-time",
+    "email",
+    "iso-date",
+    "iso-date-time",
+    "objectid",
+    "uri",
+    "url",
+    "uuid",
+]
+
+
+class PydanticOpenApiRegistrationString(TypedDict):
+    schema_exported_variable_name: str
+    type: Literal["string"]
+    format: SupportedStringFormat
+    description: str | None
+
+
+class PydanticOpenApiRegistrationStrings(TypedDict):
+    schema_exported_variable_name: str
+    type: Literal["string"]
+    formats: list[SupportedStringFormat]
+    description: str | None
+
+
+class PydanticOpenApiRegistrationPrimitive(TypedDict):
+    schema_exported_variable_name: str
+    type: Literal["number", "integer", "boolean"]
+    description: str | None
+
+
+if TYPE_CHECKING:
+    PydanticOpenApiRegistration: TypeAlias = (
+        PydanticOpenApiRegistrationString
+        | PydanticOpenApiRegistrationStrings
+        | PydanticOpenApiRegistrationPrimitive
+    )
+else:
+    PydanticOpenApiRegistration = dict[str, Any]
+
+
+class PydanticSchemaRegistry:
+    def __init__(self) -> None:
+        self._string_format_to_name: dict[str, str] = {}
+        self._primitive_type_to_name: dict[str, str] = {}
+        self._schema_ids: dict[int, PydanticOpenApiRegistration] = {}
+
+    def register(self, schema: Any, registration: PydanticOpenApiRegistration) -> None:
+        reg_type = registration["type"]
+        registration_dict = cast(dict[str, Any], registration)
+
+        if reg_type == "string":
+            format_value = registration_dict.get("format")
+            if isinstance(format_value, str):
+                self._register_string_format(format_value, registration)
+                self._schema_ids[id(schema)] = registration
+                return
+
+            format_values = registration_dict.get("formats")
+            if isinstance(format_values, list):
+                for format_item in format_values:
+                    if isinstance(format_item, str):
+                        self._register_string_format(format_item, registration)
+                self._schema_ids[id(schema)] = registration
+                return
+
+        if reg_type in {"number", "integer", "boolean"}:
+            name = registration["schema_exported_variable_name"]
+            existing = self._primitive_type_to_name.get(reg_type)
+            if existing and existing != name:
+                raise ValueError(
+                    f"duplicate Pydantic OpenAPI registration for type '{reg_type}'",
+                )
+            self._primitive_type_to_name[reg_type] = name
+            self._schema_ids[id(schema)] = registration
+            return
+
+        raise ValueError("unsupported registration type")
+
+    def _register_string_format(
+        self,
+        fmt: SupportedStringFormat | str,
+        registration: PydanticOpenApiRegistration,
+    ) -> None:
+        if fmt not in SUPPORTED_STRING_FORMATS:
+            raise ValueError(f"unsupported string format registration: {fmt!r}")
+        name = registration["schema_exported_variable_name"]
+        existing = self._string_format_to_name.get(fmt)
+        if existing and existing != name:
+            raise ValueError(
+                f"duplicate Pydantic OpenAPI registration for (type, format)=('string', '{fmt}')",
+            )
+        self._string_format_to_name[fmt] = name
+
+    def clear(self) -> None:
+        self._string_format_to_name.clear()
+        self._primitive_type_to_name.clear()
+        self._schema_ids.clear()
+
+    def get_schema_exported_variable_name_for_string_format(
+        self, format_value: SupportedStringFormat | str
+    ) -> str | None:
+        if format_value not in SUPPORTED_STRING_FORMATS:
+            return None
+        return self._string_format_to_name.get(format_value)
+
+    def get_schema_exported_variable_name_for_primitive_type(
+        self, type_value: Literal["number", "integer", "boolean"]
+    ) -> str | None:
+        return self._primitive_type_to_name.get(type_value)
+
+    def is_registered(self, schema: Any) -> bool:
+        return id(schema) in self._schema_ids
+
+
+schema_registry = PydanticSchemaRegistry()
+
+
+def register_pydantic_type_to_openapi_schema(
+    schema: Any,
+    registration: PydanticOpenApiRegistration,
+) -> None:
+    schema_registry.register(schema, registration)
+
+
+def clear_pydantic_schema_registry() -> None:
+    schema_registry.clear()
+
+
+def get_schema_exported_variable_name_for_string_format(
+    format_value: SupportedStringFormat | str,
+) -> str | None:
+    return schema_registry.get_schema_exported_variable_name_for_string_format(
+        format_value,
+    )
+
+
+def get_schema_exported_variable_name_for_primitive_type(
+    type_value: Literal["number", "integer", "boolean"],
+) -> str | None:
+    return schema_registry.get_schema_exported_variable_name_for_primitive_type(type_value)

alt_stack_openapi_pydantic/rendering.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from urllib.parse import unquote
+
+from .registry import (
+    get_schema_exported_variable_name_for_primitive_type,
+    get_schema_exported_variable_name_for_string_format,
+)
+from .type_render import format_openapi_metadata
+from .types import AnySchema
+from .types.array import convert_openapi_array_to_pydantic
+from .types.boolean import convert_openapi_boolean_to_pydantic
+from .types.intersection import convert_openapi_intersection_to_pydantic
+from .types.number import convert_openapi_number_to_pydantic
+from .types.object import convert_openapi_object_to_pydantic
+from .types.string import convert_openapi_string_to_pydantic
+from .types.union import convert_openapi_union_to_pydantic
+
+
+@dataclass(slots=True)
+class RenderContext:
+    root_model_names: set[str] = field(default_factory=set)
+
+
+def decode_component_ref(ref: str) -> str:
+    if ref.startswith("#/components/schemas/"):
+        return unquote(ref.split("#/components/schemas/")[1])
+    return ref
+
+
+def is_freeform_object_schema(schema: AnySchema) -> bool:
+    if not isinstance(schema, dict):
+        return False
+    if schema.get("type") != "object" and "properties" not in schema:
+        return False
+    return not schema.get("properties") and schema.get("additionalProperties") is not False
+
+
+def is_object_model_schema(schema: AnySchema) -> bool:
+    if not isinstance(schema, dict):
+        return False
+    properties = schema.get("properties")
+    if schema.get("type") == "object" or properties is not None:
+        if isinstance(properties, dict) and properties:
+            return True
+        return schema.get("additionalProperties") is False
+
+    parts = schema.get("allOf")
+    if not isinstance(parts, list) or not parts:
+        return False
+
+    saw_object_part = False
+    for part in parts:
+        if not isinstance(part, dict):
+            return False
+        if isinstance(part.get("$ref"), str):
+            saw_object_part = True
+            continue
+        if part.get("type") == "object" or "properties" in part:
+            saw_object_part = True
+            continue
+        return False
+    return saw_object_part
+
+
+def needs_named_model(schema: AnySchema) -> bool:
+    return is_object_model_schema(schema)
+
+
+def schema_to_type_expr(
+    schema: AnySchema | None,
+    *,
+    context: RenderContext | None = None,
+) -> str:
+    if not isinstance(schema, dict):
+        return "Any"
+
+    render_context = context or RenderContext()
+
+    if isinstance(schema.get("$ref"), str):
+        ref = schema["$ref"]
+        if not ref.startswith("#/components/schemas/"):
+            return wrap_nullable("Any", schema)
+        expr = decode_component_ref(ref)
+        return wrap_nullable(expr, schema)
+
+    if isinstance(schema.get("oneOf"), list):
+        expr = convert_openapi_union_to_pydantic(
+            schema,
+            lambda child: schema_to_type_expr(child, context=render_context),
+        )
+        return wrap_nullable(expr, schema)
+
+    if isinstance(schema.get("anyOf"), list):
+        expr = convert_openapi_union_to_pydantic(
+            {"oneOf": schema["anyOf"], "discriminator": schema.get("discriminator")},
+            lambda child: schema_to_type_expr(child, context=render_context),
+        )
+        return wrap_nullable(expr, schema)
+
+    if isinstance(schema.get("allOf"), list):
+        expr = convert_openapi_intersection_to_pydantic(
+            schema,
+            lambda child: schema_to_type_expr(child, context=render_context),
+        )
+        return wrap_nullable(expr, schema)
+
+    schema_type = schema.get("type")
+
+    if schema_type == "string":
+        expr = convert_openapi_string_to_pydantic(schema)
+        return wrap_nullable(expr, schema)
+
+    if schema_type in {"number", "integer"}:
+        expr = convert_openapi_number_to_pydantic(schema)
+        return wrap_nullable(expr, schema)
+
+    if schema_type == "boolean":
+        expr = convert_openapi_boolean_to_pydantic(schema)
+        return wrap_nullable(expr, schema)
+
+    if schema_type == "array":
+        expr = convert_openapi_array_to_pydantic(
+            schema,
+            lambda child: schema_to_type_expr(child, context=render_context),
+        )
+        return wrap_nullable(expr, schema)
+
+    if schema_type == "object" or "properties" in schema:
+        expr = convert_openapi_object_to_pydantic(
+            schema,
+            lambda child: schema_to_type_expr(child, context=render_context),
+        )
+        return wrap_nullable(expr, schema)
+
+    if isinstance(schema.get("enum"), list):
+        values = ", ".join(repr(value) for value in schema["enum"])
+        expr = f"Literal[{values}]"
+        return wrap_nullable(expr, schema)
+
+    return wrap_nullable("Any", schema)
+
+
+def wrap_nullable(expr: str, schema: dict[str, Any]) -> str:
+    if schema.get("nullable") is True:
+        return f"Optional[{expr}]"
+    return expr
+
+
+def registered_output_alias(schema: AnySchema, context: RenderContext | None = None) -> str | None:
+    if not isinstance(schema, dict):
+        return None
+
+    if schema.get("type") == "string" and isinstance(schema.get("format"), str):
+        custom = get_schema_exported_variable_name_for_string_format(schema["format"])
+        if custom:
+            return custom
+
+    primitive_type = schema.get("type")
+    if primitive_type in {"number", "integer", "boolean"}:
+        custom = get_schema_exported_variable_name_for_primitive_type(primitive_type)
+        if custom:
+            return custom
+
+    if context is None:
+        return None
+
+    if isinstance(schema.get("$ref"), str):
+        name = decode_component_ref(schema["$ref"])
+        if name in context.root_model_names:
+            return name
+
+    return None
+
+
+def root_model_annotation(type_expr: str) -> str:
+    return f"RootModel[{type_expr}]"
+
+
+def extra_field_annotation(value_type: str) -> str:
+    return f"dict[str, {value_type}]"
+
+
+__all__ = [
+    "RenderContext",
+    "decode_component_ref",
+    "extra_field_annotation",
+    "format_openapi_metadata",
+    "is_freeform_object_schema",
+    "is_object_model_schema",
+    "needs_named_model",
+    "registered_output_alias",
+    "root_model_annotation",
+    "schema_to_type_expr",
+]

alt_stack_openapi_pydantic/routes.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, cast
+
+from .types import AnySchema
+
+HttpMethod = str
+
+
+@dataclass
+class RouteParameter:
+    name: str
+    location: str
+    required: bool
+    schema: AnySchema
+
+
+@dataclass
+class RouteInfo:
+    path: str
+    method: HttpMethod
+    parameters: list[RouteParameter]
+    request_body: AnySchema | None
+    responses: dict[str, AnySchema]
+
+
+@dataclass
+class RouteSchemaNames:
+    params_schema_name: str | None = None
+    query_schema_name: str | None = None
+    headers_schema_name: str | None = None
+    body_schema_name: str | None = None
+    response_schema_name: str | None = None
+
+
+def _to_upper_method(method: str) -> HttpMethod:
+    upper = method.upper()
+    if upper in {"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"}:
+        return upper
+    return "GET"
+
+
+def _to_pascal_case(value: str) -> str:
+    parts = [part for part in "".join(c if c.isalnum() else " " for c in value).split()]
+    return "".join(part[:1].upper() + part[1:].lower() for part in parts)
+
+
+def build_route_path_name(path: str) -> str:
+    path_parts = []
+    for part in path.split("/"):
+        if not part:
+            continue
+        if part.startswith("{") and part.endswith("}"):
+            path_parts.append(part[1:-1])
+        else:
+            path_parts.append(part)
+    return "".join(_to_pascal_case(part) for part in path_parts)
+
+
+def build_route_schema_name(path: str, method: HttpMethod, suffix: str) -> str:
+    method_prefix = method[:1] + method[1:].lower()
+    return "".join([method_prefix, build_route_path_name(path), suffix])
+
+
+def parse_openapi_paths(openapi: dict[str, Any]) -> list[RouteInfo]:
+    paths_obj = openapi.get("paths")
+    if not isinstance(paths_obj, dict):
+        return []
+    paths = cast(dict[str, Any], paths_obj)
+
+    routes: list[RouteInfo] = []
+    methods = ["get", "post", "put", "patch", "delete", "head", "options"]
+
+    for path, path_item_obj in paths.items():
+        if not isinstance(path_item_obj, dict):
+            continue
+        path_item = cast(dict[str, Any], path_item_obj)
+
+        for method in methods:
+            operation_obj = path_item.get(method)
+            if not isinstance(operation_obj, dict):
+                continue
+            operation = cast(dict[str, Any], operation_obj)
+
+            parameters: list[RouteParameter] = []
+            responses: dict[str, AnySchema] = {}
+
+            for params_src in (path_item.get("parameters"), operation.get("parameters")):
+                if isinstance(params_src, list):
+                    for param in params_src:
+                        if isinstance(param, dict):
+                            parameters.append(
+                                RouteParameter(
+                                    name=str(param.get("name", "")),
+                                    location=str(param.get("in", "query")),
+                                    required=bool(param.get("required")),
+                                    schema=param.get("schema", {}),
+                                )
+                            )
+
+            request_body = None
+            rb = operation.get("requestBody")
+            if isinstance(rb, dict):
+                content = rb.get("content")
+                if isinstance(content, dict):
+                    json_content = content.get("application/json")
+                    if isinstance(json_content, dict):
+                        request_body = json_content.get("schema", {})
+
+            responses_obj = operation.get("responses")
+            if isinstance(responses_obj, dict):
+                for status_code, response in responses_obj.items():
+                    if not isinstance(response, dict):
+                        continue
+                    content = response.get("content")
+                    if isinstance(content, dict):
+                        json_content = content.get("application/json")
+                        if isinstance(json_content, dict):
+                            schema = json_content.get("schema")
+                            if schema is not None:
+                                responses[str(status_code)] = schema
+
+            routes.append(
+                RouteInfo(
+                    path=str(path),
+                    method=_to_upper_method(method),
+                    parameters=parameters,
+                    request_body=request_body,
+                    responses=responses,
+                )
+            )
+
+    return routes
+
+
+def generate_route_schema_names(route: RouteInfo) -> RouteSchemaNames:
+    path_params = [p for p in route.parameters if p.location == "path"]
+    query_params = [p for p in route.parameters if p.location == "query"]
+    header_params = [p for p in route.parameters if p.location == "header"]
+    success_statuses = [status for status in route.responses if status.startswith("2")]
+
+    result = RouteSchemaNames()
+    if success_statuses:
+        result.response_schema_name = build_route_schema_name(
+            route.path,
+            route.method,
+            "Response",
+        )
+
+    if path_params:
+        result.params_schema_name = build_route_schema_name(
+            route.path,
+            route.method,
+            "Params",
+        )
+
+    if query_params:
+        result.query_schema_name = build_route_schema_name(
+            route.path,
+            route.method,
+            "Query",
+        )
+
+    if header_params:
+        result.headers_schema_name = build_route_schema_name(
+            route.path,
+            route.method,
+            "Headers",
+        )
+
+    if route.request_body is not None:
+        result.body_schema_name = build_route_schema_name(
+            route.path,
+            route.method,
+            "Body",
+        )
+
+    return result