Add response deserialization

Closes #7

Author: dbanty

mypy.ini

@@ -1,7 +1,9 @@
 [mypy]
-disallow_any_explicit = True
 disallow_any_generics = True
 disallow_untyped_defs = True
 warn_redundant_casts = True
 warn_unused_ignores = True
 strict_equality = True
+
+[mypy-stringcase]
+ignore_missing_imports = True

openapi_python_client/__init__.py

@@ -1,7 +1,7 @@
 """ Generate modern Python clients from OpenAPI """
 import sys
 from pathlib import Path
-from typing import Dict
+from typing import Any, Dict
 
 import orjson
 import requests
@@ -10,7 +10,7 @@
 from .models import OpenAPI, import_string_from_reference
 
 
-def main():
+def main() -> None:
     """ Generate the client library """
     url = sys.argv[1]
     json = _get_json(url)
@@ -19,16 +19,16 @@ def main():
     _build_project(openapi)
 
 
-def _get_json(url) -> bytes:
+def _get_json(url: str) -> bytes:
     response = requests.get(url)
     return response.content
 
 
-def _parse_json(json: bytes) -> Dict:
+def _parse_json(json: bytes) -> Dict[str, Any]:
     return orjson.loads(json)
 
 
-def _build_project(openapi: OpenAPI):
+def _build_project(openapi: OpenAPI) -> None:
     env = Environment(loader=PackageLoader(__package__), trim_blocks=True, lstrip_blocks=True)
 
     # Create output directories
@@ -46,7 +46,9 @@ def _build_project(openapi: OpenAPI):
     # Create a pyproject.toml file
     pyproject_template = env.get_template("pyproject.toml")
     pyproject_path = project_dir / "pyproject.toml"
-    pyproject_path.write_text(pyproject_template.render(project_name=project_name, package_name=package_name, description=package_description))
+    pyproject_path.write_text(
+        pyproject_template.render(project_name=project_name, package_name=package_name, description=package_description)
+    )
 
     readme = project_dir / "README.md"
     readme_template = env.get_template("README.md")
@@ -88,5 +90,3 @@ def _build_project(openapi: OpenAPI):
     for tag, collection in openapi.endpoint_collections_by_tag.items():
         module_path = api_dir / f"{tag}.py"
         module_path.write_text(endpoint_template.render(collection=collection))
-
-

openapi_python_client/models/openapi.py

@@ -2,11 +2,11 @@
 
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Dict, List, Optional, Set, Iterable, Generator
+from typing import Any, Dict, Generator, Iterable, List, Optional, Set
 
-from .properties import Property, property_from_dict, ListProperty, RefProperty, EnumProperty
+from .properties import EnumProperty, ListProperty, Property, RefProperty, property_from_dict
 from .reference import Reference
-from .responses import Response, response_from_dict
+from .responses import ListRefResponse, RefResponse, Response, response_from_dict
 
 
 class ParameterLocation(str, Enum):
@@ -30,7 +30,7 @@ class EndpointCollection:
     relative_imports: Set[str] = field(default_factory=set)
 
     @staticmethod
-    def from_dict(d: Dict[str, Dict[str, Dict]], /) -> Dict[str, EndpointCollection]:
+    def from_dict(d: Dict[str, Dict[str, Dict[str, Any]]], /) -> Dict[str, EndpointCollection]:
         """ Parse the openapi paths data to get EndpointCollections by tag """
         endpoints_by_tag: Dict[str, EndpointCollection] = {}
         for path, path_data in d.items():
@@ -55,6 +55,10 @@ def from_dict(d: Dict[str, Dict[str, Dict]], /) -> Dict[str, EndpointCollection]
 
                 for code, response_dict in method_data["responses"].items():
                     response = response_from_dict(status_code=int(code), data=response_dict)
+                    if isinstance(response, (RefResponse, ListRefResponse)):
+                        collection.relative_imports.add(
+                            import_string_from_reference(response.reference, prefix="..models")
+                        )
                     responses.append(response)
                 form_body_reference = None
                 if "requestBody" in method_data:
