pyopenapi-gen 0.17.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

pyopenapi_gen/__init__.py

@@ -50,7 +50,7 @@ __all__ = [
 ]
 
 # Semantic version of the generator core – automatically managed by semantic-release.
-__version__: str = "0.17.0"
+__version__: str = "0.18.0"
 
 # ---------------------------------------------------------------------------
 # Lazy-loading and autocompletion support (This part remains)

pyopenapi_gen/visit/endpoint/generators/endpoint_method_generator.py

@@ -10,6 +10,7 @@ from ....types.strategies import ResponseStrategyResolver
 from ..processors.import_analyzer import EndpointImportAnalyzer
 from ..processors.parameter_processor import EndpointParameterProcessor
 from .docstring_generator import EndpointDocstringGenerator
+from .overload_generator import OverloadMethodGenerator
 from .request_generator import EndpointRequestGenerator
 from .response_handler_generator import EndpointResponseHandlerGenerator
 from .signature_generator import EndpointMethodSignatureGenerator
@@ -34,13 +35,16 @@ class EndpointMethodGenerator:
         self.url_args_generator = EndpointUrlArgsGenerator(self.schemas)
         self.request_generator = EndpointRequestGenerator(self.schemas)
         self.response_handler_generator = EndpointResponseHandlerGenerator(self.schemas)
+        self.overload_generator = OverloadMethodGenerator(self.schemas)
 
     def generate(self, op: IROperation, context: RenderContext) -> str:
         """
         Generate a fully functional async endpoint method for the given operation.
         Returns the method code as a string.
+
+        If the operation has multiple content types, generates @overload signatures
+        followed by the implementation method with runtime dispatch.
         """
-        writer = CodeWriter()
         context.add_import(f"{context.core_package_name}.http_transport", "HttpTransport")
         context.add_import(f"{context.core_package_name}.exceptions", "HTTPError")
 
@@ -51,6 +55,16 @@ class EndpointMethodGenerator:
         # Pass the response strategy to import analyzer for consistent import resolution
         self.import_analyzer.analyze_and_register_imports(op, context, response_strategy)
 
+        # Check if operation has multiple content types
+        if self.overload_generator.has_multiple_content_types(op):
+            return self._generate_overloaded_method(op, context, response_strategy)
+        else:
+            return self._generate_standard_method(op, context, response_strategy)
+
+    def _generate_standard_method(self, op: IROperation, context: RenderContext, response_strategy: Any) -> str:
+        """Generate standard method without overloads."""
+        writer = CodeWriter()
+
         ordered_params, primary_content_type, resolved_body_type = self.parameter_processor.process_parameters(
             op, context
         )
@@ -91,3 +105,111 @@ class EndpointMethodGenerator:
         writer.dedent()  # This matches the indent() from _write_method_signature
 
         return writer.get_code().strip()
