- Added the autoformat option to the CLI

- Added black as a possible auto formatter
- Added options to the main tests
- Added autoformat as doc to the latest release

Author: MarcoMuellner

docs/references/index.md

@@ -16,5 +16,6 @@ Arguments:
 Options:
 ```console
 --library                  The library to use. Defaults to `httpx`.
+--autoformat               Specifies which auto formattool to apply to the generated code. Defaults to `black`.
 -h, --help                 Show this help message and exit.
 ```

pyproject.toml

@@ -24,10 +24,10 @@ openapi-schema-pydantic = "^1.2.3"
 Jinja2 = "^3.1.2"
 autopep8 = "^1.6.0"
 click = "^8.1.3"
+black = ">=21.10b0"
 
 [tool.poetry.dev-dependencies]
 Pygments = ">=2.10.0"
-black = ">=21.10b0"
 coverage = {extras = ["toml"], version = "^6.4.1"}
 darglint = ">=1.8.1"
 flake8 = ">=3.0.1"

src/openapi_python_generator/__main__.py

@@ -3,7 +3,7 @@
 import click
 
 from openapi_python_generator import __version__
-from openapi_python_generator.common import HTTPLibrary
+from openapi_python_generator.common import HTTPLibrary, AutoFormat
 from openapi_python_generator.generate_data import generate_data
 
 
@@ -14,19 +14,28 @@
     "--library",
     default=HTTPLibrary.httpx,
     type=HTTPLibrary,
-    help="HTTP library to use in the generation of the client. Currently only httpx is supported.",
+    help="HTTP library to use in the generation of the client.",
+)
+@click.option(
+    "--autoformat",
+    default=AutoFormat.black,
+    type=AutoFormat,
+    help="Option to choose which auto formatter is applied.",
 )
 @click.version_option(version=__version__)
 def main(
-    source: str, output: str, library: Optional[HTTPLibrary] = HTTPLibrary.httpx
+    source: str,
+    output: str,
+    library: Optional[HTTPLibrary] = HTTPLibrary.httpx,
+    autoformat: Optional[AutoFormat] = AutoFormat.black,
 ) -> None:
     """
     Generate Python code from an OpenAPI 3.0 specification.
 
     Provide a SOURCE (file or URL) containing the OpenAPI 3 specification and
     an OUTPUT path, where the resulting client is created.
     """
-    generate_data(source, output, library)
+    generate_data(source, output, library, autoformat)
 
 
 if __name__ == "__main__":  # pragma: no cover

src/openapi_python_generator/common.py

@@ -14,6 +14,16 @@ class HTTPLibrary(str, Enum):
     aiohttp = "aiohttp"
 
 
