fix: types are always defined before being used

Author: Anders Brams

openapi_python/generator/render.py

@@ -157,48 +157,47 @@ def _alias_dependencies(defn: TypeAliasDef, names: set[str]) -> set[str]:
     return dependencies
 
 
-def _order_aliases(defns: tuple[TypeAliasDef, ...]) -> list[TypeAliasDef]:
-    by_name = {item.name: item for item in defns}
+def _type_dependencies(defn: TypeAliasDef | TypedDictDef, names: set[str]) -> set[str]:
+    match defn:
+        case TypeAliasDef():
+            return _alias_dependencies(defn, names)
+        case TypedDictDef():
+            return _typed_dict_dependencies(defn, names)
+
+
+def _order_type_definitions(
+    aliases: tuple[TypeAliasDef, ...], typed_dicts: tuple[TypedDictDef, ...]
+) -> list[TypeAliasDef | TypedDictDef]:
+    by_name: dict[str, TypeAliasDef | TypedDictDef] = {
+        item.name: item for item in (*aliases, *typed_dicts)
+    }
     names = set(by_name)
-    ordered: list[TypeAliasDef] = []
+    ordered: list[TypeAliasDef | TypedDictDef] = []
     temporary: set[str] = set()
     permanent: set[str] = set()
 
     def visit(name: str) -> None:
         if name in permanent or name in temporary:
             return
         temporary.add(name)
-        for dependency in sorted(_alias_dependencies(by_name[name], names)):
+        for dependency in sorted(_type_dependencies(by_name[name], names)):
             visit(dependency)
         temporary.remove(name)
         permanent.add(name)
         ordered.append(by_name[name])
 
     for name in sorted(by_name):
         visit(name)
-    return ordered
-
 
-def _order_typeddicts(defns: tuple[TypedDictDef, ...]) -> list[TypedDictDef]:
-    by_name = {item.name: item for item in defns}
-    names = set(by_name)
-    ordered: list[TypedDictDef] = []
-    temporary: set[str] = set()
-    permanent: set[str] = set()
+    return ordered
 
-    def visit(name: str) -> None:
-        if name in permanent or name in temporary:
-            return
-        temporary.add(name)
-        for dependency in sorted(_typed_dict_dependencies(by_name[name], names)):
-            visit(dependency)
-        temporary.remove(name)
-        permanent.add(name)
-        ordered.append(by_name[name])
 
-    for name in sorted(by_name):
-        visit(name)
-    return ordered
+def _format_type_definition(defn: TypeAliasDef | TypedDictDef) -> str:
+    match defn:
+        case TypeAliasDef():
+            return _format_alias(defn)
+        case TypedDictDef():
+            return _format_typeddict(defn)
 
 
 def _call_parameters(op: OperationDef) -> dict[str, str]:
@@ -273,12 +272,11 @@ def _fallback_method_block(
 
 
 def _render_types(spec: NormalizedSpec) -> str:
-    aliases = (*_route_aliases(spec), *_order_aliases(spec.aliases))
-    blocks = (
-        [_format_enum(item) for item in spec.enums]
-        + [_format_alias(alias) for alias in aliases]
-        + [_format_typeddict(item) for item in _order_typeddicts(spec.typed_dicts)]
-    )
+    aliases = (*_route_aliases(spec), *spec.aliases)
+    type_definitions = _order_type_definitions(aliases, spec.typed_dicts)
+    blocks = [_format_enum(item) for item in spec.enums] + [
+        _format_type_definition(item) for item in type_definitions
+    ]
     return _render_template(
         "types.py.j2",
         type_blocks="\n".join(blocks).strip() + "\n",

tests/contract/type_order/generate.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from openapi_python.generator import GenerationRequest, generate_client
+
+SPEC = {
+    "openapi": "3.1.0",
+    "info": {"title": "Type order", "version": "1.0.0"},
+    "paths": {
+        "/owners": {
+            "get": {
+                "responses": {
+                    "200": {
+                        "content": {
+                            "application/json": {
+                                "schema": {"$ref": "#/components/schemas/Owner"}
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    },
+    "components": {
+        "schemas": {
+            "Owner": {
+                "oneOf": [
+                    {"$ref": "#/components/schemas/Person"},
+                    {"$ref": "#/components/schemas/Team"},
+                ]
+            },
+            "Person": {
+                "type": "object",
+                "properties": {"name": {"type": "string"}},
+                "required": ["name"],
+            },
+            "Team": {
+                "type": "object",
+                "properties": {"slug": {"type": "string"}},
+                "required": ["slug"],
+            },
+        }
+    },
+}
+
+
+def main() -> None:
+    generate_client(
+        GenerationRequest(
+            output_dir=Path(__file__).parent / "generated",
+            spec_json=json.dumps(SPEC),
+            overwrite=True,
+        )
+    )
+
+
+if __name__ == "__main__":
+    main()

tests/contract/type_order/usage_async.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import assert_type
+
+from generated.my_client import AsyncClient
+from generated.my_client.types import Owner, Person, Team
+
+async_client = AsyncClient(base_url="http://testserver")
+
+
+async def use_async_client() -> None:
+    person: Person = {"name": "Ada"}
+    team: Team = {"slug": "core"}
+
+    assert_type(person, Person)
+    assert_type(team, Team)
+    assert_type(await async_client.get("/owners")(), Owner)

tests/contract/type_order/usage_sync.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from typing import assert_type
+
+from generated.my_client import Client
+from generated.my_client.types import Owner, Person, Team
+
+client = Client(base_url="http://testserver")
+
+person: Person = {"name": "Ada"}
+team: Team = {"slug": "core"}
+
+assert_type(person, Person)
+assert_type(team, Team)
+assert_type(client.get("/owners")(), Owner)

tests/test_contracts.py

@@ -46,3 +46,9 @@ def test_contract_types(contract_dir: Path) -> None:
         cwd=contract_dir,
     )
     assert typecheck.returncode == 0, _output(typecheck)
+
+    generated_types = _run(
+        ["ty", "check", "generated/my_client/types.py", "--python-version", "3.12"],
+        cwd=contract_dir,
+    )
+    assert generated_types.returncode == 0, _output(generated_types)