+
+    def _generate_overloaded_method(self, op: IROperation, context: RenderContext, response_strategy: Any) -> str:
+        """Generate method with @overload signatures for multiple content types."""
+        parts = []
+
+        # Generate overload signatures
+        overload_sigs = self.overload_generator.generate_overload_signatures(op, context, response_strategy)
+        parts.extend(overload_sigs)
+
+        # Generate implementation method
+        impl_method = self._generate_implementation_method(op, context, response_strategy)
+        parts.append(impl_method)
+
+        # Join with double newlines between overloads and implementation
+        return "\n\n".join(parts)
+
+    def _generate_implementation_method(self, op: IROperation, context: RenderContext, response_strategy: Any) -> str:
+        """Generate the implementation method with runtime dispatch for multiple content types."""
+        # Type narrowing: request_body is guaranteed to exist when this method is called
+        assert (
+            op.request_body is not None
+        ), "request_body should not be None in _generate_implementation_method"  # nosec B101 - Type narrowing for mypy, validated by has_multiple_content_types
+
+        writer = CodeWriter()
+
+        # Generate implementation signature (accepts all content-type parameters as optional)
+        impl_sig = self.overload_generator.generate_implementation_signature(op, context, response_strategy)
+        writer.write_block(impl_sig)
+
+        # Generate docstring
+        ordered_params, primary_content_type, _ = self.parameter_processor.process_parameters(op, context)
+        writer.indent()
+        writer.write_line('"""')
+        writer.write_line(f"{op.summary or op.operation_id}")
+        writer.write_line("")
+        writer.write_line("Supports multiple content types:")
+        for content_type in op.request_body.content.keys():
+            writer.write_line(f"- {content_type}")
+        writer.write_line('"""')
+
+        # Generate URL construction
+        writer.write_line(f'url = f"{{self.base_url}}{op.path}"')
+        writer.write_line("")
+
+        # Generate runtime dispatch logic
+        writer.write_line("# Runtime dispatch based on content type")
+
+        first_content_type = True
+        for content_type in op.request_body.content.keys():
+            param_info = self.overload_generator._get_content_type_param_info(
+                content_type, op.request_body.content[content_type], context
+            )
+
+            if first_content_type:
+                writer.write_line(f"if {param_info['name']} is not None:")
+                first_content_type = False
+            else:
+                writer.write_line(f"elif {param_info['name']} is not None:")
+
+            writer.indent()
+
+            # Generate request call for this content type
+            if content_type == "application/json":
+                writer.write_line(f"json_body = {param_info['name']}")
+                writer.write_line("response = await self._transport.request(")
+                writer.indent()
+                writer.write_line(f'"{op.method.value.upper()}", url,')
+                writer.write_line("params=None,")
+                writer.write_line("json=json_body,")
+                writer.write_line("headers=None")
+                writer.dedent()
+                writer.write_line(")")
+            elif content_type == "multipart/form-data":
+                writer.write_line(f"files_data = {param_info['name']}")
+                writer.write_line("response = await self._transport.request(")
+                writer.indent()
+                writer.write_line(f'"{op.method.value.upper()}", url,')
+                writer.write_line("params=None,")
+                writer.write_line("files=files_data,")
+                writer.write_line("headers=None")
+                writer.dedent()
+                writer.write_line(")")
+            else:
+                writer.write_line(f"data = {param_info['name']}")
+                writer.write_line("response = await self._transport.request(")
+                writer.indent()
+                writer.write_line(f'"{op.method.value.upper()}", url,')
+                writer.write_line("params=None,")
+                writer.write_line("data=data,")
+                writer.write_line("headers=None")
+                writer.dedent()
+                writer.write_line(")")
+
+            writer.dedent()
+
+        # Add else clause for error
+        writer.write_line("else:")
+        writer.indent()
+        writer.write_line('raise ValueError("One of the content-type parameters must be provided")')
+        writer.dedent()
+        writer.write_line("")
+
+        # Generate response handling (reuse existing generator)
+        self.response_handler_generator.generate_response_handling(writer, op, context, response_strategy)
+
+        writer.dedent()
+
+        return writer.get_code().strip()

pyopenapi_gen/visit/endpoint/generators/overload_generator.py

