feat: Add new client parameters: encoding

Author: dongfangtianyu

openapi_python_client/__init__.py

@@ -44,10 +44,19 @@ class Project:
     project_name_override: Optional[str] = None
     package_name_override: Optional[str] = None
     package_version_override: Optional[str] = None
-
-    def __init__(self, *, openapi: GeneratorData, meta: MetaType, custom_template_path: Optional[Path] = None) -> None:
+    encoding: Optional[str] = None
+
+    def __init__(
+        self,
+        *,
+        openapi: GeneratorData,
+        meta: MetaType,
+        custom_template_path: Optional[Path] = None,
+        encoding: Optional[str] = None,
+    ) -> None:
         self.openapi: GeneratorData = openapi
         self.meta: MetaType = meta
+        self.encoding = encoding
 
         package_loader = PackageLoader(__package__)
         loader: BaseLoader
@@ -137,15 +146,17 @@ def _create_package(self) -> None:
         package_init = self.package_dir / "__init__.py"
 
         package_init_template = self.env.get_template("package_init.py.jinja")
-        package_init.write_text(package_init_template.render(description=self.package_description))
+        package_init.write_text(
+            package_init_template.render(description=self.package_description), encoding=self.encoding
+        )
 
         if self.meta != MetaType.NONE:
             pytyped = self.package_dir / "py.typed"
-            pytyped.write_text("# Marker file for PEP 561")
+            pytyped.write_text("# Marker file for PEP 561", encoding=self.encoding)
 
         types_template = self.env.get_template("types.py.jinja")
         types_path = self.package_dir / "types.py"
-        types_path.write_text(types_template.render())
+        types_path.write_text(types_template.render(), encoding=self.encoding)
 
     def _build_metadata(self) -> None:
         if self.meta == MetaType.NONE:
@@ -161,13 +172,14 @@ def _build_metadata(self) -> None:
         readme.write_text(
             readme_template.render(
                 project_name=self.project_name, description=self.package_description, package_name=self.package_name
-            )
+            ),
+            encoding=self.encoding,
         )
 
         # .gitignore
         git_ignore_path = self.project_dir / ".gitignore"
         git_ignore_template = self.env.get_template(".gitignore.jinja")
-        git_ignore_path.write_text(git_ignore_template.render())
+        git_ignore_path.write_text(git_ignore_template.render(), encoding=self.encoding)
 
     def _build_pyproject_toml(self, *, use_poetry: bool) -> None:
         template = "pyproject.toml.jinja" if use_poetry else "pyproject_no_poetry.toml.jinja"
@@ -179,7 +191,8 @@ def _build_pyproject_toml(self, *, use_poetry: bool) -> None:
                 package_name=self.package_name,
                 version=self.version,
                 description=self.package_description,
-            )
+            ),
+            encoding=self.encoding,
         )
 
     def _build_setup_py(self) -> None:
@@ -191,7 +204,8 @@ def _build_setup_py(self) -> None:
                 package_name=self.package_name,
                 version=self.version,
                 description=self.package_description,
-            )
+            ),
+            encoding=self.encoding,
         )
 
     def _build_models(self) -> None:
@@ -204,7 +218,7 @@ def _build_models(self) -> None:
         model_template = self.env.get_template("model.py.jinja")
         for model in self.openapi.models.values():
             module_path = models_dir / f"{model.reference.module_name}.py"
-            module_path.write_text(model_template.render(model=model))
+            module_path.write_text(model_template.render(model=model), encoding=self.encoding)
             imports.append(import_string_from_reference(model.reference))
 
         # Generate enums
@@ -213,25 +227,25 @@ def _build_models(self) -> None:
         for enum in self.openapi.enums.values():
             module_path = models_dir / f"{enum.reference.module_name}.py"
             if enum.value_type is int:
-                module_path.write_text(int_enum_template.render(enum=enum))
+                module_path.write_text(int_enum_template.render(enum=enum), encoding=self.encoding)
             else:
-                module_path.write_text(str_enum_template.render(enum=enum))
+                module_path.write_text(str_enum_template.render(enum=enum), encoding=self.encoding)
             imports.append(import_string_from_reference(enum.reference))
 
         models_init_template = self.env.get_template("models_init.py.jinja")
-        models_init.write_text(models_init_template.render(imports=imports))
+        models_init.write_text(models_init_template.render(imports=imports), encoding=self.encoding)
 
     def _build_api(self) -> None:
         # Generate Client
         client_path = self.package_dir / "client.py"
         client_template = self.env.get_template("client.py.jinja")
-        client_path.write_text(client_template.render())
+        client_path.write_text(client_template.render(), encoding=self.encoding)
 
         # Generate endpoints
         api_dir = self.package_dir / "api"
         api_dir.mkdir()
         api_init = api_dir / "__init__.py"
