Cherry-pick optional params

Author: forest-benchling

end_to_end_tests/openapi.json

@@ -290,12 +290,49 @@
           {
             "required": false,
             "schema": {
-              "title": "Datetime Prop",
+              "title": "Not Required, Not Nullable Datetime Prop",
+              "nullable": false,
               "type": "string",
               "format": "date-time",
               "default": "1010-10-10T00:00:00"
             },
-            "name": "datetime_prop",
+            "name": "not_required_not_nullable_datetime_prop",
+            "in": "query"
+          },
+          {
+            "required": false,
+            "schema": {
+              "title": "Not Required, Nullable Datetime Prop",
+              "nullable": true,
+              "type": "string",
+              "format": "date-time",
+              "default": "1010-10-10T00:00:00"
+            },
+            "name": "not_required_nullable_datetime_prop",
+            "in": "query"
+          },
+          {
+            "required": true,
+            "schema": {
+              "title": "Required, Not Nullable Datetime Prop",
+              "nullable": false,
+              "type": "string",
+              "format": "date-time",
+              "default": "1010-10-10T00:00:00"
+            },
+            "name": "required_not_nullable_datetime_prop",
+            "in": "query"
+          },
+          {
+            "required": true,
+            "schema": {
+              "title": "Required, Nullable Datetime Prop",
+              "nullable": true,
+              "type": "string",
+              "format": "date-time",
+              "default": "1010-10-10T00:00:00"
+            },
+            "name": "required_nullable_datetime_prop",
             "in": "query"
           },
           {
@@ -396,14 +433,6 @@
             },
             "name": "enum_prop",
             "in": "query"
