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

{alt_stack_openapi_pydantic-1.6.2/src/alt_stack_openapi_pydantic.egg-info → alt_stack_openapi_pydantic-1.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alt-stack-openapi-pydantic
-Version: 1.6.2
+Version: 1.6.4
 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

{alt_stack_openapi_pydantic-1.6.2 → alt_stack_openapi_pydantic-1.6.4}/pyproject.toml

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

@@ -9,6 +9,7 @@ from .rendering import (
     RenderContext,
     decode_component_ref,
     extra_field_annotation,
+    is_nullable_schema,
     is_object_model_schema,
     root_model_annotation,
     schema_to_type_expr,
@@ -266,7 +267,7 @@ def _build_model_lines(
             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"
 

{alt_stack_openapi_pydantic-1.6.2 → alt_stack_openapi_pydantic-1.6.4}/src/alt_stack_openapi_pydantic/rendering.py

@@ -8,7 +8,7 @@ from .registry import (
     get_schema_exported_variable_name_for_primitive_type,
     get_schema_exported_variable_name_for_string_format,
 )
-from .type_render import format_openapi_metadata
+from .type_render import format_openapi_metadata, literal_type_expr
 from .types import AnySchema
 from .types.array import convert_openapi_array_to_pydantic
 from .types.boolean import convert_openapi_boolean_to_pydantic
@@ -79,6 +79,13 @@ def schema_to_type_expr(
 
     render_context = context or RenderContext()
 
+    # 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/"):
@@ -135,10 +142,9 @@ def schema_to_type_expr(
         )
         return wrap_nullable(expr, schema)
 
-    if isinstance(schema.get("enum"), list):
-        values = ", ".join(repr(value) for value in schema["enum"])
-        expr = f"Literal[{values}]"
-        return wrap_nullable(expr, schema)
+    literal = literal_type_expr(schema)
+    if literal is not None:
+        return wrap_nullable(literal, schema)
 
     return wrap_nullable("Any", schema)
 
@@ -149,6 +155,52 @@ 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
+    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.4/src/alt_stack_openapi_pydantic/type_render.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def format_openapi_metadata(meta: dict[str, Any]) -> str:
+    ordered = {key: meta[key] for key in sorted(meta)}
+    return f"json_schema_extra={{'openapi': {ordered!r}}}"
+
+
+def wrap_annotated(base: str, metadata: list[str]) -> str:
+    if not metadata:
+        return base
+    parts = ", ".join(metadata)
+    return f"Annotated[{base}, {parts}]"
+
+
+def literal_type_expr(schema: dict[str, Any]) -> str | None:
+    """Render ``enum`` values, or a single-value ``const``, as ``Literal[...]``.
+
+    OpenAPI 3.1 documents (and Pydantic-exported schemas) express a fixed value with
+    ``const``; treating it as a one-member enum keeps discriminated unions valid, because
+    Pydantic requires the discriminator field of every member to be a ``Literal``.
+    """
+    values = schema.get("enum")
+    if not isinstance(values, list):
+        if "const" not in schema:
+            return None
+        values = [schema["const"]]
+    rendered = ", ".join(repr(value) for value in values)
+    return f"Literal[{rendered}]"
+
+
+def integer_bound(value: Any, base: str) -> Any:
+    """Render an integer field's bound as an ``int`` when the document spells it ``0.0``."""
+    if base == "int" and isinstance(value, float) and value.is_integer():
+        return int(value)
+    return value

{alt_stack_openapi_pydantic-1.6.2 → alt_stack_openapi_pydantic-1.6.4}/src/alt_stack_openapi_pydantic/types/boolean.py

@@ -3,11 +3,13 @@ from __future__ import annotations
 from typing import Any
 
 from ..registry import get_schema_exported_variable_name_for_primitive_type
-from ..type_render import wrap_annotated
+from ..type_render import literal_type_expr, wrap_annotated
 
 
 def convert_openapi_boolean_to_pydantic(schema: dict[str, Any]) -> str:
-    _ = schema
+    literal = literal_type_expr(schema)
+    if literal is not None:
+        return literal
     custom = get_schema_exported_variable_name_for_primitive_type("boolean")
     if custom:
         return custom

{alt_stack_openapi_pydantic-1.6.2 → alt_stack_openapi_pydantic-1.6.4}/src/alt_stack_openapi_pydantic/types/number.py

@@ -3,13 +3,13 @@ from __future__ import annotations
 from typing import Any
 
 from ..registry import get_schema_exported_variable_name_for_primitive_type
-from ..type_render import format_openapi_metadata, wrap_annotated
+from ..type_render import format_openapi_metadata, integer_bound, literal_type_expr, wrap_annotated
 
 
 def convert_openapi_number_to_pydantic(schema: dict[str, Any]) -> str:
-    if isinstance(schema.get("enum"), list):
-        values = ", ".join(repr(value) for value in schema["enum"])
-        return f"Literal[{values}]"
+    literal = literal_type_expr(schema)
+    if literal is not None:
+        return literal
 
     schema_type = schema.get("type")
     if schema_type in {"number", "integer", "boolean"}:
@@ -24,9 +24,9 @@ def convert_openapi_number_to_pydantic(schema: dict[str, Any]) -> str:
 
     field_args: list[str] = ["strict=True"]
     if isinstance(minimum, (int, float)):
-        field_args.append(f"ge={minimum}")
+        field_args.append(f"ge={integer_bound(minimum, base)}")
     if isinstance(maximum, (int, float)):
-        field_args.append(f"le={maximum}")
+        field_args.append(f"le={integer_bound(maximum, base)}")
 
     meta: dict[str, Any] = {}
     if isinstance(minimum, (int, float)):

{alt_stack_openapi_pydantic-1.6.2 → alt_stack_openapi_pydantic-1.6.4}/src/alt_stack_openapi_pydantic/types/string.py

@@ -3,13 +3,13 @@ from __future__ import annotations
 from typing import Any
 
 from ..registry import get_schema_exported_variable_name_for_string_format
-from ..type_render import format_openapi_metadata, wrap_annotated
+from ..type_render import format_openapi_metadata, literal_type_expr, wrap_annotated
 
 
 def convert_openapi_string_to_pydantic(schema: dict[str, Any]) -> str:
-    if isinstance(schema.get("enum"), list):
-        values = ", ".join(repr(value) for value in schema["enum"])
-        return f"Literal[{values}]"
+    literal = literal_type_expr(schema)
+    if literal is not None:
+        return literal
 
     fmt = schema.get("format")
     if isinstance(fmt, str) and fmt:

{alt_stack_openapi_pydantic-1.6.2 → alt_stack_openapi_pydantic-1.6.4/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.2
+Version: 1.6.4
 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

{alt_stack_openapi_pydantic-1.6.2 → alt_stack_openapi_pydantic-1.6.4}/tests/test_boolean.py

@@ -8,3 +8,9 @@ def test_boolean_basic() -> None:
         convert_openapi_boolean_to_pydantic({"type": "boolean"})
         == "Annotated[bool, Field(strict=True)]"
     )
+
+
+def test_const_boolean_is_a_single_literal() -> None:
+    assert (
+        convert_openapi_boolean_to_pydantic({"type": "boolean", "const": True}) == "Literal[True]"
+    )

{alt_stack_openapi_pydantic-1.6.2 → alt_stack_openapi_pydantic-1.6.4}/tests/test_convert_schema.py

@@ -160,3 +160,39 @@ def test_string_constraints() -> None:
 )
 def test_string_formats(schema: dict, expected: str) -> None:
     assert convert_schema_to_pydantic_string(schema) == expected
+
+
+def test_untyped_const_and_enum_render_as_literals() -> None:
+    assert convert_schema_to_pydantic_string({"const": "only"}) == "Literal['only']"
+    assert convert_schema_to_pydantic_string({"enum": ["a", 1]}) == "Literal['a', 1]"
+    assert (
+        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.2 → alt_stack_openapi_pydantic-1.6.4}/tests/test_number.py

@@ -27,6 +27,31 @@ def test_integer_enum() -> None:
     assert result == "Literal[100, 200]"
 
 
+def test_const_integer_is_a_single_literal() -> None:
+    result = convert_openapi_number_to_pydantic({"type": "integer", "const": 1})
+    assert result == "Literal[1]"
+
+
+def test_integer_bounds_written_as_floats_render_as_ints() -> None:
+    result = convert_openapi_number_to_pydantic(
+        {"type": "integer", "minimum": 0.0, "maximum": 10.0}
+    )
+    expected = (
+        "Annotated[int, Field(strict=True, ge=0, le=10, "
+        "json_schema_extra={'openapi': {'maximum': 10.0, 'minimum': 0.0}})]"
+    )
+    assert result == expected
+
+
+def test_number_bounds_keep_their_float_form() -> None:
+    result = convert_openapi_number_to_pydantic({"type": "number", "minimum": 0.0})
+    expected = (
+        "Annotated[float, Field(strict=True, ge=0.0, "
+        "json_schema_extra={'openapi': {'minimum': 0.0}})]"
+    )
+    assert result == expected
+
+
 def test_min_max() -> None:
     result = convert_openapi_number_to_pydantic({"type": "integer", "minimum": 1, "maximum": 10})
     expected = (

{alt_stack_openapi_pydantic-1.6.2 → alt_stack_openapi_pydantic-1.6.4}/tests/test_string.py

@@ -23,6 +23,11 @@ def test_enum_string() -> None:
     assert result == "Literal['red', 'green']"
 
 
+def test_const_string_is_a_single_literal() -> None:
+    result = convert_openapi_string_to_pydantic({"type": "string", "const": "plaintext"})
+    assert result == "Literal['plaintext']"
+
+
 def test_format_email() -> None:
     result = convert_openapi_string_to_pydantic({"type": "string", "format": "email"})
     assert (

{alt_stack_openapi_pydantic-1.6.2 → alt_stack_openapi_pydantic-1.6.4}/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": {
@@ -1006,3 +1043,55 @@ def test_intersection_helper_is_inlined_only_when_used() -> None:
 
     plain = openapi_to_pydantic_code({"components": {"schemas": {}}, "paths": {}})
     assert "def all_of" not in plain
+
+
+def test_const_discriminators_generate_a_valid_discriminated_union() -> None:
+    openapi = {
+        "components": {
+            "schemas": {
+                "Plaintext": {
+                    "type": "object",
+                    "additionalProperties": False,
+                    "properties": {
+                        "mode": {"type": "string", "const": "plaintext"},
+                        "v": {"type": "integer", "const": 1},
+                        "data": {"type": "string"},
+                    },
+                    "required": ["mode", "v", "data"],
+                },
+                "Encrypted": {
+                    "type": "object",
+                    "additionalProperties": False,
+                    "properties": {
+                        "mode": {"type": "string", "const": "kms"},
+                        "v": {"type": "integer", "const": 1},
+                        "ct": {"type": "string"},
+                    },
+                    "required": ["mode", "v", "ct"],
+                },
+                "Envelope": {
+                    "oneOf": [
+                        {"$ref": "#/components/schemas/Plaintext"},
+                        {"$ref": "#/components/schemas/Encrypted"},
+                    ],
+                    "discriminator": {
+                        "propertyName": "mode",
+                        "mapping": {
+                            "plaintext": "#/components/schemas/Plaintext",
+                            "kms": "#/components/schemas/Encrypted",
+                        },
+                    },
+                },
+            }
+        },
+        "paths": {},
+    }
+
+    module = _load_module(openapi_to_pydantic_code(openapi))
+
+    envelope = module.Envelope.model_validate({"mode": "plaintext", "v": 1, "data": "x"})
+    assert isinstance(envelope.root, module.Plaintext)
+    with pytest.raises(ValidationError):
+        module.Envelope.model_validate({"mode": "other", "v": 1, "data": "x"})
+    with pytest.raises(ValidationError):
+        module.Plaintext.model_validate({"mode": "plaintext", "v": 2, "data": "x"})

alt_stack_openapi_pydantic-1.6.2/src/alt_stack_openapi_pydantic/type_render.py

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