@@ -0,0 +1,243 @@
+"""Generator for @overload signatures when operations have multiple content types."""
+
+import logging
+from typing import Any
+
+from pyopenapi_gen import IROperation
+
+from ....context.render_context import RenderContext
+from ....core.writers.code_writer import CodeWriter
+from ..processors.parameter_processor import EndpointParameterProcessor
+from .docstring_generator import EndpointDocstringGenerator
+from .signature_generator import EndpointMethodSignatureGenerator
+
+logger = logging.getLogger(__name__)
+
+
+class OverloadMethodGenerator:
+    """
+    Generates @overload signatures for operations with multiple content types.
+
+    When an operation's request body accepts multiple content types
+    (e.g., application/json and multipart/form-data), this generator creates
+    type-safe @overload signatures following PEP 484.
+    """
+
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas = schemas or {}
+        self.parameter_processor = EndpointParameterProcessor(self.schemas)
+        self.signature_generator = EndpointMethodSignatureGenerator(self.schemas)
+        self.docstring_generator = EndpointDocstringGenerator(self.schemas)
+
+    def has_multiple_content_types(self, op: IROperation) -> bool:
+        """
+        Check if operation request body has multiple content types.
+
+        Args:
+            op: The operation to check
+
+        Returns:
+            True if operation has request body with multiple content types
+        """
+        if not op.request_body:
+            return False
+        return len(op.request_body.content) > 1
+
+    def generate_overload_signatures(
+        self, op: IROperation, context: RenderContext, response_strategy: Any
+    ) -> list[str]:
+        """
+        Generate @overload signatures for each content type.
+
+        Args:
+            op: The operation with multiple content types
+            context: Render context for import tracking
+            response_strategy: Response strategy for return type resolution
+
+        Returns:
+            List of @overload signature code strings
+        """
+        if not self.has_multiple_content_types(op):
+            return []
+
+        # Ensure typing.overload is imported
+        context.add_import("typing", "overload")
+        context.add_import("typing", "Literal")
+        context.add_import("typing", "IO")
+        context.add_import("typing", "Any")
+
+        overload_signatures = []
+
+        # Type narrowing: request_body is guaranteed to exist by has_multiple_content_types check
+        assert (
+            op.request_body is not None
+        ), "request_body should not be None after has_multiple_content_types check"  # nosec B101 - Type narrowing for mypy, validated by has_multiple_content_types
+
+        for content_type, schema in op.request_body.content.items():
+            signature_code = self._generate_single_overload(op, content_type, schema, context, response_strategy)
+            overload_signatures.append(signature_code)
+
+        return overload_signatures
+
+    def _generate_single_overload(
+        self,
+        op: IROperation,
+        content_type: str,
+        schema: Any,
+        context: RenderContext,
+        response_strategy: Any,
+    ) -> str:
+        """
+        Generate a single @overload signature for one content type.
+
+        Args:
+            op: The operation
+            content_type: The media type (e.g., "application/json")
+            schema: The schema for this content type
+            context: Render context
+            response_strategy: Response strategy for return type
+
+        Returns:
+            @overload signature code as string
+        """
+        writer = CodeWriter()
+
+        # Write @overload decorator
+        writer.write_line("@overload")
+
+        # Determine parameter name and type based on content type
+        param_info = self._get_content_type_param_info(content_type, schema, context)
+
+        # Build parameter list from operation parameters directly
+        param_parts = ["self"]
+
+        # Add path, query, and header parameters from operation
+        if op.parameters:
+            from ....types.services.type_service import UnifiedTypeService
+
+            type_service = UnifiedTypeService(self.schemas)
+
+            for param in op.parameters:
+                if param.param_in in ("path", "query", "header"):
+                    param_type = type_service.resolve_schema_type(param.schema, context, required=param.required)
+                    param_parts.append(f"{param.name}: {param_type}")
+
+        # Add keyword-only separator
+        param_parts.append("*")
+
+        # Add content-type-specific parameter
+        param_parts.append(f"{param_info['name']}: {param_info['type']}")
+
+        # Add content_type parameter with Literal type
+        param_parts.append(f'content_type: Literal["{content_type}"] = "{content_type}"')
+
+        # Get return type from response strategy
+        return_type = response_strategy.return_type
+
+        # Write signature
+        params_str = ",\n    ".join(param_parts)
+        writer.write_line(f"async def {op.operation_id}(")
+        writer.indent()
+        writer.write_line(params_str)
+        writer.dedent()
+        writer.write_line(f") -> {return_type}: ...")
+
+        return writer.get_code()
+
+    def _get_content_type_param_info(self, content_type: str, schema: Any, context: RenderContext) -> dict[str, str]:
+        """
+        Get parameter name and type hint for a content type.
+
+        Args:
+            content_type: Media type string
+            schema: Schema for this content type
+            context: Render context for type resolution
+
+        Returns:
+            Dictionary with 'name' and 'type' keys
+        """
+        from ....types.services.type_service import UnifiedTypeService
+
+        type_service = UnifiedTypeService(self.schemas)
+
+        # Map content types to parameter names and base types
+        if content_type == "application/json":
+            # For JSON, resolve the actual schema type
+            type_hint = type_service.resolve_schema_type(schema, context, required=True)
+            return {"name": "body", "type": type_hint}
+
+        elif content_type == "multipart/form-data":
+            # For multipart, always use files dict
+            return {"name": "files", "type": "dict[str, IO[Any]]"}
+
+        elif content_type == "application/x-www-form-urlencoded":
+            # For form data, use dict
+            return {"name": "data", "type": "dict[str, str]"}
+
+        else:
+            # Default: use body with Any type
+            logger.warning(f"Unknown content type {content_type}, using body: Any")
+            return {"name": "body", "type": "Any"}
+
+    def generate_implementation_signature(self, op: IROperation, context: RenderContext, response_strategy: Any) -> str:
+        """
+        Generate the actual implementation method signature with optional parameters.
+
+        This signature accepts all possible content-type parameters as optional,
+        and includes runtime dispatch logic.
+
+        Args:
+            op: The operation
+            context: Render context
+            response_strategy: Response strategy for return type
+
+        Returns:
+            Implementation method signature code
+        """
+        writer = CodeWriter()
+
+        # Build parameter list
+        param_parts = ["self"]
+
+        # Add path, query, and header parameters from operation
+        if op.parameters:
+            from ....types.services.type_service import UnifiedTypeService
+
+            type_service = UnifiedTypeService(self.schemas)
+
+            for param in op.parameters:
+                if param.param_in in ("path", "query", "header"):
+                    param_type = type_service.resolve_schema_type(param.schema, context, required=param.required)
+                    param_parts.append(f"{param.name}: {param_type}")
+
+        # Add keyword-only separator
+        param_parts.append("*")
+
+        # Add all possible content-type parameters as optional
+        if op.request_body:
+            param_types_seen = set()
+
+            for content_type, schema in op.request_body.content.items():
+                param_info = self._get_content_type_param_info(content_type, schema, context)
+
+                # Avoid duplicate parameters (e.g., if multiple JSON variants)
+                param_key = param_info["name"]
+                if param_key not in param_types_seen:
+                    param_parts.append(f"{param_info['name']}: {param_info['type']} | None = None")
+                    param_types_seen.add(param_key)
+
+        # Add content_type parameter (no Literal, just str)
+        param_parts.append('content_type: str = "application/json"')
+
+        # Get return type
+        return_type = response_strategy.return_type
+
+        # Write signature
+        params_str = ",\n    ".join(param_parts)
+        writer.write_line(f"async def {op.operation_id}(")
+        writer.indent()
+        writer.write_line(params_str)
+        writer.dedent()
+        writer.write_line(f") -> {return_type}:")
+
+        return writer.get_code()

