pyopenapi-gen 0.12.1__py3-none-any.whl → 0.14.0__py3-none-any.whl

pyopenapi_gen/core/http_status_codes.py

@@ -0,0 +1,220 @@
+"""HTTP status code definitions and human-readable names.
+
+This module provides a registry of standard HTTP status codes with their
+canonical names according to RFC specifications.
+
+References:
+    - RFC 9110 (HTTP Semantics): https://www.rfc-editor.org/rfc/rfc9110.html
+    - IANA HTTP Status Code Registry: https://www.iana.org/assignments/http-status-codes/
+"""
+
+from typing import Dict
+
+# Standard HTTP status codes with human-readable names
+HTTP_STATUS_CODES: Dict[int, str] = {
+    # 1xx Informational
+    100: "Continue",
+    101: "Switching Protocols",
+    102: "Processing",
+    103: "Early Hints",
+    # 2xx Success
+    200: "OK",
+    201: "Created",
+    202: "Accepted",
+    203: "Non-Authoritative Information",
+    204: "No Content",
+    205: "Reset Content",
+    206: "Partial Content",
+    207: "Multi-Status",
+    208: "Already Reported",
+    226: "IM Used",
+    # 3xx Redirection
+    300: "Multiple Choices",
+    301: "Moved Permanently",
+    302: "Found",
+    303: "See Other",
+    304: "Not Modified",
+    305: "Use Proxy",
+    307: "Temporary Redirect",
+    308: "Permanent Redirect",
+    # 4xx Client Error
+    400: "Bad Request",
+    401: "Unauthorised",
+    402: "Payment Required",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    406: "Not Acceptable",
+    407: "Proxy Authentication Required",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    411: "Length Required",
+    412: "Precondition Failed",
+    413: "Payload Too Large",
+    414: "URI Too Long",
+    415: "Unsupported Media Type",
+    416: "Range Not Satisfiable",
+    417: "Expectation Failed",
+    418: "I'm a teapot",
+    421: "Misdirected Request",
+    422: "Unprocessable Entity",
+    423: "Locked",
+    424: "Failed Dependency",
+    425: "Too Early",
+    426: "Upgrade Required",
+    428: "Precondition Required",
+    429: "Too Many Requests",
+    431: "Request Header Fields Too Large",
+    451: "Unavailable For Legal Reasons",
+    # 5xx Server Error
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+    505: "HTTP Version Not Supported",
+    506: "Variant Also Negotiates",
+    507: "Insufficient Storage",
+    508: "Loop Detected",
+    510: "Not Extended",
+    511: "Network Authentication Required",
+}
+
+
+def get_status_name(code: int) -> str:
+    """Get the human-readable name for an HTTP status code.
+
+    Args:
+        code: HTTP status code (e.g., 404)
+
+    Returns:
+        Human-readable status name (e.g., "Not Found"), or "Unknown" if not found
+    """
+    return HTTP_STATUS_CODES.get(code, "Unknown")
+
+
+def is_error_code(code: int) -> bool:
+    """Check if a status code represents an error (4xx or 5xx).
+
+    Args:
+        code: HTTP status code
+
+    Returns:
+        True if the code is a client or server error, False otherwise
+    """
+    return 400 <= code < 600
+
+
+def is_client_error(code: int) -> bool:
+    """Check if a status code represents a client error (4xx).
+
+    Args:
+        code: HTTP status code
+
+    Returns:
+        True if the code is a client error, False otherwise
+    """
+    return 400 <= code < 500
+
+
+def is_server_error(code: int) -> bool:
+    """Check if a status code represents a server error (5xx).
+
+    Args:
+        code: HTTP status code
+
+    Returns:
+        True if the code is a server error, False otherwise
+    """
+    return 500 <= code < 600
+
+
+def is_success_code(code: int) -> bool:
+    """Check if a status code represents success (2xx).
+
+    Args:
+        code: HTTP status code
+
+    Returns:
+        True if the code is a success code, False otherwise
+    """
+    return 200 <= code < 300
+
+
+# Mapping of HTTP status codes to Python exception class names
+# These are semantically meaningful names that Python developers expect
+HTTP_EXCEPTION_NAMES: Dict[int, str] = {
+    # 4xx Client Errors
+    400: "BadRequestError",
+    401: "UnauthorisedError",
+    402: "PaymentRequiredError",
+    403: "ForbiddenError",
+    404: "NotFoundError",
+    405: "MethodNotAllowedError",
+    406: "NotAcceptableError",
+    407: "ProxyAuthenticationRequiredError",
+    408: "RequestTimeoutError",
+    409: "ConflictError",
+    410: "GoneError",
+    411: "LengthRequiredError",
+    412: "PreconditionFailedError",
+    413: "PayloadTooLargeError",
+    414: "UriTooLongError",
+    415: "UnsupportedMediaTypeError",
+    416: "RangeNotSatisfiableError",
+    417: "ExpectationFailedError",
+    418: "ImATeapotError",
+    421: "MisdirectedRequestError",
+    422: "UnprocessableEntityError",
+    423: "LockedError",
+    424: "FailedDependencyError",
+    425: "TooEarlyError",
+    426: "UpgradeRequiredError",
+    428: "PreconditionRequiredError",
+    429: "TooManyRequestsError",
+    431: "RequestHeaderFieldsTooLargeError",
+    451: "UnavailableForLegalReasonsError",
+    # 5xx Server Errors
+    500: "InternalServerError",
+    501: "NotImplementedError",  # Note: Conflicts with Python built-in, will be handled
+    502: "BadGatewayError",
+    503: "ServiceUnavailableError",
+    504: "GatewayTimeoutError",
+    505: "HttpVersionNotSupportedError",
+    506: "VariantAlsoNegotiatesError",
+    507: "InsufficientStorageError",
+    508: "LoopDetectedError",
+    510: "NotExtendedError",
+    511: "NetworkAuthenticationRequiredError",
+}
+
+
+def get_exception_class_name(code: int) -> str:
+    """Get the Python exception class name for an HTTP status code.
+
+    Args:
+        code: HTTP status code (e.g., 404)
+
+    Returns:
+        Python exception class name (e.g., "NotFoundError"), or "Error{code}" as fallback
+
+    Examples:
+        >>> get_exception_class_name(404)
+        'NotFoundError'
+        >>> get_exception_class_name(429)
+        'TooManyRequestsError'
+        >>> get_exception_class_name(999)  # Unknown code
+        'Error999'
+    """
+    # Check if we have a semantic name for this code
+    if code in HTTP_EXCEPTION_NAMES:
+        name = HTTP_EXCEPTION_NAMES[code]
+        # Handle Python keyword conflicts
+        if name == "NotImplementedError":
+            # Avoid conflict with Python's built-in NotImplementedError
+            return "HttpNotImplementedError"
+        return name
+
+    # Fallback to Error{code} for codes we don't have semantic names for
+    return f"Error{code}"

