Added detailed response functions, updated Black version.

Author: dbanty

CHANGELOG.md

@@ -9,8 +9,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Reorganized api calls in generated clients. `async_api` will no longer be generated. Each path operation will now 
     have it's own module under its tag. For example, if there was a generated function `api.my_tag.my_function()` it is 
     replaced with `api.my_tag.my_function.sync()`. The async version can be called with `asyncio()` instead of `sync()`.
+    (#167)
 - Removed support for mutable default values (e.g. dicts, lists). They may be added back in a future version given enough 
-    demand, but the existing implementation was not up to this project's standards.
+    demand, but the existing implementation was not up to this project's standards. (#170)
+- Removed generated `errors` module (and the `ApiResponseError` therein). Instead of raising an exception on failure, 
+  the `sync()` and `asyncio()` functions for a path operation will return `None`. This means all return types are now 
+  `Optional`, so mypy will require you to handle potential errors (or explicitly ignore them).
+- Moved `models.types` generated module up a level, so just `types`.
+
+### Additions
+- Every generated API module will have a `sync_detailed()` and `asyncio_detailed()` function which work like their 
+  non-detailed counterparts, but return a `types.Response[T]` instead of an `Optional[T]` (where T is the parsed body type).
+  `types.Response` contains `status_code`, `content` (bytes of returned content), `headers`, and `parsed` (the 
+  parsed return type you would get from the non-detailed function). (#115)
 
 
 ## 0.5.4 - Unreleased

end_to_end_tests/fastapi_app/__init__.py

@@ -9,7 +9,10 @@
 from pydantic import BaseModel
 from starlette.responses import FileResponse
 
-app = FastAPI(title="My Test API", description="An API for testing openapi-python-client",)
+app = FastAPI(
+    title="My Test API",
+    description="An API for testing openapi-python-client",
+)
 
 
 @app.get("/ping", response_model=bool)
@@ -51,7 +54,8 @@ class AModel(BaseModel):
 
 @test_router.get("/", response_model=List[AModel], operation_id="getUserList")
 def get_list(
-    an_enum_value: List[AnEnum] = Query(...), some_date: Union[date, datetime] = Query(...),
+    an_enum_value: List[AnEnum] = Query(...),
+    some_date: Union[date, datetime] = Query(...),
 ):
     """ Get a list of things """
     return

end_to_end_tests/golden-master/my_test_api_client/api/default/ping_ping_get.py

@@ -4,10 +4,13 @@
 import httpx
 
 from ...client import AuthenticatedClient, Client
-from ...errors import ApiResponseError
+from ...types import Response
 
 
-def _get_kwargs(*, client: Client,) -> Dict[str, Any]:
+def _get_kwargs(
+    *,
+    client: Client,
+) -> Dict[str, Any]:
     url = "{}/ping".format(client.base_url)
 
     headers: Dict[str, Any] = client.get_headers()
@@ -18,31 +21,69 @@ def _get_kwargs(*, client: Client,) -> Dict[str, Any]:
     }
 
 
-def _parse_response(*, response: httpx.Response) -> bool:
-
+def _parse_response(*, response: httpx.Response) -> Optional[bool]:
     if response.status_code == 200:
         return bool(response.text)
-    else:
-        raise ApiResponseError(response=response)
-
+    return None
 
-def sync(*, client: Client,) -> bool:
 
-    """ A quick check to see if the system is running  """
+def _build_response(*, response: httpx.Response) -> Response[bool]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
 
-    kwargs = _get_kwargs(client=client,)
 
-    response = httpx.get(**kwargs,)
+def sync_detailed(
+    *,
+    client: Client,
+) -> Response[bool]:
+    kwargs = _get_kwargs(
+        client=client,
+    )
 
-    return _parse_response(response=response)
+    response = httpx.get(
+        **kwargs,
+    )
 
+    return _build_response(response=response)
 
-async def asyncio(*, client: Client,) -> bool:
 
+def sync(
+    *,
+    client: Client,
+) -> Optional[bool]:
     """ A quick check to see if the system is running  """
-    kwargs = _get_kwargs(client=client,)
+
+    return sync_detailed(
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+) -> Response[bool]:
+    kwargs = _get_kwargs(
+        client=client,
+    )
 
     async with httpx.AsyncClient() as _client:
         response = await _client.get(**kwargs)
 
-    return _parse_response(response=response)
+    return _build_response(response=response)
+
+
+async def asyncio(
+    *,
+    client: Client,
+) -> Optional[bool]:
+    """ A quick check to see if the system is running  """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+        )
+    ).parsed

