pyopenapi-gen 0.8.3__py3-none-any.whl → 0.8.5__py3-none-any.whl

pyopenapi_gen/cli.py

@@ -6,26 +6,6 @@ import yaml
 
 from .generator.client_generator import ClientGenerator, GenerationError
 
-app = typer.Typer(invoke_without_command=True)
-
-
-@app.callback()
-def main(ctx: typer.Context) -> None:
-    """
-    PyOpenAPI Generator CLI.
-    """
-    if ctx.invoked_subcommand is None:
-        # Show basic help without using ctx.get_help() to avoid Click compatibility issues
-        typer.echo("PyOpenAPI Generator CLI")
-        typer.echo("")
-        typer.echo("Usage: pyopenapi-gen [OPTIONS] COMMAND [ARGS]...")
-        typer.echo("")
-        typer.echo("Commands:")
-        typer.echo("  gen    Generate a Python OpenAPI client from a spec file or URL")
-        typer.echo("")
-        typer.echo("Run 'pyopenapi-gen gen --help' for more information on the gen command.")
-        raise typer.Exit(code=0)
-
 
 def _load_spec(path_or_url: str) -> Union[Dict[str, Any], Any]:
     """Load a spec from a file path or URL."""
@@ -35,8 +15,7 @@ def _load_spec(path_or_url: str) -> Union[Dict[str, Any], Any]:
     raise typer.Exit(code=1)
 
 
