Merge branch 'main' into benchling-allof-support

Author: dbanty

CHANGELOG.md

@@ -5,7 +5,11 @@ 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.8.0 - Unreleased
+## 0.8.0 - 2021-02-19
+
+### Breaking Changes
+
+- Generated clients will no longer pass through `None` to query parameters. Previously, any query params set to `None` would surface as empty strings (per the default behavior of `httpx`). This is contrary to the defaults indicated by the OpenAPI 3.0.3 spec. Ommitting these parameters makes us more compliant. If you require a style of `null` to be passed to your query parameters, please request support for the OpenAPI "style" attribute. Thank you to @forest-benchling and @bowenwr for a ton of input on this.
 
 ### Additions
 
@@ -15,13 +19,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
     project info.
   - `none` will not create a project folder at all, only the inner package folder (which won't be inner anymore)
 - Attempt to detect and alert users if they are using an unsupported version of OpenAPI (#281).
-- Fixes `Enum` deserialization when the value is `UNSET`.
-- Basic support for `allOf` in models (#98)
+- The media type application/vnd.api+json will now be handled just like application/json (#307). Thanks @jrversteegh!
+- Support passing models into query parameters (#316). Thanks @forest-benchling!
+- Add support for cookie parameters (#326).
+- New `--file-encoding` command line option (#330). Sets the encoding used when writing generated files (defaults to utf-8). Thanks @dongfangtianyu!
 
 ### Changes
 
 - Lowered the minimum version of `python-dateutil` to 2.8.0 for improved compatibility (#298 & #299). Thanks @bowenwr!
 - The `from_dict` method on generated models is now a `@classmethod` instead of `@staticmethod` (#215 & #292). Thanks @forest-benchling!
+- Renamed all templates to end in `.jinja`, and all python-templates to end in `.py.jinja` to fix confusion with the latest version of mypy. Note **this will break existing custom templates until you update your template file names**.
+
+### Fixes
+
+- Endpoint tags are now sanitized during parsing to fix an issue where `My Tag` and `MyTag` are seen as two different tags but are then later unified, causing errors when creating directories. Thanks @p1-ra! (#328)
+- Parser will softly ignore value error during schema responses' status code convertion from string to integer (not a number). Errors will be reported to the end user and parsing will continue to proceed (#327).
+- The generated `from_dict` and `to_dict` methods of models will now properly handle `nullable` and `not required` properties that are themselves generated models (#315). Thanks @forest-benchling!
+- Fixed a typo in the async example in generated README.md files (#337). Thanks @synchronizing!
+- Fix deserialization of `None` and `Unset` properties for all types by unifying the checks (#334). Thanks @forest-benchling!
+- If duplicate model names are detected during generation, you'll now get an error message instead of broken code (#336). Thanks @forest-benchling!
+- Fixes `Enum` deserialization when the value is `UNSET` (#306). Thanks @bowenwr!
 
 ## 0.7.3 - 2020-12-21
 

dobby.toml

@@ -0,0 +1,20 @@
+[[workflows]]
+name = "Start Task"
+    [[workflows.steps]]
+    type = "SelectGitHubIssue"
+
+    [[workflows.steps]]
+    type = "SwitchBranches"
+
+[[workflows]]
+name = "Prepare Release"
+    [[workflows.steps]]
+    type = "UpdateProjectFromCommits"
+
+    [[workflows.steps]]
+    type = "Command"
+    command = "prettier --write CHANGELOG.md"
+
+[github]
+owner = "triaxtec"
+repo = "openapi-python-client"

end_to_end_tests/golden-record-custom/README.md

@@ -34,7 +34,7 @@ Or do the same thing with an async version:
 
 ```python
 from custom_e2e.models import MyDataModel
-from custom_e2e.async_api.my_tag import get_my_data_model
+from custom_e2e.api.my_tag import get_my_data_model
 from custom_e2e.types import Response
 
 my_data: MyDataModel = await get_my_data_model.asyncio(client=client)

end_to_end_tests/golden-record-custom/custom_e2e/api/tests/defaults_tests_defaults_post.py

@@ -13,6 +13,7 @@
 
 from ...models.an_enum import AnEnum
 from ...models.http_validation_error import HTTPValidationError
+from ...models.model_with_union_property import ModelWithUnionProperty
 from ...types import UNSET, Unset
 
 
@@ -50,6 +51,8 @@ def httpx_request(
     union_prop: Union[Unset, float, str] = "not a float",
     union_prop_with_ref: Union[Unset, float, AnEnum] = 0.6,
     enum_prop: Union[Unset, AnEnum] = UNSET,
+    model_prop: Union[ModelWithUnionProperty, Unset] = UNSET,
+    required_model_prop: ModelWithUnionProperty,
 ) -> Response[Union[None, HTTPValidationError]]:
 
     json_datetime_prop: Union[Unset, str] = UNSET
@@ -89,27 +92,28 @@ def httpx_request(
     if not isinstance(enum_prop, Unset):
         json_enum_prop = enum_prop
 
-    params: Dict[str, Any] = {}
-    if string_prop is not UNSET:
-        params["string_prop"] = string_prop
-    if datetime_prop is not UNSET:
-        params["datetime_prop"] = json_datetime_prop
-    if date_prop is not UNSET:
-        params["date_prop"] = json_date_prop
-    if float_prop is not UNSET:
-        params["float_prop"] = float_prop
-    if int_prop is not UNSET:
-        params["int_prop"] = int_prop
-    if boolean_prop is not UNSET:
-        params["boolean_prop"] = boolean_prop
-    if list_prop is not UNSET:
-        params["list_prop"] = json_list_prop
-    if union_prop is not UNSET:
-        params["union_prop"] = json_union_prop
-    if union_prop_with_ref is not UNSET:
-        params["union_prop_with_ref"] = json_union_prop_with_ref
-    if enum_prop is not UNSET:
-        params["enum_prop"] = json_enum_prop
+    json_model_prop: Union[Unset, Dict[str, Any]] = UNSET
+    if not isinstance(model_prop, Unset):
+        json_model_prop = model_prop.to_dict()
+
+    json_required_model_prop = required_model_prop.to_dict()
+
+    params: Dict[str, Any] = {
+        "string_prop": string_prop,
+        "datetime_prop": json_datetime_prop,
+        "date_prop": json_date_prop,
+        "float_prop": float_prop,
+        "int_prop": int_prop,
+        "boolean_prop": boolean_prop,
+        "list_prop": json_list_prop,
+        "union_prop": json_union_prop,
+        "union_prop_with_ref": json_union_prop_with_ref,
+        "enum_prop": json_enum_prop,
+    }
+    if not isinstance(json_model_prop, Unset):
+        params.update(json_model_prop)
+    params.update(json_required_model_prop)
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     response = client.request(
         "post",

end_to_end_tests/golden-record-custom/custom_e2e/api/tests/get_user_list.py

@@ -62,6 +62,7 @@ def httpx_request(
         "an_enum_value": json_an_enum_value,
         "some_date": json_some_date,
     }
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     response = client.request(
         "get",

end_to_end_tests/golden-record-custom/custom_e2e/api/tests/int_enum_tests_int_enum_post.py

@@ -44,6 +44,7 @@ def httpx_request(
     params: Dict[str, Any] = {
         "int_enum": json_int_enum,
     }
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     response = client.request(
         "post",

end_to_end_tests/golden-record-custom/custom_e2e/api/tests/optional_value_tests_optional_query_param.py

@@ -43,9 +43,10 @@ def httpx_request(
     if not isinstance(query_param, Unset):
         json_query_param = query_param
 
-    params: Dict[str, Any] = {}
-    if query_param is not UNSET:
-        params["query_param"] = json_query_param
+    params: Dict[str, Any] = {
+        "query_param": json_query_param,
+    }
+    params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
 
     response = client.request(
         "get",

end_to_end_tests/golden-record-custom/custom_e2e/api/tests/token_with_cookie_auth_token_with_cookie_get.py

@@ -0,0 +1,42 @@
+from typing import Optional
+
+import httpx
+
+from ...types import Response
+
+Client = httpx.Client
+
+
+def _parse_response(*, response: httpx.Response) -> Optional[Union[None, None]]:
+    if response.status_code == 200:
+        response_200 = None
+
+        return response_200
+    if response.status_code == 401:
+        response_401 = None
+
+        return response_401
+    return None
+
+
+def _build_response(*, response: httpx.Response) -> Response[Union[None, None]]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def httpx_request(
+    *,
+    client: Client,
+    my_token: str,
+) -> Response[Union[None, None]]:
+
+    response = client.request(
+        "get",
+        "/auth/token_with_cookie",
+    )
+
+    return _build_response(response=response)

end_to_end_tests/golden-record-custom/custom_e2e/api/tests/upload_file_tests_upload_post.py

@@ -24,6 +24,8 @@ def _parse_response(*, response: httpx.Response) -> Optional[Union[
     if response.status_code == 422:
         response_422 = HTTPValidationError.from_dict(response.json())
 
+
+
         return response_422
     return None
 

end_to_end_tests/golden-record-custom/custom_e2e/models/__init__.py

@@ -1,6 +1,10 @@
 """ Contains all the data models used in inputs/outputs """
 
 from .a_model import AModel
+from .a_model_model import AModelModel
+from .a_model_not_required_model import AModelNotRequiredModel
+from .a_model_not_required_nullable_model import AModelNotRequiredNullableModel
+from .a_model_nullable_model import AModelNullableModel
 from .all_of_sub_model import AllOfSubModel
 from .an_enum import AnEnum
 from .an_int_enum import AnIntEnum

end_to_end_tests/golden-record-custom/custom_e2e/models/a_model.py

@@ -1,9 +1,13 @@
 import datetime
-from typing import Any, Dict, List, Optional, Type, TypeVar, Union, cast
+from typing import Any, Dict, List, Optional, Type, TypeVar, Union
 
 import attr
 from dateutil.parser import isoparse
 
+from ..models.a_model_model import AModelModel
+from ..models.a_model_not_required_model import AModelNotRequiredModel
+from ..models.a_model_not_required_nullable_model import AModelNotRequiredNullableModel
+from ..models.a_model_nullable_model import AModelNullableModel
 from ..models.an_enum import AnEnum
 from ..models.different_enum import DifferentEnum
 from ..types import UNSET, Unset
@@ -19,12 +23,17 @@ class AModel:
     a_camel_date_time: Union[datetime.datetime, datetime.date]
     a_date: datetime.date
     required_not_nullable: str
+    model: AModelModel
     a_nullable_date: Optional[datetime.date]
     required_nullable: Optional[str]
+    nullable_model: Optional[AModelNullableModel]
     nested_list_of_enums: Union[Unset, List[List[DifferentEnum]]] = UNSET
+    a_not_required_date: Union[Unset, datetime.date] = UNSET
     attr_1_leading_digit: Union[Unset, str] = UNSET
     not_required_nullable: Union[Unset, Optional[str]] = UNSET
     not_required_not_nullable: Union[Unset, str] = UNSET
+    not_required_model: Union[AModelNotRequiredModel, Unset] = UNSET
+    not_required_nullable_model: Union[Optional[AModelNotRequiredNullableModel], Unset] = UNSET
 
     def to_dict(self) -> Dict[str, Any]:
         an_enum_value = self.an_enum_value.value
@@ -37,6 +46,8 @@ def to_dict(self) -> Dict[str, Any]:
 
         a_date = self.a_date.isoformat()
         required_not_nullable = self.required_not_nullable
+        model = self.model.to_dict()
+
         nested_list_of_enums: Union[Unset, List[Any]] = UNSET
         if not isinstance(self.nested_list_of_enums, Unset):
             nested_list_of_enums = []
@@ -50,10 +61,25 @@ def to_dict(self) -> Dict[str, Any]:
                 nested_list_of_enums.append(nested_list_of_enums_item)
 
         a_nullable_date = self.a_nullable_date.isoformat() if self.a_nullable_date else None
+        a_not_required_date: Union[Unset, str] = UNSET
+        if not isinstance(self.a_not_required_date, Unset):
+            a_not_required_date = self.a_not_required_date.isoformat()
+
         attr_1_leading_digit = self.attr_1_leading_digit
         required_nullable = self.required_nullable
         not_required_nullable = self.not_required_nullable
         not_required_not_nullable = self.not_required_not_nullable
+        nullable_model = self.nullable_model.to_dict() if self.nullable_model else None
+
+        not_required_model: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.not_required_model, Unset):
+            not_required_model = self.not_required_model.to_dict()
+
+        not_required_nullable_model: Union[None, Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.not_required_nullable_model, Unset):
+            not_required_nullable_model = (
+                self.not_required_nullable_model.to_dict() if self.not_required_nullable_model else None
+            )
 
         field_dict: Dict[str, Any] = {}
         field_dict.update(
@@ -62,18 +88,26 @@ def to_dict(self) -> Dict[str, Any]:
                 "aCamelDateTime": a_camel_date_time,
                 "a_date": a_date,
                 "required_not_nullable": required_not_nullable,
+                "model": model,
                 "a_nullable_date": a_nullable_date,
                 "required_nullable": required_nullable,
+                "nullable_model": nullable_model,
             }
         )
         if nested_list_of_enums is not UNSET:
             field_dict["nested_list_of_enums"] = nested_list_of_enums
+        if a_not_required_date is not UNSET:
+            field_dict["a_not_required_date"] = a_not_required_date
         if attr_1_leading_digit is not UNSET:
             field_dict["1_leading_digit"] = attr_1_leading_digit
         if not_required_nullable is not UNSET:
             field_dict["not_required_nullable"] = not_required_nullable
         if not_required_not_nullable is not UNSET:
             field_dict["not_required_not_nullable"] = not_required_not_nullable
+        if not_required_model is not UNSET:
+            field_dict["not_required_model"] = not_required_model
+        if not_required_nullable_model is not UNSET:
+            field_dict["not_required_nullable_model"] = not_required_nullable_model
 
         return field_dict
 
@@ -101,6 +135,8 @@ def _parse_a_camel_date_time(data: Any) -> Union[datetime.datetime, datetime.dat
 
         required_not_nullable = d.pop("required_not_nullable")
 
+        model = AModelModel.from_dict(d.pop("model"))
+
         nested_list_of_enums = []
         _nested_list_of_enums = d.pop("nested_list_of_enums", UNSET)
         for nested_list_of_enums_item_data in _nested_list_of_enums or []:
@@ -116,7 +152,12 @@ def _parse_a_camel_date_time(data: Any) -> Union[datetime.datetime, datetime.dat
         a_nullable_date = None
         _a_nullable_date = d.pop("a_nullable_date")
         if _a_nullable_date is not None:
-            a_nullable_date = isoparse(cast(str, _a_nullable_date)).date()
+            a_nullable_date = isoparse(_a_nullable_date).date()
+
+        a_not_required_date: Union[Unset, datetime.date] = UNSET
+        _a_not_required_date = d.pop("a_not_required_date", UNSET)
+        if not isinstance(_a_not_required_date, Unset):
+            a_not_required_date = isoparse(_a_not_required_date).date()
 
         attr_1_leading_digit = d.pop("1_leading_digit", UNSET)
 
@@ -126,17 +167,37 @@ def _parse_a_camel_date_time(data: Any) -> Union[datetime.datetime, datetime.dat
 
         not_required_not_nullable = d.pop("not_required_not_nullable", UNSET)
 
+        nullable_model = None
+        _nullable_model = d.pop("nullable_model")
+        if _nullable_model is not None:
+            nullable_model = AModelNullableModel.from_dict(_nullable_model)
+
+        not_required_model: Union[AModelNotRequiredModel, Unset] = UNSET
+        _not_required_model = d.pop("not_required_model", UNSET)
+        if not isinstance(_not_required_model, Unset):
+            not_required_model = AModelNotRequiredModel.from_dict(_not_required_model)
+
+        not_required_nullable_model = None
+        _not_required_nullable_model = d.pop("not_required_nullable_model", UNSET)
+        if _not_required_nullable_model is not None and not isinstance(_not_required_nullable_model, Unset):
+            not_required_nullable_model = AModelNotRequiredNullableModel.from_dict(_not_required_nullable_model)
+
         a_model = cls(
             an_enum_value=an_enum_value,
             a_camel_date_time=a_camel_date_time,
             a_date=a_date,
             required_not_nullable=required_not_nullable,
+            model=model,
             nested_list_of_enums=nested_list_of_enums,
             a_nullable_date=a_nullable_date,
+            a_not_required_date=a_not_required_date,
             attr_1_leading_digit=attr_1_leading_digit,
             required_nullable=required_nullable,
             not_required_nullable=not_required_nullable,
             not_required_not_nullable=not_required_not_nullable,
+            nullable_model=nullable_model,
+            not_required_model=not_required_model,
+            not_required_nullable_model=not_required_nullable_model,
         )
 
         return a_model