end_to_end_tests/golden-master/my_test_api_client/api/tests/get_user_list.py

@@ -5,14 +5,17 @@
 import httpx
 
 from ...client import AuthenticatedClient, Client
-from ...errors import ApiResponseError
 from ...models.a_model import AModel
 from ...models.an_enum import AnEnum
 from ...models.http_validation_error import HTTPValidationError
+from ...types import Response
 
 
 def _get_kwargs(
-    *, client: Client, an_enum_value: List[AnEnum], some_date: Union[datetime.date, datetime.datetime],
+    *,
+    client: Client,
+    an_enum_value: List[AnEnum],
+    some_date: Union[datetime.date, datetime.datetime],
 ) -> Dict[str, Any]:
     url = "{}/tests/".format(client.base_url)
 
@@ -44,40 +47,89 @@ def _get_kwargs(
 
 def _parse_response(
     *, response: httpx.Response
-) -> Union[
-    List[AModel], HTTPValidationError,
-]:
+) -> Optional[Union[List[AModel], HTTPValidationError,]]:
     if response.status_code == 200:
         return [AModel.from_dict(item) for item in cast(List[Dict[str, Any]], response.json())]
     if response.status_code == 422:
         return HTTPValidationError.from_dict(cast(Dict[str, Any], response.json()))
-    else:
-        raise ApiResponseError(response=response)
+    return None
+
+
+def _build_response(
+    *, response: httpx.Response
+) -> Response[Union[List[AModel], HTTPValidationError,]]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
+
+
+def sync_detailed(
+    *,
+    client: Client,
+    an_enum_value: List[AnEnum],
+    some_date: Union[datetime.date, datetime.datetime],
+) -> Response[Union[List[AModel], HTTPValidationError,]]:
+    kwargs = _get_kwargs(
+        client=client,
+        an_enum_value=an_enum_value,
+        some_date=some_date,
+    )
+
+    response = httpx.get(
+        **kwargs,
+    )
+
+    return _build_response(response=response)
 
 
 def sync(
-    *, client: Client, an_enum_value: List[AnEnum], some_date: Union[datetime.date, datetime.datetime],
-) -> Union[
-    List[AModel], HTTPValidationError,
-]:
+    *,
+    client: Client,
+    an_enum_value: List[AnEnum],
+    some_date: Union[datetime.date, datetime.datetime],
+) -> Optional[Union[List[AModel], HTTPValidationError,]]:
     """ Get a list of things  """
 
-    kwargs = _get_kwargs(client=client, an_enum_value=an_enum_value, some_date=some_date,)
+    return sync_detailed(
+        client=client,
+        an_enum_value=an_enum_value,
+        some_date=some_date,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    an_enum_value: List[AnEnum],
+    some_date: Union[datetime.date, datetime.datetime],
+) -> Response[Union[List[AModel], HTTPValidationError,]]:
+    kwargs = _get_kwargs(
+        client=client,
+        an_enum_value=an_enum_value,
+        some_date=some_date,
+    )
 
-    response = httpx.get(**kwargs,)
+    async with httpx.AsyncClient() as _client:
+        response = await _client.get(**kwargs)
 
