alt-stack-openapi-pydantic 1.7.0__tar.gz → 1.7.1__tar.gz

{alt_stack_openapi_pydantic-1.7.0/src/alt_stack_openapi_pydantic.egg-info → alt_stack_openapi_pydantic-1.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alt-stack-openapi-pydantic
-Version: 1.7.0
+Version: 1.7.1
 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
@@ -101,12 +101,26 @@ Python requires a class as a `NewType` base. Literal brands use their primitive
 base; composite unions use `object` with the original Pydantic validator retained
 in `Annotated` metadata.
 
+## Identifiers and wire names
+
+Component names become Python identifiers: `Rule-Output` becomes `Rule_Output`,
+leading digits gain an underscore, and Python keywords gain a trailing underscore.
+Names that normalize to the same identifier cause a generation error with both
+original names. References and route maps use the generated identifiers.
+
+Underscore properties become public fields with aliases: `_id` becomes `id_`.
+Invalid property characters and Python keywords are also handled, with numeric
+suffixes where needed to avoid field collisions. Validate with the original wire
+names and use `model_dump(by_alias=True)` or `model_dump_json(by_alias=True)` to
+serialize them. The HTTP client serializes aliases automatically.
+
 ## 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
+uv sync --project packages/python-pydantic-openapi --extra dev
+packages/python-pydantic-openapi/.venv/bin/pytest packages/python-pydantic-openapi/tests -q
+packages/python-pydantic-openapi/.venv/bin/ruff check packages/python-pydantic-openapi
+packages/python-pydantic-openapi/.venv/bin/ty check packages/python-pydantic-openapi
 ```
 
 ## Documentation

{alt_stack_openapi_pydantic-1.7.0 → alt_stack_openapi_pydantic-1.7.1}/README.md

@@ -77,12 +77,26 @@ Python requires a class as a `NewType` base. Literal brands use their primitive
 base; composite unions use `object` with the original Pydantic validator retained
 in `Annotated` metadata.
 
+## Identifiers and wire names
+
+Component names become Python identifiers: `Rule-Output` becomes `Rule_Output`,
+leading digits gain an underscore, and Python keywords gain a trailing underscore.
+Names that normalize to the same identifier cause a generation error with both
+original names. References and route maps use the generated identifiers.
+
+Underscore properties become public fields with aliases: `_id` becomes `id_`.
+Invalid property characters and Python keywords are also handled, with numeric
+suffixes where needed to avoid field collisions. Validate with the original wire
+names and use `model_dump(by_alias=True)` or `model_dump_json(by_alias=True)` to
+serialize them. The HTTP client serializes aliases automatically.
+
 ## 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
+uv sync --project packages/python-pydantic-openapi --extra dev
+packages/python-pydantic-openapi/.venv/bin/pytest packages/python-pydantic-openapi/tests -q
+packages/python-pydantic-openapi/.venv/bin/ruff check packages/python-pydantic-openapi
+packages/python-pydantic-openapi/.venv/bin/ty check packages/python-pydantic-openapi
 ```
 
 ## Documentation

{alt_stack_openapi_pydantic-1.7.0 → alt_stack_openapi_pydantic-1.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alt-stack-openapi-pydantic"
-version = "1.7.0"
+version = "1.7.1"
 description = "Generate Pydantic models, typed route maps, and an asyncio client from OpenAPI"
 readme = "README.md"
 requires-python = ">=3.11"

{alt_stack_openapi_pydantic-1.7.0 → alt_stack_openapi_pydantic-1.7.1}/src/alt_stack_openapi_pydantic/emission.py

@@ -5,6 +5,7 @@ from typing import Any
 
 from .brands import newtype_base, prepare_brand_schemas
 from .dependencies import topological_sort_schemas
+from .identifiers import component_identifiers, field_identifiers
 from .lowering import LoweringContext, NamedSchema, lower_named_schema
 from .rendering import (
     RenderContext,
@@ -34,8 +35,6 @@ from .schema_dedup import (
 )
 from .types import AnySchema
 
-_VALID_IDENTIFIER_CHARS = set("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
-
 
 @dataclass(slots=True)
 class EmissionState:
@@ -60,16 +59,19 @@ def openapi_to_pydantic_code(
         schemas, routes, schema_to_type_expr, is_object_model_schema
     )
 
-    lowering_context = LoweringContext(set(schemas.keys()))
+    component_names = component_identifiers(schemas)
+    lowering_context = LoweringContext(set(component_names.values()))
     lowered_components: list[NamedSchema] = []
     for name in topological_sort_schemas(schemas):
         schema = schemas.get(name)
         if schema is None:
             continue
-        lowered_components.extend(lower_named_schema(lowering_context, name, schema))
+        lowered_components.extend(
+            lower_named_schema(lowering_context, component_names[name], schema)
+        )
 
     lines = _build_module_preamble(custom_import_lines)
-    state = EmissionState()
+    state = EmissionState(render_context=RenderContext(component_names=component_names))
     registry = create_schema_registry()
 
     for named_schema in lowered_components:
@@ -96,7 +98,11 @@ def openapi_to_pydantic_code(
             lines.extend(_emit_model_rebuilds(state.rebuild_names))
             if route_lines:
                 lines.append("")
-            lines.extend(_generate_request_response_objects(routes, schema_name_to_canonical))
+            lines.extend(
+                _generate_request_response_objects(
+                    routes, schema_name_to_canonical, state.render_context
+                )
+            )
             return _finalize_module(lines, state)
 
     lines.extend(_emit_model_rebuilds(state.rebuild_names))
@@ -188,7 +194,7 @@ def _has_root_model_allof_base(schema: AnySchema, state: EmissionState) -> bool:
     return any(
         isinstance(part, dict)
         and isinstance(part.get("$ref"), str)
-        and decode_component_ref(part["$ref"]) in state.render_context.root_model_names
+        and state.render_context.resolve_ref(part["$ref"]) in state.render_context.root_model_names
         for part in all_of
     )
 
@@ -196,7 +202,7 @@ def _has_root_model_allof_base(schema: AnySchema, state: EmissionState) -> bool:
 def _emit_object_model(name: str, schema: AnySchema, state: EmissionState) -> list[str]:
     all_of = schema.get("allOf") if isinstance(schema, dict) else None
     if isinstance(all_of, list):
-        base_classes, merged_schema = _merge_allof_object_schema(all_of)
+        base_classes, merged_schema = _merge_allof_object_schema(all_of, state.render_context)
         model_lines = _build_model_lines(
             name, merged_schema, context=state.render_context, base_classes=base_classes or None
         )
@@ -219,7 +225,9 @@ def _emit_root_model(name: str, schema: AnySchema, state: EmissionState) -> list
     ]
 
 
-def _merge_allof_object_schema(all_of: list[Any]) -> tuple[list[str], dict[str, Any]]:
+def _merge_allof_object_schema(
+    all_of: list[Any], context: RenderContext
+) -> tuple[list[str], dict[str, Any]]:
     base_classes: list[str] = []
     inline_properties: dict[str, Any] = {}
     inline_required: list[str] = []
@@ -229,7 +237,7 @@ def _merge_allof_object_schema(all_of: list[Any]) -> tuple[list[str], dict[str,
         if not isinstance(part, dict):
             continue
         if isinstance(part.get("$ref"), str):
-            base_classes.append(decode_component_ref(part["$ref"]))
+            base_classes.append(context.resolve_ref(part["$ref"]))
             continue
 
         if part.get("type") == "object" or "properties" in part:
@@ -275,23 +283,25 @@ def _build_model_lines(
 
     alias_used = False
     field_lines: list[str] = []
-    used_names: set[str] = set()
 
     if isinstance(properties, dict):
+        attr_names = field_identifiers(properties)
         for prop_name, prop_schema in properties.items():
-            attr_name = _dedupe_name(_sanitize_identifier(prop_name), used_names)
+            attr_name = attr_names[prop_name]
             alias = prop_name if attr_name != prop_name else None
-            if alias:
+            if alias is not None:
                 alias_used = True
 
             type_expr = schema_to_type_expr(prop_schema, context=context)
             is_required = prop_name in required
             if is_required:
-                default_expr = f" = Field(alias={alias!r})" if alias else ""
+                default_expr = f" = Field(alias={alias!r})" if alias is not None else ""
             else:
                 if not is_nullable_schema(prop_schema):
                     type_expr = f"Annotated[Optional[{type_expr}], _omit_not_null]"
-                default_expr = f" = Field(default=None, alias={alias!r})" if alias else " = None"
+                default_expr = (
+                    f" = Field(default=None, alias={alias!r})" if alias is not None else " = None"
+                )
 
             field_lines.append(f"    {attr_name}: {type_expr}{default_expr}")
 
@@ -361,7 +371,7 @@ def _emit_route_schemas(
         )
 
     def register_route_schema(name: str, schema: AnySchema) -> None:
-        if _route_schema_ref_target(schema):
+        if _route_schema_ref_target(schema, state.render_context):
             return
         register_named_schema_batch(lower_named_schema(lowering_context, name, schema))
 
@@ -446,12 +456,13 @@ RouteMap = dict[str, dict[str, dict[str, str]]]
 def _generate_request_response_objects(
     routes: list[RouteInfo],
     schema_name_to_canonical: dict[str, str],
+    context: RenderContext,
 ) -> list[str]:
     request_paths: RouteMap = {}
     response_paths: RouteMap = {}
 
     def resolve_schema_name(name: str, schema: AnySchema) -> str:
-        ref_target = _route_schema_ref_target(schema)
+        ref_target = _route_schema_ref_target(schema, context)
         if ref_target:
             return ref_target
         return schema_name_to_canonical.get(name, name)
@@ -692,7 +703,7 @@ def _build_openapi_object_schema(params: list[dict[str, Any]]) -> dict[str, Any]
     }
 
 
-def _route_schema_ref_target(schema: AnySchema) -> str | None:
+def _route_schema_ref_target(schema: AnySchema, context: RenderContext) -> str | None:
     if not isinstance(schema, dict):
         return None
     ref = schema.get("$ref")
@@ -700,7 +711,7 @@ def _route_schema_ref_target(schema: AnySchema) -> str | None:
         return None
     if set(schema.keys()) != {"$ref"}:
         return None
-    return decode_component_ref(ref)
+    return context.resolve_ref(ref)
 
 
 def _rewrite_schema_refs(schema: AnySchema, aliases: dict[str, str]) -> AnySchema:
@@ -727,15 +738,6 @@ def _rewrite_schema_refs(schema: AnySchema, aliases: dict[str, str]) -> AnySchem
     return rewritten
 
 
-def _sanitize_identifier(name: str) -> str:
-    result = "".join(ch if ch in _VALID_IDENTIFIER_CHARS else "_" for ch in name)
-    if result and result[0].isupper() and result[1:].islower():
-        result = result[0].lower() + result[1:]
-    if not result or result[0].isdigit():
-        result = f"_{result}"
-    return f"{result}_" if result in {"class", "from", "global", "pass"} else result
-
-
 def _dedupe_name(name: str, used: set[str]) -> str:
     if name not in used:
         used.add(name)

alt_stack_openapi_pydantic-1.7.1/src/alt_stack_openapi_pydantic/identifiers.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import keyword
+import re
+from collections.abc import Iterable
+
+
+def component_identifiers(names: Iterable[str]) -> dict[str, str]:
+    """Keep wire names separate from the unique symbols used in Python source."""
+    identifiers: dict[str, str] = {}
+    owners: dict[str, str] = {}
+    for name in names:
+        identifier = re.sub(r"[^A-Za-z0-9_]", "_", name) or "Schema"
+        if identifier[0].isdigit():
+            identifier = f"_{identifier}"
+        if keyword.iskeyword(identifier):
+            identifier += "_"
+        if identifier in owners:
+            raise ValueError(
+                f"Component names {owners[identifier]!r} and {name!r} normalize to the "
+                f"same Python identifier {identifier!r}"
+            )
+        identifiers[name] = identifier
+        owners[identifier] = name
+    return identifiers
+
+
+def field_identifiers(names: Iterable[str]) -> dict[str, str]:
+    names = list(names)
+    wire_names = set(names)
+    identifiers: dict[str, str] = {}
+    used: set[str] = set()
+    for name in names:
+        candidate = re.sub(r"[^A-Za-z0-9_]", "_", name)
+        if candidate and candidate[0].isupper() and candidate[1:].islower():
+            candidate = candidate[0].lower() + candidate[1:]
+        if not candidate or candidate.startswith("_"):
+            candidate = f"{candidate.lstrip('_') or 'field'}_"
+        if candidate[0].isdigit():
+            candidate = f"field_{candidate}"
+        if keyword.iskeyword(candidate):
+            candidate += "_"
+
+        # Preserve existing casing aliases, and reserve wire names when repairing fields.
+        unavailable = used
+        if not name.isidentifier() or name.startswith("_") or keyword.iskeyword(name):
+            unavailable = used | wire_names
+        identifier = candidate
+        index = 2
+        while identifier in unavailable:
+            identifier = f"{candidate}_{index}"
+            index += 1
+        identifiers[name] = identifier
+        used.add(identifier)
+    return identifiers

{alt_stack_openapi_pydantic-1.7.0 → alt_stack_openapi_pydantic-1.7.1}/src/alt_stack_openapi_pydantic/rendering.py

@@ -24,6 +24,11 @@ from .types.union import convert_openapi_union_to_pydantic
 class RenderContext:
     root_model_names: set[str] = field(default_factory=set)
     uses_json: bool = False
+    component_names: dict[str, str] = field(default_factory=dict)
+
+    def resolve_ref(self, ref: str) -> str:
+        name = decode_component_ref(ref)
+        return self.component_names.get(name, name)
 
 
 def decode_component_ref(ref: str) -> str:
@@ -83,7 +88,7 @@ def schema_to_type_expr(
 
     brand_schema = schema.get("_altstack_brand_schema")
     if isinstance(brand_schema, dict):
-        name = decode_component_ref(schema["$ref"])
+        name = render_context.resolve_ref(schema["$ref"])
         expr = schema_to_type_expr(brand_schema, context=render_context)
         return wrap_nullable(branded_annotation(name, expr), schema)
     brand = get_brand_name(schema)
@@ -103,7 +108,7 @@ def schema_to_type_expr(
         ref = schema["$ref"]
         if not ref.startswith("#/components/schemas/"):
             return wrap_nullable("Any", schema)
-        expr = decode_component_ref(ref)
+        expr = render_context.resolve_ref(ref)
         return wrap_nullable(expr, schema)
 
     if isinstance(schema.get("oneOf"), list):

{alt_stack_openapi_pydantic-1.7.0 → alt_stack_openapi_pydantic-1.7.1/src/alt_stack_openapi_pydantic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alt-stack-openapi-pydantic
-Version: 1.7.0
+Version: 1.7.1
 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
@@ -101,12 +101,26 @@ Python requires a class as a `NewType` base. Literal brands use their primitive
 base; composite unions use `object` with the original Pydantic validator retained
 in `Annotated` metadata.
 
+## Identifiers and wire names
+
+Component names become Python identifiers: `Rule-Output` becomes `Rule_Output`,
+leading digits gain an underscore, and Python keywords gain a trailing underscore.
+Names that normalize to the same identifier cause a generation error with both
+original names. References and route maps use the generated identifiers.
+
+Underscore properties become public fields with aliases: `_id` becomes `id_`.
+Invalid property characters and Python keywords are also handled, with numeric
+suffixes where needed to avoid field collisions. Validate with the original wire
+names and use `model_dump(by_alias=True)` or `model_dump_json(by_alias=True)` to
+serialize them. The HTTP client serializes aliases automatically.
+
 ## 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
+uv sync --project packages/python-pydantic-openapi --extra dev
+packages/python-pydantic-openapi/.venv/bin/pytest packages/python-pydantic-openapi/tests -q
+packages/python-pydantic-openapi/.venv/bin/ruff check packages/python-pydantic-openapi
+packages/python-pydantic-openapi/.venv/bin/ty check packages/python-pydantic-openapi
 ```
 
 ## Documentation

{alt_stack_openapi_pydantic-1.7.0 → alt_stack_openapi_pydantic-1.7.1}/src/alt_stack_openapi_pydantic.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/alt_stack_openapi_pydantic/brands.py
 src/alt_stack_openapi_pydantic/cli.py
 src/alt_stack_openapi_pydantic/dependencies.py
 src/alt_stack_openapi_pydantic/emission.py
+src/alt_stack_openapi_pydantic/identifiers.py
 src/alt_stack_openapi_pydantic/lowering.py
 src/alt_stack_openapi_pydantic/py.typed
 src/alt_stack_openapi_pydantic/registry.py
@@ -36,6 +37,7 @@ tests/test_brands.py
 tests/test_convert_schema.py
 tests/test_dependencies.py
 tests/test_generated_client.py
+tests/test_identifiers.py
 tests/test_intersection.py
 tests/test_master_openapi.py
 tests/test_number.py

alt_stack_openapi_pydantic-1.7.1/tests/test_identifiers.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import keyword
+from typing import Any
+
+import pytest
+from pydantic import ValidationError
+
+from alt_stack_openapi_pydantic import openapi_to_pydantic_code
+
+
+@pytest.mark.parametrize(
+    ("wire_name", "python_name"),
+    [
+        ("Rule-Output", "Rule_Output"),
+        ("Order.Input", "Order_Input"),
+        ("123Value", "_123Value"),
+        ("class", "class_"),
+    ],
+)
+def test_component_identifiers_resolve_references_and_route_maps(
+    wire_name: str, python_name: str
+) -> None:
+    ref = {"$ref": f"#/components/schemas/{wire_name}"}
+    schema = {
+        "type": "object",
+        "properties": {"name": {"type": "string", "enum": [wire_name]}},
+        "required": ["name"],
+        "additionalProperties": False,
+    }
+    spec = {
+        "openapi": "3.1.0",
+        "info": {"title": "Identifiers", "version": "1"},
+        "components": {
+            "schemas": {
+                wire_name: schema,
+                "Alias": ref,
+                "Envelope": {
+                    "type": "object",
+                    "properties": {
+                        "item": ref,
+                        "items": {"type": "array", "items": ref},
+                        "values": {"type": "object", "additionalProperties": ref},
+                        "choice": {"anyOf": [ref, {"type": "null"}]},
+                    },
+                    "required": ["item", "items", "values", "choice"],
+                },
+                "Extended": {"allOf": [ref]},
+            }
+        },
+        "paths": {
+            "/items": {
+                "post": {
+                    "requestBody": {"content": {"application/json": {"schema": ref}}},
+                    "responses": {"200": {"content": {"application/json": {"schema": ref}}}},
+                }
+            }
+        },
+    }
+    namespace: dict[str, Any] = {}
+    exec(openapi_to_pydantic_code(spec, options={"include_routes": True}), namespace)
+
+    model = namespace[python_name]
+    payload = {"name": wire_name}
+    assert model.model_validate(payload).model_dump(by_alias=True) == payload
+    assert namespace["Alias"].model_validate(payload).root == model.model_validate(payload)
+    envelope = namespace["Envelope"].model_validate(
+        {"item": payload, "items": [payload], "values": {"key": payload}, "choice": payload}
+    )
+    assert isinstance(envelope.item, model)
+    assert isinstance(envelope.items[0], model)
+    assert isinstance(envelope.values["key"], model)
+    assert isinstance(envelope.choice, model)
+    assert issubclass(namespace["Extended"], model)
+    assert namespace["Request"]["/items"]["POST"]["body"] is model
+    assert namespace["Response"]["/items"]["POST"]["200"] is model
+    assert spec["components"]["schemas"][wire_name] == schema
+
+
+@pytest.mark.parametrize(
+    "names", [("Rule-Output", "Rule_Output"), ("class", "class_"), ("1", "_1")]
+)
+def test_component_identifier_collisions_fail_generation(names: tuple[str, str]) -> None:
+    spec = {"components": {"schemas": {name: {"type": "string"} for name in names}}}
+
+    with pytest.raises(ValueError, match="same Python identifier") as error:
+        openapi_to_pydantic_code(spec)
+
+    assert all(repr(name) in str(error.value) for name in names)
+
+
+@pytest.mark.parametrize(
+    "names",
+    [
+        ["_id", "id_", "id__2", "id"],
+        ["_id", "id_", "id__2", "id", "__", "", "1st", "display-name", *keyword.kwlist],
+    ],
+    ids=["underscore", "invalid-and-keyword"],
+)
+def test_public_property_aliases_validate_and_round_trip_without_collisions(
+    names: list[str],
+) -> None:
+    properties = {name: {"type": "string"} for name in names}
+    properties["_meta"] = {"type": "string"}
+    spec = {
+        "components": {
+            "schemas": {
+                "Item": {
+                    "type": "object",
+                    "properties": properties,
+                    "required": names,
+                    "additionalProperties": False,
+                }
+            }
+        }
+    }
+    namespace: dict[str, Any] = {}
+    exec(openapi_to_pydantic_code(spec), namespace)
+    model = namespace["Item"]
+
+    assert len(model.model_fields) == len(properties)
+    assert all(not name.startswith("_") for name in model.model_fields)
+    assert all(name.isidentifier() and not keyword.iskeyword(name) for name in model.model_fields)
+    payload = {name: f"value:{name}" for name in properties}
+    instance = model.model_validate(payload)
+    assert instance.id_ == payload["id_"]
+    assert instance.model_dump(by_alias=True) == payload
+    assert model.model_validate_json(instance.model_dump_json(by_alias=True)) == instance
+    assert model.model_validate({name: payload[name] for name in names}).model_dump(
+        by_alias=True, exclude_unset=True
+    ) == {name: payload[name] for name in names}
+
+    with pytest.raises(ValidationError):
+        model.model_validate({**payload, "_id": 123})
+    with pytest.raises(ValidationError):
+        model.model_validate({name: value for name, value in payload.items() if name != "_id"})
+    with pytest.raises(ValidationError):
+        model.model_validate({**payload, "_meta": 123})

{alt_stack_openapi_pydantic-1.7.0 → alt_stack_openapi_pydantic-1.7.1}/tests/test_master_openapi.py

@@ -28,8 +28,8 @@ from alt_stack_openapi_pydantic.schema_dedup import get_schema_fingerprint
 from alt_stack_openapi_pydantic.to_python import openapi_to_pydantic_code
 
 
-def _load_fixture() -> dict[str, Any]:
-    spec_path = Path(__file__).resolve().parents[2] / "openapi-test-spec" / "openapi.json"
+def _load_fixture(filename: str) -> dict[str, Any]:
+    spec_path = Path(__file__).resolve().parents[2] / "openapi-test-spec" / filename
     return json.loads(spec_path.read_text(encoding="utf-8"))
 
 
@@ -280,22 +280,27 @@ def _to_openapi_schema(
     return schema
 
 
-def test_master_openapi_fixture() -> None:
+@pytest.mark.parametrize("filename", ["openapi.json", "python-identifiers.json"])
+def test_master_openapi_fixture(filename: str) -> None:
     clear_pydantic_schema_registry()
-    spec = _load_fixture()
+    spec = _load_fixture(filename)
     code = openapi_to_pydantic_code(spec, options={"include_routes": True})
     module = _load_module(code)
 
     schemas = spec.get("components", {}).get("schemas", {})
-    type_to_name = {getattr(module, name): name for name in schemas}
+    python_names = {"Rule-Output": "Rule_Output", "Order-Input": "Order_Input"}
+    models = {name: getattr(module, python_names.get(name, name)) for name in schemas}
+    type_to_name = {model: name for name, model in models.items()}
 
     for name, schema in schemas.items():
         examples = schema.get("x-altstack-examples")
         if not isinstance(examples, dict):
             continue
-        model = getattr(module, name)
+        model = models[name]
         for value in examples.get("valid", []):
-            model.model_validate(value)
+            instance = model.model_validate(value)
+            if filename == "python-identifiers.json":
+                assert instance.model_dump(by_alias=True, exclude_unset=True) == value
         for value in examples.get("invalid", []):
             with pytest.raises(ValidationError):
                 model.model_validate(value)
@@ -311,7 +316,7 @@ def test_master_openapi_fixture() -> None:
 
     for name in schemas:
         actual["components"]["schemas"][name] = _to_openapi_schema(
-            getattr(module, name),
+            models[name],
             type_to_name,
             self_name=name,
             schema_fingerprint_to_name=schema_fingerprint_to_name,

{alt_stack_openapi_pydantic-1.7.0 → alt_stack_openapi_pydantic-1.7.1}/tests/test_route_typing.py

@@ -394,13 +394,15 @@ def test_route_maps_infer_exact_models_with_pyrefly(
         pytest.param(_check_with_pyrefly, PYREFLY_PATTERN, id="pyrefly"),
     ],
 )
+@pytest.mark.parametrize("filename", ["openapi.json", "python-identifiers.json"])
 def test_master_spec_route_maps_type_check(
     check: Callable[[Path], str],
     pattern: str,
+    filename: str,
 ) -> None:
     """The full test spec's route maps produce a type-clean module (no name collisions)."""
     clear_pydantic_schema_registry()
-    spec_path = Path(__file__).resolve().parents[2] / "openapi-test-spec" / "openapi.json"
+    spec_path = Path(__file__).resolve().parents[2] / "openapi-test-spec" / filename
     spec = json.loads(spec_path.read_text(encoding="utf-8"))
     code = openapi_to_pydantic_code(spec, options={"include_routes": True})