{pyopenapi_gen-0.17.0.dist-info → pyopenapi_gen-0.18.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyopenapi-gen
-Version: 0.17.0
+Version: 0.18.0
 Summary: Modern, async-first Python client generator for OpenAPI specifications with advanced cycle detection and unified type resolution
 Project-URL: Homepage, https://github.com/your-org/pyopenapi-gen
 Project-URL: Documentation, https://github.com/your-org/pyopenapi-gen/blob/main/README.md
@@ -123,6 +123,254 @@ async def main():
 asyncio.run(main())
 ```
 
+## 🐍 Using as a Library (Programmatic API)
+
+### Why Programmatic Usage?
+The generator was designed to work both as a CLI tool and as a Python library. Programmatic usage enables integration with build systems, CI/CD pipelines, code generators, and custom tooling. You get the same powerful code generation capabilities with full Python API access.
+
+### What Is the Programmatic API?
+A simple, function-based API that wraps the internal `ClientGenerator` class, providing a clean entry point for library usage without requiring knowledge of internal structure.
+
+```mermaid
+graph TD
+    A[Your Build Script] --> B[generate_client Function]
+    B --> C[ClientGenerator]
+    C --> D[Load OpenAPI Spec]
+    D --> E[Generate Code]
+    E --> F[Write Files]
+    F --> G[Post-Process]
+    G --> H[Return File List]
+    
+    subgraph "Public API"
+        B
+        I[ClientGenerator Class]
+        J[GenerationError Exception]
+    end
+    
+    subgraph "Advanced API"
+        K[load_ir_from_spec]
+        L[IR Models]
+        M[WarningCollector]
+    end
+```
+
+### How to Use Programmatically
+
+#### Basic Usage
+```python
+from pyopenapi_gen import generate_client
+
+# Simple client generation
+files = generate_client(
+    spec_path="input/openapi.yaml",
+    project_root=".",
+    output_package="pyapis.my_client"
+)
+
+print(f"Generated {len(files)} files")
+```
+
+#### Advanced Usage with All Options
+```python
+from pyopenapi_gen import generate_client, GenerationError
+
+try:
+    files = generate_client(
+        spec_path="input/openapi.yaml",
+        project_root=".",
+        output_package="pyapis.my_client",
+        core_package="pyapis.core",  # Optional shared core
+        force=True,                   # Overwrite without diff check
+        no_postprocess=False,         # Run Black + mypy
+        verbose=True                  # Show progress
+    )
+
+    # Process generated files
+    for file_path in files:
+        print(f"Generated: {file_path}")
+
+except GenerationError as e:
+    print(f"Generation failed: {e}")
+```
+
+#### Multi-Client Generation Script
+```python
+from pyopenapi_gen import generate_client
+from pathlib import Path
+
+# Configuration for multiple clients
+clients = [
+    {"spec": "api_v1.yaml", "package": "pyapis.client_v1"},
+    {"spec": "api_v2.yaml", "package": "pyapis.client_v2"},
+]
+
+# Shared core package
+core_package = "pyapis.core"
+
+# Generate all clients
+for client_config in clients:
+    print(f"Generating {client_config['package']}...")
+    
+    generate_client(
+        spec_path=client_config["spec"],
+        project_root=".",
+        output_package=client_config["package"],
+        core_package=core_package,
+        force=True,
+        verbose=True
+    )
+
+print("All clients generated successfully!")
+```
+
+#### Integration with Build Systems
+```python
+# Example: Custom build script
+import sys
+from pathlib import Path
+from pyopenapi_gen import generate_client, GenerationError
+
+def build_api_clients():
+    """Generate all API clients as part of build process"""
+    
+    specs_dir = Path("specs")
+    
+    # Find all OpenAPI specs
+    spec_files = list(specs_dir.glob("*.yaml")) + list(specs_dir.glob("*.json"))
+    
+    if not spec_files:
+        print("No OpenAPI specs found in specs/")
+        return False
+    
+    # Generate clients
+    for spec_file in spec_files:
+        client_name = spec_file.stem
+        package_name = f"pyapis.{client_name}"
+        
+        print(f"Generating client for {spec_file.name}...")
+        
+        try:
+            generate_client(
+                spec_path=str(spec_file),
+                project_root="src",
+                output_package=package_name,
+                core_package="pyapis.core",
+                force=True
+            )
+        except GenerationError as e:
+            print(f"Failed to generate {client_name}: {e}", file=sys.stderr)
+            return False
+    
+    return True
+
+if __name__ == "__main__":
+    success = build_api_clients()
+    sys.exit(0 if success else 1)
+```
+
+### API Reference
+
+#### `generate_client()` Function
+
+```python
+def generate_client(
+    spec_path: str,
+    project_root: str,
+    output_package: str,
+    core_package: str | None = None,
+    force: bool = False,
+    no_postprocess: bool = False,
+    verbose: bool = False,
+) -> List[Path]
+```
+
+**Parameters**:
+- `spec_path`: Path to OpenAPI spec file (YAML or JSON)
+- `project_root`: Root directory of your Python project
+- `output_package`: Python package name (e.g., `'pyapis.my_client'`)
+- `core_package`: Optional shared core package name (defaults to `{output_package}.core`)
+- `force`: Skip diff check and overwrite existing output
+- `no_postprocess`: Skip Black formatting and mypy type checking
+- `verbose`: Print detailed progress information
+
+**Returns**: List of `Path` objects for all generated files
+
+**Raises**: `GenerationError` if generation fails
+
+#### `ClientGenerator` Class (Advanced)
+
+For advanced use cases requiring more control:
+
+```python
+from pyopenapi_gen import ClientGenerator, GenerationError
+from pathlib import Path
+
+# Create generator with custom settings
+generator = ClientGenerator(verbose=True)
+
+# Generate with full control
+try:
+    files = generator.generate(
+        spec_path="openapi.yaml",
+        project_root=Path("."),
+        output_package="pyapis.my_client",
+        core_package="pyapis.core",
+        force=False,
+        no_postprocess=False
+    )
+except GenerationError as e:
+    print(f"Generation failed: {e}")
+```
+
+#### `GenerationError` Exception
+
+Raised when generation fails. Contains contextual information about the failure:
+
+```python
+from pyopenapi_gen import generate_client, GenerationError
+
+try:
+    generate_client(
+        spec_path="invalid.yaml",
+        project_root=".",
+        output_package="test"
+    )
+except GenerationError as e:
+    # Exception message includes context
+    print(f"Error: {e}")
+    # Typical causes:
+    # - Invalid OpenAPI specification
+    # - File I/O errors
+    # - Type checking failures
+    # - Invalid project structure
+```
+
+### Comparison: CLI vs Programmatic API
+
+**CLI Usage**:
+```bash
+pyopenapi-gen input/openapi.yaml \
+  --project-root . \
+  --output-package pyapis.my_client \
+  --force \
+  --verbose
+```
+
+**Equivalent Programmatic Usage**:
+```python
+from pyopenapi_gen import generate_client
+
+generate_client(
+    spec_path="input/openapi.yaml",
+    project_root=".",
+    output_package="pyapis.my_client",
+    force=True,
+    verbose=True
+)
+```
+
+Both approaches use the same underlying implementation and produce identical results.
+
 ## 🔧 Configuration Options
 
 ### Standalone Client (Default)

{pyopenapi_gen-0.17.0.dist-info → pyopenapi_gen-0.18.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyopenapi_gen/__init__.py,sha256=nLxgWZNVSv0wDYh4S5NlwKP7DrQGisi4J3IL7WCmLX8,7533
+pyopenapi_gen/__init__.py,sha256=PuqDvWUTyOlVU2Et6YBu9am_aSyMIC-O3YrbFuGnEXY,7533
 pyopenapi_gen/__main__.py,sha256=4-SCaCNhBd7rtyRK58uoDbdl93J0KhUeajP_b0CPpLE,110
 pyopenapi_gen/cli.py,sha256=9T_XF3-ih_JlM_BOkmHft-HoMCGOqL5UrnAHBJ0fb5w,2320
 pyopenapi_gen/http_types.py,sha256=EMMYZBt8PNVZKPFu77TQija-JI-nOKyXvpiQP9-VSWE,467
@@ -112,7 +112,8 @@ pyopenapi_gen/visit/endpoint/__init__.py,sha256=DftIZSWp6Z8jKWoJE2VGKL4G_5cqwFXe
 pyopenapi_gen/visit/endpoint/endpoint_visitor.py,sha256=1aS0i2D_Y-979_7aBd0W6IS2UVO6wMujsMMw8Qt8PRE,3574
 pyopenapi_gen/visit/endpoint/generators/__init__.py,sha256=-X-GYnJZ9twiEBr_U0obW8VuSoY6IJmYaxinn-seMzA,50
 pyopenapi_gen/visit/endpoint/generators/docstring_generator.py,sha256=_VpRabZ2g_N42TTWGI6gtPxqzlZD65dOHm8U_YvtWbQ,5891
-pyopenapi_gen/visit/endpoint/generators/endpoint_method_generator.py,sha256=wUJ4_gaA1gRrFCHYFCObBIankxGQu0MNqiOSoZOZmoA,4352
+pyopenapi_gen/visit/endpoint/generators/endpoint_method_generator.py,sha256=X0tdSVmfUTDSOVKmC5cQLO3SfC_hsRCQpt5lPoC6MYI,9998
+pyopenapi_gen/visit/endpoint/generators/overload_generator.py,sha256=1W8pt5iUSDsgxJJUoxfQyRZkxCwFi1WbvVM__SazCe0,9074
 pyopenapi_gen/visit/endpoint/generators/request_generator.py,sha256=MKtZ6Fa050gCgqAGhXeo--p_AzqV9RmDd8e4Zvglgo0,5349
 pyopenapi_gen/visit/endpoint/generators/response_handler_generator.py,sha256=Jb_8hRQY1OfpThupa7UdCNxa712m3WaeNIbLhlYk1bg,24193
 pyopenapi_gen/visit/endpoint/generators/signature_generator.py,sha256=ENi34Rf2x1Ijtvca652ihV9L2UUT1O2SEsG-66Pm_Z8,3873
@@ -125,8 +126,8 @@ pyopenapi_gen/visit/model/alias_generator.py,sha256=wEMHipPA1_CFxvQ6CS9j4qgXK93s
 pyopenapi_gen/visit/model/dataclass_generator.py,sha256=L794s2yyYUO__akGd120NJMV7g2xqiPfQyZo8CduIVM,14426
 pyopenapi_gen/visit/model/enum_generator.py,sha256=AXqKUFuWUUjUF_6_HqBKY8vB5GYu35Pb2C2WPFrOw1k,10061
 pyopenapi_gen/visit/model/model_visitor.py,sha256=TC6pbxpQiy5FWhmQpfllLuXA3ImTYNMcrazkOFZCIyo,9470
-pyopenapi_gen-0.17.0.dist-info/METADATA,sha256=YkgkvtWTtSfD9_1lhlfVYRRwM9pzBYpR7HVKROSP0C0,14025
-pyopenapi_gen-0.17.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pyopenapi_gen-0.17.0.dist-info/entry_points.txt,sha256=gxSlNiwom50T3OEZnlocA6qRjGdV0bn6hN_Xr-Ub5wA,56
-pyopenapi_gen-0.17.0.dist-info/licenses/LICENSE,sha256=UFAyTWKa4w10-QerlJaHJeep7G2gcwpf-JmvI2dS2Gc,1088
-pyopenapi_gen-0.17.0.dist-info/RECORD,,
+pyopenapi_gen-0.18.0.dist-info/METADATA,sha256=kLYKgzczN64FbkIQ0y_Tg-jnZ78yU8VrFZVeVL-LKic,20551
+pyopenapi_gen-0.18.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyopenapi_gen-0.18.0.dist-info/entry_points.txt,sha256=gxSlNiwom50T3OEZnlocA6qRjGdV0bn6hN_Xr-Ub5wA,56
+pyopenapi_gen-0.18.0.dist-info/licenses/LICENSE,sha256=UFAyTWKa4w10-QerlJaHJeep7G2gcwpf-JmvI2dS2Gc,1088
+pyopenapi_gen-0.18.0.dist-info/RECORD,,