pyopenapi-gen 0.13.0__py3-none-any.whl → 0.14.1__py3-none-any.whl

pyopenapi_gen/emitters/endpoints_emitter.py

@@ -1,6 +1,6 @@
 import logging
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import List, Tuple
 
 from pyopenapi_gen import IROperation, IRParameter, IRRequestBody
 from pyopenapi_gen.context.render_context import RenderContext
@@ -17,7 +17,7 @@ PARAM_TYPE_MAPPING = {
     "boolean": "bool",
     "string": "str",
     "array": "List",
-    "object": "Dict[str, Any]",
+    "object": "dict[str, Any]",
 }
 # Format-specific overrides
 PARAM_FORMAT_MAPPING = {
@@ -47,7 +47,7 @@ def schema_to_type(schema: IRParameter) -> str:
     # Array handling
     elif s.type == "array" and s.items:
         # For array items, we recursively call schema_to_type.
-        # The nullability of the item_type itself (e.g. List[Optional[int]])
+        # The nullability of the item_type itself (e.g. List[int | None])
         # will be handled by the recursive call based on s.items.is_nullable.
         item_schema_as_param = IRParameter(name="_item", param_in="_internal", required=False, schema=s.items)
         item_type_str = schema_to_type(item_schema_as_param)
@@ -70,8 +70,8 @@ def schema_to_type(schema: IRParameter) -> str:
     # 2. Apply nullability based on IRSchema's is_nullable field
     # This s.is_nullable should be the source of truth from the IR after parsing.
     if s.is_nullable:
-        # Ensure "Any" also gets wrapped, e.g. Optional[Any]
-        py_type = f"Optional[{py_type}]"
+        # Ensure "Any" also gets wrapped, e.g. Any | None
+        py_type = f"{py_type} | None"
 
     return py_type
 
@@ -82,7 +82,7 @@ def _get_request_body_type(body: IRRequestBody) -> str:
         if "json" in mt.lower():
             return schema_to_type(IRParameter(name="body", param_in="body", required=body.required, schema=sch))
     # Fallback to generic dict
-    return "Dict[str, Any]"
+    return "dict[str, Any]"
 
 
 def _deduplicate_tag_clients(client_classes: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
@@ -106,7 +106,7 @@ class EndpointsEmitter:
     def __init__(self, context: RenderContext) -> None:
         self.context = context
         self.formatter = Formatter()
-        self.visitor: Optional[EndpointVisitor] = None
+        self.visitor: EndpointVisitor | None = None
 
     def _deduplicate_operation_ids(self, operations: List[IROperation]) -> None:
         """
@@ -115,7 +115,7 @@ class EndpointsEmitter:
         Args:
             operations: List of operations for a single tag.
         """
-        seen_methods: Dict[str, int] = {}
+        seen_methods: dict[str, int] = {}
         for op in operations:
             method_name = NameSanitizer.sanitize_method_name(op.operation_id)
             if method_name in seen_methods:
@@ -144,7 +144,7 @@ class EndpointsEmitter:
                 self.context.file_manager.write_file(str(file_path), content)
 
         # Ensure parsed_schemas is at least an empty dict if None,
-        # as EndpointVisitor expects Dict[str, IRSchema]
+        # as EndpointVisitor expects dict[str, IRSchema]
         current_parsed_schemas = self.context.parsed_schemas
         if current_parsed_schemas is None:
             logger.warning(
@@ -156,8 +156,8 @@ class EndpointsEmitter:
         if self.visitor is None:
             self.visitor = EndpointVisitor(current_parsed_schemas)  # Pass the (potentially defaulted) dict
 
-        tag_key_to_ops: Dict[str, List[IROperation]] = {}
-        tag_key_to_candidates: Dict[str, List[str]] = {}
+        tag_key_to_ops: dict[str, List[IROperation]] = {}
+        tag_key_to_candidates: dict[str, List[str]] = {}
         for op in operations:
             tags = op.tags or [DEFAULT_TAG]
             for tag in tags:
@@ -175,7 +175,7 @@ class EndpointsEmitter:
             upper = sum(1 for c in t if c.isupper())
             return (is_pascal, word_count, upper, t)
 
-        tag_map: Dict[str, str] = {}
+        tag_map: dict[str, str] = {}
         for key, candidates in tag_key_to_candidates.items():
             best_tag_for_key = DEFAULT_TAG  # Default if no candidates somehow
             if candidates:

pyopenapi_gen/emitters/exceptions_emitter.py

@@ -1,34 +1,46 @@
+import json
 import os
-from typing import Optional
+from pathlib import Path
 
 from pyopenapi_gen import IRSpec
 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:
+    def __init__(self, core_package_name: str = "core", overall_project_root: str | None = 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: str | None = 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 +49,139 @@ 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
+        alias_names.sort()
+
+        # 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/emitters/models_emitter.py

@@ -1,6 +1,6 @@
 import logging
 from pathlib import Path
-from typing import Dict, List, Optional, Set
+from typing import List, Set
 
 from pyopenapi_gen import IRSchema, IRSpec
 from pyopenapi_gen.context.render_context import RenderContext
@@ -22,15 +22,15 @@ class ModelsEmitter:
     Handles creation of __init__.py and py.typed files.
     """
 
-    def __init__(self, context: RenderContext, parsed_schemas: Dict[str, IRSchema]):
+    def __init__(self, context: RenderContext, parsed_schemas: dict[str, IRSchema]):
         self.context: RenderContext = context
         # Store a reference to the schemas that were passed in.
         # These schemas will have their .generation_name and .final_module_stem updated.
-        self.parsed_schemas: Dict[str, IRSchema] = parsed_schemas
+        self.parsed_schemas: dict[str, IRSchema] = parsed_schemas
         self.import_collector = self.context.import_collector
         self.writer = CodeWriter()
 
-    def _generate_model_file(self, schema_ir: IRSchema, models_dir: Path) -> Optional[str]:
+    def _generate_model_file(self, schema_ir: IRSchema, models_dir: Path) -> str | None:
         """Generates a single Python file for a given IRSchema."""
         if not schema_ir.name:  # Original name, used for logging/initial identification
             logger.warning(f"Skipping model generation for schema without an original name: {schema_ir}")
@@ -168,7 +168,7 @@ class ModelsEmitter:
         generated_content = init_writer.get_code()
         return generated_content
 
-    def emit(self, spec: IRSpec, output_root: str) -> Dict[str, List[str]]:
+    def emit(self, spec: IRSpec, output_root: str) -> dict[str, List[str]]:
         """Emits all model files derived from IR schemas.
 
         Contracts:
@@ -352,7 +352,7 @@ class ModelsEmitter:
 
                 # Fetch the schema_ir object using the key from all_schemas_for_generation
                 # This ensures we are working with the potentially newly created & named schemas.
-                current_schema_ir_obj: Optional[IRSchema] = all_schemas_for_generation.get(schema_key)
+                current_schema_ir_obj: IRSchema | None = all_schemas_for_generation.get(schema_key)
 
                 if not current_schema_ir_obj:
                     logger.warning(f"Schema key '{schema_key}' from all_schemas_for_generation not found. Skipping.")

pyopenapi_gen/generator/client_generator.py

@@ -9,7 +9,7 @@ import tempfile
 import time
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, List
 
 from pyopenapi_gen.context.render_context import RenderContext
 from pyopenapi_gen.core.loader.loader import load_ir_from_spec
@@ -47,9 +47,9 @@ class ClientGenerator:
         """
         self.verbose = verbose
         self.start_time = time.time()
-        self.timings: Dict[str, float] = {}
+        self.timings: dict[str, float] = {}
 
-    def _log_progress(self, message: str, stage: Optional[str] = None) -> None:
+    def _log_progress(self, message: str, stage: str | None = None) -> None:
         """
         Log a progress message with timestamp.
 
@@ -89,7 +89,7 @@ class ClientGenerator:
         output_package: str,
         force: bool = False,
         no_postprocess: bool = False,
-        core_package: Optional[str] = None,
+        core_package: str | None = None,
     ) -> List[Path]:
         """
         Generate the client code from the OpenAPI spec.
@@ -99,10 +99,10 @@ class ClientGenerator:
             project_root (Path): Path to the root of the Python project (absolute or relative).
             output_package (str): Python package path for the generated client (e.g., 'pyapis.my_api_client').
             force (bool): Overwrite output without diff check.
-            name (Optional[str]): Custom client package name (not used).
+            name (str | None): Custom client package name (not used).
             docs (bool): Kept for interface compatibility.
             telemetry (bool): Kept for interface compatibility.
-            auth (Optional[str]): Kept for interface compatibility.
+            auth (str | None): Kept for interface compatibility.
             no_postprocess (bool): Skip post-processing (type checking, etc.).
             core_package (str): Python package path for the core package.
 
@@ -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/helpers/endpoint_utils.py

@@ -5,7 +5,7 @@ Used by EndpointVisitor and related emitters.
 
 import logging
 import re
-from typing import Any, Dict, List, Optional
+from typing import Any, List
 
 from pyopenapi_gen import IROperation, IRParameter, IRRequestBody, IRResponse, IRSchema
 from pyopenapi_gen.context.render_context import RenderContext
@@ -17,7 +17,7 @@ from ..types.services.type_service import UnifiedTypeService
 logger = logging.getLogger(__name__)
 
 
-def get_params(op: IROperation, context: RenderContext, schemas: Dict[str, IRSchema]) -> List[Dict[str, Any]]:
+def get_params(op: IROperation, context: RenderContext, schemas: dict[str, IRSchema]) -> List[dict[str, Any]]:
     """
     Returns a list of dicts with name, type, default, and required for template rendering.
     Requires the full schema dictionary for type resolution.
@@ -37,7 +37,7 @@ def get_params(op: IROperation, context: RenderContext, schemas: Dict[str, IRSch
     return params
 
 
-def get_param_type(param: IRParameter, context: RenderContext, schemas: Dict[str, IRSchema]) -> str:
+def get_param_type(param: IRParameter, context: RenderContext, schemas: dict[str, IRSchema]) -> str:
     """Returns the Python type hint for a parameter, resolving references using the schemas dict."""
     # Use unified service for type resolution
     type_service = UnifiedTypeService(schemas)
@@ -59,7 +59,7 @@ def get_param_type(param: IRParameter, context: RenderContext, schemas: Dict[str
     return py_type
 
 
-def get_request_body_type(body: IRRequestBody, context: RenderContext, schemas: Dict[str, IRSchema]) -> str:
+def get_request_body_type(body: IRRequestBody, context: RenderContext, schemas: dict[str, IRSchema]) -> str:
     """Returns the Python type hint for a request body, resolving references using the schemas dict."""
     # Prefer application/json schema if available
     json_schema = body.content.get("application/json")
@@ -70,11 +70,11 @@ def get_request_body_type(body: IRRequestBody, context: RenderContext, schemas:
         if py_type.startswith(".") and not py_type.startswith(".."):
             py_type = "models" + py_type
 
-        # If the resolved type is 'Any' for a JSON body, default to Dict[str, Any]
+        # If the resolved type is 'Any' for a JSON body, default to dict[str, Any]
         if py_type == "Any":
             context.add_import("typing", "Dict")
             # context.add_import("typing", "Any") # Already added by the fallback or TypeHelper
-            return "Dict[str, Any]"
+            return "dict[str, Any]"
         return py_type
     # Fallback for other content types (e.g., octet-stream)
     # TODO: Handle other types more specifically if needed
@@ -89,7 +89,7 @@ def get_request_body_type(body: IRRequestBody, context: RenderContext, schemas:
 def get_return_type(
     op: IROperation,
     context: RenderContext,
-    schemas: Dict[str, IRSchema],
+    schemas: dict[str, IRSchema],
 ) -> tuple[str | None, bool]:
     """
     DEPRECATED: Use get_return_type_unified instead.
@@ -136,7 +136,7 @@ def get_return_type(
     return (py_type, False)
 
 
-def _get_primary_response(op: IROperation) -> Optional[IRResponse]:
+def _get_primary_response(op: IROperation) -> IRResponse | None:
     """Helper to find the best primary success response."""
     resp = None
     # Prioritize 200, 201, 202, 204
@@ -158,7 +158,7 @@ def _get_primary_response(op: IROperation) -> Optional[IRResponse]:
     return None
 
 
-def _get_response_schema_and_content_type(resp: IRResponse) -> tuple[Optional[IRSchema], Optional[str]]:
+def _get_response_schema_and_content_type(resp: IRResponse) -> tuple[IRSchema | None, str | None]:
     """Helper to get the schema and content type from a response."""
     if not resp.content:
         return None, None
@@ -179,7 +179,7 @@ def _get_response_schema_and_content_type(resp: IRResponse) -> tuple[Optional[IR
     return resp.content.get(mt), mt
 
 
-def _find_resource_schema(update_schema_name: str, schemas: Dict[str, IRSchema]) -> Optional[IRSchema]:
+def _find_resource_schema(update_schema_name: str, schemas: dict[str, IRSchema]) -> IRSchema | None:
     """
     Given an update schema name (e.g. 'TenantUpdate'), try to find the corresponding
     resource schema (e.g. 'Tenant') in the schemas dictionary.
@@ -205,7 +205,7 @@ def _find_resource_schema(update_schema_name: str, schemas: Dict[str, IRSchema])
     return None
 
 
-def _infer_type_from_path(path: str, schemas: Dict[str, IRSchema]) -> Optional[IRSchema]:
+def _infer_type_from_path(path: str, schemas: dict[str, IRSchema]) -> IRSchema | None:
     """
     Infers a response type from a path. This is used when a response schema is not specified.
 
@@ -350,8 +350,8 @@ def merge_params_with_model_fields(
     op: IROperation,
     model_schema: IRSchema,
     context: RenderContext,
-    schemas: Dict[str, IRSchema],
-) -> List[Dict[str, Any]]:
+    schemas: dict[str, IRSchema],
+) -> List[dict[str, Any]]:
     """
     Merge endpoint parameters with required model fields for function signatures.
     - Ensures all required model fields are present as parameters (without duplication).
@@ -484,7 +484,7 @@ def get_type_for_specific_response(
         ctx.add_import("typing", "AsyncIterator")
         ctx.add_import("typing", "Dict")
         ctx.add_import("typing", "Any")
-        return "AsyncIterator[Dict[str, Any]]"
+        return "AsyncIterator[dict[str, Any]]"
 
     return final_py_type
 
@@ -504,9 +504,7 @@ def _is_binary_stream_content(resp_ir: IRResponse) -> bool:
     )
 
 
-def _get_item_type_from_schema(
-    resp_ir: IRResponse, all_schemas: dict[str, IRSchema], ctx: RenderContext
-) -> Optional[str]:
+def _get_item_type_from_schema(resp_ir: IRResponse, all_schemas: dict[str, IRSchema], ctx: RenderContext) -> str | None:
     """Extract item type from schema for streaming responses."""
     schema, _ = _get_response_schema_and_content_type(resp_ir)
     if not schema:
@@ -528,7 +526,7 @@ def get_python_type_for_response_body(resp_ir: IRResponse, all_schemas: dict[str
     return type_service.resolve_schema_type(schema, ctx, required=True)
 
 
-def get_schema_from_response(resp_ir: IRResponse, all_schemas: dict[str, IRSchema]) -> Optional[IRSchema]:
+def get_schema_from_response(resp_ir: IRResponse, all_schemas: dict[str, IRSchema]) -> IRSchema | None:
     """Get the schema from a response object."""
     schema, _ = _get_response_schema_and_content_type(resp_ir)
     return schema