Support Form bodies

Also a bit of cleanup for References
Closes #11

Author: dbanty

openapi_python_client/models/openapi.py

@@ -8,6 +8,7 @@
 
 from .properties import Property, property_from_dict, ListProperty, RefProperty, EnumProperty
 from .responses import Response, response_from_dict
+from .reference import Reference
 
 
 class ParameterLocation(Enum):
@@ -29,17 +30,18 @@ def from_dict(d: Dict, /) -> Parameter:
         """ Construct a parameter from it's OpenAPI dict form """
         return Parameter(
             location=ParameterLocation(d["in"]),
-            property=property_from_dict(name=d["name"], required=d["required"], data=d["schema"],),
+            property=property_from_dict(name=d["name"], required=d["required"], data=d["schema"]),
         )
 
 
-def _import_string_from_ref(ref: str, prefix: str = "") -> str:
-    return f"from {prefix}.{stringcase.snakecase(ref)} import {ref}"
+def _import_string_from_reference(reference: Reference, prefix: str = "") -> str:
+    return f"from {prefix}.{reference.module_name} import {reference.class_name}"
 
 
 @dataclass
 class EndpointCollection:
     """ A bunch of endpoints grouped under a tag that will become a module """
+
     tag: str
     endpoints: List[Endpoint] = field(default_factory=list)
     relative_imports: Set[str] = field(default_factory=set)
@@ -56,14 +58,11 @@ def from_dict(d: Dict[str, Dict[str, Dict]], /) -> Dict[str, EndpointCollection]
                     parameters.append(Parameter.from_dict(param_dict))
                 tag = method_data.get("tags", ["default"])[0]
                 for code, response_dict in method_data["responses"].items():
-                    response = response_from_dict(
-                        status_code=int(code),
-                        data=response_dict,
-                    )
+                    response = response_from_dict(status_code=int(code), data=response_dict)
                     responses.append(response)
-                form_body_ref = None
+                form_body_reference = None
                 if "requestBody" in method_data:
-                    form_body_ref = Endpoint.parse_request_body(method_data["requestBody"])
+                    form_body_reference = Endpoint.parse_request_body(method_data["requestBody"])
 
                 endpoint = Endpoint(
                     path=path,
@@ -72,13 +71,15 @@ def from_dict(d: Dict[str, Dict[str, Dict]], /) -> Dict[str, EndpointCollection]
                     name=method_data["operationId"],
                     parameters=parameters,
                     responses=responses,
-                    form_body_ref=form_body_ref,
+                    form_body_reference=form_body_reference,
                 )
 
                 collection = endpoints_by_tag.setdefault(tag, EndpointCollection(tag=tag))
                 collection.endpoints.append(endpoint)
-                if form_body_ref:
-                    collection.relative_imports.add(_import_string_from_ref(form_body_ref, prefix="..models"))
+                if form_body_reference:
+                    collection.relative_imports.add(
+                        _import_string_from_reference(form_body_reference, prefix="..models")
+                    )
         return endpoints_by_tag
 
 
@@ -94,17 +95,17 @@ class Endpoint:
     name: str
     parameters: List[Parameter]
     responses: List[Response]
-    form_body_ref: Optional[str]
+    form_body_reference: Optional[Reference]
 
     @staticmethod
-    def parse_request_body(body: Dict, /) -> Optional[str]:
+    def parse_request_body(body: Dict, /) -> Optional[Reference]:
         """ Return form_body_ref """
-        form_body_ref = None
+        form_body_reference = None
         body_content = body["content"]
         form_body = body_content.get("application/x-www-form-urlencoded")
         if form_body:
-            form_body_ref = form_body["schema"]["$ref"].split("/")[-1]
-        return form_body_ref
+            form_body_reference = Reference(form_body["schema"]["$ref"])
+        return form_body_reference
 
 
 @dataclass
