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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alt-stack-openapi-pydantic
-Version: 1.6.3
+Version: 1.7.0
 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,6 +80,27 @@ 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.
+
 ## Development
 
 ```bash

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

@@ -56,6 +56,27 @@ 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.
+
 ## Development
 
 ```bash

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

@@ -1,6 +1,6 @@
 [project]
 name = "alt-stack-openapi-pydantic"
-version = "1.6.3"
+version = "1.7.0"
 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/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.3 → alt_stack_openapi_pydantic-1.7.0}/src/alt_stack_openapi_pydantic/emission.py

@@ -3,12 +3,14 @@ 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 .lowering import LoweringContext, NamedSchema, lower_named_schema
 from .rendering import (
     RenderContext,
     decode_component_ref,
     extra_field_annotation,
+    is_nullable_schema,
     is_object_model_schema,
     root_model_annotation,
     schema_to_type_expr,
@@ -39,6 +41,7 @@ _VALID_IDENTIFIER_CHARS = set("_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUV
 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(
@@ -52,6 +55,11 @@ def openapi_to_pydantic_code(
     if not isinstance(schemas, dict):
         schemas = {}
 
+    routes = parse_openapi_paths(openapi) if include_routes else []
+    schemas, routes = prepare_brand_schemas(
+        schemas, routes, schema_to_type_expr, is_object_model_schema
+    )
+
     lowering_context = LoweringContext(set(schemas.keys()))
     lowered_components: list[NamedSchema] = []
     for name in topological_sort_schemas(schemas):
@@ -73,7 +81,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,10 +97,10 @@ def openapi_to_pydantic_code(
             if route_lines:
                 lines.append("")
             lines.extend(_generate_request_response_objects(routes, schema_name_to_canonical))
-            return _finalize_module(lines)
+            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 = [
@@ -110,12 +117,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
@@ -154,6 +170,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)
@@ -177,10 +197,12 @@ def _emit_object_model(name: str, schema: AnySchema, state: EmissionState) -> li
     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)
+        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, ""]
@@ -241,6 +263,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
@@ -261,12 +284,12 @@ def _build_model_lines(
             if alias:
                 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 ""
             else:
-                if not isinstance(prop_schema, dict) or prop_schema.get("nullable") is not True:
+                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"
 
@@ -283,7 +306,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)"
         )

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

@@ -4,6 +4,7 @@ from dataclasses import dataclass, field
 from typing import Any
 from urllib.parse import unquote
 
+from .brands import branded_annotation, get_brand_name
 from .registry import (
     get_schema_exported_variable_name_for_primitive_type,
     get_schema_exported_variable_name_for_string_format,
@@ -22,6 +23,7 @@ from .types.union import convert_openapi_union_to_pydantic
 @dataclass(slots=True)
 class RenderContext:
     root_model_names: set[str] = field(default_factory=set)
+    uses_json: bool = False
 
 
 def decode_component_ref(ref: str) -> str:
@@ -79,6 +81,24 @@ def schema_to_type_expr(
 
     render_context = context or RenderContext()
 
+    brand_schema = schema.get("_altstack_brand_schema")
+    if isinstance(brand_schema, dict):
+        name = decode_component_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)
+    if brand:
+        base = {k: v for k, v in schema.items() if k not in {"x-altstack-brand", "nullable"}}
+        expr = schema_to_type_expr(base, context=render_context)
+        return wrap_nullable(branded_annotation(brand, expr), schema)
+
+    # OpenAPI 3.1 spells "may be null" three ways; all of them render as Optional[...].
+    if schema.get("type") == "null":
+        return "None"
+    without_null = strip_null_member(schema)
+    if without_null is not None:
+        return f"Optional[{schema_to_type_expr(without_null, context=render_context)}]"
+
     if isinstance(schema.get("$ref"), str):
         ref = schema["$ref"]
         if not ref.startswith("#/components/schemas/"):
@@ -139,7 +159,10 @@ def schema_to_type_expr(
     if literal is not None:
         return wrap_nullable(literal, schema)
 
-    return wrap_nullable("Any", schema)
+    json_value = "Annotated[_JsonValue, BeforeValidator(_json_value.validate_python)]"
+    if schema_type is None:
+        render_context.uses_json = True
+    return wrap_nullable(json_value if schema_type is None else "Any", schema)
 
 
 def wrap_nullable(expr: str, schema: dict[str, Any]) -> str:
@@ -148,6 +171,57 @@ def wrap_nullable(expr: str, schema: dict[str, Any]) -> str:
     return expr
 
 
+def _is_null_schema(schema: Any) -> bool:
+    return isinstance(schema, dict) and schema.get("type") == "null" and len(schema) <= 2
+
+
+def strip_null_member(schema: dict[str, Any]) -> dict[str, Any] | None:
+    """Return the schema without its null alternative, or None when it has none.
+
+    Handles ``type: ["string", "null"]`` and ``anyOf``/``oneOf`` compositions that include a
+    ``{"type": "null"}`` member. A composition left with one member collapses to that member so
+    the caller renders ``Optional[Member]`` rather than ``Optional[Union[Member]]``.
+    """
+    type_value = schema.get("type")
+    if isinstance(type_value, list) and "null" in type_value:
+        remaining = [item for item in type_value if item != "null"]
+        stripped = dict(schema)
+        if len(remaining) == 1:
+            stripped["type"] = remaining[0]
+        else:
+            stripped.pop("type")
+            stripped["anyOf"] = [{"type": item} for item in remaining]
+        return stripped
+    for keyword in ("anyOf", "oneOf"):
+        members = schema.get(keyword)
+        if isinstance(members, list) and any(_is_null_schema(member) for member in members):
+            remaining = [member for member in members if not _is_null_schema(member)]
+            stripped = {key: value for key, value in schema.items() if key != keyword}
+            if len(remaining) == 1 and isinstance(remaining[0], dict):
+                merged = dict(remaining[0])
+                for key in ("description", "title", "default"):
+                    if key in stripped and key not in merged:
+                        merged[key] = stripped[key]
+                return merged
+            stripped[keyword] = remaining
+            return stripped
+    return None
+
+
+def is_nullable_schema(schema: Any) -> bool:
+    """True when the schema admits null: ``nullable: true``, ``type: "null"``, or a null member."""
+    if not isinstance(schema, dict):
+        return False
+    if schema.get("nullable") is True or schema.get("type") == "null":
+        return True
+    if not any(
+        key in schema
+        for key in ("type", "$ref", "properties", "enum", "const", "anyOf", "oneOf", "allOf")
+    ):
+        return True
+    return strip_null_member(schema) is not None
+
+
 def registered_output_alias(schema: AnySchema, context: RenderContext | None = None) -> str | None:
     if not isinstance(schema, dict):
         return None

{alt_stack_openapi_pydantic-1.6.3 → alt_stack_openapi_pydantic-1.7.0}/src/alt_stack_openapi_pydantic/types/number.py

@@ -21,18 +21,28 @@ def convert_openapi_number_to_pydantic(schema: dict[str, Any]) -> str:
 
     minimum = schema.get("minimum")
     maximum = schema.get("maximum")
+    exclusive_minimum = schema.get("exclusiveMinimum")
+    exclusive_maximum = schema.get("exclusiveMaximum")
 
     field_args: list[str] = ["strict=True"]
     if isinstance(minimum, (int, float)):
         field_args.append(f"ge={integer_bound(minimum, base)}")
     if isinstance(maximum, (int, float)):
         field_args.append(f"le={integer_bound(maximum, base)}")
+    if type(exclusive_minimum) in (int, float):
+        field_args.append(f"gt={integer_bound(exclusive_minimum, base)}")
+    if type(exclusive_maximum) in (int, float):
+        field_args.append(f"lt={integer_bound(exclusive_maximum, base)}")
 
     meta: dict[str, Any] = {}
     if isinstance(minimum, (int, float)):
         meta["minimum"] = minimum
     if isinstance(maximum, (int, float)):
         meta["maximum"] = maximum
+    if type(exclusive_minimum) in (int, float):
+        meta["exclusiveMinimum"] = exclusive_minimum
+    if type(exclusive_maximum) in (int, float):
+        meta["exclusiveMaximum"] = exclusive_maximum
     if meta:
         field_args.append(format_openapi_metadata(meta))
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alt-stack-openapi-pydantic
-Version: 1.6.3
+Version: 1.7.0
 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,6 +80,27 @@ 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.
+
 ## Development
 
 ```bash

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

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 src/alt_stack_openapi_pydantic/__init__.py
+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
@@ -31,6 +32,7 @@ src/alt_stack_openapi_pydantic/types/types.py
 src/alt_stack_openapi_pydantic/types/union.py
 tests/test_array.py
 tests/test_boolean.py
+tests/test_brands.py
 tests/test_convert_schema.py
 tests/test_dependencies.py
 tests/test_generated_client.py

alt_stack_openapi_pydantic-1.7.0/tests/test_brands.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+
+from typing import Any, get_args
+from uuid import UUID
+
+import pytest
+from pydantic import ValidationError
+
+from alt_stack_openapi_pydantic import openapi_to_pydantic_code
+from tests.test_route_typing import (
+    PYREFLY_PATTERN,
+    TY_PATTERN,
+    _assert_route_contract,
+    _check_with_pyrefly,
+    _check_with_ty,
+    _expected_error_lines,
+)
+
+
+def generate(schemas: dict[str, Any], paths: dict[str, Any] | None = None) -> tuple[str, Any]:
+    code = openapi_to_pydantic_code(
+        {"components": {"schemas": schemas}, "paths": paths or {}},
+        options={"include_routes": True},
+    )
+    namespace: dict[str, Any] = {}
+    exec(code, namespace)
+    return code, namespace
+
+
+def test_brands_share_types_and_preserve_validation_in_every_schema_position() -> None:
+    identifier = {"type": "string", "format": "uuid", "x-altstack-brand": "UserId"}
+    code, module = generate(
+        {
+            "UserId": identifier,
+            "User": {
+                "type": "object",
+                "properties": {
+                    "id": {"$ref": "#/components/schemas/UserId"},
+                    "optional": {**identifier, "nullable": True},
+                    "ids": {"type": "array", "items": identifier},
+                    "choice": {"anyOf": [identifier, {"type": "null"}]},
+                },
+                "required": ["id", "ids", "choice"],
+                "additionalProperties": False,
+            },
+        },
+        {
+            "/users/{id}": {
+                "get": {
+                    "parameters": [
+                        {"name": "id", "in": "path", "required": True, "schema": identifier}
+                    ],
+                    "responses": {
+                        "200": {
+                            "content": {
+                                "application/json": {
+                                    "schema": {"$ref": "#/components/schemas/User"}
+                                }
+                            }
+                        }
+                    },
+                }
+            }
+        },
+    )
+    assert code.count('UserId = NewType("UserId", UUID)') == 1
+    assert module["UserId"].__supertype__ is UUID
+    model = module["User"]
+    assert model.model_fields["id"].annotation is module["UserId"]
+    assert get_args(get_args(model.model_fields["ids"].annotation)[0])[0] is module["UserId"]
+    value = "f47ac10b-58cc-4372-a567-0e02b2c3d479"
+    user = model.model_validate({"id": value, "ids": [value], "choice": None})
+    assert user.id == UUID(value)
+    assert user.optional is None
+    assert (
+        model.model_validate({"id": value, "ids": [], "choice": value, "optional": None}).optional
+        is None
+    )
+    with pytest.raises(ValidationError):
+        model.model_validate({"id": "invalid", "ids": [], "choice": None})
+    params = module["Request"]["/users/{id}"]["GET"]["params"]
+    assert params.model_fields["id"].annotation is module["UserId"]
+    assert params.model_validate({"id": value}).id == UUID(value)
+    assert module["Response"]["/users/{id}"]["GET"]["200"] is model
+
+
+@pytest.mark.parametrize("brand", ["bad-name", "class", "", 123, None])
+def test_invalid_brand_names_fail_generation(brand: Any) -> None:
+    with pytest.raises(ValueError, match="Invalid x-altstack-brand"):
+        generate({"Value": {"type": "string", "x-altstack-brand": brand}})
+
+
+def test_conflicting_brand_bases_and_component_names_fail_generation() -> None:
+    with pytest.raises(ValueError, match="Conflicting base types.*UserId"):
+        generate(
+            {
+                "First": {"type": "string", "x-altstack-brand": "UserId"},
+                "Second": {"type": "integer", "x-altstack-brand": "UserId"},
+            }
+        )
+    with pytest.raises(ValueError, match="conflicts with component UserId"):
+        generate(
+            {
+                "UserId": {"type": "integer"},
+                "First": {"type": "string", "x-altstack-brand": "UserId"},
+            }
+        )
+    with pytest.raises(ValueError, match="conflicts with a route model"):
+        generate(
+            {},
+            {
+                "/users/{id}": {
+                    "get": {
+                        "parameters": [
+                            {
+                                "name": "id",
+                                "in": "path",
+                                "required": True,
+                                "schema": {
+                                    "type": "string",
+                                    "x-altstack-brand": "GetUsersIdParams",
+                                },
+                            }
+                        ],
+                        "responses": {},
+                    }
+                }
+            },
+        )
+
+
+def test_empty_schema_rejects_non_json_values() -> None:
+    _, module = generate({"Json": {}, "Value": {"type": "object", "properties": {"value": {}}}})
+    model = module["Json"]
+    assert model.model_validate({"key": [None, True, 1]}).root == {"key": [None, True, 1]}
+    for value in (object(), float("nan"), float("inf")):
+        with pytest.raises(ValidationError):
+            model.model_validate({"key": value})
+    assert module["Value"].model_validate({"value": None}).value is None
+
+
+def test_exclusive_numeric_bounds_are_enforced() -> None:
+    _, module = generate(
+        {
+            "Bounded": {
+                "type": "number",
+                "minimum": -1,
+                "maximum": 11,
+                "exclusiveMinimum": 0,
+                "exclusiveMaximum": 10,
+            }
+        }
+    )
+    model = module["Bounded"]
+    assert model.model_validate(5).root == 5
+    for value in (0, 10, -1, 11):
+        with pytest.raises(ValidationError):
+            model.model_validate(value)
+
+
+@pytest.mark.parametrize(
+    ("check", "pattern"), [(_check_with_ty, TY_PATTERN), (_check_with_pyrefly, PYREFLY_PATTERN)]
+)
+def test_generated_brands_are_nominal_and_composite_bases_type_check(
+    tmp_path, check, pattern
+) -> None:
+    code, module = generate(
+        {
+            "Identifier": {"type": "string", "x-altstack-brand": "UserId"},
+            "Record": {
+                "type": "object",
+                "properties": {"id": {"type": "string", "x-altstack-brand": "UserId"}},
+                "required": ["id"],
+            },
+            "UnionValue": {
+                "anyOf": [{"type": "string"}, {"type": "integer"}],
+                "x-altstack-brand": "ValueId",
+            },
+            "Constant": {"type": "string", "const": "fixed", "x-altstack-brand": "TagId"},
+        }
+    )
+    assert module["UnionValue"].model_validate(1).root == 1
+    assert module["Constant"].model_validate("fixed").root == "fixed"
+    with pytest.raises(ValidationError):
+        module["Constant"].model_validate("wrong")
+    with pytest.raises(ValidationError):
+        module["UnionValue"].model_validate({})
+    consumer = "\n".join(
+        [
+            "from typing import assert_type",
+            "from generated_sdk import Record, UserId",
+            'record = Record.model_validate({"id": "value"})',
+            "assert_type(record.id, UserId)",
+            'plain: UserId = "value"  # expect-error',
+        ]
+    )
+    (tmp_path / "generated_sdk.py").write_text(code)
+    (tmp_path / "consumer.py").write_text(consumer)
+    _assert_route_contract(check(tmp_path), pattern, _expected_error_lines(consumer))

{alt_stack_openapi_pydantic-1.6.3 → alt_stack_openapi_pydantic-1.7.0}/tests/test_convert_schema.py

@@ -169,3 +169,30 @@ def test_untyped_const_and_enum_render_as_literals() -> None:
         convert_schema_to_pydantic_string({"const": "only", "nullable": True})
         == "Optional[Literal['only']]"
     )
+
+
+def test_null_members_render_as_optional() -> None:
+    assert (
+        convert_schema_to_pydantic_string({"anyOf": [{"type": "string"}, {"type": "null"}]})
+        == "Optional[Annotated[str, Field(strict=True)]]"
+    )
+    assert (
+        convert_schema_to_pydantic_string({"oneOf": [{"type": "integer"}, {"type": "null"}]})
+        == "Optional[Annotated[int, Field(strict=True)]]"
+    )
+    assert (
+        convert_schema_to_pydantic_string({"type": ["string", "null"]})
+        == "Optional[Annotated[str, Field(strict=True)]]"
+    )
+    assert (
+        convert_schema_to_pydantic_string(
+            {"anyOf": [{"type": "string"}, {"type": "integer"}, {"type": "null"}]}
+        )
+        == "Optional[Union[Annotated[str, Field(strict=True)], Annotated[int, Field(strict=True)]]]"
+    )
+    assert (
+        convert_schema_to_pydantic_string(
+            {"anyOf": [{"$ref": "#/components/schemas/User"}, {"type": "null"}]}
+        )
+        == "Optional[User]"
+    )

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

@@ -12,7 +12,15 @@ from typing import Annotated, Any, Literal, Union, cast, get_args, get_origin
 from uuid import UUID
 
 import pytest
-from pydantic import AnyUrl, BaseModel, BeforeValidator, EmailStr, RootModel, ValidationError
+from pydantic import (
+    AnyUrl,
+    BaseModel,
+    BeforeValidator,
+    EmailStr,
+    JsonValue,
+    RootModel,
+    ValidationError,
+)
 from pydantic.fields import FieldInfo
 
 from alt_stack_openapi_pydantic.registry import clear_pydantic_schema_registry
@@ -33,7 +41,7 @@ def _strip_examples(value: Any) -> Any:
         for key, child in value.items():
             if key == "x-altstack-examples":
                 continue
-            result[key] = _strip_examples(child)
+            result["oneOf" if key == "anyOf" else key] = _strip_examples(child)
         return result
     return value
 
@@ -137,7 +145,12 @@ def _to_openapi_schema(
     schema: dict[str, Any]
 
     origin = get_origin(base)
-    if origin is Literal:
+    if hasattr(base, "__supertype__"):
+        schema = _to_openapi_schema(base.__supertype__, type_to_name, self_name=self_name)
+        schema["x-altstack-brand"] = base.__name__
+    elif base is JsonValue:
+        schema = {}
+    elif origin is Literal:
         values = list(get_args(base))
         schema = {"enum": values}
         if all(isinstance(v, str) for v in values):

{alt_stack_openapi_pydantic-1.6.3 → alt_stack_openapi_pydantic-1.7.0}/tests/test_to_python.py

@@ -292,6 +292,43 @@ def test_optional_non_nullable_fields_reject_explicit_none() -> None:
     module.Item.model_validate({"description": None})
 
 
+def test_optional_null_member_fields_accept_explicit_none() -> None:
+    openapi = {
+        "components": {
+            "schemas": {
+                "Bundle": {
+                    "type": "object",
+                    "properties": {
+                        "access_token": {"type": "string"},
+                        "refresh_token": {"anyOf": [{"type": "string"}, {"type": "null"}]},
+                        "expires_in": {"type": ["integer", "null"]},
+                        "scope": {"type": "string"},
+                    },
+                    "required": ["access_token"],
+                    "additionalProperties": False,
+                }
+            }
+        }
+    }
+
+    code = openapi_to_pydantic_code(openapi)
+    assert "refresh_token: Optional[Annotated[str, Field(strict=True)]] = None" in code
+    assert "expires_in: Optional[Annotated[int, Field(strict=True)]] = None" in code
+    assert (
+        "scope: Annotated[Optional[Annotated[str, Field(strict=True)]], _omit_not_null] = None"
+        in code
+    )
+
+    module = _load_module(code)
+    bundle = module.Bundle.model_validate(
+        {"access_token": "a", "refresh_token": None, "expires_in": None}
+    )
+    assert bundle.refresh_token is None and bundle.expires_in is None
+    assert module.Bundle.model_validate({"access_token": "a"}).refresh_token is None
+    with pytest.raises(ValidationError):
+        module.Bundle.model_validate({"access_token": "a", "scope": None})
+
+
 def test_allof_wrapper_around_root_model_imports() -> None:
     openapi = {
         "components": {