-        api_init.write_text('""" Contains methods for accessing the API """')
+        api_init.write_text('""" Contains methods for accessing the API """', encoding=self.encoding)
 
         endpoint_template = self.env.get_template("endpoint_module.py.jinja")
         for tag, collection in self.openapi.endpoint_collections_by_tag.items():
@@ -242,31 +256,42 @@ def _build_api(self) -> None:
 
             for endpoint in collection.endpoints:
                 module_path = tag_dir / f"{snake_case(endpoint.name)}.py"
-                module_path.write_text(endpoint_template.render(endpoint=endpoint))
+                module_path.write_text(endpoint_template.render(endpoint=endpoint), encoding=self.encoding)
 
 
 def _get_project_for_url_or_path(
-    url: Optional[str], path: Optional[Path], meta: MetaType, custom_template_path: Optional[Path] = None
+    url: Optional[str],
+    path: Optional[Path],
+    meta: MetaType,
+    custom_template_path: Optional[Path] = None,
+    encoding: Optional[str] = None,
 ) -> Union[Project, GeneratorError]:
     data_dict = _get_document(url=url, path=path)
     if isinstance(data_dict, GeneratorError):
         return data_dict
     openapi = GeneratorData.from_dict(data_dict)
     if isinstance(openapi, GeneratorError):
         return openapi
-    return Project(openapi=openapi, custom_template_path=custom_template_path, meta=meta)
+    return Project(openapi=openapi, custom_template_path=custom_template_path, meta=meta, encoding=encoding)
 
 
 def create_new_client(
-    *, url: Optional[str], path: Optional[Path], meta: MetaType, custom_template_path: Optional[Path] = None
+    *,
+    url: Optional[str],
+    path: Optional[Path],
+    meta: MetaType,
+    custom_template_path: Optional[Path] = None,
+    encoding: Optional[str] = None,
 ) -> Sequence[GeneratorError]:
     """
     Generate the client library
 
     Returns:
          A list containing any errors encountered when generating.
     """
-    project = _get_project_for_url_or_path(url=url, path=path, custom_template_path=custom_template_path, meta=meta)
+    project = _get_project_for_url_or_path(
+        url=url, path=path, custom_template_path=custom_template_path, meta=meta, encoding=encoding
+    )
     if isinstance(project, GeneratorError):
         return [project]
     return project.build()

openapi_python_client/cli.py

@@ -116,6 +116,7 @@ def generate(
     url: Optional[str] = typer.Option(None, help="A URL to read the JSON from"),
     path: Optional[pathlib.Path] = typer.Option(None, help="A path to the JSON file"),
     custom_template_path: Optional[pathlib.Path] = typer.Option(None, **custom_template_path_options),  # type: ignore
+    encoding: Optional[str] = typer.Option(None, help="Set file encoding for client files"),  # type: ignore
     meta: MetaType = _meta_option,
 ) -> None:
     """ Generate a new OpenAPI Client library """
@@ -127,7 +128,9 @@ def generate(
     if url and path:
         typer.secho("Provide either --url or --path, not both", fg=typer.colors.RED)
         raise typer.Exit(code=1)
-    errors = create_new_client(url=url, path=path, meta=meta, custom_template_path=custom_template_path)
+    errors = create_new_client(
+        url=url, path=path, meta=meta, custom_template_path=custom_template_path, encoding=encoding
+    )
     handle_errors(errors)
 
 

tests/test___init__.py

@@ -23,7 +23,7 @@ def test__get_project_for_url_or_path(mocker):
 
     _get_document.assert_called_once_with(url=url, path=path)
     from_dict.assert_called_once_with(data_dict)
-    _Project.assert_called_once_with(openapi=openapi, custom_template_path=None, meta=MetaType.POETRY)
+    _Project.assert_called_once_with(openapi=openapi, custom_template_path=None, meta=MetaType.POETRY, encoding=None)
     assert project == _Project.return_value
 
 
@@ -76,7 +76,7 @@ def test_create_new_client(mocker):
     result = create_new_client(url=url, path=path, meta=MetaType.POETRY)
 
     _get_project_for_url_or_path.assert_called_once_with(
-        url=url, path=path, custom_template_path=None, meta=MetaType.POETRY
+        url=url, path=path, custom_template_path=None, meta=MetaType.POETRY, encoding=None
     )
     project.build.assert_called_once()
     assert result == project.build.return_value
@@ -95,7 +95,7 @@ def test_create_new_client_project_error(mocker):
     result = create_new_client(url=url, path=path, meta=MetaType.POETRY)
 
     _get_project_for_url_or_path.assert_called_once_with(
-        url=url, path=path, custom_template_path=None, meta=MetaType.POETRY
+        url=url, path=path, custom_template_path=None, meta=MetaType.POETRY, encoding=None
     )
     assert result == [error]
 
@@ -392,9 +392,9 @@ def test__build_metadata_poetry(self, mocker):
             project_name=project.project_name,
             package_name=project.package_name,
         )
