Added config file option

- Allows overriding class names, closing #9

Author: dbanty

README.md

@@ -51,13 +51,37 @@ get an error.
     for endpoints without a tag.  Each of these modules in turn contains one function for calling each endpoint.
     1. A `models` module which has all the classes defined by the various schemas in your OpenAPI spec
 
+For a full example you can look at tests/test_end_to_end which has a declared [FastAPI](https://fastapi.tiangolo.com/) 
+server and the resulting openapi.json file in the "fastapi" directory.  "golden-master" is the generated client from that 
+OpenAPI document.
+    
 ## OpenAPI features supported
 1. All HTTP Methods
 1. JSON and form bodies, path and query parameters
 1. float, string, int, datetimes, string enums, and custom schemas or lists containing any of those
 1. html/text or application/json responses containing any of the previous types
 1. Bearer token security
 
+## Configuration
+You can pass a YAML (or JSON) file to openapi-python-client in order to change some behavior.  The following parameters 
+are supported:
+
+### class_overrides
+Used to change the name of generated model classes, especially useful if you have a name like ABCModel which, when 
+converted to snake case for module naming will be a_b_c_model.  This param should be a mapping of existing class name 
+(usually a key in the "schemas" section of your OpenAPI document) to class_name and module_name.
+
+Example:
+```yaml
+class_overrides:
+    ABCModel:
+      class_name: ABCModel
+      module_name: abc_model
+```
+
+The easiest way to find what needs to be overridden is probably to generate your client and go look at everything in the
+ models folder.
+
 
 ## Contributors 
  - Dylan Anthony <[email protected]> (Owner)

openapi_python_client/__init__.py

@@ -9,6 +9,7 @@
 from typing import Any, Dict, Optional
 
 import httpx
+import yaml
 from jinja2 import Environment, PackageLoader
 
 from .openapi_parser import OpenAPI, import_string_from_reference
@@ -22,6 +23,17 @@ def _get_project_for_url_or_path(url: Optional[str], path: Optional[Path]) -> _P
     return _Project(openapi=openapi)
 
 
+def load_config(*, path: Path) -> None:
+    """ Loads config from provided Path """
+    config_data = yaml.safe_load(path.read_text())
+
+    if "class_overrides" in config_data:
+        from .openapi_parser import reference
+
+        for class_name, class_data in config_data["class_overrides"].items():
+            reference.class_overrides[class_name] = reference.Reference(**class_data)
+
+
 def create_new_client(*, url: Optional[str], path: Optional[Path]) -> None:
     """ Generate the client library """
     project = _get_project_for_url_or_path(url=url, path=path)

openapi_python_client/cli.py

@@ -14,10 +14,25 @@ def _version_callback(value: bool) -> None:
         raise typer.Exit()
 
 
+def _process_config(path: Optional[pathlib.Path]) -> None:
+    from openapi_python_client import load_config
+
+    if not path:
+        return
+
+    try:
+        load_config(path=path)
+    except:
+        raise typer.BadParameter("Unable to parse config")
+
+
 # noinspection PyUnusedLocal
 @app.callback(name="openapi-python-client")
 def cli(
     version: bool = typer.Option(False, "--version", callback=_version_callback, help="Print the version and exit"),
+    config: Optional[pathlib.Path] = typer.Option(
+        None, callback=_process_config, help="Path to the config file to use"
+    ),
 ) -> None:
     """ Generate a Python client from an OpenAPI JSON document """
     pass

openapi_python_client/openapi_parser/reference.py

@@ -3,9 +3,12 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import Dict
 
 import stringcase
 
+class_overrides: Dict[str, Reference] = {}
+
 
 @dataclass
 class Reference:
@@ -18,4 +21,9 @@ class Reference:
     def from_ref(ref: str) -> Reference:
         """ Get a Reference from the openapi #/schemas/blahblah string """
         ref_value = ref.split("/")[-1]
-        return Reference(class_name=stringcase.pascalcase(ref_value), module_name=stringcase.snakecase(ref_value),)
+        class_name = stringcase.pascalcase(ref_value)
+
+        if class_name in class_overrides:
+            return class_overrides[class_name]
+
+        return Reference(class_name=class_name, module_name=stringcase.snakecase(ref_value),)

poetry.lock

@@ -24,6 +24,7 @@ shellingham = "^1.3.2"
 httpx = "^0.12.1"
 black = "^19.10b0"
 isort = "^4.3.21"
+pyyaml = "^5.3.1"
 
 [tool.poetry.scripts]
 openapi-python-client = "openapi_python_client.cli:app"

pyproject.toml

@@ -437,3 +437,21 @@ def test__reformat(mocker):
             mocker.call("black .", cwd=project.project_dir, shell=True),
         ]
     )
