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

alt_stack_openapi_pydantic/schema_dedup.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any, TypedDict
+
+from .types import AnySchema
+
+
+def _sort_object_deep(obj: Any) -> Any:
+    if obj is None or not isinstance(obj, (dict, list)):
+        return obj
+    if isinstance(obj, list):
+        return [_sort_object_deep(item) for item in obj]
+    sorted_obj: dict[str, Any] = {}
+    for key in sorted(obj.keys()):
+        sorted_obj[key] = _sort_object_deep(obj[key])
+    return sorted_obj
+
+
+def get_schema_fingerprint(schema: AnySchema) -> str:
+    return json.dumps(_sort_object_deep(schema), sort_keys=True)
+
+
+@dataclass
+class SchemaRegistry:
+    fingerprint_to_name: dict[str, str]
+
+
+def create_schema_registry() -> SchemaRegistry:
+    return SchemaRegistry(fingerprint_to_name={})
+
+
+@dataclass
+class RegisterSchemaResult:
+    is_new: bool
+    canonical_name: str
+
+
+def register_schema(
+    registry: SchemaRegistry,
+    name: str,
+    schema: AnySchema,
+) -> RegisterSchemaResult:
+    fingerprint = get_schema_fingerprint(schema)
+    existing = registry.fingerprint_to_name.get(fingerprint)
+    if existing:
+        return RegisterSchemaResult(is_new=False, canonical_name=existing)
+    registry.fingerprint_to_name[fingerprint] = name
+    return RegisterSchemaResult(is_new=True, canonical_name=name)
+
+
+def pre_register_schema(
+    registry: SchemaRegistry,
+    name: str,
+    fingerprint: str,
+) -> None:
+    registry.fingerprint_to_name[fingerprint] = name
+
+
+def extract_error_code(schema: AnySchema) -> str | None:
+    props = schema.get("properties")
+    if not isinstance(props, dict):
+        return None
+    error_obj = props.get("error")
+    if not isinstance(error_obj, dict):
+        return None
+    error_props = error_obj.get("properties")
+    if not isinstance(error_props, dict):
+        return None
+    code_schema = error_props.get("code")
+    if not isinstance(code_schema, dict):
+        return None
+    code_enum = code_schema.get("enum")
+    if isinstance(code_enum, list) and len(code_enum) == 1:
+        return str(code_enum[0])
+    return None
+
+
+def error_code_to_pascal_case(code: str) -> str:
+    return "".join(part.capitalize() for part in code.split("_"))
+
+
+def generate_common_error_schema_name(error_code: str) -> str:
+    return f"{error_code_to_pascal_case(error_code)}Error"
+
+
+@dataclass
+class CommonSchema:
+    name: str
+    schema: AnySchema
+    fingerprint: str
+    count: int
+
+
+class NamedSchema(TypedDict):
+    name: str
+    schema: AnySchema
+
+
+def find_common_schemas(
+    schemas: list[NamedSchema],
+    min_count: int = 2,
+) -> list[CommonSchema]:
+    fingerprints: dict[str, dict[str, Any]] = {}
+
+    for item in schemas:
+        name = item["name"]
+        schema = item["schema"]
+        fingerprint = get_schema_fingerprint(schema)
+        existing = fingerprints.get(fingerprint)
+        if existing:
+            existing["names"].append(name)
+        else:
+            fingerprints[fingerprint] = {
+                "schema": schema,
+                "names": [name],
+                "error_code": extract_error_code(schema),
+            }
+
+    common: list[CommonSchema] = []
+    for fingerprint, data in fingerprints.items():
+        names = data["names"]
+        if len(names) < min_count:
+            continue
+        error_code = data["error_code"]
+        name = (
+            generate_common_error_schema_name(error_code)
+            if isinstance(error_code, str)
+            else names[0]
+        )
+        common.append(
+            CommonSchema(
+                name=name,
+                schema=data["schema"],
+                fingerprint=fingerprint,
+                count=len(names),
+            )
+        )
+
+    return sorted(common, key=lambda item: item.count, reverse=True)

alt_stack_openapi_pydantic/to_python.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .emission import openapi_to_pydantic_code
+from .rendering import schema_to_type_expr
+from .types import AnySchema
+
+
+def convert_schema_to_pydantic_string(schema: AnySchema | None) -> str:
+    return schema_to_type_expr(schema)
+
+
+__all__ = ["convert_schema_to_pydantic_string", "openapi_to_pydantic_code"]

alt_stack_openapi_pydantic/type_render.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def format_openapi_metadata(meta: dict[str, Any]) -> str:
+    ordered = {key: meta[key] for key in sorted(meta)}
+    return f"json_schema_extra={{'openapi': {ordered!r}}}"
+
+
+def wrap_annotated(base: str, metadata: list[str]) -> str:
+    if not metadata:
+        return base
+    parts = ", ".join(metadata)
+    return f"Annotated[{base}, {parts}]"

