feat: add OpenAPI 3.1 support (version detection, parsers, unified generate_data)

Author: Doug Borg

src/openapi_python_generator/__main__.py

@@ -6,6 +6,7 @@
 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")
@@ -63,15 +64,22 @@ def main(
     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, formatter
+        source,
+        output,
+        library,
+        env_token_name,
+        use_orjson,
+        custom_template_path,
+        pydantic_version,
+        formatter,
     )
 
 
 if __name__ == "__main__":  # pragma: no cover
-    main()
+    main()

src/openapi_python_generator/generate_data.py

@@ -4,23 +4,27 @@
 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 FormatOptions, Formatter, HTTPLibrary, PydanticVersion
-from .common import library_config_dict
-from .language_converters.python.generator import generator
 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_30,
+    parse_openapi_31,
+    generate_code_30,
+    generate_code_31,
+)
 
 
 def write_code(path: Path, content: str, formatter: Formatter) -> None:
@@ -35,31 +39,36 @@ def write_code(path: Path, content: str, formatter: Formatter) -> None:
     elif formatter == Formatter.NONE:
         formatted_contend = content
     else:
-        raise NotImplementedError(f"Missing implementation for formatter {formatter!r}.")
+        raise NotImplementedError(
+            f"Missing implementation for formatter {formatter!r}."
+        )
     with open(path, "w") as f:
         f.write(formatted_contend)
 
 
 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)
+            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
@@ -70,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))
-
-        # Handle local files
-        with open(source, "r") as f:
-            file_content = f.read()
+                data = yaml.safe_load(content)
+        else:
+            # 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_30(data)  # type: ignore[assignment]
+        elif version == "3.1":
+            openapi_obj = parse_openapi_31(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(
@@ -105,13 +129,13 @@ 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], formatter: Formatter) -> None:
+def write_data(
+    data: ConversionResult, output: Union[str, Path], formatter: Formatter
+) -> None:
     """
     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
@@ -156,7 +180,7 @@ def write_data(data: ConversionResult, output: Union[str, Path], formatter: Form
         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,
         )
 
@@ -177,26 +201,39 @@ def write_data(data: ConversionResult, output: Union[str, Path], formatter: Form
 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_30(
+            openapi_obj,  # type: ignore
+            library,
+            env_token_name,
+            use_orjson,
+            custom_template_path,
+            pydantic_version,
+        )
+    elif version == "3.1":
+        result = generate_code_31(
+            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, formatter)

src/openapi_python_generator/parsers/__init__.py

@@ -0,0 +1,13 @@
+"""
+OpenAPI parsers for different specification versions.
+"""
+
+from .openapi_30 import parse_openapi_30, generate_code_30
+from .openapi_31 import parse_openapi_31, generate_code_31
+
+__all__ = [
+    "parse_openapi_30",
+    "generate_code_30",
+    "parse_openapi_31",
+    "generate_code_31",
+]

src/openapi_python_generator/parsers/openapi_30.py

@@ -0,0 +1,65 @@
+"""
+OpenAPI 3.0 specific parsing and generation.
+"""
+
+from typing import Optional
+
+from openapi_pydantic.v3.v3_0 import OpenAPI
+
+from openapi_python_generator.common import HTTPLibrary, PydanticVersion
+from openapi_python_generator.language_converters.python.generator import (
+    generator as base_generator,
+)
+from openapi_python_generator.models import ConversionResult
+
+
+def parse_openapi_30(spec_data: dict) -> OpenAPI:
+    """
+    Parse OpenAPI 3.0 specification data.
+
+    Args:
+        spec_data: Dictionary containing OpenAPI 3.0 specification
+
+    Returns:
+        OpenAPI: Parsed OpenAPI 3.0 specification object
+
+    Raises:
+        ValidationError: If the specification is invalid
+    """
+    return OpenAPI(**spec_data)
+
+
+def generate_code_30(
+    data: OpenAPI,
+    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,
+) -> ConversionResult:
+    """
+    Generate Python code from OpenAPI 3.0 specification.
+
+    Args:
+        data: OpenAPI 3.0 specification object
+        library: HTTP library to use
+        env_token_name: Environment variable name for token
+        use_orjson: Whether to use orjson for serialization
+        custom_template_path: Custom template path
+        pydantic_version: Pydantic version to use
+
+    Returns:
+        ConversionResult: Generated code and metadata
+    """
+    from openapi_python_generator.common import library_config_dict
+
+    library_config = library_config_dict[library]
+
+    return base_generator(
+        data=data,
+        library_config=library_config,
+        env_token_name=env_token_name,
+        use_orjson=use_orjson,
+        custom_template_path=custom_template_path,
+        pydantic_version=pydantic_version,
+    )