Migrate to a global configuration (#900)

* Move to a single generator

To have a unique configuration module, move to a single generator for
both specs.

* Migrate tests

* Typo

* Only support v2 auth

* Small tweaks

* Expose objects in init

* Rebase

Author: therve

.generator/src/generator/cli.py

@@ -10,24 +10,20 @@
 
 
 @click.command()
-@click.option(
-    "-i",
-    "--input",
+@click.argument(
+    "specs",
+    nargs=-1,
     type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=pathlib.Path),
 )
 @click.option(
     "-o",
     "--output",
     type=click.Path(path_type=pathlib.Path),
 )
-def cli(input, output):
+def cli(specs, output):
     """
     Generate a Python code snippet from OpenAPI specification.
     """
-    spec = openapi.load(input)
-
-    version = input.parent.name
-
     env = Environment(loader=FileSystemLoader(str(pathlib.Path(__file__).parent / "templates")))
 
     env.filters["accept_headers"] = openapi.accept_headers
@@ -41,9 +37,7 @@ def cli(input, output):
     env.filters["safe_snake_case"] = openapi.safe_snake_case
 
     env.globals["enumerate"] = enumerate
-    env.globals["version"] = version
     env.globals["package"] = PACKAGE_NAME
-    env.globals["openapi"] = spec
     env.globals["get_name"] = formatter.get_name
     env.globals["get_type_for_attribute"] = openapi.get_type_for_attribute
     env.globals["get_types_for_attribute"] = openapi.get_types_for_attribute
@@ -70,12 +64,8 @@ def cli(input, output):
         "exceptions.py": env.get_template("exceptions.j2"),
         "model_utils.py": env.get_template("model_utils.j2"),
         "rest.py": env.get_template("rest.j2"),
-        "configuration.py": env.get_template("base_configuration.j2"),
     }
 
-    apis = openapi.apis(spec)
-    models = openapi.models(spec)
-
     top_package = output / PACKAGE_NAME
     top_package.mkdir(parents=True, exist_ok=True)
 
@@ -84,45 +74,61 @@ def cli(input, output):
         with filename.open("w") as fp:
             fp.write(template.render())
 