alt_stack_openapi_pydantic/types/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .types import AnySchema, OpenAPIObjectSchema
+
+__all__ = ["AnySchema", "OpenAPIObjectSchema"]

alt_stack_openapi_pydantic/types/array.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from ..type_render import format_openapi_metadata, wrap_annotated
+
+
+def convert_openapi_array_to_pydantic(
+    schema: dict[str, Any],
+    convert_schema: Callable[[dict[str, Any]], str],
+) -> str:
+    items = schema.get("items")
+    item_type = "Any"
+    if isinstance(items, dict):
+        item_type = convert_schema(items)
+
+    base = f"list[{item_type}]"
+
+    min_items = schema.get("minItems")
+    max_items = schema.get("maxItems")
+
+    field_args: list[str] = []
+    if isinstance(min_items, int):
+        field_args.append(f"min_length={min_items}")
+    if isinstance(max_items, int):
+        field_args.append(f"max_length={max_items}")
+
+    meta: dict[str, Any] = {}
+    if isinstance(min_items, int):
+        meta["minItems"] = min_items
+    if isinstance(max_items, int):
+        meta["maxItems"] = max_items
+    if meta:
+        field_args.append(format_openapi_metadata(meta))
+
+    if field_args:
+        return wrap_annotated(base, [f"Field({', '.join(field_args)})"])
+
+    return base

alt_stack_openapi_pydantic/types/boolean.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..registry import get_schema_exported_variable_name_for_primitive_type
+from ..type_render import wrap_annotated
+
+
+def convert_openapi_boolean_to_pydantic(schema: dict[str, Any]) -> str:
+    _ = schema
+    custom = get_schema_exported_variable_name_for_primitive_type("boolean")
+    if custom:
+        return custom
+    return wrap_annotated("bool", ["Field(strict=True)"])

alt_stack_openapi_pydantic/types/intersection.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+
+def convert_openapi_intersection_to_pydantic(
+    schema: dict[str, Any],
+    convert_schema: Callable[[dict[str, Any]], str],
+) -> str:
+    items = schema.get("allOf")
+    if not isinstance(items, list):
+        return "Any"
+
+    parts = [convert_schema(item) for item in items if isinstance(item, dict)]
+    if not parts:
+        return "Any"
+    if len(parts) == 1:
+        return parts[0]
+
+    return f"all_of({', '.join(parts)})"

alt_stack_openapi_pydantic/types/number.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..registry import get_schema_exported_variable_name_for_primitive_type
+from ..type_render import format_openapi_metadata, wrap_annotated
+
+
+def convert_openapi_number_to_pydantic(schema: dict[str, Any]) -> str:
+    if isinstance(schema.get("enum"), list):
+        values = ", ".join(repr(value) for value in schema["enum"])
+        return f"Literal[{values}]"
+
+    schema_type = schema.get("type")
+    if schema_type in {"number", "integer", "boolean"}:
+        custom = get_schema_exported_variable_name_for_primitive_type(schema_type)
+        if custom:
+            return custom
+
+    base = "int" if schema.get("type") == "integer" else "float"
+
+    minimum = schema.get("minimum")
+    maximum = schema.get("maximum")
+
+    field_args: list[str] = ["strict=True"]
+    if isinstance(minimum, (int, float)):
+        field_args.append(f"ge={minimum}")
+    if isinstance(maximum, (int, float)):
+        field_args.append(f"le={maximum}")
+
+    meta: dict[str, Any] = {}
+    if isinstance(minimum, (int, float)):
+        meta["minimum"] = minimum
+    if isinstance(maximum, (int, float)):
+        meta["maximum"] = maximum
+    if meta:
+        field_args.append(format_openapi_metadata(meta))
+
+    return wrap_annotated(base, [f"Field({', '.join(field_args)})"])

alt_stack_openapi_pydantic/types/object.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+
+def convert_openapi_object_to_pydantic(
+    schema: dict[str, Any],
+    convert_schema: Callable[[dict[str, Any]], str],
+) -> str:
+    additional = schema.get("additionalProperties")
+
+    if isinstance(additional, dict):
+        return f"dict[str, {convert_schema(additional)}]"
+
+    return "dict[str, Any]"