pyopenapi_gen/core/parsing/schema_parser.py

@@ -17,6 +17,8 @@ from .keywords.any_of_parser import _parse_any_of_schemas
 from .keywords.one_of_parser import _parse_one_of_schemas
 from .unified_cycle_detection import CycleAction
 
+logger = logging.getLogger(__name__)
+
 # Environment variables for configurable limits, with defaults
 try:
     MAX_CYCLES = int(os.environ.get("PYOPENAPI_MAX_CYCLES", "0"))  # Default 0 means no explicit cycle count limit
@@ -27,8 +29,6 @@ try:
 except ValueError:
     ENV_MAX_DEPTH = 150  # Fallback to 150 if env var is invalid
 
-logger = logging.getLogger(__name__)
-
 
 def _resolve_ref(
     ref_path_str: str,
@@ -417,7 +417,23 @@ def _parse_schema(
         raw_type_field = schema_node.get("type")
 
         if isinstance(raw_type_field, str):
-            extracted_type = raw_type_field
+            # Handle non-standard type values that might appear
+            if raw_type_field in ["Any", "any"]:
+                # Convert 'Any' to None - will be handled as object later
+                extracted_type = None
+                logger.warning(
+                    f"Schema{f' {schema_name}' if schema_name else ''} uses non-standard type 'Any'. "
+                    "Converting to 'object'. Use standard OpenAPI types: string, number, integer, boolean, array, object."
+                )
+            elif raw_type_field == "None":
+                # Convert 'None' string to null handling
+                extracted_type = "null"
+                logger.warning(
+                    f"Schema{f' {schema_name}' if schema_name else ''} uses type 'None'. "
+                    'Converting to nullable object. Use \'type: ["object", "null"]\' for nullable types.'
+                )
+            else:
+                extracted_type = raw_type_field
         elif isinstance(raw_type_field, list):
             if "null" in raw_type_field:
                 is_nullable_from_type_field = True
@@ -446,10 +462,33 @@ def _parse_schema(
             if props_from_comp or "allOf" in schema_node or "properties" in schema_node:
                 current_final_type = "object"
             elif any_of_irs or one_of_irs:
+                # Keep None for composition types - they'll be handled by resolver
                 current_final_type = None
+            elif "enum" in schema_node:
+                # Enum without explicit type - infer from enum values
+                enum_values = schema_node.get("enum", [])
+                if enum_values:
+                    first_val = enum_values[0]
+                    if isinstance(first_val, str):
+                        current_final_type = "string"
+                    elif isinstance(first_val, (int, float)):
+                        current_final_type = "number"
+                    elif isinstance(first_val, bool):
+                        current_final_type = "boolean"
+                    else:
+                        # Fallback to object for complex enum values
+                        current_final_type = "object"
+                else:
+                    current_final_type = "string"  # Default for empty enums
+            else:
+                # No type specified and no clear indicators - default to object
+                # This is safer than 'Any' and matches OpenAPI spec defaults
+                current_final_type = "object"
 
         if current_final_type == "null":
-            current_final_type = None
+            # Explicit null type - mark as nullable but use object type
+            is_nullable_overall = True
+            current_final_type = "object"
 
         if current_final_type == "object":
             # Properties from allOf have already been handled by _parse_composition_keywords
@@ -511,7 +550,13 @@ def _parse_schema(
                 else:
                     items_ir = actual_item_ir
             else:
-                items_ir = IRSchema(type="Any")
+                # Array without items specification - use object as safer default
+                # Log warning to help developers fix their specs
+                logger.warning(
+                    f"Array type without 'items' specification found{f' in {schema_name}' if schema_name else ''}. "
+                    "Using 'object' as item type. Consider adding 'items' to your OpenAPI spec for better type safety."
+                )
+                items_ir = IRSchema(type="object")
 
         schema_ir_name_attr = NameSanitizer.sanitize_class_name(schema_name) if schema_name else None
 

pyopenapi_gen/core/postprocess_manager.py

@@ -32,13 +32,15 @@ class PostprocessManager:
         # Ensure all targets are Path objects
         target_paths = [Path(t) for t in targets]
 
-        # --- RE-ENABLE RUFF CHECKS ---
-        for target_path in target_paths:
-            if target_path.is_file() and target_path.suffix == ".py":
-                self.remove_unused_imports(target_path)
-                self.sort_imports(target_path)
-                self.format_code(target_path)
-        # --- END RE-ENABLE ---
+        # OPTIMISED: Run Ruff once on all files instead of per-file
+        # Collect all Python files
+        python_files = [p for p in target_paths if p.is_file() and p.suffix == ".py"]
+
+        if python_files:
+            # Run Ruff checks once on all files (much faster than per-file)
+            self.remove_unused_imports_bulk(python_files)
+            self.sort_imports_bulk(python_files)
+            self.format_code_bulk(python_files)
 
         # Determine the package root directory(s) for Mypy
         package_roots = set()
@@ -58,11 +60,82 @@ class PostprocessManager:
                 package_roots.add(target_path)
 
         # Run Mypy on each identified package root
-        if package_roots:
-            print(f"Running Mypy on package root(s): {package_roots}")
-        for root_dir in package_roots:
-            print(f"Running mypy on {root_dir}...")
-            self.type_check(root_dir)
+        # TEMPORARILY DISABLED: Mypy is slow on large specs, disabled for faster iteration
+        # if package_roots:
+        #     print(f"Running Mypy on package root(s): {package_roots}")
+        # for root_dir in package_roots:
+        #     print(f"Running mypy on {root_dir}...")
+        #     self.type_check(root_dir)
+
+    def remove_unused_imports_bulk(self, targets: List[Path]) -> None:
+        """Remove unused imports from multiple targets using Ruff (bulk operation)."""
+        if not targets:
+            return
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "ruff",
+                "check",
+                "--select=F401",
+                "--fix",
+            ]
+            + [str(t) for t in targets],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        if result.returncode != 0 or result.stderr:
+            if result.stdout:
+                _print_filtered_stdout(result.stdout)
+            if result.stderr:
+                print(result.stderr, file=sys.stderr)
+
+    def sort_imports_bulk(self, targets: List[Path]) -> None:
+        """Sort imports in multiple targets using Ruff (bulk operation)."""
+        if not targets:
+            return
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "ruff",
+                "check",
+                "--select=I",
+                "--fix",
+            ]
+            + [str(t) for t in targets],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        if result.returncode != 0 or result.stderr:
+            if result.stdout:
+                _print_filtered_stdout(result.stdout)
+            if result.stderr:
+                print(result.stderr, file=sys.stderr)
+
+    def format_code_bulk(self, targets: List[Path]) -> None:
+        """Format code in multiple targets using Ruff (bulk operation)."""
+        if not targets:
+            return
+        result = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "ruff",
+                "format",
+            ]
+            + [str(t) for t in targets],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+        if result.returncode != 0 or result.stderr:
+            if result.stdout:
+                _print_filtered_stdout(result.stdout)
+            if result.stderr:
+                print(result.stderr, file=sys.stderr)
 
     def remove_unused_imports(self, target: Union[str, Path]) -> None:
         """Remove unused imports from the target using Ruff."""

pyopenapi_gen/core/writers/python_construct_renderer.py

@@ -312,7 +312,11 @@ class PythonConstructRenderer:
             has_content = True
         if body_lines:
             for line in body_lines:
-                writer.write_line(line)
+                # Handle empty lines without adding indentation (Ruff W293)
+                if line == "":
+                    writer.writer.newline()  # Just add a newline, no indent
+                else:
+                    writer.write_line(line)
             has_content = True
 
         if not has_content:

pyopenapi_gen/emitters/exceptions_emitter.py

@@ -1,4 +1,6 @@
+import json
 import os
+from pathlib import Path
 from typing import Optional
 
 from pyopenapi_gen import IRSpec
@@ -6,29 +8,40 @@ from pyopenapi_gen.context.render_context import RenderContext
 
 from ..visit.exception_visitor import ExceptionVisitor
 
-# Template for spec-specific exception aliases
-EXCEPTIONS_ALIASES_TEMPLATE = '''
-from .exceptions import HTTPError, ClientError, ServerError
 
-# Generated exception aliases for specific status codes
-{% for code in codes %}
-class Error{{ code }}({% if code < 500 %}ClientError{% else %}ServerError{% endif %}):
-    """Exception alias for HTTP {{ code }} responses."""
-    pass
-{% endfor %}
-'''
+class ExceptionsEmitter:
+    """Generates spec-specific exception aliases with multi-client support.
 
+    This emitter handles two scenarios:
+    1. **Single client**: Generates exception_aliases.py directly in the core package
+    2. **Shared core**: Maintains a registry of all needed exception codes across clients
+       and regenerates the complete exception_aliases.py file
 
-class ExceptionsEmitter:
-    """Generates spec-specific exception aliases in exceptions.py using visitor/context."""
+    The registry file (.exception_registry.json) tracks which status codes are used by
+    which clients, ensuring that when multiple clients share a core package, all required
+    exceptions are available.
+    """
 
     def __init__(self, core_package_name: str = "core", overall_project_root: Optional[str] = None) -> None:
         self.visitor = ExceptionVisitor()
         self.core_package_name = core_package_name
         self.overall_project_root = overall_project_root
 
-    def emit(self, spec: IRSpec, output_dir: str) -> tuple[list[str], list[str]]:
+    def emit(
+        self, spec: IRSpec, output_dir: str, client_package_name: Optional[str] = None
+    ) -> tuple[list[str], list[str]]:
+        """Generate exception aliases for the given spec.
+
+        Args:
+            spec: IRSpec containing operations and responses
+            output_dir: Directory where exception_aliases.py will be written
+            client_package_name: Name of the client package (for registry tracking)
+
+        Returns:
+            Tuple of (list of generated file paths, list of exception class names)
+        """
         file_path = os.path.join(output_dir, "exception_aliases.py")
+        registry_path = os.path.join(output_dir, ".exception_registry.json")
 
         context = RenderContext(
             package_root_for_generated_code=output_dir,
@@ -37,16 +50,137 @@ class ExceptionsEmitter:
         )
         context.set_current_file(file_path)
 
-        generated_code, alias_names = self.visitor.visit(spec, context)
+        # Generate exception classes for this spec
+        generated_code, alias_names, status_codes = self.visitor.visit(spec, context)
+
+        # Update registry if we have a client package name (shared core scenario)
+        if client_package_name and self._is_shared_core(output_dir):
+            all_codes = self._update_registry(registry_path, client_package_name, status_codes)
+            # Regenerate with ALL codes from registry
+            generated_code, alias_names = self._generate_for_codes(all_codes, context)
+
         generated_imports = context.render_imports()
 
-        # Add __all__ list
+        # Add __all__ list with proper spacing (2 blank lines after last class - Ruff E305)
         if alias_names:
             all_list_str = ", ".join([f'"{name}"' for name in alias_names])
-            all_assignment = f"\n\n__all__ = [{all_list_str}]\n"
+            all_assignment = f"\n\n\n__all__ = [{all_list_str}]\n"
             generated_code += all_assignment
 
         full_content = f"{generated_imports}\n\n{generated_code}"
         with open(file_path, "w") as f:
             f.write(full_content)
+
         return [file_path], alias_names
+
+    def _is_shared_core(self, core_dir: str) -> bool:
+        """Check if this core package is shared between multiple clients.
+
+        Args:
+            core_dir: Path to the core package directory
+
+        Returns:
+            True if the core package is outside the immediate client package
+        """
+        # If overall_project_root is set and different from the core dir's parent,
+        # we're in a shared core scenario
+        if self.overall_project_root:
+            core_path = Path(core_dir).resolve()
+            project_root = Path(self.overall_project_root).resolve()
+            # Check if there are other client directories at the same level
+            parent_dir = core_path.parent
+            return parent_dir == project_root or parent_dir.parent == project_root
+        return False
+
+    def _update_registry(self, registry_path: str, client_name: str, status_codes: list[int]) -> list[int]:
+        """Update the exception registry with this client's status codes.
+
+        Args:
+            registry_path: Path to the .exception_registry.json file
+            client_name: Name of the client package
+            status_codes: List of status codes used by this client
+
+        Returns:
+            Complete list of all status codes across all clients
+        """
+        registry = {}
+        if os.path.exists(registry_path):
+            with open(registry_path) as f:
+                registry = json.load(f)
+
+        # Update this client's codes
+        registry[client_name] = sorted(status_codes)
+
+        # Write back to registry
+        with open(registry_path, "w") as f:
+            json.dump(registry, f, indent=2, sort_keys=True)
+
+        # Return union of all codes
+        all_codes = set()
+        for codes in registry.values():
+            all_codes.update(codes)
+
+        return sorted(all_codes)
+
+    def _generate_for_codes(self, status_codes: list[int], context: RenderContext) -> tuple[str, list[str]]:
+        """Generate exception classes for a specific list of status codes.
+
+        Args:
+            status_codes: List of HTTP status codes to generate exceptions for
+            context: Render context for imports
+
+        Returns:
+            Tuple of (generated_code, exception_class_names)
+        """
+        from ..core.http_status_codes import (
+            get_exception_class_name,
+            get_status_name,
+            is_client_error,
+            is_server_error,
+        )
+        from ..core.writers.python_construct_renderer import PythonConstructRenderer
+
+        renderer = PythonConstructRenderer()
+        all_exception_code = []
+        generated_alias_names = []
+
+        for code in status_codes:
+            # Determine base class
+            if is_client_error(code):
+                base_class = "ClientError"
+            elif is_server_error(code):
+                base_class = "ServerError"
+            else:
+                continue
+
+            # Get human-readable exception class name (e.g., NotFoundError instead of Error404)
+            class_name = get_exception_class_name(code)
+            generated_alias_names.append(class_name)
+
+            # Get human-readable status name for documentation
+            status_name = get_status_name(code)
+            docstring = f"HTTP {code} {status_name}.\n\nRaised when the server responds with a {code} status code."
+
+            # Define the __init__ method body
+            init_method_body = [
+                "def __init__(self, response: Response) -> None:",
+                f'    """Initialise {class_name} with the HTTP response.',
+                "",  # Empty line without trailing whitespace (Ruff W293)
+                "    Args:",
+                "        response: The httpx Response object that triggered this exception",
+                '    """',
+                "    super().__init__(status_code=response.status_code, message=response.text, response=response)",
+            ]
+
+            exception_code = renderer.render_class(
+                class_name=class_name,
+                base_classes=[base_class],
+                docstring=docstring,
+                body_lines=init_method_body,
+                context=context,
+            )
+            all_exception_code.append(exception_code)
+
+        # Join the generated class strings with 2 blank lines between classes (PEP 8 / Ruff E302)
+        final_code = "\n\n\n".join(all_exception_code)
+        return final_code, generated_alias_names

pyopenapi_gen/generator/client_generator.py

@@ -203,7 +203,7 @@ class ClientGenerator:
                     overall_project_root=str(tmp_project_root_for_diff),  # Use temp project root for context
                 )
                 exception_files_list, exception_alias_names = exceptions_emitter.emit(
-                    ir, str(tmp_core_dir_for_diff)
+                    ir, str(tmp_core_dir_for_diff), client_package_name=output_package
                 )  # Emit TO temp core dir
                 exception_files = [Path(p) for p in exception_files_list]
                 temp_generated_files += exception_files
