Add 0 boilerplate sync and async client objects

With the current approach, for every API call, the user has to import a
a module from a tag package and call the `asyncio` or `sync` method with
the "client=client" argument. This patch adds a wrapper around tag
packages and two wrapper `Client` objects to spare the need for that
boilerplate code.

Check this issue for more information:
openapi-generators#224

Author: fyhertz

openapi_python_client/__init__.py

@@ -26,7 +26,7 @@
 
 
 class Project:
-    TEMPLATE_FILTERS = {"snakecase": utils.snake_case, "kebabcase": utils.kebab_case}
+    TEMPLATE_FILTERS = {"snakecase": utils.snake_case, "kebabcase": utils.kebab_case, "pascalcase": utils.pascal_case}
     project_name_override: Optional[str] = None
     package_name_override: Optional[str] = None
 
@@ -76,7 +76,7 @@ def update(self) -> Sequence[GeneratorError]:
 
     def _reformat(self) -> None:
         subprocess.run(
-            "autoflake -i -r --remove-all-unused-imports --remove-unused-variables .",
+            "autoflake -i -r --remove-all-unused-imports --remove-unused-variables . --ignore-init-module-imports",
             cwd=self.package_dir,
             shell=True,
             stdout=subprocess.PIPE,
@@ -173,6 +173,13 @@ def _build_api(self) -> None:
         client_template = self.env.get_template("client.pyi")
         client_path.write_text(client_template.render())
 
+        # Generate wrapper
+        wrapper = self.package_dir / "wrapper.py"
+        wrapper_template = self.env.get_template("wrapper.pyi")
+        wrapper.write_text(wrapper_template.render(
+            models=self.openapi.schemas.models.values(),
+            endpoint_collections=self.openapi.endpoint_collections_by_tag))
+
         # Generate endpoints
         api_dir = self.package_dir / "api"
         api_dir.mkdir()
@@ -184,13 +191,17 @@ def _build_api(self) -> None:
             tag = utils.snake_case(tag)
             tag_dir = api_dir / tag
             tag_dir.mkdir()
-            (tag_dir / "__init__.py").touch()
+            tag_init = tag_dir / "__init__.py"
+            tag_init_template = self.env.get_template("tag_init.pyi")
+            tag_init.write_text(tag_init_template.render(
+                tag=tag, collection=collection))
 
             for endpoint in collection.endpoints:
                 module_path = tag_dir / f"{snake_case(endpoint.name)}.py"
                 module_path.write_text(endpoint_template.render(endpoint=endpoint))
 
 
+
 def _get_project_for_url_or_path(url: Optional[str], path: Optional[Path]) -> Union[Project, GeneratorError]:
     data_dict = _get_document(url=url, path=path)
     if isinstance(data_dict, GeneratorError):

openapi_python_client/templates/endpoint_macros.pyi

@@ -70,14 +70,19 @@ Union[
 {% endmacro %}
 
 {# The all the kwargs passed into an endpoint (and variants thereof)) #}
-{% macro arguments(endpoint) %}
+{% macro arguments(endpoint, client=True) %}
+
+{% if endpoint.path_parameters.__len__() > 1 %}
 *,
+{% endif %}
 {# Proper client based on whether or not the endpoint requires authentication #}
+{% if client %}
 {% if endpoint.requires_security %}
 client: AuthenticatedClient,
 {% else %}
 client: Client,
 {% endif %}
+{% endif %}
 {# path parameters #}
 {% for parameter in endpoint.path_parameters %}
 {{ parameter.to_string() }},

openapi_python_client/templates/package_init.pyi

@@ -1,2 +1,3 @@
 """ {{ description }} """
-from .client import AuthenticatedClient, Client
+
+from .wrapper import Client, SyncClient

openapi_python_client/templates/tag_init.pyi

@@ -0,0 +1,2 @@
+from . import {% for e in collection.endpoints %} {{e.name | snakecase }}, {% endfor %}
+

openapi_python_client/templates/wrapper.pyi

@@ -0,0 +1,72 @@
+from typing import Any, Dict, Optional, Union, cast
+from .client import Client as InnerClient, AuthenticatedClient
+
+from .models import (
+    {% for model in models %}
+    {{ model.reference.class_name }},
+    {% endfor %}
+)
+
+from .api import (
+    {% for tag, collection in endpoint_collections.items() %}
+    {{ tag | snakecase }},
+    {% endfor %}
+)
+
+{% from "endpoint_macros.pyi" import arguments, client, kwargs %}
+
+{% for tag, collection in endpoint_collections.items() %}
+
+class {{ tag | pascalcase }}Api:
+
+    def __init__(self, client: InnerClient):
+        self._client = client
+
+    {% for endpoint in collection.endpoints %}
+    async def {{ endpoint.name | snakecase }}(self, {{ arguments(endpoint, False) }}):
+        {% if endpoint.requires_security %}
+        client = cast(AuthenticatedClient, self._client)
+        {% else %}
+        client = self._client
+        {% endif %}
+        return await {{ tag }}.{{ endpoint.name | snakecase }}.asyncio({{ kwargs(endpoint) }})
+
+    {% endfor %}
+
+
+class Sync{{ tag | pascalcase }}Api:
+
+    def __init__(self, client: InnerClient):
+        self._client = client
+
+    {% for endpoint in collection.endpoints %}
+    def {{ endpoint.name | snakecase }}(self, {{ arguments(endpoint, False) }}):
+        {% if endpoint.requires_security %}
+        client = cast(AuthenticatedClient, self._client)
+        {% else %}
+        client = self._client
+        {% endif %}
+        return {{ tag }}.{{ endpoint.name | snakecase }}.sync({{ kwargs(endpoint) }})
+
+    {% endfor %}
+
+{% endfor %}
+
+{% for i in '', 'Sync' %}
+
+class {{ i }}Client:
+    def __init__(self, base_url: str, timeout: float = 5.0, token: Optional[str] = None):
+        if token is None:
+            self.connection = InnerClient(
+                base_url=base_url,
+                timeout=timeout)
+        else:
+            self.connection = AuthenticatedClient(
+                base_url=base_url,
+                timeout=timeout,
+                token=token)
+        {% for tag, collection in endpoint_collections.items() %}
+        self.{{ tag | snakecase }} = {{ i }}{{ tag | pascalcase }}Api(self.connection)
+        {% endfor %}
+
+{% endfor %}