Add async_api to generated clients

Closes #16

Author: dbanty

openapi_python_client/__init__.py

@@ -155,13 +155,21 @@ def _build_api(self) -> None:
         api_dir = self.package_dir / "api"
         api_dir.mkdir()
         api_init = api_dir / "__init__.py"
-        api_init.write_text('""" Contains all methods for accessing the API """')
+        api_init.write_text('""" Contains synchronous methods for accessing the API """')
 
-        api_errors = api_dir / "errors.py"
+        async_api_dir = self.package_dir / "async_api"
+        async_api_dir.mkdir()
+        async_api_init = async_api_dir / "__init__.py"
+        async_api_init.write_text('""" Contains async methods for accessing the API """')
+
+        api_errors = self.package_dir / "errors.py"
         errors_template = self.env.get_template("errors.pyi")
         api_errors.write_text(errors_template.render())
 
         endpoint_template = self.env.get_template("endpoint_module.pyi")
+        async_endpoint_template = self.env.get_template("async_endpoint_module.pyi")
         for tag, collection in self.openapi.endpoint_collections_by_tag.items():
             module_path = api_dir / f"{tag}.py"
             module_path.write_text(endpoint_template.render(collection=collection))
+            async_module_path = async_api_dir / f"{tag}.py"
+            async_module_path.write_text(async_endpoint_template.render(collection=collection))

openapi_python_client/templates/async_endpoint_module.pyi