-    return _parse_response(response=response)
+    return _build_response(response=response)
 
 
 async def asyncio(
-    *, client: Client, an_enum_value: List[AnEnum], some_date: Union[datetime.date, datetime.datetime],
-) -> Union[
-    List[AModel], HTTPValidationError,
-]:
+    *,
+    client: Client,
+    an_enum_value: List[AnEnum],
+    some_date: Union[datetime.date, datetime.datetime],
+) -> Optional[Union[List[AModel], HTTPValidationError,]]:
     """ Get a list of things  """
-    kwargs = _get_kwargs(client=client, an_enum_value=an_enum_value, some_date=some_date,)
-
-    async with httpx.AsyncClient() as _client:
-        response = await _client.get(**kwargs)
 
-    return _parse_response(response=response)
+    return (
+        await asyncio_detailed(
+            client=client,
+            an_enum_value=an_enum_value,
+            some_date=some_date,
+        )
+    ).parsed

end_to_end_tests/golden-master/my_test_api_client/api/tests/json_body_tests_json_body_post.py

@@ -4,12 +4,16 @@
 import httpx
 
 from ...client import AuthenticatedClient, Client
-from ...errors import ApiResponseError
 from ...models.a_model import AModel
 from ...models.http_validation_error import HTTPValidationError
+from ...types import Response
 
 
-def _get_kwargs(*, client: Client, json_body: AModel,) -> Dict[str, Any]:
+def _get_kwargs(
+    *,
+    client: Client,
+    json_body: AModel,
+) -> Dict[str, Any]:
     url = "{}/tests/json_body".format(client.base_url)
 
     headers: Dict[str, Any] = client.get_headers()
@@ -25,40 +29,81 @@ def _get_kwargs(*, client: Client, json_body: AModel,) -> Dict[str, Any]:
 
 def _parse_response(
     *, response: httpx.Response
-) -> Union[
-    None, HTTPValidationError,
-]:
+) -> Optional[Union[None, HTTPValidationError,]]:
     if response.status_code == 200:
         return None
     if response.status_code == 422:
         return HTTPValidationError.from_dict(cast(Dict[str, Any], response.json()))
-    else:
-        raise ApiResponseError(response=response)
+    return None
 
 
-def sync(
-    *, client: Client, json_body: AModel,
-) -> Union[
-    None, HTTPValidationError,
-]:
-    """ Try sending a JSON body  """
+def _build_response(
+    *, response: httpx.Response
+) -> Response[Union[None, HTTPValidationError,]]:
+    return Response(
+        status_code=response.status_code,
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(response=response),
+    )
 
-    kwargs = _get_kwargs(client=client, json_body=json_body,)
 
-    response = httpx.post(**kwargs,)
+def sync_detailed(
+    *,
+    client: Client,
+    json_body: AModel,
+) -> Response[Union[None, HTTPValidationError,]]:
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
 
-    return _parse_response(response=response)
+    response = httpx.post(
+        **kwargs,
+    )
 
+    return _build_response(response=response)
 
-async def asyncio(
-    *, client: Client, json_body: AModel,
-) -> Union[
-    None, HTTPValidationError,
-]:
+
+def sync(
+    *,
+    client: Client,
+    json_body: AModel,
+) -> Optional[Union[None, HTTPValidationError,]]:
     """ Try sending a JSON body  """
-    kwargs = _get_kwargs(client=client, json_body=json_body,)
+
+    return sync_detailed(
+        client=client,
+        json_body=json_body,
+    ).parsed
+
+
+async def asyncio_detailed(
+    *,
+    client: Client,
+    json_body: AModel,
+) -> Response[Union[None, HTTPValidationError,]]:
+    kwargs = _get_kwargs(
+        client=client,
+        json_body=json_body,
+    )
 
     async with httpx.AsyncClient() as _client:
         response = await _client.post(**kwargs)
 
-    return _parse_response(response=response)
+    return _build_response(response=response)
+
+
+async def asyncio(
+    *,
+    client: Client,
+    json_body: AModel,
+) -> Optional[Union[None, HTTPValidationError,]]:
+    """ Try sending a JSON body  """
+
+    return (
+        await asyncio_detailed(
+            client=client,
+            json_body=json_body,
+        )
+    ).parsed