alt-stack-openapi-pydantic 1.6.2__tar.gz

alt_stack_openapi_pydantic-1.6.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Anthony Altieri
+
+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.

alt_stack_openapi_pydantic-1.6.2/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: alt-stack-openapi-pydantic
+Version: 1.6.2
+Summary: Generate Pydantic models, typed route maps, and an asyncio client from OpenAPI
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/anthonyaltieri/alt-stack
+Project-URL: Repository, https://github.com/anthonyaltieri/alt-stack
+Project-URL: Issues, https://github.com/anthonyaltieri/alt-stack/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic[email]>=2.7.0
+Provides-Extra: dev
+Requires-Dist: alt-stack-http-client-httpx; extra == "dev"
+Requires-Dist: pyrefly>=1.0.0; extra == "dev"
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: ruff>=0.6.0; extra == "dev"
+Requires-Dist: ty>=0.0.78; extra == "dev"
+Dynamic: license-file
+
+# `alt-stack-openapi-pydantic`
+
+Generate Python 3.11+ Pydantic 2 models, statically typed `Request`/`Response` route maps, and an asyncio `HttpxApiClient` from OpenAPI JSON. This is the Python counterpart of `@alt-stack/zod-openapi`; the generated client runs on `alt-stack-http-client-httpx`.
+
+## Install
+
+```bash
+python -m pip install alt-stack-openapi-pydantic
+```
+
+Consumers of a generated SDK install the runtime package instead:
+
+```bash
+python -m pip install alt-stack-http-client-httpx
+```
+
+## Generate
+
+```bash
+alt-stack-openapi-pydantic ./openapi.json --output ./generated_types.py
+```
+
+`input` may be a local JSON path or HTTP(S) URL. Use `--registry` to execute custom type mappings and `--include` to insert imports/definitions into output.
+
+```python
+from generated_types import User
+
+user = User.model_validate({"id": "u_1", "name": "Ada"})
+```
+
+The CLI enables route generation and emits `Request`/`Response` dictionaries whose leaves are Pydantic model classes. The dictionaries carry generated `TypedDict` annotations, so type checkers resolve literal lookups to the exact model and reject unknown paths, methods, request parts, and status codes:
+
+```python
+from generated_types import Request, Response
+
+Request["/users"]["POST"]["body"]          # type[CreateUserBody]
+Response["/users/{id}"]["GET"]["200"]      # type[User]
+Response["/users/{id}"]["GET"]["999"]      # static error: unknown status
+```
+
+Generated modules also include an asyncio `HttpxApiClient` with one typed method per route, built on `alt_stack_http_client_httpx`:
+
+```python
+from alt_stack_http_client_httpx import ApiSuccess
+
+from generated_types import GetUsersIdParams, HttpxApiClient, Request, Response
+
+async with HttpxApiClient(
+    "https://api.example.com", request_map=Request, response_map=Response
+) as client:
+    result = await client.get("/users/{id}", params=GetUsersIdParams(id="u_1"))
+
+if isinstance(result, ApiSuccess):
+    result.body  # User; unknown paths, missing params, and wrong models are static errors
+```
+
+Generated modules that use non-object intersections inline a small `all_of` validator, so they depend only on `pydantic` and `alt-stack-http-client-httpx` at runtime.
+
+## Development
+
+```bash
+uv run --project packages/python-pydantic-openapi --extra dev pytest packages/python-pydantic-openapi/tests
+uv run --project packages/python-pydantic-openapi --extra dev ruff check packages/python-pydantic-openapi
+uv run --project packages/python-pydantic-openapi --extra dev ty check packages/python-pydantic-openapi
+```
+
+## Documentation
+
+- [Code generation Quickstart](../../apps/docs/docs/codegen/quickstart.md)
+- [Common Patterns](../../apps/docs/docs/codegen/common-patterns.md)
+- [Python/Pydantic API Documentation](../../apps/docs/docs/codegen/api/pydantic-openapi.md)

alt_stack_openapi_pydantic-1.6.2/README.md

