Update for 0.2.1

- Fix errors import
- Add list of enum support
- Bump to 0.2.1

Author: dbanty

CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.2.1 - 2020-03-22
+### Fixes
+- Fixed import of errors.py in generated api modules
+
+### Additions
+- Support for lists of Enums
+
 ## 0.2.0 - 2020-03-22
 ### Changes
 - Update Typer dependency to 0.1.0 and remove click-completion dependency (#19)

openapi_python_client/openapi_parser/openapi.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-from dataclasses import dataclass, field, replace
+from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, Dict, Generator, Iterable, List, Optional, Set
+from typing import Any, Dict, Generator, Iterable, List, Optional, Set, Union
 
-from .properties import EnumProperty, ListProperty, Property, RefProperty, property_from_dict
+from .properties import EnumListProperty, EnumProperty, Property, ReferenceListProperty, RefProperty, property_from_dict
 from .reference import Reference
 from .responses import ListRefResponse, RefResponse, Response, response_from_dict
 
@@ -91,7 +91,7 @@ def _add_body(self, data: Dict[str, Any]) -> None:
             self.relative_imports.add(import_string_from_reference(self.form_body_reference, prefix="..models"))
         if (
             self.json_body is not None
-            and isinstance(self.json_body, (ListProperty, RefProperty, EnumProperty))
+            and isinstance(self.json_body, (ReferenceListProperty, EnumListProperty, RefProperty, EnumProperty))
             and self.json_body.reference is not None
         ):
             self.relative_imports.add(import_string_from_reference(self.json_body.reference, prefix="..models"))
@@ -108,7 +108,10 @@ def _add_parameters(self, data: Dict[str, Any]) -> None:
             prop = property_from_dict(
                 name=param_dict["name"], required=param_dict["required"], data=param_dict["schema"]
             )
-            if isinstance(prop, (ListProperty, RefProperty, EnumProperty)) and prop.reference:
+            if (
+                isinstance(prop, (ReferenceListProperty, EnumListProperty, RefProperty, EnumProperty))
+                and prop.reference
+            ):
                 self.relative_imports.add(import_string_from_reference(prop.reference, prefix="..models"))
             if param_dict["in"] == ParameterLocation.QUERY:
                 self.query_parameters.append(prop)
@@ -165,7 +168,7 @@ def from_dict(d: Dict[str, Any], /) -> Schema:
                 required_properties.append(p)
             else:
                 optional_properties.append(p)
-            if isinstance(p, (ListProperty, RefProperty, EnumProperty)) and p.reference:
+            if isinstance(p, (ReferenceListProperty, EnumListProperty, RefProperty, EnumProperty)) and p.reference:
                 relative_imports.add(import_string_from_reference(p.reference))
         schema = Schema(
             reference=Reference.from_ref(d["title"]),
@@ -195,17 +198,19 @@ class OpenAPI:
     version: str
     schemas: Dict[str, Schema]
     endpoint_collections_by_tag: Dict[str, EndpointCollection]
-    enums: Dict[str, EnumProperty]
+    enums: Dict[str, Union[EnumProperty, EnumListProperty]]
 
     @staticmethod
-    def _check_enums(schemas: Iterable[Schema], collections: Iterable[EndpointCollection]) -> Dict[str, EnumProperty]:
+    def _check_enums(
+        schemas: Iterable[Schema], collections: Iterable[EndpointCollection]
+    ) -> Dict[str, Union[EnumProperty, EnumListProperty]]:
         """
         Create EnumProperties for every enum in any schema or collection.
         Enums are deduplicated by class name.
 
         :raises AssertionError: if two Enums with the same name but different values are detected
         """
-        enums: Dict[str, EnumProperty] = {}
+        enums: Dict[str, Union[EnumProperty, EnumListProperty]] = {}
 
         def _iterate_properties() -> Generator[Property, None, None]:
             for schema in schemas:
@@ -217,7 +222,7 @@ def _iterate_properties() -> Generator[Property, None, None]:
                     yield from endpoint.query_parameters
 
         for prop in _iterate_properties():
-            if not isinstance(prop, EnumProperty):
+            if not isinstance(prop, (EnumProperty, EnumListProperty)):
                 continue
 
             if prop.reference.class_name in enums:

openapi_python_client/openapi_parser/properties.py

@@ -93,25 +93,52 @@ class BooleanProperty(Property):
 
 
 @dataclass
-class ListProperty(Property):
-    """ Property for list """
+class BasicListProperty(Property):
+    """ A List of basic types """
 
-    type: Optional[str]
-    reference: Optional[Reference]
-    constructor_template: ClassVar[str] = "list_property.pyi"
+    type: str
+
+    def constructor_from_dict(self, dict_name: str) -> str:
+        """ How to set this property from a dictionary of values """
+        return f'{dict_name}.get("{self.name}", [])'
 
     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}]]"
+
+
+@dataclass
+class ReferenceListProperty(Property):
+    """ A List of References """
 
