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

pyopenapi_gen/core/parsing/unified_cycle_detection.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Dict, List, Optional, Set
+from typing import List, Set
 
 from pyopenapi_gen import IRSchema
 from pyopenapi_gen.core.utils import NameSanitizer
@@ -62,10 +62,10 @@ class CycleDetectionResult:
     """Result of cycle detection check."""
 
     is_cycle: bool
-    cycle_type: Optional[CycleType]
+    cycle_type: CycleType | None
     action: CycleAction
-    cycle_info: Optional[CycleInfo] = None
-    placeholder_schema: Optional[IRSchema] = None
+    cycle_info: CycleInfo | None = None
+    placeholder_schema: IRSchema | None = None
 
 
 @dataclass
@@ -74,8 +74,8 @@ class UnifiedCycleContext:
 
     # Core tracking
     schema_stack: List[str] = field(default_factory=list)
-    schema_states: Dict[str, SchemaState] = field(default_factory=dict)
-    parsed_schemas: Dict[str, IRSchema] = field(default_factory=dict)
+    schema_states: dict[str, SchemaState] = field(default_factory=dict)
+    parsed_schemas: dict[str, IRSchema] = field(default_factory=dict)
     recursion_depth: int = 0
 
     # Detection results
@@ -155,7 +155,7 @@ def create_depth_placeholder(schema_name: str, depth: int) -> IRSchema:
     )
 
 
-def unified_cycle_check(schema_name: Optional[str], context: UnifiedCycleContext) -> CycleDetectionResult:
+def unified_cycle_check(schema_name: str | None, context: UnifiedCycleContext) -> CycleDetectionResult:
     """Unified cycle detection that handles all cases."""
 
     if schema_name is None:
