ab-openapi-python-generator 2.1.4__py3-none-any.whl → 2.1.4.dev1768280320__py3-none-any.whl

ab_openapi_python_generator/__init__.py

@@ -1,17 +1,13 @@
-"""Python client from an OPENAPI 3.0+ specification in seconds."""
+"""Alias package to preserve imports when distribution renamed.
 
-try:
-    from importlib.metadata import (
-        PackageNotFoundError,  # type: ignore
-        version,
-    )
-except ImportError:  # pragma: no cover
-    from importlib_metadata import (
-        PackageNotFoundError,  # type: ignore
-        version,  # type: ignore
-    )
+This package re-exports the real package located at
+`openapi_python_generator` so existing imports like
+`import ab_openapi_python_generator` continue to work.
+"""
+from openapi_python_generator import *  # noqa: F401,F403
 
+# Preserve __all__ if present on the real package
 try:
-    __version__ = version(__name__)
-except PackageNotFoundError:  # pragma: no cover
-    __version__ = "unknown"
+    __all__ = getattr(__import__("openapi_python_generator"), "__all__")
+except Exception:
+    __all__ = []

{ab_openapi_python_generator-2.1.4.dist-info → ab_openapi_python_generator-2.1.4.dev1768280320.dist-info}/METADATA

@@ -1,27 +1,32 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: ab-openapi-python-generator
-Version: 2.1.4
+Version: 2.1.4.dev1768280320
 Summary: Openapi Python Generator
-Project-URL: Homepage, https://github.com/auth-broker/openapi-python-generator
-Project-URL: Repository, https://github.com/auth-broker/openapi-python-generator
-Project-URL: Documentation, https://openapi-python-generator.readthedocs.io
-Project-URL: Changelog, https://github.com/auth-broker/openapi-python-generator/releases
-Author-email: Marco Müllner <muellnermarco@gmail.com>, Matt Coulter <mattcoul7@gmail.com>
-License-Expression: MIT
-License-File: LICENSE
-Keywords: Generator,OpenAPI,Python,async
+Home-page: https://github.com/auth-broker/openapi-python-generator
+License: MIT
+Keywords: OpenAPI,Generator,Python,async
+Author: Marco Müllner
+Author-email: muellnermarco@gmail.com
+Requires-Python: >=3.9,<4.0
 Classifier: Development Status :: 3 - Alpha