+    reference: Reference
+    constructor_template: ClassVar[str] = "reference_list_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 f"List[{this_type}]"
-        return f"Optional[List[{this_type}]]"
+            return f"List[{self.reference.class_name}]"
+        return f"Optional[List[{self.reference.class_name}]]"
+
+
+@dataclass
+class EnumListProperty(Property):
+    """ List of Enum values """
+
+    values: Dict[str, str]
+    reference: Reference = field(init=False)
+    constructor_template: ClassVar[str] = "enum_list_property.pyi"
+
+    def __post_init__(self) -> None:
+        self.reference = Reference.from_ref(self.name)
+
+    def get_type_string(self) -> str:
+        """ Get a string representation of type that should be used when declaring this property """
+        if self.required:
+            return f"List[{self.reference.class_name}]"
+        return f"Optional[List[{self.reference.class_name}]]"
 
 
 @dataclass
@@ -218,13 +245,21 @@ def property_from_dict(name: str, required: bool, data: Dict[str, Any]) -> Prope
     elif data["type"] == "boolean":
         return BooleanProperty(name=name, required=required, default=data.get("default"))
     elif data["type"] == "array":
-        reference = None
         if "$ref" in data["items"]:
-            reference = Reference.from_ref(data["items"]["$ref"])
-        _type = None
+            return ReferenceListProperty(
+                name=name, required=required, default=None, reference=Reference.from_ref(data["items"]["$ref"])
+            )
+        if "enum" in data["items"]:
+            return EnumListProperty(
+                name=name, required=required, default=None, values=EnumProperty.values_from_list(data["items"]["enum"])
+            )
         if "type" in data["items"]:
-            _type = _openapi_types_to_python_type_strings[data["items"]["type"]]
-        return ListProperty(name=name, required=required, type=_type, reference=reference, default=None)
+            return BasicListProperty(
+                name=name,
+                required=required,
+                default=None,
+                type=_openapi_types_to_python_type_strings[data["items"]["type"]],
+            )
     elif data["type"] == "object":
         return DictProperty(name=name, required=required, default=data.get("default"))
     raise ValueError(f"Did not recognize type of {data}")

openapi_python_client/templates/async_endpoint_module.pyi

@@ -4,7 +4,7 @@ from typing import Dict, List, Optional, Union
 import httpx
 
 from ..client import AuthenticatedClient, Client
-from .errors import ApiResponseError
+from ..errors import ApiResponseError
 
 {% for relative in collection.relative_imports %}
 {{ relative }}

openapi_python_client/templates/endpoint_module.pyi

@@ -4,7 +4,7 @@ from typing import Dict, List, Optional, Union
 import httpx
 
 from ..client import AuthenticatedClient, Client
-from .errors import ApiResponseError
+from ..errors import ApiResponseError
 
 {% for relative in collection.relative_imports %}
 {{ relative }}

openapi_python_client/templates/enum_list_property.pyi

@@ -0,0 +1,3 @@
+        {{ property.name }} = []
+        for {{ property.name }}_item in d.get("{{ property.name }}", []):
+            {{ property.name }}.append({{ property.reference.class_name }}({{ property.name }}_item))

openapi_python_client/templates/model.pyi

@@ -35,6 +35,7 @@ class {{ schema.reference.class_name }}:
         {% else %}
         {{ property.name }} = {{ property.constructor_from_dict("d") }}
         {% endif %}
+
         {% endfor %}
         return {{ schema.reference.class_name }}(
             {% for property in schema.required_properties + schema.optional_properties %}

openapi_python_client/templates/list_property.pyi renamed to openapi_python_client/templates/reference_list_property.pyi

@@ -1,7 +1,3 @@
-{% if property.type %}
-        {{ property.name }} = d.get("{{ property.name }}", [])
-{% else %}
         {{ property.name }} = []
         for {{ property.name }}_item in d.get("{{ property.name }}", []):
             {{ property.name }}.append({{ property.reference.class_name }}.from_dict({{ property.name }}_item))
-{% endif %}

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "openapi-python-client"
-version = "0.2.0"
+version = "0.2.1"
 description = "Generate modern Python clients from OpenAPI"
 
 authors = [

tests/test_end_to_end/fastapi/__init__.py

@@ -1,8 +1,10 @@
 """ A FastAPI app used to create an OpenAPI document for end-to-end testing """
 import json
+from enum import Enum
 from pathlib import Path
+from typing import List
 
-from fastapi import FastAPI
+from fastapi import APIRouter, FastAPI, Query
 from pydantic import BaseModel
 
 app = FastAPI(title="My Test API", description="An API for testing openapi-python-client",)
@@ -18,6 +20,39 @@ async def ping():
     return {"success": True}
 
 
+test_router = APIRouter()
+
+
+class TestEnum(Enum):
+    """ For testing Enums in all the ways they can be used """
+
+    FIRST_VALUE = "FIRST_VALUE"
+    SECOND_VALUE = "SECOND_VALUE"
+
+
+class OtherModel(BaseModel):
+    """ A different model for calling from TestModel """
+
+    a_value: str
+
+
+class TestModel(BaseModel):
+    """ A Model for testing all the ways custom objects can be used """
+
+    an_enum_value: TestEnum
+    a_list_of_enums: List[TestEnum]
+    a_list_of_strings: List[str]
+    a_list_of_objects: List[OtherModel]
+
+
+@test_router.get("/", response_model=List[TestModel])
+def test_getting_lists(statuses: List[TestEnum] = Query(...),):
+    """ Get users, filtered by statuses """
+    return
+
+
+app.include_router(test_router, prefix="/tests", tags=["users"])
+
 if __name__ == "__main__":
     path = Path(__file__).parent / "openapi.json"
     path.write_text(json.dumps(app.openapi()))