@@ -262,7 +262,7 @@ def unified_cycle_check(schema_name: Optional[str], context: UnifiedCycleContext
     return CycleDetectionResult(False, None, CycleAction.CONTINUE_PARSING)
 
 
-def unified_enter_schema(schema_name: Optional[str], context: UnifiedCycleContext) -> CycleDetectionResult:
+def unified_enter_schema(schema_name: str | None, context: UnifiedCycleContext) -> CycleDetectionResult:
     """Unified entry point that always maintains consistent state."""
     context.recursion_depth += 1
 
@@ -275,7 +275,7 @@ def unified_enter_schema(schema_name: Optional[str], context: UnifiedCycleContex
     return result
 
 
-def unified_exit_schema(schema_name: Optional[str], context: UnifiedCycleContext) -> None:
+def unified_exit_schema(schema_name: str | None, context: UnifiedCycleContext) -> None:
     """Unified exit that always maintains consistent state."""
     if context.recursion_depth > 0:
         context.recursion_depth -= 1
@@ -288,6 +288,6 @@ def unified_exit_schema(schema_name: Optional[str], context: UnifiedCycleContext
         context.schema_states[schema_name] = SchemaState.COMPLETED
 
 
-def get_schema_or_placeholder(schema_name: str, context: UnifiedCycleContext) -> Optional[IRSchema]:
+def get_schema_or_placeholder(schema_name: str, context: UnifiedCycleContext) -> IRSchema | None:
     """Get an existing schema or placeholder from the context."""
     return context.parsed_schemas.get(schema_name)

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/schemas.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import MISSING, dataclass, fields
-from typing import Any, Dict, Type, TypeVar, Union, get_args, get_origin, get_type_hints
+from typing import Any, Type, TypeVar, Union, get_args, get_origin, get_type_hints
 
 T = TypeVar("T", bound="BaseSchema")
 
@@ -10,7 +10,7 @@ def _extract_base_type(field_type: Any) -> Any:
     """Extract the base type from Optional/Union types."""
     origin = get_origin(field_type)
     if origin is Union:
-        # For Optional[T] or Union[T, None], get the non-None type
+        # For T | None or Union[T, None], get the non-None type
         args = get_args(field_type)
         non_none_args = [arg for arg in args if arg is not type(None)]
         if len(non_none_args) == 1:
@@ -23,26 +23,26 @@ class BaseSchema:
     """Base class for all generated models, providing validation, dict conversion, and field mapping."""
 
     @classmethod
-    def _get_field_mappings(cls) -> Dict[str, str]:
+    def _get_field_mappings(cls) -> dict[str, str]:
         """Get field mappings from Meta class if defined. Returns API field -> Python field mappings."""
         if hasattr(cls, "Meta") and hasattr(cls.Meta, "key_transform_with_load"):
             return cls.Meta.key_transform_with_load  # type: ignore[no-any-return]
         return {}
 
     @classmethod
-    def _get_reverse_field_mappings(cls) -> Dict[str, str]:
+    def _get_reverse_field_mappings(cls) -> dict[str, str]:
         """Get reverse field mappings. Returns Python field -> API field mappings."""
         mappings = cls._get_field_mappings()
         return {python_field: api_field for api_field, python_field in mappings.items()}
 
     @classmethod
-    def from_dict(cls: Type[T], data: Dict[str, Any]) -> T:
+    def from_dict(cls: Type[T], data: dict[str, Any]) -> T:
         """Create an instance from a dictionary with automatic field name mapping."""
         if not isinstance(data, dict):
             raise TypeError(f"Input must be a dictionary, got {type(data).__name__}")
 
         field_mappings = cls._get_field_mappings()  # API -> Python
-        kwargs: Dict[str, Any] = {}
+        kwargs: dict[str, Any] = {}
         cls_fields = {f.name: f for f in fields(cls)}
 
         # Process each field in the data
@@ -64,7 +64,7 @@ class BaseSchema:
                     # Fall back to raw annotation if get_type_hints fails
                     pass
 
-                # Extract base type (handles Optional[Type] -> Type)
+                # Extract base type (handles Type | None -> Type)
                 base_type = _extract_base_type(field_type)
 
                 if base_type is not None and hasattr(base_type, "from_dict") and isinstance(value, dict):
@@ -90,7 +90,7 @@ class BaseSchema:
 
         return cls(**kwargs)
 
-    def to_dict(self, exclude_none: bool = False) -> Dict[str, Any]:
+    def to_dict(self, exclude_none: bool = False) -> dict[str, Any]:
         """Convert the model instance to a dictionary with reverse field name mapping."""
         reverse_mappings = self._get_reverse_field_mappings()  # Python -> API
         result = {}
@@ -116,10 +116,10 @@ class BaseSchema:
 
     # Legacy aliases for backward compatibility
     @classmethod
-    def model_validate(cls: Type[T], data: Dict[str, Any]) -> T:
+    def model_validate(cls: Type[T], data: dict[str, Any]) -> T:
         """Legacy alias for from_dict."""
         return cls.from_dict(data)
 
-    def model_dump(self, exclude_none: bool = False) -> Dict[str, Any]:
+    def model_dump(self, exclude_none: bool = False) -> dict[str, Any]:
         """Legacy alias for to_dict."""
         return self.to_dict(exclude_none=exclude_none)

pyopenapi_gen/core/streaming_helpers.py

@@ -1,17 +1,15 @@
 import json
-from typing import Any, AsyncIterator, List, Optional
+from typing import Any, AsyncIterator, List
 
 import httpx
 
 
 class SSEEvent:
-    def __init__(
-        self, data: str, event: Optional[str] = None, id: Optional[str] = None, retry: Optional[int] = None
-    ) -> None:
+    def __init__(self, data: str, event: str | None = None, id: str | None = None, retry: int | None = None) -> None:
         self.data: str = data
-        self.event: Optional[str] = event
-        self.id: Optional[str] = id
-        self.retry: Optional[int] = retry
+        self.event: str | None = event
+        self.id: str | None = id
+        self.retry: int | None = retry
 
     def __repr__(self) -> str:
         return f"SSEEvent(data={self.data!r}, event={self.event!r}, id={self.id!r}, retry={self.retry!r})"

pyopenapi_gen/core/telemetry.py

@@ -8,7 +8,7 @@ usage telemetry for PyOpenAPI Generator. Telemetry is opt-in only.
 import json
 import os
 import time
-from typing import Any, Dict, Optional
+from typing import Any
 
 
 class TelemetryClient:
@@ -24,7 +24,7 @@ class TelemetryClient:
         enabled: Whether telemetry is currently enabled
     """
 
-    def __init__(self, enabled: Optional[bool] = None) -> None:
+    def __init__(self, enabled: bool | None = None) -> None:
         """
         Initialize a new TelemetryClient.
 
@@ -38,7 +38,7 @@ class TelemetryClient:
         else:
             self.enabled = enabled
 
-    def track_event(self, event: str, properties: Optional[Dict[str, Any]] = None) -> None:
+    def track_event(self, event: str, properties: dict[str, Any] | None = None) -> None:
         """
         Track a telemetry event if telemetry is enabled.
 
@@ -52,7 +52,7 @@ class TelemetryClient:
         if not self.enabled:
             return
 
-        data: Dict[str, Any] = {
+        data: dict[str, Any] = {
             "event": event,
             "properties": properties or {},
             "timestamp": time.time(),

pyopenapi_gen/core/utils.py

@@ -8,7 +8,7 @@ import keyword
 import logging
 import re
 from datetime import datetime
-from typing import Any, Dict, Set, Type, TypeVar, cast
+from typing import Any, Set, Type, TypeVar, cast
 
 logger = logging.getLogger(__name__)
 
@@ -228,7 +228,7 @@ class ParamSubstitutor:
     """Helper for rendering path templates with path parameters."""
 
     @staticmethod
-    def render_path(template: str, values: Dict[str, Any]) -> str:
+    def render_path(template: str, values: dict[str, Any]) -> str:
         """Replace placeholders in a URL path template using provided values."""
         rendered = template
         for key, val in values.items():
@@ -240,7 +240,7 @@ class KwargsBuilder:
     """Builder for assembling HTTP request keyword arguments."""
 
     def __init__(self) -> None:
-        self._kwargs: Dict[str, Any] = {}
+        self._kwargs: dict[str, Any] = {}
 
     def with_params(self, **params: Any) -> "KwargsBuilder":
         """Add query parameters, skipping None values."""
@@ -254,7 +254,7 @@ class KwargsBuilder:
         self._kwargs["json"] = body
         return self
 
-    def build(self) -> Dict[str, Any]:
+    def build(self) -> dict[str, Any]:
         """Return the assembled kwargs dictionary."""
         return self._kwargs
 
@@ -263,10 +263,10 @@ class Formatter:
     """Helper to format code using Black, falling back to unformatted content if Black is unavailable or errors."""
 
     def __init__(self) -> None:
-        from typing import Any, Callable, Optional
+        from typing import Any, Callable
 
-        self._file_mode: Optional[Any] = None
-        self._format_str: Optional[Callable[..., str]] = None
+        self._file_mode: Any | None = None
+        self._format_str: Callable[..., str] | None = None
         try:
             from black import FileMode, format_str
 

pyopenapi_gen/core/writers/code_writer.py

@@ -6,7 +6,7 @@ writing lines and blocks, and supporting wrapped output for code and docstrings.
 to be used by code generation visitors and emitters to ensure consistent, readable output.
 """
 
-from typing import List, Optional
+from typing import List
 
 from .line_writer import LineWriter
 
@@ -88,7 +88,7 @@ class CodeWriter:
         self.writer.max_width = old_width
 
     def write_function_signature(
-        self, name: str, args: List[str], return_type: Optional[str] = None, async_: bool = False
+        self, name: str, args: List[str], return_type: str | None = None, async_: bool = False
     ) -> None:
         """
         Write a function or method signature, with each argument on its own line and correct indentation.

pyopenapi_gen/core/writers/documentation_writer.py

@@ -6,7 +6,7 @@ for building comprehensive, type-rich docstrings for generated Python code. It s
 alignment, line wrapping, and section formatting for Args, Returns, and Raises.
 """
 
-from typing import List, Optional, Tuple, Union
+from typing import List, Tuple, Union
 
 from .line_writer import LineWriter
 
@@ -16,36 +16,36 @@ class DocumentationBlock:
     Data container for docstring content.
 
     Attributes:
-        summary (Optional[str]): The summary line for the docstring.
-        description (Optional[str]): The detailed description.
+        summary (str | None): The summary line for the docstring.
+        description (str | None): The detailed description.
         args (Optional[List[Union[Tuple[str, str, str], Tuple[str, str]]]]):
             List of arguments as (name, type, desc) or (type, desc) tuples.
-        returns (Optional[Tuple[str, str]]): The return type and description.
-        raises (Optional[List[Tuple[str, str]]]): List of (exception type, description) tuples.
+        returns (Tuple[str, str] | None): The return type and description.
+        raises (List[Tuple[str, str]] | None): List of (exception type, description) tuples.
     """
 
     def __init__(
         self,
-        summary: Optional[str] = None,
-        description: Optional[str] = None,
-        args: Optional[List[Union[Tuple[str, str, str], Tuple[str, str]]]] = None,
-        returns: Optional[Tuple[str, str]] = None,
-        raises: Optional[List[Tuple[str, str]]] = None,
+        summary: str | None = None,
+        description: str | None = None,
+        args: List[Union[Tuple[str, str, str], Tuple[str, str]]] | None = None,
+        returns: Tuple[str, str] | None = None,
+        raises: List[Tuple[str, str]] | None = None,
     ) -> None:
         """
         Initialize a DocumentationBlock.
 
         Args:
-            summary (Optional[str]): The summary line.
-            description (Optional[str]): The detailed description.
+            summary (str | None): The summary line.
+            description (str | None): The detailed description.
             args (Optional[List[Union[Tuple[str, str, str], Tuple[str, str]]]]): Arguments.
-            returns (Optional[Tuple[str, str]]): Return type and description.
-            raises (Optional[List[Tuple[str, str]]]): Exceptions.
+            returns (Tuple[str, str] | None): Return type and description.
+            raises (List[Tuple[str, str]] | None): Exceptions.
         """
-        self.summary: Optional[str] = summary
-        self.description: Optional[str] = description
+        self.summary: str | None = summary
+        self.description: str | None = description
         self.args: List[Union[Tuple[str, str, str], Tuple[str, str]]] = args or []
-        self.returns: Optional[Tuple[str, str]] = returns
+        self.returns: Tuple[str, str] | None = returns
         self.raises: List[Tuple[str, str]] = raises or []
 
 
@@ -58,7 +58,7 @@ class DocumentationFormatter:
         self.width: int = width
         self.min_desc_col: int = min_desc_col
 
-    def wrap(self, text: str, indent: int, prefix: Optional[str] = None) -> List[str]:
+    def wrap(self, text: str, indent: int, prefix: str | None = None) -> List[str]:
         if not text:
             return []
         writer = LineWriter(max_width=self.width)

pyopenapi_gen/core/writers/line_writer.py

@@ -5,7 +5,7 @@ This class is designed for use in both code and documentation generation, provid
 new lines, and query the current line's width.
 """
 
-from typing import List, Optional
+from typing import List
 
 
 class LineWriter:
@@ -169,7 +169,7 @@ class LineWriter:
             self.lines[-1] += " " * (col - current - 1)
         # If already at or past col, do nothing
 
-    def append_wrapped_at_column(self, text: str, width: int, col: Optional[int] = None) -> None:
+    def append_wrapped_at_column(self, text: str, width: int, col: int | None = None) -> None:
         """
         Append text, wrapping as needed, so that the first line continues from the current position,
         and all subsequent lines start at column `col`.
@@ -180,7 +180,7 @@ class LineWriter:
         Args:
             text (str)          : The text to append and wrap.
             width (int)         : The maximum line width.
-            col (Optional[int]) : The column at which to start wrapped lines. If None, uses current
+            col (int | None) : The column at which to start wrapped lines. If None, uses current
                                   line width.
         """
         import textwrap

pyopenapi_gen/core/writers/python_construct_renderer.py

@@ -7,7 +7,7 @@ It handles all the details of formatting, import registration, and docstring gen
 for these constructs.
 """
 
-from typing import Dict, List, Optional, Tuple
+from typing import List, Tuple
 
 from pyopenapi_gen.context.render_context import RenderContext
 
@@ -35,7 +35,7 @@ class PythonConstructRenderer:
         self,
         alias_name: str,
         target_type: str,
-        description: Optional[str],
+        description: str | None,
         context: RenderContext,
     ) -> str:
         """
@@ -80,7 +80,7 @@ class PythonConstructRenderer:
         enum_name: str,
         base_type: str,  # 'str' or 'int'
         values: List[Tuple[str, str | int]],  # List of (MEMBER_NAME, value)
-        description: Optional[str],
+        description: str | None,
         context: RenderContext,
     ) -> str:
         """
@@ -143,10 +143,10 @@ class PythonConstructRenderer:
     def render_dataclass(
         self,
         class_name: str,
-        fields: List[Tuple[str, str, Optional[str], Optional[str]]],  # name, type_hint, default_expr, description
-        description: Optional[str],
+        fields: List[Tuple[str, str, str | None, str | None]],  # name, type_hint, default_expr, description
+        description: str | None,
         context: RenderContext,
-        field_mappings: Optional[Dict[str, str]] = None,
+        field_mappings: dict[str, str] | None = None,
     ) -> str:
         """
         Render a dataclass as Python code with BaseSchema support.
@@ -168,7 +168,7 @@ class PythonConstructRenderer:
                 \"\"\"User information with automatic JSON field mapping.\"\"\"
                 id_: str
                 first_name: str
-                email: Optional[str] = None
+                email: str | None = None
                 is_active: bool = True
 
                 class Meta:
@@ -274,9 +274,9 @@ class PythonConstructRenderer:
     def render_class(
         self,
         class_name: str,
-        base_classes: Optional[List[str]],
-        docstring: Optional[str],
-        body_lines: Optional[List[str]],
+        base_classes: List[str] | None,
+        docstring: str | None,
+        body_lines: List[str] | None,
         context: RenderContext,
     ) -> str:
         """
@@ -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/emit/models_emitter.py

@@ -1,6 +1,6 @@
 import logging
 from pathlib import Path
-from typing import List, Optional
+from typing import List
 
 from pyopenapi_gen.context.render_context import RenderContext
 from pyopenapi_gen.core.utils import NameSanitizer
@@ -20,7 +20,7 @@ class ModelsEmitter:
         # self.writer an instance CodeWriter() here seems unused globally for this emitter.
         # Each file generation part either writes directly or uses a local 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. Returns file path if generated."""
         if not schema_ir.name:
             logger.warning(f"Skipping model generation for schema without a name: {schema_ir}")

pyopenapi_gen/emitters/core_emitter.py

@@ -1,6 +1,6 @@
 import importlib.resources
 import os
-from typing import List, Optional
+from typing import List
 
 from pyopenapi_gen.context.file_manager import FileManager
 
@@ -22,12 +22,10 @@ CORE_README_TEMPLATE_FILENAME = "README.md"
 
 CONFIG_TEMPLATE = """
 from dataclasses import dataclass
-from typing import Optional
-
 @dataclass
 class ClientConfig:
     base_url: str
-    timeout: Optional[float] = 30.0
+    timeout: float | None = 30.0
 """
 
 
@@ -35,7 +33,7 @@ class CoreEmitter:
     """Copies all required runtime files into the generated core module."""
 
     def __init__(
-        self, core_dir: str = "core", core_package: str = "core", exception_alias_names: Optional[List[str]] = None
+        self, core_dir: str = "core", core_package: str = "core", exception_alias_names: List[str] | None = None
     ):
         # core_dir is the relative path WITHIN the output package, e.g., "core" or "shared/core"
         # core_package is the Python import name, e.g., "core" or "shared.core"