-Requires-Python: <4,>=3.9
-Requires-Dist: black>=21.10b0
-Requires-Dist: click<9,>=8.1.3
-Requires-Dist: httpx[all]<0.29,>=0.28.0
-Requires-Dist: importlib-metadata<9,>=8.7.0
-Requires-Dist: isort>=5.10.1
-Requires-Dist: jinja2<4,>=3.1.2
-Requires-Dist: openapi-pydantic<0.6,>=0.5.1
-Requires-Dist: orjson<4,>=3.9.15
-Requires-Dist: pydantic<3,>=2.10.2
-Requires-Dist: pyyaml<7,>=6.0.2
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Dist: Jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: black (>=21.10b0)
+Requires-Dist: click (>=8.1.3,<9.0.0)
+Requires-Dist: httpx[all] (>=0.28.0,<0.29.0)
+Requires-Dist: importlib-metadata (>=8.7.0,<9.0.0)
+Requires-Dist: isort (>=5.10.1)
+Requires-Dist: openapi-pydantic (>=0.5.1,<0.6.0)
+Requires-Dist: orjson (>=3.9.15,<4.0.0)
+Requires-Dist: pydantic (>=2.10.2,<3.0.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Project-URL: Changelog, https://github.com/auth-broker/openapi-python-generator/releases
+Project-URL: Documentation, https://openapi-python-generator.readthedocs.io
+Project-URL: Repository, https://github.com/auth-broker/openapi-python-generator
 Description-Content-Type: text/markdown
 
 # Openapi Python Generator
@@ -123,3 +128,4 @@ This project was generated from [@cjolowicz]'s [Hypermodern Python Cookiecutter]
 [license]: https://github.com/MarcoMuellner/openapi-python-generator/blob/main/LICENSE
 [contributor guide]: https://github.com/MarcoMuellner/openapi-python-generator/blob/main/CONTRIBUTING.md
 [Quick start page]: https://marcomuellner.github.io/openapi-python-generator/quick_start/
+

ab_openapi_python_generator-2.1.4.dev1768280320.dist-info/RECORD

@@ -0,0 +1,6 @@
+ab_openapi_python_generator/__init__.py,sha256=E3Rg8oVmW0_-8KPCxfvgdo8n6w205qFYfUyrgnjilVc,450
+ab_openapi_python_generator-2.1.4.dev1768280320.dist-info/LICENSE,sha256=0myanGwJ2vUOZN12aN95o0My6XEysnnVlbKikYw3pHg,1070
+ab_openapi_python_generator-2.1.4.dev1768280320.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+ab_openapi_python_generator-2.1.4.dev1768280320.dist-info/entry_points.txt,sha256=hqE8T8yX5Pkeb2g__7yQrEazkBPwNgTbEHmoOkaYh80,83
+ab_openapi_python_generator-2.1.4.dev1768280320.dist-info/METADATA,sha256=7yWKoxTDuK7aoN18VpfxM6w0-1411GpUuEhBlYZe0Dc,5437
+ab_openapi_python_generator-2.1.4.dev1768280320.dist-info/RECORD,,

{ab_openapi_python_generator-2.1.4.dist-info → ab_openapi_python_generator-2.1.4.dev1768280320.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.28.0
+Generator: poetry-core 1.4.0
 Root-Is-Purelib: true
 Tag: py3-none-any

ab_openapi_python_generator-2.1.4.dev1768280320.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+openapi-python-generator=openapi_python_generator.__main__:main
+

ab_openapi_python_generator/__main__.py

@@ -1,85 +0,0 @@
-from typing import Optional
-
-import click
-
-from ab_openapi_python_generator import __version__
-from ab_openapi_python_generator.common import Formatter, HTTPLibrary, PydanticVersion
-from ab_openapi_python_generator.generate_data import generate_data
-
-
-@click.command()
-@click.argument("source")
-@click.argument("output")
-@click.option(
-    "--library",
-    default=HTTPLibrary.httpx,
-    type=HTTPLibrary,
-    show_default=True,
-    help="HTTP library to use in the generation of the client.",
-)
-@click.option(
-    "--env-token-name",
-    default=None,
-    show_default=True,
-    help="Name of the environment variable that contains the token. If you set this, the code expects this environment "
-    "variable to be set and will raise an error if it is not.",
-)
-@click.option(
-    "--use-orjson",
-    is_flag=True,
-    show_default=True,
-    default=False,
-    help="Use the orjson library to serialize the data. This is faster than the default json library and provides "
-    "serialization of datetimes and other types that are not supported by the default json library.",
-)
-@click.option(
-    "--custom-template-path",
-    type=str,
-    default=None,
-    help="Custom template path to use. Allows overriding of the built in templates",
-)
-@click.option(
-    "--pydantic-version",
-    type=click.Choice(["v1", "v2"]),
-    default="v2",
-    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,
-    output: str,
-    library: Optional[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.
-
-    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 if library is not None else HTTPLibrary.httpx,
-        env_token_name,
-        use_orjson,
-        custom_template_path,
-        pydantic_version,
-        formatter,
-    )
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

ab_openapi_python_generator/common.py

@@ -1,58 +0,0 @@
-from enum import Enum
-from typing import Dict, Optional
-
-from ab_openapi_python_generator.models import LibraryConfig
-
-
-class HTTPLibrary(str, Enum):
-    """
-    Enum for the available HTTP libraries.
-    """
-
-    httpx = "httpx"
-    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",
-        library_name="httpx",
-        template_name="httpx.jinja2",
-        include_async=True,
-        include_sync=True,
-    ),
-    HTTPLibrary.requests: LibraryConfig(
-        name="requests",
-        library_name="requests",
-        template_name="requests.jinja2",
-        include_async=False,
-        include_sync=True,
-    ),
-    HTTPLibrary.aiohttp: LibraryConfig(
-        name="aiohttp",
-        library_name="aiohttp",
-        template_name="aiohttp.jinja2",
-        include_async=True,
-        include_sync=False,
-    ),
-}

ab_openapi_python_generator/generate_data.py

@@ -1,235 +0,0 @@
-from pathlib import Path
-from typing import List, Optional, Union
-
-import black
-import click
-import httpx
-import isort
-import orjson
-import yaml  # type: ignore
-from black.report import NothingChanged  # type: ignore
-from httpx import ConnectError, ConnectTimeout
-from pydantic import ValidationError
-
-from .common import FormatOptions, Formatter, HTTPLibrary, PydanticVersion
-from .language_converters.python.jinja_config import SERVICE_TEMPLATE, create_jinja_env
-from .models import ConversionResult
-from .parsers import (
-    generate_code_3_0,
-    generate_code_3_1,
-    parse_openapi_3_0,
-    parse_openapi_3_1,
-)
-from .version_detector import detect_openapi_version
-
-
-def write_code(path: Path, content: str, formatter: Formatter) -> None:
-    """
-    Write the content to the file at the given path.
-    :param path: The path to the file.
-    :param content: The content to write.
-    :param formatter: The formatter applied to the code written.
-    """
-    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)
-
-
-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]):
-    """
-    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:
-        tuple: (OpenAPI object, version) where version is "3.0" or "3.1"
-
-    Raises:
-        FileNotFoundError: If the specified file cannot be found
-        ConnectError: If the URL cannot be accessed
-        ValidationError: If the specification is invalid
-        JSONDecodeError/YAMLError: If the file cannot be parsed
-    """
-    try:
-        # Handle remote files
-        if not isinstance(source, Path) and (
-            source.startswith("http://") or source.startswith("https://")
-        ):
-            content = httpx.get(source).text
-            # Try JSON first, then YAML for remote files
-            try:
-                data = orjson.loads(content)
-            except orjson.JSONDecodeError:
-                data = yaml.safe_load(content)
-        else:
-            # Handle local files
-            with open(source, "r") as f:
-                file_content = f.read()
-
-                # Try JSON first
-                try:
-                    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(
-            f"File {source} not found. Please make sure to pass the path to the OpenAPI specification."
-        )
-        raise
-    except (ConnectError, ConnectTimeout):
-        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.")
-        raise
-
-
-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
-    into the services sub module of the output folder.
-    :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.
-    Path(output).mkdir(parents=True, exist_ok=True)
-
-    # Create the models module.
-    models_path = Path(output) / "models"
-    models_path.mkdir(parents=True, exist_ok=True)
-
-    # Create the services module.
-    services_path = Path(output) / "services"
-    services_path.mkdir(parents=True, exist_ok=True)
-
-    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, 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 = []
-
-    # Write the services.
-    jinja_env = create_jinja_env()
-    for service in data.services:
-        if len(service.operations) == 0:
-            continue
-        files.append(service.file_name)
-        write_code(
-            services_path / f"{service.file_name}.py",
-            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", "", formatter)
-
-    # Write the api_config.py file.
-    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: 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.
-    """
-    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, formatter)

ab_openapi_python_generator/language_converters/python/api_config_generator.py

@@ -1,35 +0,0 @@
-from typing import Optional
-
-from openapi_pydantic.v3 import OpenAPI
-
-from ab_openapi_python_generator.common import PydanticVersion
-from ab_openapi_python_generator.language_converters.python.jinja_config import (
-    API_CONFIG_TEMPLATE,
-    API_CONFIG_TEMPLATE_PYDANTIC_V2,
-    create_jinja_env,
-)
-from ab_openapi_python_generator.models import APIConfig
-
-
-def generate_api_config(
-    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
-    )
-    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.model_dump()
-        ),
-        base_url=data.servers[0].url if len(data.servers) > 0 else "NO SERVER",
-    )

ab_openapi_python_generator/language_converters/python/common.py

@@ -1,58 +0,0 @@
-import keyword
-import re
-from typing import Optional
-
-_use_orjson: bool = False
-_custom_template_path: Optional[str] = None
-_symbol_ascii_strip_re = re.compile(r"[^A-Za-z0-9_]")
-
-
-def set_use_orjson(value: bool) -> None:
-    """
-    Set the value of the global variable _use_orjson.
-    :param value: value of the variable
-    """
-    global _use_orjson
-    _use_orjson = value
-
-
-def get_use_orjson() -> bool:
-    """
-    Get the value of the global variable _use_orjson.
-    :return: value of the variable
-    """
-    global _use_orjson
-    return _use_orjson
-
-
-def set_custom_template_path(value: Optional[str]) -> None:
-    """
-    Set the value of the global variable _custom_template_path.
-    :param value: value of the variable
-    """
-    global _custom_template_path
-    _custom_template_path = value
-
-
-def get_custom_template_path() -> Optional[str]:
-    """
-    Get the value of the global variable _custom_template_path.
-    :return: value of the variable
-    """
-    global _custom_template_path
-    return _custom_template_path
-
-
-def normalize_symbol(symbol: str) -> str:
-    """
-    Remove invalid characters & keywords in Python symbol names
-    :param symbol: name of the identifier
-    :return: normalized identifier name
-    """
-    symbol = symbol.replace("-", "_").replace(" ", "_")
-    normalized_symbol = _symbol_ascii_strip_re.sub("", symbol)
-    if normalized_symbol in keyword.kwlist:
-        normalized_symbol = normalized_symbol + "_"
-    if len(normalized_symbol) > 0 and normalized_symbol[0].isnumeric():
-        normalized_symbol = "_" + normalized_symbol
-    return normalized_symbol

ab_openapi_python_generator/language_converters/python/generator.py

@@ -1,54 +0,0 @@
-from typing import Optional, Union
-
-from openapi_pydantic.v3.v3_0 import OpenAPI as OpenAPI30
-from openapi_pydantic.v3.v3_1 import OpenAPI as OpenAPI31
-
-from ab_openapi_python_generator.common import PydanticVersion
-from ab_openapi_python_generator.language_converters.python import common
-from ab_openapi_python_generator.language_converters.python.api_config_generator import (
-    generate_api_config,
-)
-from ab_openapi_python_generator.language_converters.python.model_generator import (
-    generate_models,
-)
-from ab_openapi_python_generator.language_converters.python.service_generator import (
-    generate_services,
-)
-from ab_openapi_python_generator.models import ConversionResult, LibraryConfig
-
-# Type alias for both OpenAPI versions
-OpenAPISpec = Union[OpenAPI30, OpenAPI31]
-
-
-def generator(
-    data: OpenAPISpec,
-    library_config: LibraryConfig,
-    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 an OpenAPI 3.0+ specification.
-    """
-
-    common.set_use_orjson(use_orjson)
-    common.set_custom_template_path(custom_template_path)
-
-    if data.components is not None:
-        models = generate_models(data.components, pydantic_version)
-    else:
-        models = []
-
-    if data.paths is not None:
-        services = generate_services(data.paths, library_config)
-    else:
-        services = []
-
-    api_config = generate_api_config(data, env_token_name, pydantic_version)
-
-    return ConversionResult(
-        models=models,
-        services=services,
-        api_config=api_config,
-    )

ab_openapi_python_generator/language_converters/python/jinja_config.py

@@ -1,38 +0,0 @@
-from pathlib import Path
-
-from jinja2 import ChoiceLoader, Environment, FileSystemLoader
-
-from . import common
-
-ENUM_TEMPLATE = "enum.jinja2"
-MODELS_TEMPLATE = "models.jinja2"
-MODELS_TEMPLATE_PYDANTIC_V2 = "models_pydantic_2.jinja2"
-SERVICE_TEMPLATE = "service.jinja2"
-HTTPX_TEMPLATE = "httpx.jinja2"
-API_CONFIG_TEMPLATE = "apiconfig.jinja2"
-API_CONFIG_TEMPLATE_PYDANTIC_V2 = "apiconfig_pydantic_2.jinja2"
-ALIAS_UNION_TEMPLATE = "alias_union.jinja2"
-DISCRIMINATOR_ENUM_TEMPLATE = "discriminator_enum.jinja2"
-TEMPLATE_PATH = Path(__file__).parent / "templates"
-
-
-def create_jinja_env():
-    custom_template_path = common.get_custom_template_path()
-    environment = Environment(
-        loader=(
-            ChoiceLoader(
-                [
-                    FileSystemLoader(custom_template_path),
-                    FileSystemLoader(TEMPLATE_PATH),
-                ]
-            )
-            if custom_template_path is not None
-            else FileSystemLoader(TEMPLATE_PATH)
-        ),
-        autoescape=True,
-        trim_blocks=True,
-    )
-
-    environment.filters["normalize_symbol"] = common.normalize_symbol
-
-    return environment