@@ -374,7 +374,9 @@ class ClientGenerator:
                 core_package_name=resolved_core_package_fqn,
                 overall_project_root=str(project_root),
             )
-            exception_files_list, exception_alias_names = exceptions_emitter.emit(ir, str(core_dir))
+            exception_files_list, exception_alias_names = exceptions_emitter.emit(
+                ir, str(core_dir), client_package_name=output_package
+            )
             generated_files += [Path(p) for p in exception_files_list]
             self._log_progress(f"Generated {len(exception_files_list)} exception files", "EMIT_EXCEPTIONS")
 

pyopenapi_gen/types/resolvers/schema_resolver.py

@@ -53,11 +53,12 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
 
         # Handle composition types (any_of, all_of, one_of)
         # These are processed for inline compositions or when generating the alias for a named composition
-        if hasattr(schema, "any_of") and schema.any_of:
+        # Check for the attribute existence, not just truthiness, to handle empty lists
+        if hasattr(schema, "any_of") and schema.any_of is not None:
             return self._resolve_any_of(schema, context, required, resolve_underlying)
-        elif hasattr(schema, "all_of") and schema.all_of:
+        elif hasattr(schema, "all_of") and schema.all_of is not None:
             return self._resolve_all_of(schema, context, required, resolve_underlying)
