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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alt-stack-openapi-pydantic
-Version: 1.6.2
+Version: 1.6.3
 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.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alt-stack-openapi-pydantic"
-version = "1.6.2"
+version = "1.6.3"
 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.3}/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
@@ -135,10 +135,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)
 

alt_stack_openapi_pydantic-1.6.3/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.3}/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.3}/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.3}/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.3/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.3
 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.3}/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.3}/tests/test_convert_schema.py

@@ -160,3 +160,12 @@ 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']]"
+    )

{alt_stack_openapi_pydantic-1.6.2 → alt_stack_openapi_pydantic-1.6.3}/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.3}/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.3}/tests/test_to_python.py

@@ -1006,3 +1006,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}]"