+class AutoFormat(str, Enum):
+    """
+    Enum for the available autoformat options
+    """
+
+    autopep8 = "autopep8"
+    black = "black"
+    none = "none"
+
+
 library_config_dict: Dict[Optional[HTTPLibrary], LibraryConfig] = {
     HTTPLibrary.httpx: LibraryConfig(
         name="httpx",

src/openapi_python_generator/generate_data.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 from typing import Optional, Union
 
+import black
 import click
 import httpx
 from httpx import ConnectError, ConnectTimeout
@@ -9,20 +10,32 @@
 import autopep8
 
 from openapi_schema_pydantic import OpenAPI
-from .common import HTTPLibrary, library_config_dict
+from .common import HTTPLibrary, library_config_dict, AutoFormat
 from .language_converters.python.generator import generator
 from .language_converters.python.jinja_config import JINJA_ENV, SERVICE_TEMPLATE
 from .models import ConversionResult
 
 
-def write_code(path: Path, content):
+def write_code(
+    path: Path, content, autoformat: Optional[AutoFormat] = AutoFormat.black
+) -> None:
     """
     Write the content to the file at the given path.
+    :param autoformat: The autoformat applied to the code written.
     :param path: The path to the file.
     :param content: The content to write.
     """
     with open(path, "w") as f:
-        f.write(autopep8.fix_code(content))
+        if autoformat == AutoFormat.black:
+            f.write(
+                black.format_file_contents(
+                    content, fast=False, mode=black.FileMode(line_length=120)
+                )
+            )
+        elif autoformat == AutoFormat.autopep8:
+            f.write(autopep8.fix_code(content, options={"max_line_length": 120}))
+        else:
+            f.write(content)
 
 
 def get_open_api(source: Union[str, Path]) -> OpenAPI:
@@ -54,11 +67,16 @@ def get_open_api(source: Union[str, Path]) -> OpenAPI:
         raise
 
 
-def write_data(data: ConversionResult, output: Union[str, Path]):
+def write_data(
+    data: ConversionResult,
+    output: Union[str, Path],
+    autoformat: Optional[AutoFormat] = AutoFormat.black,
+) -> None:
     """
     This function will firstly create the folderstrucutre of output, if it doesn't exist. Then it will create the
     models from data.models into the models sub module of the output folder. After this, the services will be created
     into the services sub module of the output folder.
+    :param autoformat: The autoformat applied to the code written.
     :param data: The data to write.
     :param output: The path to the output folder.
     """
@@ -79,12 +97,13 @@ def write_data(data: ConversionResult, output: Union[str, Path]):
     # Write the models.
     for model in data.models:
         files.append(model.file_name)
-        write_code(models_path / f"{model.file_name}.py", model.content)
+        write_code(models_path / f"{model.file_name}.py", model.content, autoformat)
 
     # Create models.__init__.py file containing imports to all models.
     write_code(
         models_path / "__init__.py",
         "\n".join([f"from .{file} import *" for file in files]),
+        autoformat,
     )
 
     files = []
@@ -97,33 +116,37 @@ def write_data(data: ConversionResult, output: Union[str, Path]):
         write_code(
             services_path / f"{service.file_name}.py",
             JINJA_ENV.get_template(SERVICE_TEMPLATE).render(**service.dict()),
+            autoformat,
         )
 
     # Create services.__init__.py file containing imports to all services.
     write_code(
         services_path / "__init__.py",
         "\n".join([f"from .{file} import *" for file in files]),
+        autoformat,
     )
 
     # Write the api_config.py file.
-    write_code(Path(output) / "api_config.py", data.api_config.content)
+    write_code(Path(output) / "api_config.py", data.api_config.content, autoformat)
 
     # Write the __init__.py file.
     write_code(
         Path(output) / "__init__.py",
         "from .models import *\nfrom .services import *\nfrom .api_config import *",
+        autoformat,
     )
 
 
 def generate_data(
     source: Union[str, Path],
     output: Union[str, Path],
     library: Optional[HTTPLibrary] = HTTPLibrary.httpx,
+    autoformat: Optional[AutoFormat] = AutoFormat.black,
 ) -> None:
     """
     Generate Python code from an OpenAPI 3.0 specification.
     """
     data = get_open_api(source)
     click.echo(f"Generating data from {source}")
     result = generator(data, library_config_dict[library])
-    write_data(result, output)
+    write_data(result, output, autoformat)

tests/test_generate_data.py

@@ -1,7 +1,7 @@
 import pytest
 from httpx import ConnectError
 
-from openapi_python_generator.common import library_config_dict, HTTPLibrary
+from openapi_python_generator.common import library_config_dict, HTTPLibrary, AutoFormat
 from openapi_python_generator.generate_data import (
     get_open_api,
     write_data,
@@ -43,9 +43,12 @@ def test_generate_data(model_data_with_cleanup):
     assert (test_result_path / "__init__.py").is_file()
 
 
-def test_write_data(model_data_with_cleanup):
+@pytest.mark.parametrize(
+    "autoformat", [AutoFormat.black, AutoFormat.autopep8, AutoFormat.none]
+)
+def test_write_data(model_data_with_cleanup, autoformat):
     result = generator(model_data_with_cleanup, library_config_dict[HTTPLibrary.httpx])
-    write_data(result, test_result_path)
+    write_data(result, test_result_path, autoformat)
 
     assert test_result_path.exists()
     assert test_result_path.is_dir()

tests/test_main.py

@@ -3,6 +3,7 @@
 from click.testing import CliRunner
 
 from openapi_python_generator.__main__ import main
+from openapi_python_generator.common import HTTPLibrary, AutoFormat
 from tests.conftest import test_data_path, test_result_path
 
 
@@ -12,7 +13,30 @@ def runner() -> CliRunner:
     return CliRunner()
 
 
-def test_main_succeeds(runner: CliRunner, model_data_with_cleanup) -> None:
+@pytest.mark.parametrize(
+    "library,autoformat",
+    [
+        (HTTPLibrary.httpx, AutoFormat.black),
+        (HTTPLibrary.httpx, AutoFormat.autopep8),
+        (HTTPLibrary.httpx, AutoFormat.none),
+        (HTTPLibrary.requests, AutoFormat.black),
+        (HTTPLibrary.requests, AutoFormat.autopep8),
+        (HTTPLibrary.requests, AutoFormat.none),
+    ],
+)
+def test_main_succeeds(
+    runner: CliRunner, model_data_with_cleanup, library, autoformat
+) -> None:
     """It exits with a status code of zero."""
-    result = runner.invoke(main, [str(test_data_path), str(test_result_path)])
+    result = runner.invoke(
+        main,
+        [
+            str(test_data_path),
+            str(test_result_path),
+            "--library",
+            library.value,
+            "--autoformat",
+            autoformat.value,
+        ],
+    )
     assert result.exit_code == 0