openapi-python-client 0.20.0__tar.gz → 0.21.1__tar.gz

{openapi_python_client-0.20.0 → openapi_python_client-0.21.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openapi-python-client
-Version: 0.20.0
+Version: 0.21.1
 Summary: Generate modern Python clients from OpenAPI
 Project-URL: repository, https://github.com/openapi-generators/openapi-python-client
 Author-email: Dylan Anthony <contact@dylananthony.com>
@@ -18,7 +18,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Typing :: Typed
-Requires-Python: <4.0,>=3.8
+Requires-Python: <4.0,>=3.8.1
 Requires-Dist: attrs>=21.3.0
 Requires-Dist: colorama>=0.4.3; sys_platform == 'win32'
 Requires-Dist: httpx<0.28.0,>=0.20.0

{openapi_python_client-0.20.0 → openapi_python_client-0.21.1}/openapi_python_client/__init__.py

@@ -65,12 +65,22 @@ class Project:
         )
 
         self.project_name: str = config.project_name_override or f"{utils.kebab_case(openapi.title).lower()}-client"
-        self.project_dir: Path = Path.cwd()
-        if config.meta_type != MetaType.NONE:
-            self.project_dir /= self.project_name
-
         self.package_name: str = config.package_name_override or self.project_name.replace("-", "_")
-        self.package_dir: Path = self.project_dir / self.package_name
+        self.project_dir: Path  # Where the generated code will be placed
+        self.package_dir: Path  # Where the generated Python module will be placed (same as project_dir if no meta)
+
+        if config.output_path is not None:
+            self.project_dir = config.output_path
+        elif config.meta_type == MetaType.NONE:
+            self.project_dir = Path.cwd() / self.package_name
+        else:
+            self.project_dir = Path.cwd() / self.project_name
+
+        if config.meta_type == MetaType.NONE:
+            self.package_dir = self.project_dir
+        else:
+            self.package_dir = self.project_dir / self.package_name
+
         self.package_description: str = utils.remove_string_escapes(
             f"A client library for accessing {self.openapi.title}"
         )
@@ -95,29 +105,16 @@ class Project:
     def build(self) -> Sequence[GeneratorError]:
         """Create the project from templates"""
 
-        if self.config.meta_type == MetaType.NONE:
-            print(f"Generating {self.package_name}")
-        else:
-            print(f"Generating {self.project_name}")
-            try:
-                self.project_dir.mkdir()
-            except FileExistsError:
-                return [GeneratorError(detail="Directory already exists. Delete it or use the update command.")]
-        self._create_package()
-        self._build_metadata()
-        self._build_models()
-        self._build_api()
-        self._run_post_hooks()
-        return self._get_errors()
-
-    def update(self) -> Sequence[GeneratorError]:
-        """Update an existing project"""
+        print(f"Generating {self.project_dir}")
+        if self.config.overwrite:
+            shutil.rmtree(self.project_dir, ignore_errors=True)
 
-        if not self.package_dir.is_dir():
-            return [GeneratorError(detail=f"Directory {self.package_dir} not found")]
-        print(f"Updating {self.package_name}")
-        shutil.rmtree(self.package_dir)
+        try:
+            self.project_dir.mkdir()
+        except FileExistsError:
+            return [GeneratorError(detail="Directory already exists. Delete it or use the --overwrite option.")]
         self._create_package()
+        self._build_metadata()
         self._build_models()
         self._build_api()
         self._run_post_hooks()
@@ -138,7 +135,7 @@ class Project:
             )
             return
         try:
