openapi-python-generator 1.1.2.dev1734089718__py3-none-any.whl → 1.2.1.dev1757310194__py3-none-any.whl

openapi_python_generator/__init__.py

@@ -1,4 +1,5 @@
-"""Python client from an OPENAPI 3.0 specification in seconds."""
+"""Python client from an OPENAPI 3.0+ specification in seconds."""
+
 try:
     from importlib.metadata import PackageNotFoundError  # type: ignore
     from importlib.metadata import version

openapi_python_generator/__main__.py

@@ -1,12 +1,12 @@
 from typing import Optional
-from enum import Enum
 
 import click
 
 from openapi_python_generator import __version__
-from openapi_python_generator.common import HTTPLibrary, PydanticVersion
+from openapi_python_generator.common import Formatter, HTTPLibrary, PydanticVersion
 from openapi_python_generator.generate_data import generate_data
 
+
 @click.command()
 @click.argument("source")
 @click.argument("output")
@@ -45,6 +45,13 @@ from openapi_python_generator.generate_data import generate_data
     show_default=True,
     help="Pydantic version to use for generated models.",
 )
+@click.option(
+    "--formatter",
+    type=click.Choice(["black", "none"]),
+    default="black",
+    show_default=True,
+    help="Option to choose which auto formatter is applied.",
+)
 @click.version_option(version=__version__)
 def main(
     source: str,
@@ -54,17 +61,25 @@ def main(
     use_orjson: bool = False,
     custom_template_path: Optional[str] = None,
     pydantic_version: PydanticVersion = PydanticVersion.V2,
+    formatter: Formatter = Formatter.BLACK,
 ) -> None:
     """
-    Generate Python code from an OpenAPI 3.0 specification.
+    Generate Python code from an OpenAPI 3.0+ specification.
 
-    Provide a SOURCE (file or URL) containing the OpenAPI 3 specification and
+    Provide a SOURCE (file or URL) containing the OpenAPI 3.0+ specification and
     an OUTPUT path, where the resulting client is created.
     """
     generate_data(
-        source, output, library, env_token_name, use_orjson, custom_template_path,pydantic_version
+        source,
+        output,
+        library,
+        env_token_name,
+        use_orjson,
+        custom_template_path,
+        pydantic_version,
+        formatter,
     )
 
 
 if __name__ == "__main__":  # pragma: no cover
-    main()
+    main()

openapi_python_generator/common.py

@@ -14,11 +14,26 @@ class HTTPLibrary(str, Enum):
     requests = "requests"
     aiohttp = "aiohttp"
 
+
 class PydanticVersion(str, Enum):
     V1 = "v1"
     V2 = "v2"
 
 
+class Formatter(str, Enum):
+    """
+    Enum for the available code formatters.
+    """
+
+    BLACK = "black"
+    NONE = "none"
+
+
+class FormatOptions:
+    skip_validation: bool = False
+    line_length: int = 120
+
+
 library_config_dict: Dict[Optional[HTTPLibrary], LibraryConfig] = {
     HTTPLibrary.httpx: LibraryConfig(
         name="httpx",

openapi_python_generator/generate_data.py

@@ -1,59 +1,74 @@
 from pathlib import Path
+from typing import List
 from typing import Optional
 from typing import Union
 
 import black
+from black.report import NothingChanged  # type: ignore
 import click
 import httpx
 import isort
 import orjson
-import yaml
-from black import NothingChanged
+import yaml  # type: ignore
 from httpx import ConnectError
 from httpx import ConnectTimeout
-from openapi_pydantic.v3.v3_0 import OpenAPI
 from pydantic import ValidationError
 
-from .common import HTTPLibrary, PydanticVersion
-from .common import library_config_dict
-from .language_converters.python.generator import generator
+from .common import FormatOptions, Formatter, HTTPLibrary, PydanticVersion
 from .language_converters.python.jinja_config import SERVICE_TEMPLATE
 from .language_converters.python.jinja_config import create_jinja_env
 from .models import ConversionResult
+from .version_detector import detect_openapi_version
+from .parsers import (
+    parse_openapi_3_0,
+    parse_openapi_3_1,
+    generate_code_3_0,
+    generate_code_3_1,
+)
 
 
-def write_code(path: Path, content) -> None:
+def write_code(path: Path, content: str, formatter: Formatter) -> 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.
+    :param formatter: The formatter applied to the code written.
     """
-    try:
-        with open(path, "w") as f:
-            try:
-                formatted_contend = black.format_file_contents(
-                    content, fast=False, mode=black.FileMode(line_length=120)
-                )
+    if formatter == Formatter.BLACK:
+        formatted_contend = format_using_black(content)
+    elif formatter == Formatter.NONE:
+        formatted_contend = content
+    else:
+        raise NotImplementedError(
+            f"Missing implementation for formatter {formatter!r}."
+        )
+    with open(path, "w") as f:
+        f.write(formatted_contend)
+
 
-            except NothingChanged:
-                formatted_contend = content
-            formatted_contend = isort.code(formatted_contend, line_length=120)
-            f.write(formatted_contend)
-    except Exception as e:
-        raise e
+def format_using_black(content: str) -> str:
+    try:
+        formatted_contend = black.format_file_contents(
+            content,
+            fast=FormatOptions.skip_validation,
+            mode=black.FileMode(line_length=FormatOptions.line_length),
+        )
+    except NothingChanged:
+        return content
+    return isort.code(formatted_contend, line_length=FormatOptions.line_length)
 
 
-def get_open_api(source: Union[str, Path]) -> OpenAPI:
+def get_open_api(source: Union[str, Path]):
     """
     Tries to fetch the openapi specification file from the web or load from a local file.
     Supports both JSON and YAML formats. Returns the according OpenAPI object.
+    Automatically supports OpenAPI 3.0 and 3.1 specifications with intelligent version detection.
 
     Args:
         source: URL or file path to the OpenAPI specification
 
     Returns:
-        OpenAPI: Parsed OpenAPI specification object
+        tuple: (OpenAPI object, version) where version is "3.0" or "3.1"
 
     Raises:
         FileNotFoundError: If the specified file cannot be found
@@ -64,31 +79,46 @@ def get_open_api(source: Union[str, Path]) -> OpenAPI:
     try:
         # Handle remote files
         if not isinstance(source, Path) and (
-                source.startswith("http://") or source.startswith("https://")
+            source.startswith("http://") or source.startswith("https://")
         ):
             content = httpx.get(source).text
             # Try JSON first, then YAML for remote files
             try:
-                return OpenAPI(**orjson.loads(content))
+                data = orjson.loads(content)
             except orjson.JSONDecodeError:
-                return OpenAPI(**yaml.safe_load(content))
+                data = yaml.safe_load(content)
+        else:
+            # Handle local files
+            with open(source, "r") as f:
+                file_content = f.read()
 
-        # Handle local files
-        with open(source, "r") as f:
-            file_content = f.read()
-
-            # Try JSON first
-            try:
-                return OpenAPI(**orjson.loads(file_content))
-            except orjson.JSONDecodeError:
-                # If JSON fails, try YAML
+                # Try JSON first
                 try:
-                    return OpenAPI(**yaml.safe_load(file_content))
-                except yaml.YAMLError as e:
-                    click.echo(
-                        f"File {source} is neither a valid JSON nor YAML file: {str(e)}"
-                    )
-                    raise
+                    data = orjson.loads(file_content)
+                except orjson.JSONDecodeError:
+                    # If JSON fails, try YAML
+                    try:
+                        data = yaml.safe_load(file_content)
+                    except yaml.YAMLError as e:
+                        click.echo(
+                            f"File {source} is neither a valid JSON nor YAML file: {str(e)}"
+                        )
+                        raise
+
+        # Detect version and parse with appropriate parser
+        version = detect_openapi_version(data)
+
+        if version == "3.0":
+            openapi_obj = parse_openapi_3_0(data)  # type: ignore[assignment]
+        elif version == "3.1":
+            openapi_obj = parse_openapi_3_1(data)  # type: ignore[assignment]
+        else:
+            # Unsupported version detected (version detection already limited to 3.0 / 3.1)
+            raise ValueError(
+                f"Unsupported OpenAPI version: {version}. Only 3.0.x and 3.1.x are supported."
+            )
+
+        return openapi_obj, version
 
     except FileNotFoundError:
         click.echo(
@@ -99,20 +129,20 @@ def get_open_api(source: Union[str, Path]) -> OpenAPI:
         click.echo(f"Could not connect to {source}.")
         raise ConnectError(f"Could not connect to {source}.") from None
     except ValidationError:
-        click.echo(
-            f"File {source} is not a valid OpenAPI 3.0 specification."
-        )
+        click.echo(f"File {source} is not a valid OpenAPI 3.0+ specification.")
         raise
 
 
-def write_data(data: ConversionResult, output: Union[str, Path]) -> None:
+def write_data(
+    data: ConversionResult, output: Union[str, Path], formatter: Formatter
+) -> None:
     """
-    This function will firstly create the folderstrucutre of output, if it doesn't exist. Then it will create the
+    This function will firstly create the folder structure 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.
+    :param formatter: The formatter applied to the code written.
     """
 
     # Create the folder structure of the output folder.
@@ -126,17 +156,18 @@ def write_data(data: ConversionResult, output: Union[str, Path]) -> None:
     services_path = Path(output) / "services"
     services_path.mkdir(parents=True, exist_ok=True)
 
-    files = []
+    files: List[str] = []
 
     # 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, formatter)
 
     # 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]),
+        formatter,
     )
 
     files = []
@@ -149,44 +180,60 @@ def write_data(data: ConversionResult, output: Union[str, Path]) -> None:
         files.append(service.file_name)
         write_code(
             services_path / f"{service.file_name}.py",
-            jinja_env.get_template(SERVICE_TEMPLATE).render(**service.dict()),
+            jinja_env.get_template(SERVICE_TEMPLATE).render(**service.model_dump()),
+            formatter,
         )
 
     # Create services.__init__.py file containing imports to all services.
-    write_code(services_path / "__init__.py", "")
+    write_code(services_path / "__init__.py", "", formatter)
 
     # 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, formatter)
 
     # Write the __init__.py file.
     write_code(
         Path(output) / "__init__.py",
         "from .models import *\nfrom .services import *\nfrom .api_config import *",
+        formatter,
     )
 
 
 def generate_data(
     source: Union[str, Path],
     output: Union[str, Path],
-    library: Optional[HTTPLibrary] = HTTPLibrary.httpx,
+    library: HTTPLibrary = HTTPLibrary.httpx,
     env_token_name: Optional[str] = None,
     use_orjson: bool = False,
     custom_template_path: Optional[str] = None,
     pydantic_version: PydanticVersion = PydanticVersion.V2,
+    formatter: Formatter = Formatter.BLACK,
 ) -> None:
     """
-    Generate Python code from an OpenAPI 3.0 specification.
+    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],
-        env_token_name,
-        use_orjson,
-        custom_template_path,
-        pydantic_version,
-    )
+    openapi_obj, version = get_open_api(source)
+    click.echo(f"Generating data from {source} (OpenAPI {version})")
+
+    # Use version-specific generator
+    if version == "3.0":
+        result = generate_code_3_0(
+            openapi_obj,  # type: ignore
+            library,
+            env_token_name,
+            use_orjson,
+            custom_template_path,
+            pydantic_version,
+        )
+    elif version == "3.1":
+        result = generate_code_3_1(
+            openapi_obj,  # type: ignore
+            library,
+            env_token_name,
+            use_orjson,
+            custom_template_path,
+            pydantic_version,
+        )
+    else:
+        raise ValueError(f"Unsupported OpenAPI version: {version}")
 
-    write_data(result, output)
+    write_data(result, output, formatter)

openapi_python_generator/language_converters/python/api_config_generator.py

@@ -1,10 +1,11 @@
 from typing import Optional
 
-from openapi_pydantic.v3.v3_0 import OpenAPI
+from openapi_pydantic.v3 import OpenAPI
 
 from openapi_python_generator.common import PydanticVersion
 from openapi_python_generator.language_converters.python.jinja_config import (
-    API_CONFIG_TEMPLATE, API_CONFIG_TEMPLATE_PYDANTIC_V2,
+    API_CONFIG_TEMPLATE,
+    API_CONFIG_TEMPLATE_PYDANTIC_V2,
 )
 from openapi_python_generator.language_converters.python.jinja_config import (
     create_jinja_env,
@@ -13,19 +14,24 @@ from openapi_python_generator.models import APIConfig
 
 
 def generate_api_config(
-        data: OpenAPI, env_token_name: Optional[str] = None,
-        pydantic_version: PydanticVersion = PydanticVersion.V2,
+    data: OpenAPI,
+    env_token_name: Optional[str] = None,
+    pydantic_version: PydanticVersion = PydanticVersion.V2,
 ) -> APIConfig:
     """
     Generate the API model.
     """
 
-    template_name = API_CONFIG_TEMPLATE_PYDANTIC_V2 if pydantic_version == PydanticVersion.V2 else API_CONFIG_TEMPLATE
+    template_name = (
+        API_CONFIG_TEMPLATE_PYDANTIC_V2
+        if pydantic_version == PydanticVersion.V2
+        else API_CONFIG_TEMPLATE
+    )
     jinja_env = create_jinja_env()
     return APIConfig(
         file_name="api_config",
         content=jinja_env.get_template(template_name).render(
-            env_token_name=env_token_name, **data.dict()
+            env_token_name=env_token_name, **data.model_dump()
         ),
         base_url=data.servers[0].url if len(data.servers) > 0 else "NO SERVER",
     )

openapi_python_generator/language_converters/python/generator.py

@@ -1,6 +1,7 @@
-from typing import Optional
+from typing import Optional, Union
 
-from openapi_pydantic.v3.v3_0 import OpenAPI
+from openapi_pydantic.v3.v3_0 import OpenAPI as OpenAPI30
+from openapi_pydantic.v3.v3_1 import OpenAPI as OpenAPI31
 
 from openapi_python_generator.common import PydanticVersion
 from openapi_python_generator.language_converters.python import common
@@ -16,9 +17,12 @@ from openapi_python_generator.language_converters.python.service_generator impor
 from openapi_python_generator.models import ConversionResult
 from openapi_python_generator.models import LibraryConfig
 
+# Type alias for both OpenAPI versions
+OpenAPISpec = Union[OpenAPI30, OpenAPI31]
+
 
 def generator(
-    data: OpenAPI,
+    data: OpenAPISpec,
     library_config: LibraryConfig,
     env_token_name: Optional[str] = None,
     use_orjson: bool = False,
@@ -26,7 +30,7 @@ def generator(
     pydantic_version: PydanticVersion = PydanticVersion.V2,
 ) -> ConversionResult:
     """
-    Generate Python code from an OpenAPI 3.0 specification.
+    Generate Python code from an OpenAPI 3.0+ specification.
     """
 
     common.set_use_orjson(use_orjson)