-        readme_path.write_text.assert_called_once_with(readme_template.render())
+        readme_path.write_text.assert_called_once_with(readme_template.render(), encoding=None)
         git_ignore_template.render.assert_called_once()
-        git_ignore_path.write_text.assert_called_once_with(git_ignore_template.render())
+        git_ignore_path.write_text.assert_called_once_with(git_ignore_template.render(), encoding=None)
         project._build_pyproject_toml.assert_called_once_with(use_poetry=True)
 
     def test__build_metadata_setup(self, mocker):
@@ -429,9 +429,9 @@ def test__build_metadata_setup(self, mocker):
             project_name=project.project_name,
             package_name=project.package_name,
         )
-        readme_path.write_text.assert_called_once_with(readme_template.render())
+        readme_path.write_text.assert_called_once_with(readme_template.render(), encoding=None)
         git_ignore_template.render.assert_called_once()
-        git_ignore_path.write_text.assert_called_once_with(git_ignore_template.render())
+        git_ignore_path.write_text.assert_called_once_with(git_ignore_template.render(), encoding=None)
         project._build_pyproject_toml.assert_called_once_with(use_poetry=False)
         project._build_setup_py.assert_called_once()
 
@@ -475,7 +475,7 @@ def test__build_pyproject_toml(self, mocker, use_poetry):
             version=project.version,
             description=project.package_description,
         )
-        pyproject_path.write_text.assert_called_once_with(pyproject_template.render())
+        pyproject_path.write_text.assert_called_once_with(pyproject_template.render(), encoding=None)
 
     def test__build_setup_py(self, mocker):
         from openapi_python_client import MetaType, Project
@@ -505,7 +505,7 @@ def test__build_setup_py(self, mocker):
             version=project.version,
             description=project.package_description,
         )
-        setup_path.write_text.assert_called_once_with(setup_template.render())
+        setup_path.write_text.assert_called_once_with(setup_template.render(), encoding=None)
 
 
 def test__reformat(mocker):

tests/test_cli.py

@@ -31,13 +31,16 @@ def test_config_arg(mocker, _create_new_client):
 
     config_path = "config/path"
     path = "cool/path"
+    encoding = "utf-8"
 
-    result = runner.invoke(app, [f"--config={config_path}", "generate", f"--path={path}"], catch_exceptions=False)
+    result = runner.invoke(
+        app, [f"--config={config_path}", "generate", f"--path={path}", f"--encoding={encoding}"], catch_exceptions=False
+    )
 
     assert result.exit_code == 0
     load_config.assert_called_once_with(path=Path(config_path))
     _create_new_client.assert_called_once_with(
-        url=None, path=Path(path), custom_template_path=None, meta=MetaType.POETRY
+        url=None, path=Path(path), custom_template_path=None, meta=MetaType.POETRY, encoding="utf-8"
     )
 
 
@@ -82,7 +85,9 @@ def test_generate_url(self, _create_new_client):
         result = runner.invoke(app, ["generate", f"--url={url}"])
 
         assert result.exit_code == 0
-        _create_new_client.assert_called_once_with(url=url, path=None, custom_template_path=None, meta=MetaType.POETRY)
+        _create_new_client.assert_called_once_with(
+            url=url, path=None, custom_template_path=None, meta=MetaType.POETRY, encoding=None
+        )
 
     def test_generate_path(self, _create_new_client):
         path = "cool/path"
@@ -92,7 +97,7 @@ def test_generate_path(self, _create_new_client):
 
         assert result.exit_code == 0
         _create_new_client.assert_called_once_with(
-            url=None, path=Path(path), custom_template_path=None, meta=MetaType.POETRY
+            url=None, path=Path(path), custom_template_path=None, meta=MetaType.POETRY, encoding=None
         )
 
     def test_generate_meta(self, _create_new_client):
@@ -103,7 +108,19 @@ def test_generate_meta(self, _create_new_client):
 
         assert result.exit_code == 0
         _create_new_client.assert_called_once_with(
-            url=None, path=Path(path), custom_template_path=None, meta=MetaType.NONE
+            url=None, path=Path(path), custom_template_path=None, meta=MetaType.NONE, encoding=None
+        )
+
+    def test_generate_encoding(self, _create_new_client):
+        path = "cool/path"
+        encoding = "utf-8"
+        from openapi_python_client.cli import MetaType, app
+
+        result = runner.invoke(app, ["generate", f"--path={path}", f"--encoding={encoding}"])
+
+        assert result.exit_code == 0
+        _create_new_client.assert_called_once_with(
+            url=None, path=Path(path), custom_template_path=None, meta=MetaType.POETRY, encoding="utf-8"
         )
 
     def test_generate_handle_errors(self, _create_new_client):