@@ -69,7 +73,7 @@ def from_dict(d: Dict[str, Dict[str, Dict]], /) -> Dict[str, EndpointCollection]
                     path_parameters=path_parameters,
                     responses=responses,
                     form_body_reference=form_body_reference,
-                    requires_security=method_data.get("security"),
+                    requires_security=bool(method_data.get("security")),
                 )
 
                 collection.endpoints.append(endpoint)
@@ -97,7 +101,7 @@ class Endpoint:
     form_body_reference: Optional[Reference]
 
     @staticmethod
-    def parse_request_body(body: Dict, /) -> Optional[Reference]:
+    def parse_request_body(body: Dict[str, Any], /) -> Optional[Reference]:
         """ Return form_body_ref """
         form_body_reference = None
         body_content = body["content"]
@@ -122,7 +126,7 @@ class Schema:
     relative_imports: Set[str]
 
     @staticmethod
-    def from_dict(d: Dict, /) -> Schema:
+    def from_dict(d: Dict[str, Any], /) -> Schema:
         """ A single Schema from its dict representation """
         required_set = set(d.get("required", []))
         required_properties: List[Property] = []
@@ -148,7 +152,7 @@ def from_dict(d: Dict, /) -> Schema:
         return schema
 
     @staticmethod
-    def dict(d: Dict, /) -> Dict[str, Schema]:
+    def dict(d: Dict[str, Dict[str, Any]], /) -> Dict[str, Schema]:
         """ Get a list of Schemas from an OpenAPI dict """
         result = {}
         for data in d.values():
@@ -164,7 +168,7 @@ class OpenAPI:
     title: str
     description: str
     version: str
-    security_schemes: Dict
+    # security_schemes: Dict
     schemas: Dict[str, Schema]
     endpoint_collections_by_tag: Dict[str, EndpointCollection]
     enums: Dict[str, EnumProperty]
@@ -173,7 +177,7 @@ class OpenAPI:
     def check_enums(schemas: Iterable[Schema], collections: Iterable[EndpointCollection]) -> Dict[str, EnumProperty]:
         enums: Dict[str, EnumProperty] = {}
 
-        def _iterate_properties() -> Generator[Property]:
+        def _iterate_properties() -> Generator[Property, None, None]:
             for schema in schemas:
                 yield from schema.required_properties
                 yield from schema.optional_properties
@@ -196,7 +200,7 @@ def _iterate_properties() -> Generator[Property]:
         return enums
 
     @staticmethod
-    def from_dict(d: Dict, /) -> OpenAPI:
+    def from_dict(d: Dict[str, Dict[str, Any]], /) -> OpenAPI:
         """ Create an OpenAPI from dict """
         schemas = Schema.dict(d["components"]["schemas"])
         endpoint_collections_by_tag = EndpointCollection.from_dict(d["paths"])
@@ -208,6 +212,6 @@ def from_dict(d: Dict, /) -> OpenAPI:
             version=d["info"]["version"],
             endpoint_collections_by_tag=endpoint_collections_by_tag,
             schemas=schemas,
-            security_schemes=d["components"]["securitySchemes"],
+            # security_schemes=d["components"]["securitySchemes"],
             enums=enums,
         )

openapi_python_client/models/properties.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-from typing import Optional, List, Dict, Union, ClassVar
+from typing import Any, ClassVar, Dict, List, Optional, Union
 
 from .reference import Reference
 
@@ -10,11 +10,12 @@ class Property:
 
     name: str
     required: bool
-    default: Optional[str]
+    default: Optional[Any]
 
+    constructor_template: ClassVar[Optional[str]] = None
     _type_string: ClassVar[str]
 
-    def get_type_string(self):
+    def get_type_string(self) -> str:
         """ Get a string representation of type that should be used when declaring this property """
         if self.required:
             return self._type_string
