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

{alt_stack_openapi_pydantic-1.6.4/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.6.4
+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
@@ -80,12 +80,47 @@ if isinstance(result, ApiSuccess):
 
 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.
 
+## Branded types
+
+Annotate an identity schema in OpenAPI:
+
+```json
+{ "type": "string", "format": "uuid", "x-altstack-brand": "UserId" }
+```
+
+The generated module declares `UserId = NewType("UserId", UUID)` once and uses it
+in field and parameter annotations. Pydantic still parses UUID strings into UUID
+values and applies each use's existing constraints. Optional and nullable fields,
+references, array items, and union members retain the nominal type.
+
+Names must be ASCII identifiers (`[A-Za-z_][A-Za-z0-9_]*`) and must not be Python
+keywords, imported helper names, or unrelated component names. Conflicting base
+types produce a generation error. If a component and its brand have the same name,
+the Pydantic wrapper is named `UserIdModel`, leaving `UserId` for the `NewType`.
+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.6.4 → alt_stack_openapi_pydantic-1.7.1}/README.md

@@ -56,12 +56,47 @@ if isinstance(result, ApiSuccess):
 
 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.
 
+## Branded types
+
+Annotate an identity schema in OpenAPI:
+
+```json
+{ "type": "string", "format": "uuid", "x-altstack-brand": "UserId" }
+```
+
+The generated module declares `UserId = NewType("UserId", UUID)` once and uses it
+in field and parameter annotations. Pydantic still parses UUID strings into UUID
+values and applies each use's existing constraints. Optional and nullable fields,
+references, array items, and union members retain the nominal type.
+
+Names must be ASCII identifiers (`[A-Za-z_][A-Za-z0-9_]*`) and must not be Python
+keywords, imported helper names, or unrelated component names. Conflicting base
+types produce a generation error. If a component and its brand have the same name,
+the Pydantic wrapper is named `UserIdModel`, leaving `UserId` for the `NewType`.
+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.6.4 → alt_stack_openapi_pydantic-1.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alt-stack-openapi-pydantic"
-version = "1.6.4"
+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.1/src/alt_stack_openapi_pydantic/brands.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import ast
+import json
+import keyword
+import re
+from dataclasses import replace
+from typing import Callable
+
+from .routes import RouteInfo, build_route_schema_name, generate_route_schema_names
+from .types import AnySchema
+
+_RESERVED = set(
+    "Any Annotated BaseModel BeforeValidator ConfigDict Field Final JsonValue Literal NewType "
+    "Optional Request Response RootModel TypeAdapter TypedDict UUID Union bool dict float int "
+    "list str date datetime cast overload _client _JsonValue _json_value "
+    "ApiClient HttpxApiClient".split()
+)
+
+
+def get_brand_name(schema: AnySchema) -> str | None:
+    if not isinstance(schema, dict) or "x-altstack-brand" not in schema:
+        return None
+    name = schema["x-altstack-brand"]
+    if (
+        not isinstance(name, str)
+        or re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", name) is None
+        or keyword.iskeyword(name)
+        or name in _RESERVED
+    ):
+        raise ValueError(f"Invalid x-altstack-brand {name!r}: expected a non-reserved identifier")
+    return name
+
+
+def annotation_base(expr: str) -> str:
+    node = ast.parse(expr, mode="eval").body
+    if (
+        isinstance(node, ast.Subscript)
+        and isinstance(node.value, ast.Name)
+        and node.value.id == "Annotated"
+        and isinstance(node.slice, ast.Tuple)
+    ):
+        return ast.unparse(node.slice.elts[0])
+    return expr
+
+
+def branded_annotation(name: str, expr: str) -> str:
+    """Retain validation metadata at each use while sharing the nominal type."""
+    if newtype_base(expr) != annotation_base(expr):
+        return f"Annotated[{name}, BeforeValidator(TypeAdapter({expr}).validate_python)]"
+    if expr.startswith("Annotated["):
+        base = ast.parse(expr, mode="eval").body
+        assert isinstance(base, ast.Subscript) and isinstance(base.slice, ast.Tuple)
+        end = base.slice.elts[0].end_col_offset
+        return f"Annotated[{name}{expr[end:]}"
+    return name
+
+
+def newtype_base(expr: str) -> str:
+    """NewType requires a class; preserve non-class validation at the use site."""
+    base = annotation_base(expr)
+    node = ast.parse(base, mode="eval").body
+    if isinstance(node, ast.Name) and node.id not in {"Any", "_JsonValue"}:
+        return base
+    if isinstance(node, ast.Subscript) and isinstance(node.value, ast.Name):
+        if node.value.id not in {"Union", "Optional", "Literal"}:
+            return base
+        if node.value.id == "Literal":
+            values = node.slice.elts if isinstance(node.slice, ast.Tuple) else [node.slice]
+            types = {type(ast.literal_eval(value)) for value in values}
+            if len(types) == 1 and next(iter(types)) in {str, int, bool, float}:
+                return next(iter(types)).__name__
+    return "object"
+
+
+def prepare_brand_schemas(
+    schemas: dict[str, AnySchema],
+    routes: list[RouteInfo],
+    to_type: Callable[[AnySchema], str],
+    needs_model: Callable[[AnySchema], bool],
+) -> tuple[dict[str, AnySchema], list[RouteInfo]]:
+    """Lower nominal aliases into the existing component dependency/emission path."""
+    definitions: dict[str, AnySchema] = {}
+    bases: dict[str, str] = {}
+    route_names: set[str] = set()
+    for route in routes:
+        names = generate_route_schema_names(route)
+        route_names.update(name for name in vars(names).values() if isinstance(name, str))
+        for status in route.responses:
+            suffix = "Response" if status.startswith("2") else "ErrorResponse"
+            route_names.add(build_route_schema_name(route.path, route.method, f"{status}{suffix}"))
+
+    def resolve_base(schema: AnySchema) -> AnySchema:
+        base = {k: v for k, v in schema.items() if k not in {"x-altstack-brand", "nullable"}}
+        seen: set[str] = set()
+        while isinstance(base.get("$ref"), str):
+            target = base["$ref"].removeprefix("#/components/schemas/")
+            if target in seen or target not in schemas:
+                break
+            seen.add(target)
+            base = {
+                k: v
+                for k, v in schemas[target].items()
+                if k != "nullable" and not (k == "x-altstack-brand" and v == get_brand_name(schema))
+            }
+        return base
+
+    def transform(schema: AnySchema) -> AnySchema:
+        if not isinstance(schema, dict):
+            return schema
+        brand = get_brand_name(schema)
+        ref = schema.get("$ref")
+        target = ref.removeprefix("#/components/schemas/") if isinstance(ref, str) else None
+        if not brand and target in schemas and get_brand_name(schemas[target]):
+            return transform(
+                {**schemas[target], **{k: v for k, v in schema.items() if k != "$ref"}}
+            )
+        if brand:
+            if brand in route_names:
+                raise ValueError(f"x-altstack-brand {brand!r} conflicts with a route model")
+            base = resolve_base(schema)
+            base_type = annotation_base(to_type(base))
+            signature = f"{base_type}:{base.get('format', '')}"
+            if needs_model(base):
+                signature = json.dumps(base, sort_keys=True)
+            if brand in bases and bases[brand] != signature:
+                raise ValueError(f"Conflicting base types for x-altstack-brand {brand!r}")
+            if brand in schemas and get_brand_name(schemas[brand]) != brand:
+                raise ValueError(f"x-altstack-brand {brand!r} conflicts with component {brand}")
+            bases[brand] = signature
+            base = transform(base)
+            if needs_model(base):
+                base_name = f"{brand}Base"
+                if base_name in schemas:
+                    raise ValueError(
+                        f"x-altstack-brand {brand!r} conflicts with component {base_name}"
+                    )
+                definitions[base_name] = base
+                base = {"$ref": f"#/components/schemas/{base_name}"}
+            definitions[brand] = {**base, "_altstack_newtype": True}
+            result = {
+                "$ref": f"#/components/schemas/{brand}",
+                "_altstack_brand_schema": base,
+            }
+            if schema.get("nullable") is True:
+                result["nullable"] = True
+            return result
+
+        result = dict(schema)
+        properties = result.get("properties")
+        if isinstance(properties, dict):
+            result["properties"] = {name: transform(child) for name, child in properties.items()}
+        for key in ("items", "additionalProperties"):
+            if isinstance(result.get(key), dict):
+                result[key] = transform(result[key])
+        for key in ("oneOf", "anyOf", "allOf"):
+            if isinstance(result.get(key), list):
+                result[key] = [transform(child) for child in result[key]]
+        return result
+
+    transformed: dict[str, AnySchema] = {}
+    for name, schema in schemas.items():
+        output_name = f"{name}Model" if get_brand_name(schema) == name else name
+        if output_name != name and output_name in schemas:
+            raise ValueError(f"x-altstack-brand {name!r} conflicts with component {output_name}")
+        transformed[output_name] = transform(schema)
+    transformed_routes = [
+        replace(
+            route,
+            parameters=[
+                replace(param, schema=transform(param.schema)) for param in route.parameters
+            ],
+            request_body=transform(route.request_body) if route.request_body is not None else None,
+            responses={status: transform(schema) for status, schema in route.responses.items()},
+        )
+        for route in routes
+    ]
+    conflicts = definitions.keys() & transformed.keys()
+    if conflicts:
+        raise ValueError(f"x-altstack-brand conflicts with generated model {min(conflicts)}")
+    return {**definitions, **transformed}, transformed_routes

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

