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

alt_stack_openapi_pydantic/__init__.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from .registry import (
+    SUPPORTED_STRING_FORMATS,
+    clear_pydantic_schema_registry,
+    get_schema_exported_variable_name_for_primitive_type,
+    get_schema_exported_variable_name_for_string_format,
+    register_pydantic_type_to_openapi_schema,
+    schema_registry,
+)
+from .to_python import openapi_to_pydantic_code
+
+__all__ = [
+    "SUPPORTED_STRING_FORMATS",
+    "clear_pydantic_schema_registry",
+    "get_schema_exported_variable_name_for_primitive_type",
+    "get_schema_exported_variable_name_for_string_format",
+    "openapi_to_pydantic_code",
+    "register_pydantic_type_to_openapi_schema",
+    "schema_registry",
+]

alt_stack_openapi_pydantic/cli.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from runpy import run_path
+from urllib.request import urlopen
+
+from .to_python import openapi_to_pydantic_code
+
+
+def _load_schema(source: str) -> dict[str, object]:
+    if source.startswith("http://") or source.startswith("https://"):
+        with urlopen(source) as response:  # nosec - user-provided URL
+            return json.loads(response.read().decode("utf-8"))
+    return json.loads(Path(source).read_text(encoding="utf-8"))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="alt-stack-openapi-pydantic",
+        description="Generate Pydantic models from an OpenAPI schema",
+    )
+    parser.add_argument("input", help="OpenAPI schema file path or URL")
+    parser.add_argument(
+        "-o",
+        "--output",
+        default="generated-types.py",
+        help="Output file path",
+    )
+    parser.add_argument(
+        "-r",
+        "--registry",
+        help="Registry file that registers custom schemas",
+    )
+    parser.add_argument(
+        "-i",
+        "--include",
+        help="Python file to include at top of generated output",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        if args.registry:
+            run_path(args.registry)
+
+        include_content = None
+        if args.include:
+            include_content = Path(args.include).read_text(encoding="utf-8")
+
+        schema = _load_schema(args.input)
+        custom_lines = [include_content] if include_content else None
+        code = openapi_to_pydantic_code(
+            schema,
+            custom_import_lines=custom_lines,
+            options={"include_routes": True},
+        )
+        Path(args.output).write_text(code, encoding="utf-8")
+    except Exception as exc:  # noqa: BLE001
+        print(f"Error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

alt_stack_openapi_pydantic/dependencies.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import unquote
+
+from .types import AnySchema
+
+
+def extract_schema_dependencies(schema: AnySchema | None) -> list[str]:
+    dependencies: set[str] = set()
+    visited: set[int] = set()
+
+    def traverse(obj: Any) -> None:
+        if obj is None or not isinstance(obj, (dict, list)):
+            return
+
+        obj_id = id(obj)
+        if obj_id in visited:
+            return
+        visited.add(obj_id)
+
+        if isinstance(obj, dict) and isinstance(obj.get("$ref"), str):
+            match = obj["$ref"].split("#/components/schemas/")
+            if len(match) == 2 and match[1]:
+                dependencies.add(unquote(match[1]))
+            return
+
+        if isinstance(obj, list):
+            for item in obj:
+                traverse(item)
+            return
+
+        if isinstance(obj, dict):
+            props = obj.get("properties")
+            if isinstance(props, dict):
+                for value in props.values():
+                    traverse(value)
+
+            for key in [
+                "items",
+                "oneOf",
+                "allOf",
+                "anyOf",
+                "not",
+                "if",
+                "then",
+                "else",
+                "prefixItems",
+                "contains",
+                "propertyNames",
+                "dependentSchemas",
+            ]:
+                if key in obj:
+                    traverse(obj[key])
+
+            additional = obj.get("additionalProperties")
+            if isinstance(additional, dict):
+                traverse(additional)
+
+            discriminator = obj.get("discriminator")
+            if isinstance(discriminator, dict):
+                mapping = discriminator.get("mapping")
+                if isinstance(mapping, dict):
+                    for value in mapping.values():
+                        traverse(value)
+
+    traverse(schema)
+    return list(dependencies)
+
+
+def topological_sort_schemas(schemas: dict[str, AnySchema]) -> list[str]:
+    schema_names = list(schemas.keys())
+    dependencies: dict[str, list[str]] = {name: [] for name in schema_names}
+    dependents: dict[str, list[str]] = {name: [] for name in schema_names}
+    in_degree: dict[str, int] = {name: 0 for name in schema_names}
+
+    for name, schema in schemas.items():
+        deps = extract_schema_dependencies(schema)
+        valid_deps = [dep for dep in deps if dep in schemas]
+        dependencies[name] = valid_deps
+        for dep in valid_deps:
+            dependents[dep].append(name)
+
+    for name, deps in dependencies.items():
+        in_degree[name] = len(deps)
+
+    queue = [name for name, degree in in_degree.items() if degree == 0]
+    sorted_names: list[str] = []
+
+    while queue:
+        current = queue.pop(0)
+        sorted_names.append(current)
+        for dependent in dependents[current]:
+            in_degree[dependent] -= 1
+            if in_degree[dependent] == 0:
+                queue.append(dependent)
+
+    if len(sorted_names) != len(schema_names):
+        for name in schema_names:
+            if name not in sorted_names:
+                sorted_names.append(name)
+
+    return sorted_names