+
+
+def test_load_config(mocker):
+    my_data = {"class_overrides": {"_MyCLASSName": {"class_name": "MyClassName", "module_name": "my_module_name"}}}
+    safe_load = mocker.patch("yaml.safe_load", return_value=my_data)
+    fake_path = mocker.MagicMock(autospec=pathlib.Path)
+
+    from openapi_python_client import load_config
+
+    load_config(path=fake_path)
+
+    fake_path.read_text.assert_called_once()
+    safe_load.assert_called_once_with(fake_path.read_text())
+    from openapi_python_client.openapi_parser import reference
+
+    assert reference.class_overrides == {
+        "_MyCLASSName": reference.Reference(class_name="MyClassName", module_name="my_module_name")
+    }

tests/test___init__.py

@@ -1,4 +1,5 @@
 from pathlib import PosixPath
+from unittest.mock import MagicMock
 
 import pytest
 from typer.testing import CliRunner
@@ -18,17 +19,46 @@ def test_version(mocker):
 
 
 @pytest.fixture
-def _create_new_client(mocker):
+def _create_new_client(mocker) -> MagicMock:
     return mocker.patch("openapi_python_client.create_new_client")
 
 
+def test_config(mocker, _create_new_client):
+    load_config = mocker.patch("openapi_python_client.load_config")
+    from openapi_python_client.cli import app
+
+    config_path = "config/path"
+    path = "cool/path"
+
+    result = runner.invoke(app, [f"--config={config_path}", "generate", f"--path={path}"], catch_exceptions=False)
+
+    assert result.exit_code == 0
+    load_config.assert_called_once_with(path=PosixPath(config_path))
+    _create_new_client.assert_called_once_with(url=None, path=PosixPath(path))
+
+
+def test_bad_config(mocker, _create_new_client):
+    load_config = mocker.patch("openapi_python_client.load_config", side_effect=ValueError("Bad Config"))
+    from openapi_python_client.cli import app
+
+    config_path = "config/path"
+    path = "cool/path"
+
+    result = runner.invoke(app, [f"--config={config_path}", "generate", f"--path={path}"])
+
+    assert result.exit_code == 2
+    assert "Unable to parse config" in result.stdout
+    load_config.assert_called_once_with(path=PosixPath(config_path))
+    _create_new_client.assert_not_called()
+
+
 class TestGenerate:
     def test_generate_no_params(self, _create_new_client):
         from openapi_python_client.cli import app
 
         result = runner.invoke(app, ["generate"])
 
-        assert result.exit_code == 1
+        assert result.exit_code == 1, result.output
         _create_new_client.assert_not_called()
 
     def test_generate_url_and_path(self, _create_new_client):

tests/test_cli.py

@@ -0,0 +1,4 @@
+class_overrides:
+  _ABCResponse:
+    class_name: ABCResponse
+    module_name: abc_response

tests/test_end_to_end/config.yml

@@ -8,11 +8,11 @@
 app = FastAPI(title="My Test API", description="An API for testing openapi-python-client",)
 
 
-class PingResponse(BaseModel):
+class _ABCResponse(BaseModel):
     success: bool
 
 
-@app.get("/ping", response_model=PingResponse)
+@app.get("/ping", response_model=_ABCResponse)
 async def ping():
     """ A quick check to see if the system is running """
     return {"success": True}