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

{alt_stack_openapi_pydantic-1.6.3/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.3
+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.3 → alt_stack_openapi_pydantic-1.6.4}/pyproject.toml

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

@@ -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/"):
@@ -148,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.3 → 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.3
+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.3 → alt_stack_openapi_pydantic-1.6.4}/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.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": {