alt_stack_openapi_pydantic/types/string.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..registry import get_schema_exported_variable_name_for_string_format
+from ..type_render import format_openapi_metadata, wrap_annotated
+
+
+def convert_openapi_string_to_pydantic(schema: dict[str, Any]) -> str:
+    if isinstance(schema.get("enum"), list):
+        values = ", ".join(repr(value) for value in schema["enum"])
+        return f"Literal[{values}]"
+
+    fmt = schema.get("format")
+    if isinstance(fmt, str) and fmt:
+        custom_schema = get_schema_exported_variable_name_for_string_format(fmt)
+        if custom_schema:
+            return custom_schema
+    else:
+        fmt = None
+
+    base = "str"
+    if fmt == "email":
+        base = "EmailStr"
+    elif fmt in {"url", "uri"}:
+        base = "AnyUrl"
+    elif fmt == "uuid":
+        base = "UUID"
+
+    min_length = schema.get("minLength")
+    max_length = schema.get("maxLength")
+    pattern = schema.get("pattern")
+    pattern_is_explicit = isinstance(pattern, str)
+
+    if fmt == "color-hex" and not pattern_is_explicit:
+        pattern = "^[a-fA-F0-9]{6}$"
+
+    field_args: list[str] = []
+    if base == "str":
+        field_args.append("strict=True")
+    if isinstance(min_length, int):
+        field_args.append(f"min_length={min_length}")
+    if isinstance(max_length, int):
+        field_args.append(f"max_length={max_length}")
+    if isinstance(pattern, str):
+        field_args.append(f"pattern={pattern!r}")
+
+    meta: dict[str, Any] = {}
+    if isinstance(fmt, str):
+        meta["format"] = fmt
+    if isinstance(pattern, str) and pattern_is_explicit:
+        meta["pattern"] = pattern
+    if isinstance(min_length, int):
+        meta["minLength"] = min_length
+    if isinstance(max_length, int):
+        meta["maxLength"] = max_length
+
+    if meta:
+        field_args.append(format_openapi_metadata(meta))
+
+    if field_args:
+        return wrap_annotated(base, [f"Field({', '.join(field_args)})"])
+
+    return base

alt_stack_openapi_pydantic/types/types.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from typing import Any
+
+AnySchema = dict[str, Any]
+OpenAPIObjectSchema = dict[str, Any]

alt_stack_openapi_pydantic/types/union.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from ..type_render import format_openapi_metadata, wrap_annotated
+
+
+def convert_openapi_union_to_pydantic(
+    schema: dict[str, Any],
+    convert_schema: Callable[[dict[str, Any]], str],
+) -> str:
+    items = schema.get("oneOf")
+    if not isinstance(items, list):
+        return "Any"
+
+    item_types = [convert_schema(item) for item in items if isinstance(item, dict)]
+    if not item_types:
+        return "Any"
+
+    union_expr = f"Union[{', '.join(item_types)}]" if len(item_types) > 1 else item_types[0]
+
+    discriminator = schema.get("discriminator")
+    field_args: list[str] = []
+    meta: dict[str, Any] = {}
+    if isinstance(discriminator, dict):
+        property_name = discriminator.get("propertyName")
+        if isinstance(property_name, str) and property_name:
+            field_args.append(f"discriminator={property_name!r}")
+            meta["discriminator"] = discriminator
+
+    if meta:
+        field_args.append(format_openapi_metadata(meta))
+
+    if field_args:
+        return wrap_annotated(union_expr, [f"Field({', '.join(field_args)})"])
+
+    return union_expr

alt_stack_openapi_pydantic/utils.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import keyword
+import re
+
+_VALID_IDENTIFIER = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+def to_pascal_case(value: str) -> str:
+    parts = re.split(r"[^A-Za-z0-9]+", value)
+    return "".join(part[:1].upper() + part[1:] for part in parts if part)
+
+
+def to_snake_case(value: str) -> str:
+    value = re.sub(r"[^A-Za-z0-9]+", "_", value).strip("_")
+    if not value:
+        return "field"
+    value = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", value)
+    return value.lower()
+
+
+def safe_identifier(name: str, used: set[str]) -> tuple[str, bool]:
+    candidate = to_snake_case(name)
+    if not _VALID_IDENTIFIER.match(candidate) or keyword.iskeyword(candidate):
+        candidate = f"_{candidate}"
+    base = candidate
+    idx = 1
+    while candidate in used:
+        idx += 1
+        candidate = f"{base}_{idx}"
+    used.add(candidate)
+    return candidate, candidate != name

