Refactor model building, add e2e section for inline objects.

Author: dbanty

end_to_end_tests/golden-record/my_test_api_client/api/default/ping_ping_get.py

@@ -0,0 +1,68 @@
+from typing import Any, Dict
+
+import httpx
+
+from ...client import Client
+from ...types import Response
+
+
+def _get_kwargs(
+    *,
+    client: Client,
+    json_body: Dict[Any, Any],
+) -> Dict[str, Any]:
+    url = "{}/tests/inline_objects".format(client.base_url)
+
+    headers: Dict[str, Any] = client.get_headers()
+
+    json_json_body = json_body
+
+    return {
+        "url": url,
+        "headers": headers,
+        "cookies": client.get_cookies(),
+        "timeout": client.get_timeout(),
+        "json": json_json_body,
+    }
+
+
+def _build_response(*, response: httpx.Response) -> Response[None]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=None,
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+    json_body: Dict[Any, Any],
+) -> Response[None]:
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    response = httpx.post(
+        **kwargs,
+    )
+
+    return _build_response(response=response)
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    json_body: Dict[Any, Any],
+) -> Response[None]:
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
+
+    async with httpx.AsyncClient() as _client:
+        response = await _client.post(**kwargs)
+
+    return _build_response(response=response)

end_to_end_tests/golden-record/my_test_api_client/api/tests/test_inline_objects.py

@@ -6,26 +6,6 @@
     "version": "0.1.0"
   },
   "paths": {
-    "/ping": {
-      "get": {
-        "summary": "Ping",
-        "description": "A quick check to see if the system is running ",
-        "operationId": "ping_ping_get",
-        "responses": {
-          "200": {
-            "description": "Successful Response",
-            "content": {
-              "application/json": {
-                "schema": {
-                  "title": "Response Ping Ping Get",
-                  "type": "boolean"
-                }
-              }
-            }
-          }
-        }
-      }
-    },
     "/tests/": {
       "get": {
         "tags": ["tests"],
@@ -516,6 +496,46 @@
           }
         }
       }
+    },
+    "/tests/inline_objects": {
+      "post": {
+        "tags": ["tests"],
+        "summary": "Test Inline Objects",
+        "operationId": "test_inline_objects",
+        "requestBody": {
+          "description": "An inline body object",
+          "required": true,
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "a_property": {
+                    "type": "string"
+                  }
+                }
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "Inline object response",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "object",
+                  "properties": {
+                    "a_property": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
     }
   },
   "components": {

end_to_end_tests/openapi.json

@@ -95,7 +95,7 @@ def _get_errors(self) -> Sequence[GeneratorError]:
         errors = []
         for collection in self.openapi.endpoint_collections_by_tag.values():
             errors.extend(collection.parse_errors)
-        errors.extend(self.openapi.schemas.errors)
+        errors.extend(self.openapi.errors)
         return errors
 
     def _create_package(self) -> None:
@@ -148,7 +148,7 @@ def _build_models(self) -> None:
         imports = []
 
         model_template = self.env.get_template("model.pyi")
-        for model in self.openapi.schemas.models.values():
+        for model in self.openapi.models.values():
             module_path = models_dir / f"{model.reference.module_name}.py"
             module_path.write_text(model_template.render(model=model))
             imports.append(import_string_from_reference(model.reference))

openapi_python_client/__init__.py

@@ -0,0 +1,59 @@
+""" A Model is used to generate classes from schemas. This module contains Model and helper functions for it """
+from dataclasses import dataclass
+from typing import List, Set, Union
+
+from .. import schema as oai
+from .errors import ParseError
+from .properties import Property, property_from_data
+from .reference import Reference
+
+
+@dataclass
+class Model:
+    """
+    A data model used by the API- usually a Schema with type "object".
+
+    These will all be converted to dataclasses in the client
+    """
+
+    reference: Reference
+    required_properties: List[Property]
+    optional_properties: List[Property]
+    description: str
+    relative_imports: Set[str]
+
+
+def model_from_data(*, data: oai.Schema, name: str) -> Union["Model", ParseError]:
+    """A single Model from its OAI data
+
+    Args:
+        data: Data of a single Schema
+        name: Name by which the schema is referenced, such as a model name.
+            Used to infer the type name if a `title` property is not available.
+    """
+    required_set = set(data.required or [])
+    required_properties: List[Property] = []
+    optional_properties: List[Property] = []
+    relative_imports: Set[str] = set()
+
+    ref = Reference.from_ref(data.title or name)
+
+    for key, value in (data.properties or {}).items():
+        required = key in required_set
+        p = property_from_data(name=key, required=required, data=value)
+        if isinstance(p, ParseError):
+            return p
+        if required:
+            required_properties.append(p)
+        else:
+            optional_properties.append(p)
+        relative_imports.update(p.get_imports(prefix=".."))
+
+    model = Model(
+        reference=ref,
+        required_properties=required_properties,
+        optional_properties=optional_properties,
+        relative_imports=relative_imports,
+        description=data.description or "",
+    )
+    return model