-@app.command()
-def gen(
+def main(
     spec: str = typer.Argument(..., help="Path or URL to OpenAPI spec"),
     project_root: Path = typer.Option(
         ...,
@@ -82,5 +61,9 @@ def gen(
         raise typer.Exit(code=1)
 
 
+app = typer.Typer(help="PyOpenAPI Generator CLI - Generate Python clients from OpenAPI specs.")
+app.command()(main)
+
+
 if __name__ == "__main__":
     app()

pyopenapi_gen/context/import_collector.py

@@ -274,10 +274,10 @@ class ImportCollector:
                 is_core_module_to_be_absolute = True
 
             if is_core_module_to_be_absolute:
-                import_statement = f"from {module_name} import {', '.join(names)}"
+                import_statement = f"from {module_name} import {", ".join(names)}"
                 standard_import_lines.append(import_statement)
             elif is_stdlib_module:
-                import_statement = f"from {module_name} import {', '.join(names)}"
+                import_statement = f"from {module_name} import {", ".join(names)}"
                 standard_import_lines.append(import_statement)
             elif (
                 current_module_dot_path_to_use
@@ -286,13 +286,13 @@ class ImportCollector:
             ):
                 try:
                     relative_module = make_relative_import(current_module_dot_path_to_use, module_name)
-                    import_statement = f"from {relative_module} import {', '.join(names)}"
+                    import_statement = f"from {relative_module} import {", ".join(names)}"
                     standard_import_lines.append(import_statement)
                 except ValueError as e:
-                    import_statement = f"from {module_name} import {', '.join(names)}"
+                    import_statement = f"from {module_name} import {", ".join(names)}"
                     standard_import_lines.append(import_statement)
             else:
-                import_statement = f"from {module_name} import {', '.join(names)}"
+                import_statement = f"from {module_name} import {", ".join(names)}"
                 standard_import_lines.append(import_statement)
 
         plain_import_lines: List[str] = []
@@ -331,7 +331,7 @@ class ImportCollector:
 
         for module in stdlib_modules:
             names = sorted(self.imports[module])
-            statements.append(f"from {module} import {', '.join(names)}")
+            statements.append(f"from {module} import {", ".join(names)}")
 
         # Then third-party and app imports
         other_modules = sorted([m for m in self.imports.keys() if not _is_stdlib(m)])
@@ -341,7 +341,7 @@ class ImportCollector:
 
         for module in other_modules:
             names = sorted(self.imports[module])
-            statements.append(f"from {module} import {', '.join(names)}")
+            statements.append(f"from {module} import {", ".join(names)}")
 
         # Then plain imports
         if self.plain_imports:
@@ -357,7 +357,7 @@ class ImportCollector:
 
         for module in sorted(self.relative_imports.keys()):
             names = sorted(self.relative_imports[module])
-            statements.append(f"from {module} import {', '.join(names)}")
+            statements.append(f"from {module} import {", ".join(names)}")
 
         return "\n".join(statements)
 

pyopenapi_gen/core/loader/operations/parser.py

@@ -120,7 +120,7 @@ def parse_operations(
                         # Handle direct schema references in responses
                         # Convert schema reference to a response with content
                         resp_node_resolved = {
-                            "description": f"Response with {rn_node['$ref'].split('/')[-1]} schema",
+                            "description": f"Response with {rn_node["$ref"].split("/")[-1]} schema",
                             "content": {"application/json": {"schema": {"$ref": rn_node["$ref"]}}},
                         }
                     else:

pyopenapi_gen/core/parsing/context.py

@@ -47,7 +47,8 @@ class ParsingContext:
         max_depth = int(os.environ.get("PYOPENAPI_MAX_DEPTH", 150))
 
         self.unified_cycle_context = UnifiedCycleContext(
-            parsed_schemas=self.parsed_schemas, max_depth=max_depth  # Share the same parsed_schemas dict
+            parsed_schemas=self.parsed_schemas,
+            max_depth=max_depth,  # Share the same parsed_schemas dict
         )
 
     def unified_enter_schema(self, schema_name: Optional[str]) -> Any:

pyopenapi_gen/core/parsing/cycle_helpers.py

@@ -92,7 +92,7 @@ def _handle_max_depth_exceeded(original_name: Optional[str], context: ParsingCon
 
     # path_prefix = schema_ir_name_attr if schema_ir_name_attr else "<anonymous_schema>"
     # cycle_path_for_desc = f"{path_prefix} -> MAX_DEPTH_EXCEEDED"
-    description = f"[Maximum recursion depth ({max_depth}) exceeded for '{original_name or 'anonymous'}']"
+    description = f"[Maximum recursion depth ({max_depth}) exceeded for '{original_name or "anonymous"}']"
     logger.warning(description)
 
     placeholder_schema = IRSchema(

pyopenapi_gen/core/parsing/keywords/properties_parser.py

@@ -81,15 +81,15 @@ def _parse_properties(
         if promoted_ir is not None:
             properties_map[prop_key] = promoted_ir
             logger.debug(
-                f"Added promoted '{prop_key}' (name: {getattr(promoted_ir, 'name', 'N/A')}) "
+                f"Added promoted '{prop_key}' (name: {getattr(promoted_ir, "name", "N/A")}) "
                 f"to properties_map for '{parent_schema_name}'"
             )
         else:
             properties_map[prop_key] = prop_schema_ir
             logger.debug(
-                f"Added original '{prop_key}' (name: {getattr(prop_schema_ir, 'name', 'N/A')}, "
-                f"type: {getattr(prop_schema_ir, 'type', 'N/A')}, "
-                f"circular: {getattr(prop_schema_ir, '_is_circular_ref', 'N/A')}) "
+                f"Added original '{prop_key}' (name: {getattr(prop_schema_ir, "name", "N/A")}, "
+                f"type: {getattr(prop_schema_ir, "type", "N/A")}, "
+                f"circular: {getattr(prop_schema_ir, "_is_circular_ref", "N/A")}) "
                 f"to properties_map for '{parent_schema_name}'"
             )
 

pyopenapi_gen/core/parsing/schema_parser.py

@@ -42,7 +42,7 @@ def _resolve_ref(
     if not (ref_name_parts and ref_name_parts[-1]):
         logger.warning(
             f"Malformed $ref path '{ref_path_str}' encountered while parsing "
-            f"parent '{parent_schema_name or 'anonymous'}'."
+            f"parent '{parent_schema_name or "anonymous"}'."
         )
         return IRSchema(
             name=None,  # Anonymous placeholder for a bad ref
@@ -60,7 +60,7 @@ def _resolve_ref(
     ref_node = context.raw_spec_schemas.get(ref_name)
     if ref_node is None:
         logger.warning(
-            f"Cannot resolve $ref '{ref_path_str}' for parent '{parent_schema_name or 'anonymous'}'. "
+            f"Cannot resolve $ref '{ref_path_str}' for parent '{parent_schema_name or "anonymous"}'. "
             f"Target '{ref_name}' not in raw_spec_schemas. Returning placeholder."
         )
         return IRSchema(
@@ -142,7 +142,7 @@ def _parse_properties(
     for prop_name, prop_schema_node in properties_node.items():
         if not isinstance(prop_name, str) or not prop_name:
             logger.warning(
-                f"Skipping property with invalid name '{prop_name}' in schema '{parent_schema_name or 'anonymous'}'."
+                f"Skipping property with invalid name '{prop_name}' in schema '{parent_schema_name or "anonymous"}'."
             )
             continue
 
@@ -379,7 +379,7 @@ def _parse_schema(
 
         assert isinstance(
             schema_node, Mapping
-        ), f"Schema node for '{schema_name or 'anonymous'}' must be a Mapping (e.g., dict), got {type(schema_node)}"
+        ), f"Schema node for '{schema_name or "anonymous"}' must be a Mapping (e.g., dict), got {type(schema_node)}"
 
         # If the current schema_node itself is a $ref, resolve it.
         if "$ref" in schema_node:

pyopenapi_gen/core/parsing/transformers/inline_enum_extractor.py

@@ -179,7 +179,7 @@ def _process_standalone_inline_enum(
 
     logger.debug(
         f"STANDALONE_ENUM_CHECK: Processing node for "
-        f"'{schema_name or schema_obj.name or 'anonymous_schema'}' for direct enum properties."
+        f"'{schema_name or schema_obj.name or "anonymous_schema"}' for direct enum properties."
     )
 
     # Ensure basic enum properties are on schema_obj if not already there from initial _parse_schema pass

pyopenapi_gen/core/postprocess_manager.py

@@ -34,7 +34,7 @@ class PostprocessManager:
 
         # --- RE-ENABLE RUFF CHECKS ---
         for target_path in target_paths:
-            if target_path.is_file():
+            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)
@@ -136,18 +136,44 @@ class PostprocessManager:
             return
 
         print(f"Running mypy on {target_dir}...")
-        result = subprocess.run(
-            [sys.executable, "-m", "mypy", str(target_dir), "--strict"],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True,
-        )
-        if result.stdout or result.stderr or result.returncode != 0:
-            if result.stdout:
-                print(result.stdout)
-            if result.stderr:
-                print(result.stderr, file=sys.stderr)
-            if result.returncode != 0:
+        # Find all Python files in the target directory
+        python_files = list(target_dir.rglob("*.py"))
+        if not python_files:
+            print(f"No Python files found in {target_dir}, skipping type check.")
+            return
+
+        # Try mypy with cache cleanup on failure
+        for attempt in range(2):
+            cmd = [sys.executable, "-m", "mypy", "--strict"]
+            if attempt == 1:
+                # Second attempt: clear cache
+                cmd.append("--cache-dir=/tmp/mypy_cache_temp")
+            cmd.extend([str(f) for f in python_files])
+
+            result = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+
+            # Check for specific mypy cache corruption errors
+            cache_error_patterns = ["KeyError: 'setter_type'", "KeyError:", "deserialize"]
+            is_cache_error = any(pattern in result.stderr for pattern in cache_error_patterns)
+
+            if result.returncode == 0:
+                # Success
+                return
+            elif attempt == 0 and is_cache_error:
+                # Retry with cache cleanup
+                print(f"Mypy cache error detected, retrying with fresh cache...", file=sys.stderr)
+                continue
+            else:
+                # Report the error
+                if result.stdout:
+                    print(result.stdout)
+                if result.stderr:
+                    print(result.stderr, file=sys.stderr)
                 print(f"Type checking failed for {target_dir}. Please fix the above issues.", file=sys.stderr)
                 sys.exit(result.returncode)
 

pyopenapi_gen/core/schemas.py

@@ -1,40 +1,125 @@
+from __future__ import annotations
+
 from dataclasses import MISSING, dataclass, fields
-from typing import Any, Dict, Type, TypeVar
+from typing import Any, Dict, Type, TypeVar, Union, get_args, get_origin, get_type_hints
+
+T = TypeVar("T", bound="BaseSchema")
+
 
-T = TypeVar("T")
+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
+        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:
+            return non_none_args[0]
+    return field_type
 
 
 @dataclass
 class BaseSchema:
-    """Base class for all generated Pydantic models, providing basic validation and dict conversion."""
+    """Base class for all generated models, providing validation, dict conversion, and field mapping."""
 
     @classmethod
-    def model_validate(cls: Type[T], data: Dict[str, Any]) -> T:
-        """Validate and create an instance from a dictionary, akin to Pydantic's model_validate."""
+    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]:
+        """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:
+        """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] = {}
-        cls_fields = {f.name: f for f in fields(cls)}  # type: ignore[arg-type]
+        cls_fields = {f.name: f for f in fields(cls)}
+
+        # Process each field in the data
+        for api_field, value in data.items():
+            # Map API field name to Python field name
+            python_field = field_mappings.get(api_field, api_field)
+
+            if python_field in cls_fields:
+                # Handle nested objects that might also be BaseSchema instances
+                field_def = cls_fields[python_field]
+                field_type = field_def.type
+
+                # Get type hints to handle forward references and generics properly
+                try:
+                    type_hints = get_type_hints(cls)
+                    if python_field in type_hints:
+                        field_type = type_hints[python_field]
+                except (NameError, AttributeError):
+                    # Fall back to raw annotation if get_type_hints fails
+                    pass
+
+                # Extract base type (handles Optional[Type] -> Type)
+                base_type = _extract_base_type(field_type)
 
+                if base_type is not None and hasattr(base_type, "from_dict") and isinstance(value, dict):
+                    # Recursively convert nested dictionaries
+                    kwargs[python_field] = base_type.from_dict(value)
+                elif get_origin(field_type) is list or get_origin(base_type) is list:
+                    # Handle List[SomeModel] types
+                    list_type = field_type if get_origin(field_type) is list else base_type
+                    args = get_args(list_type)
+                    if args and hasattr(args[0], "from_dict") and isinstance(value, list):
+                        kwargs[python_field] = [
+                            args[0].from_dict(item) if isinstance(item, dict) else item for item in value
+                        ]
+                    else:
+                        kwargs[python_field] = value
+                else:
+                    kwargs[python_field] = value
+
+        # Check for required fields
         for field_name, field_def in cls_fields.items():
-            if field_name in data:
-                kwargs[field_name] = data[field_name]
-            elif field_def.default is MISSING and field_def.default_factory is MISSING:
+            if field_name not in kwargs and field_def.default is MISSING and field_def.default_factory is MISSING:
                 raise ValueError(f"Missing required field: '{field_name}' for class {cls.__name__}")
 
-        extra_fields = set(data.keys()) - set(cls_fields.keys())
-        if extra_fields:
-            pass
-
         return cls(**kwargs)
 
-    def model_dump(self, exclude_none: bool = False) -> Dict[str, Any]:
-        """Convert the model instance to a dictionary, akin to Pydantic's model_dump."""
+    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 = {}
+
         for field_def in fields(self):
             value = getattr(self, field_def.name)
             if exclude_none and value is None:
                 continue
-            result[field_def.name] = value
+
+            # Handle nested objects
+            if hasattr(value, "to_dict"):
+                value = value.to_dict(exclude_none=exclude_none)
+            elif isinstance(value, list) and value and hasattr(value[0], "to_dict"):
+                value = [
+                    item.to_dict(exclude_none=exclude_none) if hasattr(item, "to_dict") else item for item in value
+                ]
+
+            # Map Python field name back to API field name
+            api_field = reverse_mappings.get(field_def.name, field_def.name)
+            result[api_field] = value
+
         return result
+
+    # Legacy aliases for backward compatibility
+    @classmethod
+    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]:
+        """Legacy alias for to_dict."""
+        return self.to_dict(exclude_none=exclude_none)

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 List, Optional, Tuple
+from typing import Dict, List, Optional, Tuple
 
 from pyopenapi_gen.context.render_context import RenderContext
 
@@ -146,15 +146,17 @@ class PythonConstructRenderer:
         fields: List[Tuple[str, str, Optional[str], Optional[str]]],  # name, type_hint, default_expr, description
         description: Optional[str],
         context: RenderContext,
+        field_mappings: Optional[Dict[str, str]] = None,
     ) -> str:
         """
-        Render a dataclass as Python code.
+        Render a dataclass as Python code with BaseSchema support.
 
         Args:
             class_name: The name of the dataclass
             fields: List of (name, type_hint, default_expr, description) tuples for each field
             description: Optional description for the class docstring
             context: The rendering context for import registration
+            field_mappings: Optional mapping of API field names to Python field names for BaseSchema
 
         Returns:
             Formatted Python code for the dataclass
@@ -162,31 +164,60 @@ class PythonConstructRenderer:
         Example:
             ```python
             @dataclass
-            class User:
-                \"\"\"User information.\"\"\"
-                id: str
-                name: str
+            class User(BaseSchema):
+                \"\"\"User information with automatic JSON field mapping.\"\"\"
+                id_: str
+                first_name: str
                 email: Optional[str] = None
                 is_active: bool = True
+
+                class Meta:
+                    \"\"\"Configure field name mapping for JSON conversion.\"\"\"
+                    key_transform_with_load = {
+                        'id': 'id_',
+                        'firstName': 'first_name'
+                    }
             ```
         """
         writer = CodeWriter()
         context.add_import("dataclasses", "dataclass")
 
+        # Always use self-contained BaseSchema for client independence with automatic field mapping
+        # Use the core package from context - could be relative (..core) or absolute (api_sdks.my_core)
+        if context.core_package_name.startswith(".."):
+            # Already a relative import
+            core_import_path = f"{context.core_package_name}.schemas"
+        elif "." in context.core_package_name:
+            # External core package with dots (e.g., api_sdks.my_core) - use absolute import
+            core_import_path = f"{context.core_package_name}.schemas"
+        elif context.core_package_name == "core":
+            # Default relative core package
+            core_import_path = "..core.schemas"
+        else:
+            # Simple external core package name (e.g., shared_core_pkg) - use absolute import
+            core_import_path = f"{context.core_package_name}.schemas"
+
+        context.add_import(core_import_path, "BaseSchema")
+
         # Add __all__ export
         writer.write_line(f'__all__ = ["{class_name}"]')
         writer.write_line("")  # Add a blank line for separation
 
         writer.write_line("@dataclass")
-        writer.write_line(f"class {class_name}:")
+        writer.write_line(f"class {class_name}(BaseSchema):")
         writer.indent()
 
         # Build and write docstring
         field_args: list[tuple[str, str, str] | tuple[str, str]] = []
         for name, type_hint, _, field_desc in fields:
             field_args.append((name, type_hint, field_desc or ""))
+
+        # Enhanced description with automatic field mapping
+        base_description = description or f"{class_name} dataclass"
+        enhanced_description = f"{base_description} with automatic JSON field mapping."
+
         doc_block = DocumentationBlock(
-            summary=description or f"{class_name} dataclass.",
+            summary=enhanced_description,
             args=field_args if field_args else None,
         )
         docstring = DocumentationWriter(width=88).render_docstring(doc_block, indent=0)
@@ -220,6 +251,23 @@ class PythonConstructRenderer:
                     line += f"  # {comment_text}"
                 writer.write_line(line)
 
+        # Add Meta class if field mappings are provided (for BaseSchema field mapping)
+        if field_mappings:
+            writer.write_line("")  # Blank line before Meta class
+            writer.write_line("class Meta:")
+            writer.indent()
+            writer.write_line('"""Configure field name mapping for JSON conversion."""')
+            writer.write_line("key_transform_with_load = {")
+            writer.indent()
+
+            # Sort mappings for consistent output
+            for api_field, python_field in sorted(field_mappings.items()):
+                writer.write_line(f"'{api_field}': '{python_field}',")
+
+            writer.dedent()
+            writer.write_line("}")
+            writer.dedent()
+
         writer.dedent()
         return writer.get_code()
 
@@ -254,7 +302,7 @@ class PythonConstructRenderer:
             ```
         """
         writer = CodeWriter()
-        bases = f"({', '.join(base_classes)})" if base_classes else ""
+        bases = f"({", ".join(base_classes)})" if base_classes else ""
         writer.write_line(f"class {class_name}{bases}:")
         writer.indent()
         has_content = False

pyopenapi_gen/emitters/endpoints_emitter.py

@@ -211,7 +211,7 @@ class EndpointsEmitter:
         init_lines = []
         if unique_clients:
             all_list_items = sorted([f'"{cls}"' for cls, _ in unique_clients])
-            init_lines.append(f"__all__ = [{', '.join(all_list_items)}]")
+            init_lines.append(f"__all__ = [{", ".join(all_list_items)}]")
             for cls, mod in sorted(unique_clients):
                 init_lines.append(f"from .{mod} import {cls}")
 

pyopenapi_gen/helpers/endpoint_utils.py

@@ -82,26 +82,8 @@ def get_request_body_type(body: IRRequestBody, context: RenderContext, schemas:
     return "Any"
 
 
-def get_return_type_unified(
-    op: IROperation,
-    context: RenderContext,
-    schemas: Dict[str, IRSchema],
-    responses: Optional[Dict[str, IRResponse]] = None,
-) -> str:
-    """
-    Determines the primary return type hint for an operation using the unified type service.
-
-    Args:
-        op: The operation to resolve
-        context: Render context for imports
-        schemas: Dictionary of all schemas
-        responses: Dictionary of all responses (optional)
-
-    Returns:
-        Python type string
-    """
-    type_service = UnifiedTypeService(schemas, responses)
-    return type_service.resolve_operation_response_type(op, context)
+# REMOVED: get_return_type_unified - replaced with ResponseStrategy pattern
+# All callers should now use ResponseStrategyResolver.resolve() to get consistent response handling
 
 
 def get_return_type(
@@ -326,10 +308,10 @@ def format_method_args(params: list[dict[str, Any]]) -> str:
     optional = [p for p in params if not p.get("required", True)]
     arg_strs = []
     for p in required:
-        arg_strs.append(f"{p['name']}: {p['type']}")
+        arg_strs.append(f"{p["name"]}: {p["type"]}")
     for p in optional:
         default = p["default"]
-        arg_strs.append(f"{p['name']}: {p['type']} = {default}")
+        arg_strs.append(f"{p["name"]}: {p["type"]} = {default}")
     return ", ".join(arg_strs)
 
 

pyopenapi_gen/helpers/type_cleaner.py

@@ -220,7 +220,7 @@ class TypeCleaner:
         if len(unique_members) == 1:
             return unique_members[0]  # A Union with one member is just that member.
 
-        return f"Union[{', '.join(unique_members)}]"
+        return f"Union[{", ".join(unique_members)}]"
 
     @classmethod
     def _clean_list_type(cls, type_str: str) -> str:

pyopenapi_gen/helpers/type_resolution/composition_resolver.py

@@ -73,7 +73,7 @@ class CompositionTypeResolver:
                 return unique_types[0]
 
             self.context.add_import("typing", "Union")
-            union_str = f"Union[{', '.join(unique_types)}]"
+            union_str = f"Union[{", ".join(unique_types)}]"
             return union_str
 
         return None

pyopenapi_gen/helpers/type_resolution/finalizer.py

@@ -23,7 +23,7 @@ class TypeFinalizer:
         if py_type is None:
             logger.warning(
                 f"[TypeFinalizer] Received None as py_type for schema "
-                f"'{schema.name or 'anonymous'}'. Defaulting to 'Any'."
+                f"'{schema.name or "anonymous"}'. Defaulting to 'Any'."
             )
             self.context.add_import("typing", "Any")
             py_type = "Any"

pyopenapi_gen/types/contracts/types.py

@@ -20,7 +20,6 @@ class ResolvedType:
     import_name: Optional[str] = None
     is_optional: bool = False
     is_forward_ref: bool = False
-    was_unwrapped: bool = False
 
     def __post_init__(self) -> None:
         """Validate resolved type data."""