-    package = top_package / version
-    package.mkdir(exist_ok=True)
-
-    for name, model in models.items():
-        filename = openapi.safe_snake_case(name) + ".py"
-        model_path = package / "model" / filename
-        model_path.parent.mkdir(parents=True, exist_ok=True)
-        with model_path.open("w") as fp:
-            fp.write(model_j2.render(name=name, model=model))
-
-    model_init_path = package / "model" / "__init__.py"
-    with model_init_path.open("w") as fp:
-        fp.write("")
-
-    models_path = package / "models" / "__init__.py"
-    models_path.parent.mkdir(parents=True, exist_ok=True)
-    with models_path.open("w") as fp:
-        fp.write(models_j2.render(models=sorted(models)))
-
-    for name, operations in apis.items():
-        filename = openapi.safe_snake_case(name) + "_api.py"
-        api_path = package / "api" / filename
-        api_path.parent.mkdir(parents=True, exist_ok=True)
-        with api_path.open("w") as fp:
-            fp.write(api_j2.render(name=name, operations=operations))
-
-    api_init_path = package / "api" / "__init__.py"
-    with api_init_path.open("w") as fp:
-        fp.write("")
-
-    apis_path = package / "apis" / "__init__.py"
-    apis_path.parent.mkdir(parents=True, exist_ok=True)
-    with apis_path.open("w") as fp:
-        fp.write(apis_j2.render(apis=sorted(apis)))
-
-    init_path = package / "__init__.py"
-    with init_path.open("w") as fp:
-        fp.write(init_j2.render())
-
-    config_path = package / "configuration.py"
-    with config_path.open("w") as fp:
-        fp.write(configuration_j2.render(apis=apis))
+    all_specs = {}
+    all_apis = {}
+
+    for spec_path in specs:
+        spec = openapi.load(spec_path)
+        env.globals["openapi"] = spec
+
+        version = spec_path.parent.name
+        env.globals["version"] = version
+
+        all_specs[version] = spec
+
+        apis = openapi.apis(spec)
+        all_apis[version] = apis
+        models = openapi.models(spec)
+
+        package = top_package / version
+        package.mkdir(exist_ok=True)
+
+        for name, model in models.items():
+            filename = openapi.safe_snake_case(name) + ".py"
+            model_path = package / "model" / filename
+            model_path.parent.mkdir(parents=True, exist_ok=True)
+            with model_path.open("w") as fp:
+                fp.write(model_j2.render(name=name, model=model))
+
+        model_init_path = package / "model" / "__init__.py"
+        with model_init_path.open("w") as fp:
+            fp.write("")
+
+        models_path = package / "models" / "__init__.py"
+        models_path.parent.mkdir(parents=True, exist_ok=True)
+        with models_path.open("w") as fp:
+            fp.write(models_j2.render(models=sorted(models)))
+
+        for name, operations in apis.items():
+            filename = openapi.safe_snake_case(name) + "_api.py"
+            api_path = package / "api" / filename
+            api_path.parent.mkdir(parents=True, exist_ok=True)
+            with api_path.open("w") as fp:
+                fp.write(api_j2.render(name=name, operations=operations))
+
+        api_init_path = package / "api" / "__init__.py"
+        with api_init_path.open("w") as fp:
+            fp.write("")
+
+        apis_path = package / "apis" / "__init__.py"
+        apis_path.parent.mkdir(parents=True, exist_ok=True)
+        with apis_path.open("w") as fp:
+            fp.write(apis_j2.render(apis=sorted(apis)))
+
+        init_path = package / "__init__.py"
+        with init_path.open("w") as fp:
+            fp.write(init_j2.render())
+
+    filename = top_package / "configuration.py"
+    with filename.open("w") as fp:
+        fp.write(configuration_j2.render(specs=all_specs, apis=all_apis))

.generator/src/generator/templates/api.j2

@@ -31,6 +31,7 @@ class {{ classname }}:
                 "endpoint_path": "{{ path }}",
                 "operation_id": "{{ operation.operationId|safe_snake_case }}",
                 "http_method": "{{httpMethod}}",