@@ -3,7 +3,9 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 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,
@@ -33,13 +35,12 @@ from .schema_dedup import (
 )
 from .types import AnySchema
 
-_VALID_IDENTIFIER_CHARS = set("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
-
 
 @dataclass(slots=True)
 class EmissionState:
     render_context: RenderContext = field(default_factory=RenderContext)
     rebuild_names: list[str] = field(default_factory=list)
+    uses_brands: bool = False
 
 
 def openapi_to_pydantic_code(
@@ -53,16 +54,24 @@ def openapi_to_pydantic_code(
     if not isinstance(schemas, dict):
         schemas = {}
 
-    lowering_context = LoweringContext(set(schemas.keys()))
+    routes = parse_openapi_paths(openapi) if include_routes else []
+    schemas, routes = prepare_brand_schemas(
+        schemas, routes, schema_to_type_expr, is_object_model_schema
+    )
+
+    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:
@@ -74,7 +83,6 @@ def openapi_to_pydantic_code(
         )
 
     if include_routes:
-        routes = parse_openapi_paths(openapi)
         if routes:
             route_lines, schema_name_to_canonical = _emit_route_schemas(
                 routes,
@@ -90,11 +98,15 @@ 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))
-            return _finalize_module(lines)
+            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))
-    return _finalize_module(lines)
+    return _finalize_module(lines, state)
 
 
 _ALL_OF_HELPER = [
@@ -111,12 +123,21 @@ _ALL_OF_HELPER = [
 ]
 
 
-def _finalize_module(lines: list[str]) -> str:
+def _finalize_module(lines: list[str], state: EmissionState) -> str:
     """Inline the ``all_of`` intersection helper when the module uses it.
 
     Generated modules depend only on pydantic and ``alt_stack_http_client_httpx`` at runtime,
     not on the generator package.
     """
+    if state.uses_brands:
+        lines.insert(5, "from typing import NewType")
+    if state.render_context.uses_json:
+        lines.insert(5, "from pydantic import JsonValue as _JsonValue")
+        index = lines.index("def _reject_explicit_none(value: Any) -> Any:")
+        lines[index:index] = [
+            "_json_value = TypeAdapter(_JsonValue, config=ConfigDict(allow_inf_nan=False))",
+            "",
+        ]
     anchor = "_omit_not_null = BeforeValidator(_reject_explicit_none)"
     if any("all_of(" in line for line in lines) and anchor in lines:
         index = lines.index(anchor) + 1
@@ -155,6 +176,10 @@ def _build_module_preamble(custom_import_lines: list[str] | None) -> list[str]:
 
 
 def _emit_named_schema(name: str, schema: AnySchema, state: EmissionState) -> list[str]:
+    if isinstance(schema, dict) and schema.get("_altstack_newtype"):
+        state.uses_brands = True
+        base = newtype_base(schema_to_type_expr(schema, context=state.render_context))
+        return [f'{name} = NewType("{name}", {base})', ""]
     if is_object_model_schema(schema) and not _has_root_model_allof_base(schema, state):
         return _emit_object_model(name, schema, state)
     return _emit_root_model(name, schema, state)
@@ -169,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
     )
 