-        elif hasattr(schema, "one_of") and schema.one_of:
+        elif hasattr(schema, "one_of") and schema.one_of is not None:
             return self._resolve_one_of(schema, context, required, resolve_underlying)
 
         # Handle named schemas without generation_name (fallback for references)
@@ -96,7 +97,52 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
         elif schema_type == "null":
             return self._resolve_null(context, required)
         else:
-            logger.warning(f"Unknown schema type: {schema_type}")
+            # Gather detailed information about the problematic schema
+            schema_details = {
+                "type": schema_type,
+                "name": getattr(schema, "name", None),
+                "ref": getattr(schema, "ref", None),
+                "properties": list(getattr(schema, "properties", {}).keys()) if hasattr(schema, "properties") else None,
+                "enum": getattr(schema, "enum", None),
+                "description": getattr(schema, "description", None),
+                "generation_name": getattr(schema, "generation_name", None),
+                "is_nullable": getattr(schema, "is_nullable", None),
+                "any_of": len(getattr(schema, "any_of", []) or []) if hasattr(schema, "any_of") else 0,
+                "all_of": len(getattr(schema, "all_of", []) or []) if hasattr(schema, "all_of") else 0,
+                "one_of": len(getattr(schema, "one_of", []) or []) if hasattr(schema, "one_of") else 0,
+            }
+
+            # Remove None values for cleaner output
+            schema_details = {k: v for k, v in schema_details.items() if v is not None}
+
+            # Create detailed error message
+            error_msg = f"Unknown schema type '{schema_type}' encountered."
+            if schema_details.get("name"):
+                error_msg += f" Schema name: '{schema_details['name']}'."
+            if schema_details.get("ref"):
+                error_msg += f" Reference: '{schema_details['ref']}'."
+
+            # Log full details with actionable advice
+            logger.warning(f"{error_msg} Full details: {schema_details}")
+
+            # Provide specific guidance based on the unknown type
+            if schema_type == "Any":
+                logger.info(
+                    "Schema type 'Any' will be mapped to typing.Any. Consider using a more specific type in your OpenAPI spec."
+                )
+            elif schema_type == "None" or schema_type is None:
+                logger.info(
+                    "Schema type 'None' detected - likely an optional field or null type. This will be mapped to Optional[Any]."
+                )
+                return self._resolve_null(context, required)
+            elif schema_type and isinstance(schema_type, str):
+                # Unknown string type - provide helpful suggestions
+                logger.info(f"Unknown type '{schema_type}' - common issues:")
+                logger.info("  1. Typo in type name (should be: string, integer, number, boolean, array, object)")
+                logger.info("  2. Using a schema name as type (should use $ref instead)")
+                logger.info("  3. Custom type not supported by OpenAPI (consider using allOf/oneOf/anyOf)")
+                logger.info(f"  Location: Check your OpenAPI spec for schemas with type='{schema_type}'")
+
             return self._resolve_any(context)
 
     def _resolve_reference(
@@ -115,7 +161,12 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
         module_stem = getattr(schema, "final_module_stem", None)
 
         if not module_stem:
-            logger.warning(f"Named schema {schema.name} missing final_module_stem")
+            logger.warning(f"Named schema '{schema.name}' missing final_module_stem attribute.")
+            logger.info(f"  This usually means the schema wasn't properly processed during parsing.")
+            logger.info(
+                f"  Check if '{schema.name}' is defined in components/schemas or if it's an inline schema that should be promoted."
+            )
+            logger.info(f"  The schema will be treated as 'Any' type for now.")
             return ResolvedType(python_type=class_name or "Any", is_optional=not required)
 
         # Check if we're trying to import from the same module (self-import)
@@ -237,6 +288,10 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
 
     def _resolve_null(self, context: TypeContext, required: bool) -> ResolvedType:
         """Resolve null type."""
+        # For null types in schemas, we need to import Any for the Optional[Any] pattern
+        # But the type itself is None for union composition
+        if not required:
+            context.add_import("typing", "Any")
         return ResolvedType(python_type="None", is_optional=not required)
 
     def _resolve_array(
@@ -245,7 +300,11 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
         """Resolve array type."""
         items_schema = getattr(schema, "items", None)
         if not items_schema:
-            logger.warning("Array schema missing items")
+            schema_name = getattr(schema, "name", "unnamed")
+            logger.warning(f"Array schema '{schema_name}' missing 'items' definition.")
+            logger.info("  Arrays in OpenAPI must define the type of items they contain.")
+            logger.info('  Example: { "type": "array", "items": { "type": "string" } }')
+            logger.info("  This will be mapped to List[Any] - consider fixing the OpenAPI spec.")
             context.add_import("typing", "List")
             context.add_import("typing", "Any")
             return ResolvedType(python_type="List[Any]", is_optional=not required)
@@ -340,10 +399,8 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
             if hasattr(sub_schema, "type") and sub_schema.type:
                 return self.resolve_schema(sub_schema, context, required, resolve_underlying)
 
-        # Fallback to first schema
-        if schema.all_of:
-            return self.resolve_schema(schema.all_of[0], context, required, resolve_underlying)
-
+        # Fallback - if no schema has a concrete type, return Any
+        # Don't recurse into schemas with no type as that causes warnings
         return self._resolve_any(context)
 
     def _resolve_one_of(

pyopenapi_gen/visit/endpoint/generators/response_handler_generator.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 import logging
 from typing import TYPE_CHECKING, Any, Dict, Optional, TypedDict
 
+from pyopenapi_gen.core.http_status_codes import get_exception_class_name
 from pyopenapi_gen.core.writers.code_writer import CodeWriter
 from pyopenapi_gen.helpers.endpoint_utils import (
     _get_primary_response,
@@ -353,8 +354,8 @@ class EndpointResponseHandlerGenerator:
                         else:
                             writer.write_line("return None")
                 else:
-                    # Error responses
-                    error_class_name = f"Error{status_code_val}"
+                    # Error responses - use human-readable exception names
+                    error_class_name = get_exception_class_name(status_code_val)
                     context.add_import(f"{context.core_package_name}", error_class_name)
                     writer.write_line(f"raise {error_class_name}(response=response)")
 

pyopenapi_gen/visit/exception_visitor.py

@@ -1,40 +1,78 @@
 from pyopenapi_gen import IRSpec
 
 from ..context.render_context import RenderContext
+from ..core.http_status_codes import (
+    get_exception_class_name,
+    get_status_name,
+    is_client_error,
+    is_error_code,
+    is_server_error,
+)
 from ..core.writers.python_construct_renderer import PythonConstructRenderer
 
 
 class ExceptionVisitor:
-    """Visitor for rendering exception alias classes from IRSpec."""
+    """Visitor for rendering exception alias classes from IRSpec.
+
+    This visitor generates exception classes only for error status codes (4xx and 5xx).
+    Success codes (2xx) are intentionally excluded as they represent successful responses.
+    """
 
     def __init__(self) -> None:
         self.renderer = PythonConstructRenderer()
 
-    def visit(self, spec: IRSpec, context: RenderContext) -> tuple[str, list[str]]:
-        # Register base exception imports
-        context.add_import(f"{context.core_package_name}.exceptions", "HTTPError")
+    def visit(self, spec: IRSpec, context: RenderContext) -> tuple[str, list[str], list[int]]:
+        """Generate exception classes from IRSpec.
+
+        Args:
+            spec: The IRSpec containing operations and responses
+            context: Render context for imports and code generation
+
+        Returns:
+            Tuple of (generated_code, exception_class_names, status_codes_list)
+        """
+        # Register base exception imports (only the ones we actually use)
+        # Note: HTTPError is not used in exception_aliases.py, so we don't import it
+        context.add_import("httpx", "Response")  # Third-party import first (Ruff I001)
         context.add_import(f"{context.core_package_name}.exceptions", "ClientError")
         context.add_import(f"{context.core_package_name}.exceptions", "ServerError")
-        context.add_import("httpx", "Response")
 
-        # Collect unique numeric status codes
-        codes = sorted(
-            {int(resp.status_code) for op in spec.operations for resp in op.responses if resp.status_code.isdigit()}
-        )
+        # Collect unique numeric error status codes (4xx and 5xx only)
+        all_codes = {
+            int(resp.status_code) for op in spec.operations for resp in op.responses if resp.status_code.isdigit()
+        }
+        error_codes = sorted([code for code in all_codes if is_error_code(code)])
 
         all_exception_code = []
         generated_alias_names = []
 
         # Use renderer to generate each exception class
-        for code in codes:
-            base_class = "ClientError" if code < 500 else "ServerError"
-            class_name = f"Error{code}"
+        for code in error_codes:
+            # Determine base class using helper functions
+            if is_client_error(code):
+                base_class = "ClientError"
+            elif is_server_error(code):
+                base_class = "ServerError"
+            else:
+                # Should not happen since we filtered to 4xx/5xx, but be defensive
+                continue
+
+            # Get human-readable exception class name (e.g., NotFoundError instead of Error404)
+            class_name = get_exception_class_name(code)
             generated_alias_names.append(class_name)
-            docstring = f"Exception alias for HTTP {code} responses."
+
+            # Get human-readable status name for documentation
+            status_name = get_status_name(code)
+            docstring = f"HTTP {code} {status_name}.\n\nRaised when the server responds with a {code} status code."
 
             # Define the __init__ method body
             init_method_body = [
                 "def __init__(self, response: Response) -> None:",
+                f'    """Initialise {class_name} with the HTTP response.',
+                "",  # Empty line without trailing whitespace (Ruff W293)
+                "    Args:",
+                "        response: The httpx Response object that triggered this exception",
+                '    """',
                 "    super().__init__(status_code=response.status_code, message=response.text, response=response)",
             ]
 
@@ -47,6 +85,6 @@ class ExceptionVisitor:
             )
             all_exception_code.append(exception_code)
 
-        # Join the generated class strings
-        final_code = "\n".join(all_exception_code)
-        return final_code, generated_alias_names
+        # Join the generated class strings with 2 blank lines between classes (PEP 8 / Ruff E302)
+        final_code = "\n\n\n".join(all_exception_code)
+        return final_code, generated_alias_names, error_codes

{pyopenapi_gen-0.12.1.dist-info → pyopenapi_gen-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyopenapi-gen
-Version: 0.12.1
+Version: 0.14.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

{pyopenapi_gen-0.12.1.dist-info → pyopenapi_gen-0.14.0.dist-info}/RECORD

@@ -11,9 +11,10 @@ pyopenapi_gen/context/render_context.py,sha256=AS08ha9WVjgRUsM1LFPjMCgrsHbczHH7c
 pyopenapi_gen/core/CLAUDE.md,sha256=bz48K-PSrhxCq5ScmiLiU9kfpVVzSWRKOA9RdKk_pbg,6482
 pyopenapi_gen/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyopenapi_gen/core/exceptions.py,sha256=HYFiYdmzsZUl46vB8M3B6Vpp6m8iqjUcKDWdL4yEKHo,498
+pyopenapi_gen/core/http_status_codes.py,sha256=lIkKFlRkvVa6xkY4kTq5f7djwYmUmJwRo1kCX8m_cEs,6274
 pyopenapi_gen/core/http_transport.py,sha256=77ZOTyl0_CLuDtSCOVDQoxHDQBnclJgz6f3Hs6cy7hY,9675
 pyopenapi_gen/core/pagination.py,sha256=aeDOKo-Lu8mcSDqv0TlPXV9Ul-Nca76ZuKhQHKlsMUs,2301
-pyopenapi_gen/core/postprocess_manager.py,sha256=ky27ijbq6zEo43aqe-odz9CR3vFD_3XHhQR35XgMZo0,6879
+pyopenapi_gen/core/postprocess_manager.py,sha256=cia8FbDXbulk44ElT1CTlypu1oFjNM41y1gWy8-HSug,9362
 pyopenapi_gen/core/schemas.py,sha256=FOE2e1vIl0vif_C34AehVznJG2W1hampPtJEfL80AxI,5535
 pyopenapi_gen/core/streaming_helpers.py,sha256=XToNnm-EDAqiKh9ZS4GRxyastFkfSyNR0av-NDTZMPg,2706
 pyopenapi_gen/core/telemetry.py,sha256=l6z972882MRzNOXU2leAvtnlYFLMSKKQ_oHz4qU5_n0,2225
@@ -37,7 +38,7 @@ pyopenapi_gen/core/parsing/__init__.py,sha256=RJsIR6cHaNoI4tBcpMlAa0JsY64vsHb9sP
 pyopenapi_gen/core/parsing/context.py,sha256=8cM8mPItvDvJr8ZiukvdHBumlQl9hK1gUZL4BDpHaBk,8005
 pyopenapi_gen/core/parsing/cycle_helpers.py,sha256=nG5ysNavL_6lpnHWFUZR9qraBxqOzuNfI6NgSEa8a5M,5939
 pyopenapi_gen/core/parsing/schema_finalizer.py,sha256=qRTHUoVBQTgGmdfLuBuWxtWdj_SG71STGC3rn-tJvnA,6914
-pyopenapi_gen/core/parsing/schema_parser.py,sha256=W0kCV0ucq6Wybr7x1wZl-nMSRXVWAqI4T57ASSabZsM,30557
+pyopenapi_gen/core/parsing/schema_parser.py,sha256=2hOj1Xz8a2f2PF3oAAG-DwQse9WHt9DzvR6nhQ5dHJU,33148
 pyopenapi_gen/core/parsing/unified_cycle_detection.py,sha256=3nplaCVh2dFwBPbmDc2kiU0SzTPXXktdQ5Rc0Q9Uu9s,10873
 pyopenapi_gen/core/parsing/common/__init__.py,sha256=U3sHMO-l6S3Cm04CVOYmBCpqLEZvCylUI7yQfcTwxYU,27
 pyopenapi_gen/core/parsing/common/type_parser.py,sha256=cK7xtxhoD43K2WjLP9TGip3As3akYeYW7L2XztXCecg,2562
@@ -63,7 +64,7 @@ pyopenapi_gen/core/parsing/transformers/inline_object_promoter.py,sha256=4njv5ra
 pyopenapi_gen/core/writers/code_writer.py,sha256=uWH5tRFIdT3RHsRV1haWQxESwhwMoM2G_CxnKB8uP88,4776
 pyopenapi_gen/core/writers/documentation_writer.py,sha256=Vce-_kD4XDm3HfZb_ibSEKAu2fbTZCzzdojn9TPgFhU,8706
 pyopenapi_gen/core/writers/line_writer.py,sha256=uhysxO6bh_9POUQHhoqYI4_savfAgjH4EcwBdNrVtPc,7759
-pyopenapi_gen/core/writers/python_construct_renderer.py,sha256=H2-dbUoc0wgI5Ll2OiRIRkfaDVBG_rFB4j44NXvF7Fk,12602
+pyopenapi_gen/core/writers/python_construct_renderer.py,sha256=lKj5nR-ULeceapoP2EQQOfmJif7eKAyTuhkCgGd3cI4,12812
 pyopenapi_gen/core_package_template/README.md,sha256=8YP-MS0KxphRbCGBf7kV3dYIFLU9piOJ3IMm3K_0hcI,1488
 pyopenapi_gen/emit/models_emitter.py,sha256=Ty5yHGzvBDYa_qQwbyPNRLWPnHaWR_KLh6pYxT7uePY,7193
 pyopenapi_gen/emitters/CLAUDE.md,sha256=iZYEZq1a1h033rxuh97cMpsKUElv72ysvTm3-QQUvrs,9323
@@ -71,10 +72,10 @@ pyopenapi_gen/emitters/client_emitter.py,sha256=kmMVnG-wAOJm7TUm0xOQ5YnSJfYxz1Sw
 pyopenapi_gen/emitters/core_emitter.py,sha256=RcBsAYQ3ZKcWwtkzQmyHkL7VtDQjbIObFLXD9M_GdpI,8020
 pyopenapi_gen/emitters/docs_emitter.py,sha256=aouKqhRdtVvYfGVsye_uqM80nONRy0SqN06cr1l3OgA,1137
 pyopenapi_gen/emitters/endpoints_emitter.py,sha256=tzSLUzlZle2Lih_aZc4cJ-Y1ItjN5H_rABEWcDwECXA,9586
-pyopenapi_gen/emitters/exceptions_emitter.py,sha256=qPTIPXDyqSUtpmBIp-V4ap1uMHUPmYziCSN62t7qcAE,1918
+pyopenapi_gen/emitters/exceptions_emitter.py,sha256=3k3UTskmZyv_fQXyOudBnBHUvhvQTenjY7qa-KK1F48,7553
 pyopenapi_gen/emitters/models_emitter.py,sha256=Gd0z2Xoze1XkVnajkOptW90ti7197wQ15I7vIITnULM,22243
 pyopenapi_gen/generator/CLAUDE.md,sha256=BS9KkmLvk2WD-Io-_apoWjGNeMU4q4LKy4UOxYF9WxM,10870
-pyopenapi_gen/generator/client_generator.py,sha256=MULKJY9SdRuYjt_R4XCXh3vJSW-92rsxOu-MVpIklho,29333
+pyopenapi_gen/generator/client_generator.py,sha256=_L_MJ9fUG8roD_DhymIM0nsdqOOjlQF_JAkBTND9ttA,29435
 pyopenapi_gen/helpers/CLAUDE.md,sha256=GyIJ0grp4SkD3plAUzyycW4nTUZf9ewtvvsdAGkmIZw,10609
 pyopenapi_gen/helpers/__init__.py,sha256=m4jSQ1sDH6CesIcqIl_kox4LcDFabGxBpSIWVwbHK0M,39
 pyopenapi_gen/helpers/endpoint_utils.py,sha256=bkRu6YddIPQQD3rZLbB8L5WYzG-2Bd_JgMbxMUYY2wY,22198
@@ -97,7 +98,7 @@ pyopenapi_gen/types/contracts/types.py,sha256=-Qvbx3N_14AaN-1BeyocrvsjiwXPn_eWQh
 pyopenapi_gen/types/resolvers/__init__.py,sha256=_5kA49RvyOTyXgt0GbbOfHJcdQw2zHxvU9af8GGyNWc,295
 pyopenapi_gen/types/resolvers/reference_resolver.py,sha256=qnaZeLmtyh4_NBMcKib58s6o5ycUJaattYt8F38_qIo,2053
 pyopenapi_gen/types/resolvers/response_resolver.py,sha256=Kb1a2803lyoukoZy06ztPBlUw-A1lHiZ6NlJmsixxA8,6500
-pyopenapi_gen/types/resolvers/schema_resolver.py,sha256=PsSF-DE8-GDXmvbAJz-tHlTCR-1UATGhT4dHf6kUDQQ,17988
+pyopenapi_gen/types/resolvers/schema_resolver.py,sha256=n8pI9kUJo-vLjZAOPSvwpVmRoM7AzTa7cOMlidYJVXo,21779
 pyopenapi_gen/types/services/__init__.py,sha256=inSUKmY_Vnuym6tC-AhvjCTj16GbkfxCGLESRr_uQPE,123
 pyopenapi_gen/types/services/type_service.py,sha256=-LQj7oSx1mxb10Zi6DpawS8uyoUrUbnYhmUA0GuKZTc,4402
 pyopenapi_gen/types/strategies/__init__.py,sha256=bju8_KEPNIow1-woMO-zJCgK_E0M6JnFq0NFsK1R4Ss,171
@@ -105,7 +106,7 @@ pyopenapi_gen/types/strategies/response_strategy.py,sha256=Y6E3O5xvCrJ2Y6IGn4BWl
 pyopenapi_gen/visit/CLAUDE.md,sha256=Rq2e4S74TXv0ua2ZcCrO6cwCCccf3Yph44oVdj1yFPY,8297
 pyopenapi_gen/visit/client_visitor.py,sha256=vpLCGF353XtBjfS7W69-1b1d79opTb1i6qBue6vSz5g,11152
 pyopenapi_gen/visit/docs_visitor.py,sha256=hqgd4DAoy7T5Bap4mpH4R-nIZSyAWwFYmrIuNHM03Rg,1644
-pyopenapi_gen/visit/exception_visitor.py,sha256=6gWkjEWMYM35_rBNCgB-xdE0RvYwbj49wytAorLHK9k,2097
+pyopenapi_gen/visit/exception_visitor.py,sha256=D4LtLqdeS34kw6WbwhoWeMQzlh9uHqGNZjFtY0kq3Q4,3855
 pyopenapi_gen/visit/visitor.py,sha256=PANoV9zXMUrefr0pBLXIKkDOaTIjQ2hyL82cidVBCLU,3645
 pyopenapi_gen/visit/endpoint/__init__.py,sha256=DftIZSWp6Z8jKWoJE2VGKL4G_5cqwFXe9v-PALMmsGk,73
 pyopenapi_gen/visit/endpoint/endpoint_visitor.py,sha256=1aS0i2D_Y-979_7aBd0W6IS2UVO6wMujsMMw8Qt8PRE,3574
@@ -113,7 +114,7 @@ pyopenapi_gen/visit/endpoint/generators/__init__.py,sha256=-X-GYnJZ9twiEBr_U0obW
 pyopenapi_gen/visit/endpoint/generators/docstring_generator.py,sha256=U02qvuYtFElQNEtOHuTNXFl2NxUriIiuZMkmUsapOg4,5913
 pyopenapi_gen/visit/endpoint/generators/endpoint_method_generator.py,sha256=wUJ4_gaA1gRrFCHYFCObBIankxGQu0MNqiOSoZOZmoA,4352
 pyopenapi_gen/visit/endpoint/generators/request_generator.py,sha256=OnkrkRk39_BrK9ZDvyWqJYLz1mocD2zY7j70yIpS0J4,5374
-pyopenapi_gen/visit/endpoint/generators/response_handler_generator.py,sha256=xbh4GQcA-fA98mOZxVSylLbZADse-7RLcLIbjnVAmlE,22834
+pyopenapi_gen/visit/endpoint/generators/response_handler_generator.py,sha256=OAD3_CDXiA0lXv7KvUjmp6QBBYxs569vmP-6K_SuGJc,22961
 pyopenapi_gen/visit/endpoint/generators/signature_generator.py,sha256=CYtfsPMlTZN95g2WxrdnTloGx2RmqeNQRiyP9fOkUEQ,3892
 pyopenapi_gen/visit/endpoint/generators/url_args_generator.py,sha256=EsmNuVSkGfUqrmV7-1GiLPzdN86V5UqLfs1SVY0jsf0,9590
 pyopenapi_gen/visit/endpoint/processors/__init__.py,sha256=_6RqpOdDuDheArqDBi3ykhsaetACny88WUuuAJvr_ME,29
@@ -124,8 +125,8 @@ pyopenapi_gen/visit/model/alias_generator.py,sha256=TGL3AMq_PkBWFWeeXbNnA8hgO9hv
 pyopenapi_gen/visit/model/dataclass_generator.py,sha256=nyTvBph6rtbJlCwTiDW_Y2UJmLLiA6D2QJUpA2xE0m8,10289
 pyopenapi_gen/visit/model/enum_generator.py,sha256=AXqKUFuWUUjUF_6_HqBKY8vB5GYu35Pb2C2WPFrOw1k,10061
 pyopenapi_gen/visit/model/model_visitor.py,sha256=4kAQSWsI4XumVYB3aAE7Ts_31hGfDlbytRalxyMFV3g,9510
-pyopenapi_gen-0.12.1.dist-info/METADATA,sha256=JuNfuruc2Nc7du_GdSrJh9MCXDvEcjP8bTNk5QyzuaU,14025
-pyopenapi_gen-0.12.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pyopenapi_gen-0.12.1.dist-info/entry_points.txt,sha256=gxSlNiwom50T3OEZnlocA6qRjGdV0bn6hN_Xr-Ub5wA,56
-pyopenapi_gen-0.12.1.dist-info/licenses/LICENSE,sha256=UFAyTWKa4w10-QerlJaHJeep7G2gcwpf-JmvI2dS2Gc,1088
-pyopenapi_gen-0.12.1.dist-info/RECORD,,
+pyopenapi_gen-0.14.0.dist-info/METADATA,sha256=VQEURt-RzzvWvLDj0mDetS6zNnRNGx41B1pYO2wKJ0o,14025
+pyopenapi_gen-0.14.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyopenapi_gen-0.14.0.dist-info/entry_points.txt,sha256=gxSlNiwom50T3OEZnlocA6qRjGdV0bn6hN_Xr-Ub5wA,56
+pyopenapi_gen-0.14.0.dist-info/licenses/LICENSE,sha256=UFAyTWKa4w10-QerlJaHJeep7G2gcwpf-JmvI2dS2Gc,1088
+pyopenapi_gen-0.14.0.dist-info/RECORD,,