@@ -116,21 +117,35 @@ class Schema:
     """
 
     title: str
-    properties: List[Property]
+    required_properties: List[Property]
+    optional_properties: List[Property]
     description: str
-    relative_imports: Set[str] = field(default_factory=set)
+    relative_imports: Set[str]
 
     @staticmethod
     def from_dict(d: Dict, /) -> Schema:
         """ A single Schema from its dict representation """
-        required = set(d.get("required", []))
-        properties: List[Property] = []
-        schema = Schema(title=d["title"], properties=properties, description=d.get("description", ""))
+        required_set = set(d.get("required", []))
+        required_properties: List[Property] = []
+        optional_properties: List[Property] = []
+        relative_imports: Set[str] = set()
+
         for key, value in d["properties"].items():
-            p = property_from_dict(name=key, required=key in required, data=value)
-            properties.append(p)
-            if isinstance(p, (ListProperty, RefProperty)) and p.ref:
-                schema.relative_imports.add(_import_string_from_ref(p.ref))
+            required = key in required_set
+            p = property_from_dict(name=key, required=required, data=value)
+            if required:
+                required_properties.append(p)
+            else:
+                optional_properties.append(p)
+            if isinstance(p, (ListProperty, RefProperty)) and p.reference:
+                relative_imports.add(_import_string_from_reference(p.reference))
+        schema = Schema(
+            title=stringcase.pascalcase(d["title"]),
+            required_properties=required_properties,
+            optional_properties=optional_properties,
+            relative_imports=relative_imports,
+            description=d.get("description", ""),
+        )
         return schema
 
     @staticmethod
@@ -161,7 +176,7 @@ def from_dict(d: Dict, /) -> OpenAPI:
         schemas = Schema.dict(d["components"]["schemas"])
         enums: Dict[str, EnumProperty] = {}
         for schema in schemas.values():
-            for prop in schema.properties:
+            for prop in schema.required_properties + schema.optional_properties:
                 if not isinstance(prop, EnumProperty):
                     continue
                 schema.relative_imports.add(f"from .{prop.name} import {prop.class_name}")

openapi_python_client/models/properties.py

@@ -1,14 +1,18 @@
 from dataclasses import dataclass, field
 from typing import Optional, List, Dict, Union, ClassVar
+
 import stringcase
 
+from .reference import Reference
+
 
 @dataclass
 class Property:
     """ Describes a single property for a schema """
 
     name: str
     required: bool
+    default: Optional[str]
 
     _type_string: ClassVar[str]
 
@@ -18,23 +22,33 @@ def get_type_string(self):
             return self._type_string
         return f"Optional[{self._type_string}]"
 
+    def to_string(self) -> str:
+        """ How this should be declared in a dataclass """
+        if self.default:
+            default = self.default
+        elif not self.required:
+            default = "None"
+        else:
+            default = None
+
+        if default is not None:
+            return f"{self.name}: {self.get_type_string()} = {self.default}"
+        else:
+            return f"{self.name}: {self.get_type_string()}"
+
 
 @dataclass
 class StringProperty(Property):
     """ A property of type str """
 
     max_length: Optional[int] = None
-    default: Optional[str] = None
     pattern: Optional[str] = None
 
     _type_string: ClassVar[str] = "str"
 
-    def to_string(self) -> str:
-        """ How this should be declared in a dataclass """
-        if self.default:
-            return f"{self.name}: {self.get_type_string()} = {self.default}"
-        else:
-            return f"{self.name}: {self.get_type_string()}"
+    def __post_init__(self):
+        if self.default is not None:
+            self.default = f'"{self.default}"'
 
 
 @dataclass
@@ -43,10 +57,6 @@ class DateTimeProperty(Property):
 
     _type_string: ClassVar[str] = "datetime"
 
-    def to_string(self) -> str:
-        """ How this should be declared in a dataclass """
-        return f"{self.name}: {self.get_type_string()}"
-
 
 @dataclass
 class FloatProperty(Property):
@@ -55,13 +65,6 @@ class FloatProperty(Property):
     default: Optional[float] = None
     _type_string: ClassVar[str] = "float"
 
-    def to_string(self) -> str:
-        """ How this should be declared in a dataclass """
-        if self.default:
-            return f"{self.name}: {self.get_type_string()} = {self.default}"
-        else:
-            return f"{self.name}: {self.get_type_string()}"
-
 
 @dataclass
 class IntProperty(Property):
@@ -70,42 +73,27 @@ class IntProperty(Property):
     default: Optional[int] = None
     _type_string: ClassVar[str] = "int"
 
-    def to_string(self) -> str:
-        """ How this should be declared in a dataclass """
-        if self.default:
-            return f"{self.name}: {self.get_type_string()} = {self.default}"
-        else:
-            return f"{self.name}: {self.get_type_string()}"
-
 
 @dataclass
 class BooleanProperty(Property):
     """ Property for bool """
 
     _type_string: ClassVar[str] = "bool"
 
-    def to_string(self) -> str:
-        """ How this should be declared in a dataclass """
-        return f"{self.name}: {self.get_type_string()}"
-
 
 @dataclass
 class ListProperty(Property):
     """ Property for list """
 
     type: Optional[str]
-    ref: Optional[str]
+    reference: Optional[Reference]
 
     def get_type_string(self):
         """ Get a string representation of type that should be used when declaring this property """
         if self.required:
             return f"List[{self.type}]"
         return f"Optional[List[{self.type}]]"
 
-    def to_string(self) -> str:
-        """ How this should be declared in a dataclass """
-        return f"{self.name}: {self.get_type_string()}"
-
 
 @dataclass
 class EnumProperty(Property):
@@ -124,10 +112,6 @@ def get_type_string(self):
             return self.class_name
         return f"Optional[{self.class_name}]"
 
-    def to_string(self) -> str:
-        """ How this should be declared in a dataclass """
-        return f"{self.name}: {self.get_type_string()}"
-
     @staticmethod
     def values_from_list(l: List[str], /) -> Dict[str, str]:
         """ Convert a list of values into dict of {name: value} """
@@ -148,13 +132,13 @@ def values_from_list(l: List[str], /) -> Dict[str, str]:
 class RefProperty(Property):
     """ A property which refers to another Schema """
 
-    ref: str
+    reference: Reference
 
     def get_type_string(self):
         """ Get a string representation of type that should be used when declaring this property """
         if self.required:
-            return self.ref
-        return f"Optional[{self.ref}]"
+            return self.reference.class_name
+        return f"Optional[{self.reference.class_name}]"
 
     def to_string(self) -> str:
         """ How this should be declared in a dataclass """
@@ -186,31 +170,35 @@ def property_from_dict(
 ) -> Property:
     """ Generate a Property from the OpenAPI dictionary representation of it """
     if "enum" in data:
-        return EnumProperty(name=name, required=required, values=EnumProperty.values_from_list(data["enum"]))
+        return EnumProperty(
+            name=name,
+            required=required,
+            values=EnumProperty.values_from_list(data["enum"]),
+            default=data.get("default"),
+        )
     if "$ref" in data:
-        ref = data["$ref"].split("/")[-1]
-        return RefProperty(name=name, required=required, ref=ref)
+        return RefProperty(name=name, required=required, reference=Reference(data["$ref"]), default=None)
     if data["type"] == "string":
         if "format" not in data:
             return StringProperty(
                 name=name, default=data.get("default"), required=required, pattern=data.get("pattern"),
             )
         elif data["format"] == "date-time":
-            return DateTimeProperty(name=name, required=required)
+            return DateTimeProperty(name=name, required=required, default=data.get("default"))
     elif data["type"] == "number":
         return FloatProperty(name=name, default=data.get("default"), required=required)
     elif data["type"] == "integer":
         return IntProperty(name=name, default=data.get("default"), required=required)
     elif data["type"] == "boolean":
-        return BooleanProperty(name=name, required=required)
+        return BooleanProperty(name=name, required=required, default=data.get("default"))
     elif data["type"] == "array":
-        ref = None
+        reference = None
         if "$ref" in data["items"]:
-            ref = data["items"]["$ref"].split("/")[-1]
+            reference = Reference(data["items"]["$ref"])
         _type = None
         if "type" in data["items"]:
             _type = _openapi_types_to_python_type_strings[data["items"]["type"]]
-        return ListProperty(name=name, required=required, type=_type, ref=ref)
+        return ListProperty(name=name, required=required, type=_type, reference=reference, default=None)
     elif data["type"] == "object":
-        return DictProperty(name=name, required=required)
+        return DictProperty(name=name, required=required, default=None)
     raise ValueError(f"Did not recognize type of {data}")

openapi_python_client/models/reference.py

@@ -0,0 +1,9 @@
+import stringcase
+
+
+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)
+        self.module_name: str = stringcase.snakecase(ref_value)