@@ -0,0 +1,71 @@
+# `alt-stack-openapi-pydantic`
+
+Generate Python 3.11+ Pydantic 2 models, statically typed `Request`/`Response` route maps, and an asyncio `HttpxApiClient` from OpenAPI JSON. This is the Python counterpart of `@alt-stack/zod-openapi`; the generated client runs on `alt-stack-http-client-httpx`.
+
+## Install
+
+```bash
+python -m pip install alt-stack-openapi-pydantic
+```
+
+Consumers of a generated SDK install the runtime package instead:
+
+```bash
+python -m pip install alt-stack-http-client-httpx
+```
+
+## Generate
+
+```bash
+alt-stack-openapi-pydantic ./openapi.json --output ./generated_types.py
+```
+
+`input` may be a local JSON path or HTTP(S) URL. Use `--registry` to execute custom type mappings and `--include` to insert imports/definitions into output.
+
+```python
+from generated_types import User
+
+user = User.model_validate({"id": "u_1", "name": "Ada"})
+```
+
+The CLI enables route generation and emits `Request`/`Response` dictionaries whose leaves are Pydantic model classes. The dictionaries carry generated `TypedDict` annotations, so type checkers resolve literal lookups to the exact model and reject unknown paths, methods, request parts, and status codes:
+
+```python
+from generated_types import Request, Response
+
+Request["/users"]["POST"]["body"]          # type[CreateUserBody]
+Response["/users/{id}"]["GET"]["200"]      # type[User]
+Response["/users/{id}"]["GET"]["999"]      # static error: unknown status
+```
+
+Generated modules also include an asyncio `HttpxApiClient` with one typed method per route, built on `alt_stack_http_client_httpx`:
+
+```python
+from alt_stack_http_client_httpx import ApiSuccess
+
+from generated_types import GetUsersIdParams, HttpxApiClient, Request, Response
+
+async with HttpxApiClient(
+    "https://api.example.com", request_map=Request, response_map=Response
+) as client:
+    result = await client.get("/users/{id}", params=GetUsersIdParams(id="u_1"))
+
+if isinstance(result, ApiSuccess):
+    result.body  # User; unknown paths, missing params, and wrong models are static errors
+```
+
+Generated modules that use non-object intersections inline a small `all_of` validator, so they depend only on `pydantic` and `alt-stack-http-client-httpx` at runtime.
+
+## Development
+
+```bash
+uv run --project packages/python-pydantic-openapi --extra dev pytest packages/python-pydantic-openapi/tests
+uv run --project packages/python-pydantic-openapi --extra dev ruff check packages/python-pydantic-openapi
+uv run --project packages/python-pydantic-openapi --extra dev ty check packages/python-pydantic-openapi
+```
+
+## Documentation
+
+- [Code generation Quickstart](../../apps/docs/docs/codegen/quickstart.md)
+- [Common Patterns](../../apps/docs/docs/codegen/common-patterns.md)
+- [Python/Pydantic API Documentation](../../apps/docs/docs/codegen/api/pydantic-openapi.md)

alt_stack_openapi_pydantic-1.6.2/pyproject.toml

@@ -0,0 +1,61 @@
+[project]
+name = "alt-stack-openapi-pydantic"
+version = "1.6.2"
+description = "Generate Pydantic models, typed route maps, and an asyncio client from OpenAPI"
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Typing :: Typed",
+]
+dependencies = ["pydantic[email]>=2.7.0"]
+
+[project.urls]
+Homepage = "https://github.com/anthonyaltieri/alt-stack"
+Repository = "https://github.com/anthonyaltieri/alt-stack"
+Issues = "https://github.com/anthonyaltieri/alt-stack/issues"
+
+[project.optional-dependencies]
+dev = [
+  "alt-stack-http-client-httpx",
+  "pyrefly>=1.0.0",
+  "pytest>=8.0.0",
+  "ruff>=0.6.0",
+  "ty>=0.0.78",
+]
+
+[project.scripts]
+alt-stack-openapi-pydantic = "alt_stack_openapi_pydantic.cli:main"
+
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+include-package-data = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["alt_stack_openapi_pydantic*"]
+
+[tool.setuptools.package-data]
+"alt_stack_openapi_pydantic" = ["py.typed"]
+
+[tool.uv.sources]
+alt-stack-http-client-httpx = { path = "../python-http-client-httpx" }
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"

alt_stack_openapi_pydantic-1.6.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

alt_stack_openapi_pydantic-1.6.2/src/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-1.6.2/src/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-1.6.2/src/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