alt_stack_openapi_pydantic-1.6.2.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,28 @@
+alt_stack_openapi_pydantic/__init__.py,sha256=fFC0seuk0nMLp7ocTUuHyvTR3RJoPK8dLCPDWQ7a8_s,665
+alt_stack_openapi_pydantic/cli.py,sha256=wyjMEXo4mHTcmrQzBLz0vMEopKZ152Mqi9QoRP99TGY,1909
+alt_stack_openapi_pydantic/dependencies.py,sha256=27kkVQo8l5jSfytoXpPW6k_gJu_QAL-KSKS1B0ABGMY,3192
+alt_stack_openapi_pydantic/emission.py,sha256=z5O1j8-q9FoZbzMdt9ib3JzrpCLO8m08-pWNr3P3tqI,27463
+alt_stack_openapi_pydantic/lowering.py,sha256=p9fOcDPCNwNiYvsTNnxXHbF30ytx6KusPmW3Y9R-kns,3721
+alt_stack_openapi_pydantic/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+alt_stack_openapi_pydantic/registry.py,sha256=11v1K_6yAKjfMp4hFTNFD7VIxV1LMNFgHbESZBoiL6k,5085
+alt_stack_openapi_pydantic/rendering.py,sha256=Tx1YvO9npLMtmeQ8sR-UR24YqAFlyFRceNT-aDdisJw,6264
+alt_stack_openapi_pydantic/routes.py,sha256=A_NPx6zZGKpZbTl5rIDdf7YR083_vHNg49eMRCalKpk,5814
+alt_stack_openapi_pydantic/schema_dedup.py,sha256=nR8VrXFooeV02xDDDdRDCD5FsMYLFq2kMpdz8KqOo28,3751
+alt_stack_openapi_pydantic/to_python.py,sha256=x4wDyXvaOV_I4UjmpeYEF_72AL3G5NGrusn1ZncJWSk,346
+alt_stack_openapi_pydantic/type_render.py,sha256=n2j0iPy5daNPMOWQwwYo5hF3ok2vuSf0Ls8FGiVhoiI,408
+alt_stack_openapi_pydantic/utils.py,sha256=91xMmdRwQP0WMPJSg7n2GrQq5Uqk2cLI3auq3Uq2n4g,907
+alt_stack_openapi_pydantic/types/__init__.py,sha256=MUlvT6Woc4YFbN82M7-k7_3k5rXztfdfPw3TTNzoVwM,134
+alt_stack_openapi_pydantic/types/array.py,sha256=KXsC_l2kz4sUMIaTIWZiZKDasYK7cuJ9yvkPNv1w8LI,1071
+alt_stack_openapi_pydantic/types/boolean.py,sha256=otAaBJmsaZTBV-8-gVDS9OIqIaacz3hlbO5nO6PTq6o,438
+alt_stack_openapi_pydantic/types/intersection.py,sha256=iGGVPzbJAYMhG3ktalWPgm1hbicN528ZgzoRTAnxrvI,506
+alt_stack_openapi_pydantic/types/number.py,sha256=39lakX2P-6V1Ipf-qrY5jJ2mnSEyjBRpYDYShQ2e1IU,1323
+alt_stack_openapi_pydantic/types/object.py,sha256=BDQyu77Ouz2M-bj7YLkNDsTxzPyg4Ap_7iMNtlr7wXg,379
+alt_stack_openapi_pydantic/types/string.py,sha256=qNsNXCbJNmzjebkqOYUKi0tapiZ5USqCUT7Tv6fWkXE,1962
+alt_stack_openapi_pydantic/types/types.py,sha256=2rbEHIxFMrRFHw72tUuOCim2vzIUErfJuclliUUahiQ,124
+alt_stack_openapi_pydantic/types/union.py,sha256=qWIMXaqN4D4x2PnYEu0w-H3TOHG5VkXMZbF6-7F6Agc,1158
+alt_stack_openapi_pydantic-1.6.2.dist-info/licenses/LICENSE,sha256=OvI3tgOAzCyCFOjcQ42mFXk6SKQTicTDrUgbqofOXGY,1072
+alt_stack_openapi_pydantic-1.6.2.dist-info/METADATA,sha256=0imf_TzJfH8e-3ySDrSgHxeHlYFLe61cirWQgnuWrOg,3765
+alt_stack_openapi_pydantic-1.6.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+alt_stack_openapi_pydantic-1.6.2.dist-info/entry_points.txt,sha256=n_oPzTHD1-LolT8dLBmubt9ajr9-A-rokIx-CpT6Nlg,83
+alt_stack_openapi_pydantic-1.6.2.dist-info/top_level.txt,sha256=qUyCFcP-72UcOp06tPOxJLqxzRXMr7OOhenSuZKIaqo,27
+alt_stack_openapi_pydantic-1.6.2.dist-info/RECORD,,

alt_stack_openapi_pydantic-1.6.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

alt_stack_openapi_pydantic-1.6.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+alt-stack-openapi-pydantic = alt_stack_openapi_pydantic.cli:main

alt_stack_openapi_pydantic-1.6.2.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+alt_stack_openapi_pydantic