@@ -0,0 +1,84 @@
+from dataclasses import asdict
+from typing import Dict, List, Optional, Union
+
+import httpx
+
+from ..client import AuthenticatedClient, Client
+from .errors import ApiResponseError
+
+{% for relative in collection.relative_imports %}
+{{ relative }}
+{% endfor %}
+{% for endpoint in collection.endpoints %}
+
+
+async def {{ endpoint.name }}(
+    *,
+    {# Proper client based on whether or not the endpoint requires authentication #}
+    {% if endpoint.requires_security %}
+    client: AuthenticatedClient,
+    {% else %}
+    client: Client,
+    {% endif %}
+    {# path parameters #}
+    {% for parameter in endpoint.path_parameters %}
+    {{ parameter.to_string() }},
+    {% endfor %}
+    {# Form data if any #}
+    {% if endpoint.form_body_reference %}
+    form_data: {{ endpoint.form_body_reference.class_name }},
+    {% endif %}
+    {# JSON body if any #}
+    {% if endpoint.json_body %}
+    json_body: {{ endpoint.json_body.get_type_string() }},
+    {% endif %}
+    {# query parameters #}
+    {% for parameter in endpoint.query_parameters %}
+    {{ parameter.to_string() }},
+    {% endfor %}
+) -> Union[
+    {% for response in endpoint.responses %}
+    {{ response.return_string() }},
+    {% endfor %}
+]:
+    """ {{ endpoint.description }} """
+    url = f"{client.base_url}{{ endpoint.path }}"
+
+    {% if endpoint.query_parameters %}
+    params = {
+        {% for parameter in endpoint.query_parameters %}
+        {% if parameter.required %}
+            "{{ parameter.name }}": {{ parameter.transform() }},
+        {% endif %}
+        {% endfor %}
+    }
+    {% for parameter in endpoint.query_parameters %}
+    {% if not parameter.required %}
+    if {{ parameter.name }} is not None:
+        params["{{ parameter.name }}"] = {{ parameter.transform() }}
+    {% endif %}
+    {% endfor %}
+    {% endif %}
+
+    with httpx.AsyncClient() as client:
+        response = await client.{{ endpoint.method }}(
+            url=url,
+            headers=client.get_headers(),
+            {% if endpoint.form_body_reference %}
+            data=asdict(form_data),
+            {% endif %}
+            {% if endpoint.json_body %}
+            json={{ endpoint.json_body.transform() }},
+            {% endif %}
+            {% if endpoint.query_parameters %}
+            params=params,
+            {% endif %}
+        )
+
+    {% for response in endpoint.responses %}
+    if response.status_code == {{ response.status_code }}:
+        return {{ response.constructor() }}
+    {% endfor %}
+    else:
+        raise ApiResponseError(response=response)
+{% endfor %}

tests/test___init__.py

@@ -343,55 +343,82 @@ def test__build_api(self, mocker):
         openapi.endpoint_collections_by_tag = {tag_1: collection_1, tag_2: collection_2}
         project = _Project(openapi=openapi)
         project.package_dir = mocker.MagicMock()
+        api_errors = mocker.MagicMock(autospec=pathlib.Path)
         client_path = mocker.MagicMock()
         api_init = mocker.MagicMock(autospec=pathlib.Path)
-        api_errors = mocker.MagicMock(autospec=pathlib.Path)
         collection_1_path = mocker.MagicMock(autospec=pathlib.Path)
         collection_2_path = mocker.MagicMock(autospec=pathlib.Path)
+        async_api_init = mocker.MagicMock(autospec=pathlib.Path)
+        async_collection_1_path = mocker.MagicMock(autospec=pathlib.Path)
+        async_collection_2_path = mocker.MagicMock(autospec=pathlib.Path)
         api_paths = {
             "__init__.py": api_init,
-            "errors.py": api_errors,
             f"{tag_1}.py": collection_1_path,
             f"{tag_2}.py": collection_2_path,
         }
+        async_api_paths = {
+            "__init__.py": async_api_init,
+            f"{tag_1}.py": async_collection_1_path,
+            f"{tag_2}.py": async_collection_2_path,
+        }
         api_dir = mocker.MagicMock(autospec=pathlib.Path)
         api_dir.__truediv__.side_effect = lambda x: api_paths[x]
+        async_api_dir = mocker.MagicMock(autospec=pathlib.Path)
+        async_api_dir.__truediv__.side_effect = lambda x: async_api_paths[x]
+
         package_paths = {
             "client.py": client_path,
             "api": api_dir,
+            "async_api": async_api_dir,
+            "errors.py": api_errors,
         }
         project.package_dir.__truediv__.side_effect = lambda x: package_paths[x]
         client_template = mocker.MagicMock(autospec=Template)
         errors_template = mocker.MagicMock(autospec=Template)
         endpoint_template = mocker.MagicMock(autospec=Template)
+        async_endpoint_template = mocker.MagicMock(autospec=Template)
         templates = {
             "client.pyi": client_template,
             "errors.pyi": errors_template,
             "endpoint_module.pyi": endpoint_template,
+            "async_endpoint_module.pyi": async_endpoint_template,
         }
         mocker.patch.object(project.env, "get_template", autospec=True, side_effect=lambda x: templates[x])
         endpoint_renders = {
             collection_1: mocker.MagicMock(),
             collection_2: mocker.MagicMock(),
         }
         endpoint_template.render.side_effect = lambda collection: endpoint_renders[collection]
+        async_endpoint_renders = {
+            collection_1: mocker.MagicMock(),
+            collection_2: mocker.MagicMock(),
+        }
+        async_endpoint_template.render.side_effect = lambda collection: async_endpoint_renders[collection]
 
         project._build_api()
 
         project.package_dir.__truediv__.assert_has_calls([mocker.call(key) for key in package_paths])
         project.env.get_template.assert_has_calls([mocker.call(key) for key in templates])
         client_template.render.assert_called_once()
         client_path.write_text.assert_called_once_with(client_template.render())
-        api_dir.mkdir.assert_called_once()
-        api_dir.__truediv__.assert_has_calls([mocker.call(key) for key in api_paths])
-        api_init.write_text.assert_called_once_with('""" Contains all methods for accessing the API """')
         errors_template.render.assert_called_once()
         api_errors.write_text.assert_called_once_with(errors_template.render())
+        api_dir.mkdir.assert_called_once()
+        api_dir.__truediv__.assert_has_calls([mocker.call(key) for key in api_paths])
+        api_init.write_text.assert_called_once_with('""" Contains synchronous methods for accessing the API """')
         endpoint_template.render.assert_has_calls(
             [mocker.call(collection=collection_1), mocker.call(collection=collection_2)]
         )
         collection_1_path.write_text.assert_called_once_with(endpoint_renders[collection_1])
         collection_2_path.write_text.assert_called_once_with(endpoint_renders[collection_2])
+        async_api_dir.mkdir.assert_called_once()
+        async_api_dir.__truediv__.assert_has_calls([mocker.call(key) for key in async_api_paths])
+        async_api_init.write_text.assert_called_once_with('""" Contains async methods for accessing the API """')
+        async_endpoint_template.render.assert_has_calls(
+            [mocker.call(collection=collection_1), mocker.call(collection=collection_2)]
+        )
+        async_collection_1_path.write_text.assert_called_once_with(async_endpoint_renders[collection_1])
+        async_collection_2_path.write_text.assert_called_once_with(async_endpoint_renders[collection_2])
 
 
 def test__reformat(mocker):

tests/test_end_to_end/golden-master/my_test_api_client/api/__init__.py

@@ -1 +1 @@
-""" Contains all methods for accessing the API """
+""" Contains synchronous methods for accessing the API """

tests/test_end_to_end/golden-master/my_test_api_client/async_api/__init__.py

@@ -0,0 +1 @@
+""" Contains async methods for accessing the API """

tests/test_end_to_end/golden-master/my_test_api_client/async_api/default.py

@@ -0,0 +1,25 @@
+from dataclasses import asdict
+from typing import Dict, List, Optional, Union
+
+import httpx
+
+from ..client import AuthenticatedClient, Client
+from ..models.ping_response import PingResponse
+from .errors import ApiResponseError
+
+
+async def ping_ping_get(
+    *, client: Client,
+) -> Union[
+    PingResponse,
+]:
+    """ A quick check to see if the system is running  """
+    url = f"{client.base_url}/ping"
+
+    with httpx.AsyncClient() as client:
+        response = await client.get(url=url, headers=client.get_headers(),)
+
+    if response.status_code == 200:
+        return PingResponse.from_dict(response.json())
+    else:
+        raise ApiResponseError(response=response)