-          },
-          {
-            "required": false,
-            "schema": {
-              "$ref": "#/components/schemas/ModelWithUnionProperty"
-            },
-            "name": "model_prop",
-            "in": "query"
           }
         ],
         "responses": {
@@ -630,7 +659,7 @@
     "schemas": {
       "AModel": {
         "title": "AModel",
-        "required": ["an_enum_value", "aCamelDateTime", "a_date", "a_nullable_date", "required_nullable", "required_not_nullable", "model", "nullable_model"],
+        "required": ["an_enum_value", "aCamelDateTime", "a_date", "a_nullable_date", "required_nullable", "required_not_nullable"],
         "type": "object",
         "properties": {
           "an_enum_value": {
@@ -694,42 +723,6 @@
             "title": "NOT Required AND NOT Nullable",
             "type": "string",
             "nullable": false
-          },
-          "model": {
-            "type": "object",
-            "allOf": [
-              {
-                "ref": "#/components/schemas/ModelWithUnionProperty"
-              }
-            ],
-            "nullable": false
-          },
-          "nullable_model": {
-            "type": "object",
-            "allOf": [
-              {
-                "ref": "#/components/schemas/ModelWithUnionProperty"
-              }
-            ],
-            "nullable": true
-          },
-          "not_required_model": {
-            "type": "object",
-            "allOf": [
-              {
-                "ref": "#/components/schemas/ModelWithUnionProperty"
-              }
-            ],
-            "nullable": false
-          },
-          "not_required_nullable_model": {
-            "type": "object",
-            "allOf": [
-              {
-                "ref": "#/components/schemas/ModelWithUnionProperty"
-              }
-            ],
-            "nullable": true
           }
         },
         "description": "A Model for testing all the ways custom objects can be used ",

openapi_python_client/parser/properties/__init__.py

@@ -19,6 +19,7 @@ class NoneProperty(Property):
     """ A property that is always None (used for empty schemas) """
 
     _type_string: ClassVar[str] = "None"
+    _json_type_string: ClassVar[str] = "None"
     template: ClassVar[Optional[str]] = "none_property.pyi"
 
 
@@ -29,6 +30,7 @@ class StringProperty(Property):
     max_length: Optional[int] = None
     pattern: Optional[str] = None
     _type_string: ClassVar[str] = "str"
+    _json_type_string: ClassVar[str] = "str"
 
 
 @attr.s(auto_attribs=True, frozen=True)
@@ -38,6 +40,7 @@ class DateTimeProperty(Property):
     """
 
     _type_string: ClassVar[str] = "datetime.datetime"
+    _json_type_string: ClassVar[str] = "str"
     template: ClassVar[str] = "datetime_property.pyi"
 
     def get_imports(self, *, prefix: str) -> Set[str]:
@@ -58,6 +61,7 @@ class DateProperty(Property):
     """ A property of type datetime.date """
 
     _type_string: ClassVar[str] = "datetime.date"
+    _json_type_string: ClassVar[str] = "str"
     template: ClassVar[str] = "date_property.pyi"
 
     def get_imports(self, *, prefix: str) -> Set[str]:
@@ -78,6 +82,8 @@ class FileProperty(Property):
     """ A property used for uploading files """
 
     _type_string: ClassVar[str] = "File"
+    # Return type of File.to_tuple()
+    _json_type_string: ClassVar[str] = "Tuple[Optional[str], Union[BinaryIO, TextIO], Optional[str]]"
     template: ClassVar[str] = "file_property.pyi"
 
     def get_imports(self, *, prefix: str) -> Set[str]:
@@ -98,20 +104,23 @@ class FloatProperty(Property):
     """ A property of type float """
 
     _type_string: ClassVar[str] = "float"
+    _json_type_string: ClassVar[str] = "float"
 
 
 @attr.s(auto_attribs=True, frozen=True)
 class IntProperty(Property):
     """ A property of type int """
 
     _type_string: ClassVar[str] = "int"
+    _json_type_string: ClassVar[str] = "int"
 
 
 @attr.s(auto_attribs=True, frozen=True)
 class BooleanProperty(Property):
     """ Property for bool """
 
     _type_string: ClassVar[str] = "bool"
+    _json_type_string: ClassVar[str] = "bool"
 
 
 InnerProp = TypeVar("InnerProp", bound=Property)
@@ -122,18 +131,11 @@ class ListProperty(Property, Generic[InnerProp]):
     """ A property representing a list (array) of other properties """
 
     inner_property: InnerProp
+    _json_type_string: ClassVar[str] = "List[Any]"
     template: ClassVar[str] = "list_property.pyi"
 
-    def get_type_string(self, no_optional: bool = False) -> str:
-        """ Get a string representation of type that should be used when declaring this property """
-        type_string = f"List[{self.inner_property.get_type_string()}]"
-        if no_optional:
-            return type_string
-        if self.nullable:
-            type_string = f"Optional[{type_string}]"
-        if not self.required:
-            type_string = f"Union[Unset, {type_string}]"
-        return type_string
+    def get_base_type_string(self) -> str:
+        return f"List[{self.inner_property.get_type_string()}]"
 
     def get_instance_type_string(self) -> str:
         """Get a string representation of runtime type that should be used for `isinstance` checks"""
@@ -167,18 +169,38 @@ def __attrs_post_init__(self) -> None:
             self, "has_properties_without_templates", any(prop.template is None for prop in self.inner_properties)
         )
 
-    def get_type_string(self, no_optional: bool = False) -> str:
-        """ Get a string representation of type that should be used when declaring this property """
-        inner_types = [p.get_type_string(no_optional=True) for p in self.inner_properties]
-        inner_prop_string = ", ".join(inner_types)
-        type_string = f"Union[{inner_prop_string}]"
+    def _get_inner_prop_string(self, json: bool = False) -> str:
+        inner_types = [p.get_type_string(no_optional=True, json=json) for p in self.inner_properties]
+        unique_inner_types = list(dict.fromkeys(inner_types))
+        return ", ".join(unique_inner_types)
+
+    def get_base_type_string(self, json: bool = False) -> str:
+        return f"Union[{self._get_inner_prop_string(json=json)}]"
+
+    def get_type_string(self, no_optional: bool = False, query_parameter: bool = False, json: bool = False) -> str:
+        """
+        Get a string representation of type that should be used when declaring this property.
+
+        This implementation differs slightly from `Property.get_type_string` in order to collapse
+        nested union types.
+        """
+        type_string = self.get_base_type_string(json=json)
         if no_optional:
             return type_string
-        if not self.required:
-            type_string = f"Union[Unset, {inner_prop_string}]"
-        if self.nullable:
-            type_string = f"Optional[{type_string}]"
-        return type_string
+        if self.required:
+            if self.nullable:
+                return f"Union[None, {self._get_inner_prop_string(json=json)}]"
+            else:
+                return type_string
+        else:
+            if self.nullable:
+                return f"Union[Unset, None, {self._get_inner_prop_string(json=json)}]"
+            else:
+                if query_parameter:
+                    # For query parameters, None has the same meaning as Unset
+                    return f"Union[Unset, None, {self._get_inner_prop_string(json=json)}]"
+                else:
+                    return f"Union[Unset, {self._get_inner_prop_string(json=json)}]"
 
     def get_imports(self, *, prefix: str) -> Set[str]:
         """
@@ -250,23 +272,13 @@ def build_model_property(
     required_properties: List[Property] = []
     optional_properties: List[Property] = []
     relative_imports: Set[str] = set()
-    references: List[oai.Reference] = []
 
     class_name = data.title or name
     if parent_name:
         class_name = f"{utils.pascal_case(parent_name)}{utils.pascal_case(class_name)}"
     ref = Reference.from_ref(class_name)
 
-    all_props = data.properties or {}
-    if not isinstance(data, oai.Reference) and data.allOf:
-        for sub_prop in data.allOf:
-            if isinstance(sub_prop, oai.Reference):
-                references += [sub_prop]
-            else:
-                all_props.update(sub_prop.properties or {})
-                required_set.update(sub_prop.required or [])
-
-    for key, value in all_props.items():
+    for key, value in (data.properties or {}).items():
         prop_required = key in required_set
         prop, schemas = property_from_data(
             name=key, required=prop_required, data=value, schemas=schemas, parent_name=class_name
@@ -302,7 +314,6 @@ def build_model_property(
 
     prop = ModelProperty(
         reference=ref,
-        references=references,
         required_properties=required_properties,
         optional_properties=optional_properties,
         relative_imports=relative_imports,
@@ -460,6 +471,9 @@ def _property_from_data(
         )
     if data.anyOf or data.oneOf:
         return build_union_property(data=data, name=name, required=required, schemas=schemas, parent_name=parent_name)
+    if not data.type:
+        return NoneProperty(name=name, required=required, nullable=False, default=None), schemas
+
     if data.type == "string":
         return _string_based_property(name=name, required=required, data=data), schemas
     elif data.type == "number":
@@ -494,10 +508,8 @@ def _property_from_data(
         )
     elif data.type == "array":
         return build_list_property(data=data, name=name, required=required, schemas=schemas, parent_name=parent_name)
-    elif data.type == "object" or data.allOf:
+    elif data.type == "object":
         return build_model_property(data=data, name=name, schemas=schemas, required=required, parent_name=parent_name)
-    elif not data.type:
-        return NoneProperty(name=name, required=required, nullable=False, default=None), schemas
     return PropertyError(data=data, detail=f"unknown type {data.type}"), schemas
 
 
@@ -554,16 +566,6 @@ def build_schemas(*, components: Dict[str, Union[oai.Reference, oai.Schema]]) ->
                 schemas = schemas_or_err
                 processing = True  # We made some progress this round, do another after it's done
         to_process = next_round
-
-    resolve_errors: List[PropertyError] = []
-    models = list(schemas.models.values())
-    for model in models:
-        schemas_or_err = model.resolve_references(components=components, schemas=schemas)
-        if isinstance(schemas_or_err, PropertyError):
-            resolve_errors.append(schemas_or_err)
-        else:
-            schemas = schemas_or_err
-
     schemas.errors.extend(errors)
-    schemas.errors.extend(resolve_errors)
+
     return schemas

openapi_python_client/parser/properties/enum_property.py

@@ -18,21 +18,13 @@ class EnumProperty(Property):
     values: Dict[str, ValueType]
     reference: Reference
     value_type: Type[ValueType]
+    _json_type_string: ClassVar[str] = "int"
     default: Optional[Any] = attr.ib()
 
     template: ClassVar[str] = "enum_property.pyi"
 
-    def get_type_string(self, no_optional: bool = False) -> str:
-        """ Get a string representation of type that should be used when declaring this property """
-
-        type_string = self.reference.class_name
-        if no_optional:
-            return type_string
-        if self.nullable:
-            type_string = f"Optional[{type_string}]"
-        if not self.required:
-            type_string = f"Union[Unset, {type_string}]"
-        return type_string
+    def get_base_type_string(self) -> str:
+        return self.reference.class_name
 
     def get_imports(self, *, prefix: str) -> Set[str]:
         """