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

`base_url` can be omitted during client initialization
if `SPEC_TITLE_BASE_URL` is set. Object-oriented clients
have also been renamed to include the spec title.

Author: dependabot-preview[bot]

openapi_python_client/__init__.py

@@ -55,8 +55,8 @@ def __init__(self, *, openapi: GeneratorData, custom_template_path: Optional[Pat
         self.package_description: str = utils.remove_string_escapes(
             f"A client library for accessing {self.openapi.title}"
         )
+        self.client_name: str = f'{utils.pascal_case(openapi.title)}Client'
         self.version: str = self.package_version_override or openapi.version
-
         self.env.filters.update(self.TEMPLATE_FILTERS)
 
     def build(self) -> Sequence[GeneratorError]:
@@ -117,7 +117,9 @@ def _create_package(self) -> None:
         package_init = self.package_dir / "__init__.py"
 
         package_init_template = self.env.get_template("package_init.pyi")
-        package_init.write_text(package_init_template.render(description=self.package_description))
+        package_init.write_text(
+            package_init_template.render(client_name=self.client_name, description=self.package_description)
+        )
 
         pytyped = self.package_dir / "py.typed"
         pytyped.write_text("# Marker file for PEP 561")
@@ -184,7 +186,20 @@ def _build_api(self) -> None:
         # Generate Client
         client_path = self.package_dir / "client.py"
         client_template = self.env.get_template("client.pyi")
-        client_path.write_text(client_template.render())
+        client_path.write_text(client_template.render(title=self.openapi.title))
+
+        # Generate wrapper
+        imports = [m.reference.class_name for m in self.openapi.models.values()]
+        imports.extend([e.reference.class_name for e in self.openapi.enums.values()])
+        wrapper = self.package_dir / "wrapper.py"
+        wrapper_template = self.env.get_template("wrapper.pyi")
+        wrapper.write_text(
+            wrapper_template.render(
+                client_name=self.client_name,
+                imports=imports,
+                endpoint_collections=self.openapi.endpoint_collections_by_tag,
+            )
+        )
 
         # Generate endpoints
         api_dir = self.package_dir / "api"
@@ -197,7 +212,9 @@ 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"

openapi_python_client/templates/client.pyi

@@ -1,16 +1,25 @@
-from typing import Dict
+import os
+from typing import Dict, Optional
 
 import attr
 
 @attr.s(auto_attribs=True)
 class Client:
     """ A class for keeping track of data related to the API """
 
-    base_url: str
+    base_url: Optional[str] = attr.ib(None, kw_only=True)
     cookies: Dict[str, str] = attr.ib(factory=dict, kw_only=True)
     headers: Dict[str, str] = attr.ib(factory=dict, kw_only=True)
     timeout: float = attr.ib(5.0, kw_only=True)
 
+    def __attrs_post_init__(self):
+        env_base_url = os.environ.get('{{ title | snakecase | upper }}_BASE_URL')
+        self.base_url = self.base_url or env_base_url
+        if self.base_url is None:
+            raise ValueError(f'"base_url" has to be set either from the '
+                             f'environment variable "{env_base_url}", or '
+                             f'passed with the "base_url" argument')
+
     def get_headers(self) -> Dict[str, str]:
         """ Get headers to be used in all endpoints """
         return {**self.headers}

openapi_python_client/templates/endpoint_macros.pyi

@@ -70,14 +70,18 @@ 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 or endpoint.form_body_reference or endpoint.multipart_body_reference or endpoint.query_parameters or endpoint.json_body or endpoint.header_parameters %}
 *,
+{% 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 Sync{{ client_name }}, {{ client_name }}

openapi_python_client/templates/property_templates/union_property.pyi

@@ -19,7 +19,14 @@ def _parse_{{ property.python_name }}(data: Any) -> {{ property.get_type_string(
     {% endif %}
     {% endfor %}
 
+{% if not property.nullable %}
 {{ property.python_name }} = _parse_{{ property.python_name }}({{ source }})
+{% else %}
+{{ property.python_name }} = None
+if {{ source }} is not None:
+    {{ property.python_name }} = _parse_{{ property.python_name }}({{ source }})
+{% endif %}
+
 {% endmacro %}
 
 {% macro transform(property, source, destination, declare_type=True) %}

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,84 @@
+from typing import Any, Dict, Optional, Union, cast, List
+from .client import Client as InnerClient, AuthenticatedClient
+from .types import UNSET, Unset
+
+
+from .models import (
+    {% for import in imports | sort %}
+    {{ import }},
+    {% 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) | indent(8) }}
+    ):
+        {% if endpoint.requires_security %}
+        client = cast(AuthenticatedClient, self._client)
+        {% else %}
+        client = self._client
+        {% endif %}
+        return await {{ tag }}.{{ endpoint.name | snakecase }}.asyncio(
+            {{ kwargs(endpoint) | indent(12) }}
+        )
+
+    {% 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) | indent(8) }}
+    ):
+        {% if endpoint.requires_security %}
+        client = cast(AuthenticatedClient, self._client)
+        {% else %}
+        client = self._client
+        {% endif %}
+        return {{ tag }}.{{ endpoint.name | snakecase }}.sync(
+            {{ kwargs(endpoint) | indent(12) }}
+        )
+
+    {% endfor %}
+
+{% endfor %}
+
+{% for prefix in '', 'Sync' %}
+
+class {{ prefix }}{{ client_name }}:
+    def __init__(self, base_url: Optional[str] = None, 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 }} = {{ prefix }}{{ tag | pascalcase }}Api(self.connection)
+        {% endfor %}
+
+{% endfor %}