+                "version": "{{ version }}",
 {%- set servers = operation.servers %}
 {%- if servers %}
                 "servers": [

.generator/src/generator/templates/api_client.j2

@@ -253,7 +253,6 @@ class ApiClient(object):
         post_params: Optional[List[Tuple[str, Any]]] = None,
         files: Optional[Dict[str, List[io.FileIO]]] = None,
         response_type: Optional[Tuple[Any]] = None,
-        auth_settings: Optional[List[str]] = None,
         async_req: Optional[bool] = None,
         _return_http_data_only: Optional[bool] = None,
         collection_formats: Optional[Dict[str, str]] = None,
@@ -275,7 +274,6 @@ class ApiClient(object):
         :param body: Request body.
         :param post_params dict: Request post form parameters,
             for `application/x-www-form-urlencoded`, `multipart/form-data`.
-        :param auth_settings list: Auth Settings names for the request.
         :param response_type: For the response, a tuple containing:
             valid classes
             a list containing valid classes (for list schemas)
@@ -353,9 +351,6 @@ class ApiClient(object):
         if body:
             body = self.sanitize_for_serialization(body)
 
-        # auth setting
-        self.update_params_for_auth(header_params, query_params, auth_settings, resource_path, method, body)
-
         # request url
         if _host is None:
             url = self.configuration.host + resource_path
@@ -494,35 +489,6 @@ class ApiClient(object):
         else:
             return content_types[0]
 
-    def update_params_for_auth(self, headers, queries, auth_settings, resource_path, method, body):
-        """Updates header and query params based on authentication setting.
-
-        :param headers: Header parameters dict to be updated.
-        :param queries: Query parameters tuple list to be updated.
-        :param auth_settings: Authentication setting identifiers list.
-        :param resource_path: A string representation of the HTTP request resource path.
-        :param method: A string representation of the HTTP request method.
-        :param body: A object representing the body of the HTTP request.
-            The object type is the return value of _encoder.default().
-        """
-        if not auth_settings:
-            return
-
-        for auth in auth_settings:
-            auth_setting = self.configuration.auth_settings().get(auth)
-            if auth_setting:
-                if auth_setting["in"] == "cookie":
-                    headers["Cookie"] = auth_setting["value"]
-                elif auth_setting["in"] == "header":
-                    if auth_setting["type"] != "http-signature":
-                        if auth_setting["value"] is None:
-                            raise ApiValueError("Invalid authentication token for {}".format(auth_setting["key"]))
-                        headers[auth_setting["key"]] = auth_setting["value"]
-                elif auth_setting["in"] == "query":
-                    queries.append((auth_setting["key"], auth_setting["value"]))
-                else:
-                    raise ApiValueError("Authentication token must be in `query` or `header`")
-
 
 class AsyncApiClient(ApiClient):
     def _build_rest_client(self):
@@ -598,6 +564,7 @@ class Endpoint(object):
             'operation_id' (str): endpoint string identifier
             'http_method' (str): POST/PUT/PATCH/GET etc
             'servers' (list): list of str servers that this endpoint is at
+            'version' (str): the API version
         :type settings: dict
         :param params_map: See below key value pairs:
             'required' (bool): whether the parameter is required
@@ -706,7 +673,8 @@ class Endpoint(object):
 
     def call_with_http_info(self, **kwargs):
 
-        is_unstable = self.api_client.configuration.unstable_operations.get(self.settings["operation_id"])
+        is_unstable = self.api_client.configuration.unstable_operations.get(
+            "{}.{}".format(self.settings["version"], self.settings["operation_id"]))
         if is_unstable:
             warnings.warn("Using unstable operation '{0}'".format(self.settings["operation_id"]))
         elif is_unstable is False:
@@ -764,6 +732,8 @@ class Endpoint(object):
             header_list = self.api_client.select_header_content_type(content_type_headers_list)
             params["header"]["Content-Type"] = header_list
 
+        self.update_params_for_auth(params["header"], params["query"])
+
         return self.api_client.call_api(
             self.settings["endpoint_path"],
             self.settings["http_method"],
@@ -774,7 +744,6 @@ class Endpoint(object):
             post_params=params["form"],
             files=params["file"],
             response_type=self.settings["response_type"],
-            auth_settings=self.settings["auth"],
             async_req=kwargs["async_req"],
             _check_type=kwargs["_check_return_type"],
             _return_http_data_only=kwargs["_return_http_data_only"],
@@ -784,6 +753,30 @@ class Endpoint(object):
             collection_formats=params["collection_format"],
         )
 
+    def update_params_for_auth(self, headers, queries):
+        """Updates header and query params based on authentication setting.
+
+        :param headers: Header parameters dict to be updated.
+        :param queries: Query parameters tuple list to be updated.
+        """
+        if not self.settings["auth"]:
+            return
+
+        for auth in self.settings["auth"]:
+            auth_setting = self.api_client.configuration.auth_settings().get(auth)
+            if auth_setting:
+                if auth_setting["in"] == "cookie":
+                    headers["Cookie"] = auth_setting["value"]
+                elif auth_setting["in"] == "header":
+                    if auth_setting["type"] != "http-signature":
+                        if auth_setting["value"] is None:
+                            raise ApiValueError("Invalid authentication token for {}".format(auth_setting["key"]))
+                        headers[auth_setting["key"]] = auth_setting["value"]
+                elif auth_setting["in"] == "query":
+                    queries.append((auth_setting["key"], auth_setting["value"]))
+                else:
+                    raise ApiValueError("Authentication token must be in `query` or `header`")
+
 
 def user_agent():
     """Generate default User-Agent header."""