-            cwd = self.package_dir if self.config.meta_type == MetaType.NONE else self.project_dir
+            cwd = self.project_dir
             subprocess.run(cmd, cwd=cwd, shell=True, capture_output=True, check=True)
         except CalledProcessError as err:
             self.errors.append(
@@ -158,7 +155,8 @@ class Project:
         return errors
 
     def _create_package(self) -> None:
-        self.package_dir.mkdir()
+        if self.package_dir != self.project_dir:
+            self.package_dir.mkdir()
         # Package __init__.py
         package_init = self.package_dir / "__init__.py"
 
@@ -303,7 +301,7 @@ def _get_project_for_url_or_path(
     )
 
 
-def create_new_client(
+def generate(
     *,
     config: Config,
     custom_template_path: Optional[Path] = None,
@@ -323,26 +321,6 @@ def create_new_client(
     return project.build()
 
 
-def update_existing_client(
-    *,
-    config: Config,
-    custom_template_path: Optional[Path] = None,
-) -> Sequence[GeneratorError]:
-    """
-    Update an existing client library
-
-    Returns:
-         A list containing any errors encountered when generating.
-    """
-    project = _get_project_for_url_or_path(
-        custom_template_path=custom_template_path,
-        config=config,
-    )
-    if isinstance(project, GeneratorError):
-        return [project]
-    return project.update()
-
-
 def _load_yaml_or_json(data: bytes, content_type: Optional[str]) -> Union[Dict[str, Any], GeneratorError]:
     if content_type == "application/json":
         try:

{openapi_python_client-0.20.0 → openapi_python_client-0.21.1}/openapi_python_client/cli.py

@@ -21,7 +21,14 @@ def _version_callback(value: bool) -> None:
 
 
 def _process_config(
-    *, url: Optional[str], path: Optional[Path], config_path: Optional[Path], meta_type: MetaType, file_encoding: str
+    *,
+    url: Optional[str],
+    path: Optional[Path],
+    config_path: Optional[Path],
+    meta_type: MetaType,
+    file_encoding: str,
+    overwrite: bool,
+    output_path: Optional[Path],
 ) -> Config:
     source: Union[Path, str]
     if url and not path:
@@ -49,7 +56,7 @@ def _process_config(
         except Exception as err:
             raise typer.BadParameter("Unable to parse config") from err
 
-    return Config.from_sources(config_file, meta_type, source, file_encoding)
+    return Config.from_sources(config_file, meta_type, source, file_encoding, overwrite, output_path=output_path)
 
 
 # noinspection PyUnusedLocal
@@ -117,62 +124,46 @@ def handle_errors(errors: Sequence[GeneratorError], fail_on_warning: bool = Fals
         raise typer.Exit(code=1)
 
 
-custom_template_path_options = {
-    "help": "A path to a directory containing custom template(s)",
-    "file_okay": False,
-    "dir_okay": True,
-    "readable": True,
-    "resolve_path": True,
-}
-
-_meta_option = typer.Option(
-    MetaType.POETRY,
-    help="The type of metadata you want to generate.",
-)
-
-CONFIG_OPTION = typer.Option(None, "--config", help="Path to the config file to use")
-
-
 @app.command()
 def generate(
-    url: Optional[str] = typer.Option(None, help="A URL to read the JSON from"),
-    path: Optional[Path] = typer.Option(None, help="A path to the JSON file"),
-    custom_template_path: Optional[Path] = typer.Option(None, **custom_template_path_options),  # type: ignore
-    meta: MetaType = _meta_option,
+    url: Optional[str] = typer.Option(None, help="A URL to read the OpenAPI document from"),
+    path: Optional[Path] = typer.Option(None, help="A path to the OpenAPI document"),
+    custom_template_path: Optional[Path] = typer.Option(
+        None,
+        help="A path to a directory containing custom template(s)",
+        file_okay=False,
+        dir_okay=True,
+        readable=True,
+        resolve_path=True,
+    ),  # type: ignore
+    meta: MetaType = typer.Option(
+        MetaType.POETRY,
+        help="The type of metadata you want to generate.",
+    ),
     file_encoding: str = typer.Option("utf-8", help="Encoding used when writing generated"),
-    config_path: Optional[Path] = CONFIG_OPTION,
+    config_path: Optional[Path] = typer.Option(None, "--config", help="Path to the config file to use"),
     fail_on_warning: bool = False,
+    overwrite: bool = typer.Option(False, help="Overwrite the existing client if it exists"),
+    output_path: Optional[Path] = typer.Option(
+        None,
+        help="Path to write the generated code to. "
+        "Defaults to the OpenAPI document title converted to kebab or snake case (depending on meta type). "
+        "Can also be overridden with `project_name_override` or `package_name_override` in config.",
+    ),
 ) -> None:
     """Generate a new OpenAPI Client library"""
-    from . import create_new_client
-
-    config = _process_config(url=url, path=path, config_path=config_path, meta_type=meta, file_encoding=file_encoding)
-    errors = create_new_client(
-        custom_template_path=custom_template_path,
-        config=config,
+    from . import generate
+
+    config = _process_config(
+        url=url,
+        path=path,
+        config_path=config_path,
+        meta_type=meta,
+        file_encoding=file_encoding,
+        overwrite=overwrite,
+        output_path=output_path,
     )
-    handle_errors(errors, fail_on_warning)
-
-
-@app.command()
-def update(
-    url: Optional[str] = typer.Option(None, help="A URL to read the JSON from"),
-    path: Optional[Path] = typer.Option(None, help="A path to the JSON file"),
-    custom_template_path: Optional[Path] = typer.Option(None, **custom_template_path_options),  # type: ignore
-    meta: MetaType = _meta_option,
-    file_encoding: str = typer.Option("utf-8", help="Encoding used when writing generated"),
-    config_path: Optional[Path] = CONFIG_OPTION,
-    fail_on_warning: bool = False,
-) -> None:
-    """Update an existing OpenAPI Client library
-
-    The update command performs the same operations as generate except it does not overwrite specific metadata for the
-    generated client such as the README.md, .gitignore, and pyproject.toml.
-    """
-    from . import update_existing_client
-
-    config = _process_config(config_path=config_path, meta_type=meta, url=url, path=path, file_encoding=file_encoding)
-    errors = update_existing_client(
+    errors = generate(
         custom_template_path=custom_template_path,
         config=config,
     )

{openapi_python_client-0.20.0 → openapi_python_client-0.21.1}/openapi_python_client/config.py

@@ -73,10 +73,17 @@ class Config:
     document_source: Union[Path, str]
     file_encoding: str
     content_type_overrides: Dict[str, str]
+    overwrite: bool
+    output_path: Optional[Path]
 
     @staticmethod
     def from_sources(
-        config_file: ConfigFile, meta_type: MetaType, document_source: Union[Path, str], file_encoding: str
+        config_file: ConfigFile,
+        meta_type: MetaType,
+        document_source: Union[Path, str],
+        file_encoding: str,
+        overwrite: bool,
+        output_path: Optional[Path],
     ) -> "Config":
         if config_file.post_hooks is not None:
             post_hooks = config_file.post_hooks
@@ -104,5 +111,7 @@ class Config:
             http_timeout=config_file.http_timeout,
             document_source=document_source,
             file_encoding=file_encoding,
+            overwrite=overwrite,
+            output_path=output_path,
         )
         return config

{openapi_python_client-0.20.0 → openapi_python_client-0.21.1}/openapi_python_client/parser/bodies.py

@@ -1,5 +1,5 @@
 import sys
-from typing import List, Tuple, Union
+from typing import Dict, List, Tuple, Union
 
 import attr
 
@@ -44,15 +44,19 @@ def body_from_data(
     *,
     data: oai.Operation,
     schemas: Schemas,
+    request_bodies: Dict[str, Union[oai.RequestBody, oai.Reference]],
     config: Config,
     endpoint_name: str,
 ) -> Tuple[List[Union[Body, ParseError]], Schemas]:
     """Adds form or JSON body to Endpoint if included in data"""
-    if data.request_body is None or isinstance(data.request_body, oai.Reference):
+    body = _resolve_reference(data.request_body, request_bodies)
+    if isinstance(body, ParseError):
+        return [body], schemas
+    if body is None:
         return [], schemas
 
     bodies: List[Union[Body, ParseError]] = []
-    body_content = data.request_body.content
+    body_content = body.content
     prefix_type_names = len(body_content) > 1
 
     for content_type, media_type in body_content.items():
@@ -61,7 +65,7 @@ def body_from_data(
             bodies.append(
                 ParseError(
                     detail="Invalid content type",
-                    data=data.request_body,
+                    data=body,
                     level=ErrorLevel.WARNING,
                 )
             )
@@ -71,7 +75,7 @@ def body_from_data(
             bodies.append(
                 ParseError(
                     detail="Missing schema",
-                    data=data.request_body,
+                    data=body,
                     level=ErrorLevel.WARNING,
                 )
             )
@@ -88,7 +92,7 @@ def body_from_data(
             bodies.append(
                 ParseError(
                     detail=f"Unsupported content type {simplified_content_type}",
-                    data=data.request_body,
+                    data=body,
                     level=ErrorLevel.WARNING,
                 )
             )
@@ -123,3 +127,19 @@ def body_from_data(
         )
 
     return bodies, schemas
+
+
+def _resolve_reference(
+    body: Union[oai.RequestBody, oai.Reference, None], request_bodies: Dict[str, Union[oai.RequestBody, oai.Reference]]
+) -> Union[oai.RequestBody, ParseError, None]:
+    if body is None:
+        return None
+    references_seen = []
+    while isinstance(body, oai.Reference) and body.ref not in references_seen:
+        references_seen.append(body.ref)
+        body = request_bodies.get(body.ref.split("/")[-1])
+    if isinstance(body, oai.Reference):
+        return ParseError(detail="Circular $ref in request body", data=body)
+    if body is None and references_seen:
+        return ParseError(detail=f"Could not resolve $ref {references_seen[-1]} in request body")
+    return body

{openapi_python_client-0.20.0 → openapi_python_client-0.21.1}/openapi_python_client/parser/openapi.py

@@ -48,6 +48,7 @@ class EndpointCollection:
         data: Dict[str, oai.PathItem],
         schemas: Schemas,
         parameters: Parameters,
+        request_bodies: Dict[str, Union[oai.RequestBody, oai.Reference]],
         config: Config,
     ) -> Tuple[Dict[utils.PythonIdentifier, "EndpointCollection"], Schemas, Parameters]:
         """Parse the openapi paths data to get EndpointCollections by tag"""
@@ -69,6 +70,7 @@ class EndpointCollection:
                     tag=tag,
                     schemas=schemas,
                     parameters=parameters,
+                    request_bodies=request_bodies,
                     config=config,
                 )
                 # Add `PathItem` parameters
@@ -392,6 +394,7 @@ class Endpoint:
         tag: str,
         schemas: Schemas,
         parameters: Parameters,
+        request_bodies: Dict[str, Union[oai.RequestBody, oai.Reference]],
         config: Config,
     ) -> Tuple[Union["Endpoint", ParseError], Schemas, Parameters]:
         """Construct an endpoint from the OpenAPI data"""
@@ -423,7 +426,9 @@ class Endpoint:
         result, schemas = Endpoint._add_responses(endpoint=result, data=data.responses, schemas=schemas, config=config)
         if isinstance(result, ParseError):
             return result, schemas, parameters
-        bodies, schemas = body_from_data(data=data, schemas=schemas, config=config, endpoint_name=result.name)
+        bodies, schemas = body_from_data(
+            data=data, schemas=schemas, config=config, endpoint_name=result.name, request_bodies=request_bodies
+        )
         body_errors = []
         for body in bodies:
             if isinstance(body, ParseError):
@@ -507,8 +512,9 @@ class GeneratorData:
                 parameters=parameters,
                 config=config,
             )
+        request_bodies = (openapi.components and openapi.components.requestBodies) or {}
         endpoint_collections_by_tag, schemas, parameters = EndpointCollection.from_data(
-            data=openapi.paths, schemas=schemas, parameters=parameters, config=config
+            data=openapi.paths, schemas=schemas, parameters=parameters, request_bodies=request_bodies, config=config
         )
 
         enums = (prop for prop in schemas.classes_by_name.values() if isinstance(prop, EnumProperty))

{openapi_python_client-0.20.0 → openapi_python_client-0.21.1}/openapi_python_client/templates/property_templates/list_property.py.jinja

@@ -60,7 +60,7 @@ if not isinstance({{ source }}, Unset):
 {% else %}
 {{ destination }}: {{ type_string }} = UNSET
 if not isinstance({{ source }}, Unset):
-{{ _transform(property, source, destination, True, "to_dict") | indent(4)}}
+    {{ _transform(property, source, destination, True, "to_dict") | indent(4)}}
 {% endif %}
 {% endmacro %}
 

{openapi_python_client-0.20.0 → openapi_python_client-0.21.1}/pyproject.toml

@@ -3,7 +3,7 @@ authors = [
     { name = "Dylan Anthony", email = "contact@dylananthony.com" },
 ]
 license = { text = "MIT" }
-requires-python = ">=3.8,<4.0"
+requires-python = ">=3.8.1,<4.0"
 dependencies = [
     "jinja2>=3.0.0,<4.0.0",
     "typer>0.6,<0.13",
@@ -18,7 +18,7 @@ dependencies = [
     "typing-extensions>=4.8.0,<5.0.0",
 ]
 name = "openapi-python-client"
-version = "0.20.0"
+version = "0.21.1"
 description = "Generate modern Python clients from OpenAPI"
 keywords = [
     "OpenAPI",
@@ -84,20 +84,19 @@ ignore_missing_imports = true
 [tool.pytest.ini_options]
 junit_family = "xunit2"
 
-
 [tool.pdm.dev-dependencies]
 dev = [
     "pytest",
     "pytest-mock",
     "mypy",
     "taskipy",
-    "safety",
     "pytest-cov",
     "python-multipart",
     "types-PyYAML<7.0.0,>=6.0.3",
     "types-certifi<2021.10.9,>=2020.0.0",
     "types-python-dateutil<3.0.0,>=2.0.0",
     "ruamel-yaml-string>=0.1.1",
+    "syrupy>=4",
 ]
 
 [tool.pdm.build]
@@ -110,9 +109,8 @@ includes = [
 [tool.pdm.scripts]
 lint = "ruff check --fix ."
 format = "ruff format ."
-safety_check = { shell = "pdm export -o requirements.txt && safety check -r requirements.txt --bare && rm requirements.txt" }
 mypy = "mypy openapi_python_client"
-check = { composite = ["lint", "format", "safety_check", "mypy", "test"] }
+check = { composite = ["lint", "format", "mypy", "test"] }
 regen = {composite = ["regen_e2e", "regen_integration"]}
 e2e = "pytest openapi_python_client end_to_end_tests/test_end_to_end.py"
 re = {composite = ["regen_e2e", "e2e"]}