@@ -38,6 +39,13 @@ def transform(self) -> str:
         """ What it takes to turn this object into a native python type """
         return self.name
 
+    def constructor_from_dict(self, dict_name: str) -> str:
+        """ How to load this property from a dict (used in generated model from_dict function """
+        if self.required:
+            return f'{dict_name}["{self.name}"]'
+        else:
+            return f'{dict_name}.get("{self.name}")'
+
 
 @dataclass
 class StringProperty(Property):
@@ -48,7 +56,7 @@ class StringProperty(Property):
 
     _type_string: ClassVar[str] = "str"
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if self.default is not None:
             self.default = f'"{self.default}"'
 
@@ -58,6 +66,7 @@ class DateTimeProperty(Property):
     """ A property of type datetime.datetime """
 
     _type_string: ClassVar[str] = "datetime"
+    constructor_template: ClassVar[str] = "datetime_property.pyi"
 
 
 @dataclass
@@ -89,12 +98,20 @@ class ListProperty(Property):
 
     type: Optional[str]
     reference: Optional[Reference]
+    constructor_template: ClassVar[str] = "list_property.pyi"
 
-    def get_type_string(self):
+    def get_type_string(self) -> str:
         """ Get a string representation of type that should be used when declaring this property """
+        if self.type:
+            this_type = self.type
+        elif self.reference:
+            this_type = self.reference.class_name
+        else:
+            raise ValueError(f"Could not figure out type of ListProperty {self.name}")
+
         if self.required:
-            return f"List[{self.type}]"
-        return f"Optional[List[{self.type}]]"
+            return f"List[{this_type}]"
+        return f"Optional[List[{this_type}]]"
 
 
 @dataclass
@@ -105,13 +122,13 @@ class EnumProperty(Property):
     inverse_values: Dict[str, str] = field(init=False)
     reference: Reference = field(init=False)
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         self.reference = Reference(self.name)
         self.inverse_values = {v: k for k, v in self.values.items()}
         if self.default is not None:
             self.default = f"{self.reference.class_name}.{self.inverse_values[self.default]}"
 
-    def get_type_string(self):
+    def get_type_string(self) -> str:
         """ Get a string representation of type that should be used when declaring this property """
 
         if self.required:
@@ -122,6 +139,10 @@ def transform(self) -> str:
         """ Output to the template, convert this Enum into a JSONable value """
         return f"{self.name}.value"
 
+    def constructor_from_dict(self, dict_name: str) -> str:
+        """ How to load this property from a dict (used in generated model from_dict function """
+        return f'{self.reference.class_name}({dict_name}["{self.name}"]) if "{self.name}" in {dict_name} else None'
+
     @staticmethod
     def values_from_list(l: List[str], /) -> Dict[str, str]:
         """ Convert a list of values into dict of {name: value} """
@@ -144,7 +165,9 @@ class RefProperty(Property):
 
     reference: Reference
 
-    def get_type_string(self):
+    constructor_template: ClassVar[str] = "ref_property.pyi"
+
+    def get_type_string(self) -> str:
         """ Get a string representation of type that should be used when declaring this property """
         if self.required:
             return self.reference.class_name
@@ -167,9 +190,7 @@ class DictProperty(Property):
 }
 
 
-def property_from_dict(
-    name: str, required: bool, data: Dict[str, Union[float, int, str, List[str], Dict[str, str]]]
-) -> Property:
+def property_from_dict(name: str, required: bool, data: Dict[str, Any]) -> Property:
     """ Generate a Property from the OpenAPI dictionary representation of it """
     if "enum" in data:
         return EnumProperty(

openapi_python_client/models/reference.py

@@ -3,6 +3,7 @@
 
 class Reference:
     """ A reference to a class which will be in models """
+
     def __init__(self, ref: str):
         ref_value = ref.split("/")[-1]  # get the #/schemas/blahblah part off
         self.class_name: str = stringcase.pascalcase(ref_value)