@@ -177,11 +202,13 @@ 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)
-        model_lines = _build_model_lines(name, merged_schema, base_classes=base_classes or None)
+        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
+        )
         model_lines.insert(1, f"    __openapi_allof__ = {all_of!r}")
     else:
-        model_lines = _build_model_lines(name, schema)
+        model_lines = _build_model_lines(name, schema, context=state.render_context)
 
     state.rebuild_names.append(name)
     return [*model_lines, ""]
@@ -198,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] = []
@@ -208,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:
@@ -242,6 +271,7 @@ def _build_model_lines(
     name: str,
     schema: AnySchema,
     *,
+    context: RenderContext,
     base_classes: list[str] | None = None,
 ) -> list[str]:
     properties = schema.get("properties") if isinstance(schema, dict) else None
@@ -253,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)
+            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}")
 
@@ -284,7 +316,7 @@ def _build_model_lines(
         config_args.append("extra='allow'")
     elif isinstance(additional, dict):
         config_args.append("extra='allow'")
-        extra_type = schema_to_type_expr(additional)
+        extra_type = schema_to_type_expr(additional, context=context)
         extra_line = (
             f"    __pydantic_extra__: {extra_field_annotation(extra_type)} = Field(init=False)"
         )
@@ -339,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))
 
@@ -424,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)
@@ -670,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")
@@ -678,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:
@@ -705,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