pyopenapi-gen 2.7.2__py3-none-any.whl

pyopenapi_gen/core/parsing/unified_cycle_detection.py

@@ -0,0 +1,293 @@
+"""
+Unified cycle detection system for schema parsing.
+
+This module provides a comprehensive, conflict-free approach to cycle detection
+that handles structural cycles, processing cycles, and depth limits consistently.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Set
+
+from pyopenapi_gen import IRSchema
+from pyopenapi_gen.core.utils import NameSanitizer
+
+logger = logging.getLogger(__name__)
+
+
+class SchemaState(Enum):
+    """States a schema can be in during parsing."""
+
+    NOT_STARTED = "not_started"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    PLACEHOLDER_CYCLE = "placeholder_cycle"
+    PLACEHOLDER_DEPTH = "placeholder_depth"
+    PLACEHOLDER_SELF_REF = "placeholder_self_ref"
+
+
+class CycleType(Enum):
+    """Types of cycles that can be detected."""
+
+    STRUCTURAL = "structural"  # Schema references form a loop
+    SELF_REFERENCE = "self_reference"  # Schema directly references itself
+    MAX_DEPTH = "max_depth"  # Recursion depth limit exceeded
+
+
+class CycleAction(Enum):
+    """Actions to take when cycle is detected."""
+
+    CONTINUE_PARSING = "continue"  # No cycle or allowed cycle
+    RETURN_PLACEHOLDER = "placeholder"  # Return pre-made placeholder
+    CREATE_PLACEHOLDER = "create"  # Create new placeholder
+    RETURN_EXISTING = "existing"  # Return existing parsed schema
+
+
+@dataclass
+class CycleInfo:
+    """Information about a detected cycle."""
+
+    schema_name: str
+    cycle_path: List[str]
+    cycle_type: CycleType
+    is_direct_self_reference: bool
+    depth_when_detected: int
+
+
+@dataclass
+class CycleDetectionResult:
+    """Result of cycle detection check."""
+
+    is_cycle: bool
+    cycle_type: CycleType | None
+    action: CycleAction
+    cycle_info: CycleInfo | None = None
+    placeholder_schema: IRSchema | None = None
+
+
+@dataclass
+class UnifiedCycleContext:
+    """Unified context for all cycle detection mechanisms."""
+
+    # 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)
+    recursion_depth: int = 0
+
+    # Detection results
+    detected_cycles: List[CycleInfo] = field(default_factory=list)
+    depth_exceeded_schemas: Set[str] = field(default_factory=set)
+    cycle_detected: bool = False  # Global flag for backward compatibility
+
+    # Configuration
+    max_depth: int = 150
+    allow_self_reference: bool = False
+
+
+def analyze_cycle(schema_name: str, schema_stack: List[str]) -> CycleInfo:
+    """Analyze a detected cycle to determine its characteristics."""
+    try:
+        start_index = schema_stack.index(schema_name)
+        cycle_path = schema_stack[start_index:] + [schema_name]
+    except ValueError:
+        # Schema not in stack - shouldn't happen, but handle gracefully
+        cycle_path = [schema_name, schema_name]
+
+    is_direct_self_reference = len(cycle_path) == 2 and cycle_path[0] == cycle_path[1]
+
+    cycle_type = CycleType.SELF_REFERENCE if is_direct_self_reference else CycleType.STRUCTURAL
+
+    return CycleInfo(
+        schema_name=schema_name,
+        cycle_path=cycle_path,
+        cycle_type=cycle_type,
+        is_direct_self_reference=is_direct_self_reference,
+        depth_when_detected=len(schema_stack),
+    )
+
+
+def create_cycle_placeholder(schema_name: str, cycle_info: CycleInfo) -> IRSchema:
+    """Create a placeholder IRSchema for cycle detection."""
+    sanitized_name = NameSanitizer.sanitize_class_name(schema_name)
+    cycle_path_str = " -> ".join(cycle_info.cycle_path)
+
+    return IRSchema(
+        name=sanitized_name,
+        type="object",
+        description=f"[Circular reference detected: {cycle_path_str}]",
+        _from_unresolved_ref=True,
+        _circular_ref_path=cycle_path_str,
+        _is_circular_ref=True,
+    )
+
+
+def create_self_ref_placeholder(schema_name: str, cycle_info: CycleInfo) -> IRSchema:
+    """Create a placeholder IRSchema for allowed self-reference."""
+    sanitized_name = NameSanitizer.sanitize_class_name(schema_name)
+
+    return IRSchema(
+        name=sanitized_name,
+        type="object",
+        description=f"[Self-referencing schema: {schema_name}]",
+        _is_self_referential_stub=True,
+    )
+
+
+def create_depth_placeholder(schema_name: str, depth: int) -> IRSchema:
+    """Create a placeholder IRSchema for max depth exceeded."""
+    sanitized_name = NameSanitizer.sanitize_class_name(schema_name)
+    description = f"[Maximum recursion depth ({depth}) exceeded for '{schema_name}']"
+
+    # Import cycle_helpers to use its logging functionality
+    from .cycle_helpers import logger as cycle_helpers_logger
+
+    cycle_helpers_logger.warning(description)
+
+    return IRSchema(
+        name=sanitized_name,
+        type="object",
+        description=description,
+        _max_depth_exceeded_marker=True,
+    )
+
+
+def unified_cycle_check(schema_name: str | None, context: UnifiedCycleContext) -> CycleDetectionResult:
+    """Unified cycle detection that handles all cases."""
+
+    if schema_name is None:
+        return CycleDetectionResult(False, None, CycleAction.CONTINUE_PARSING)
+
+    # Check current state
+    current_state = context.schema_states.get(schema_name, SchemaState.NOT_STARTED)
+
+    # 1. If already completed, reuse (no cycle)
+    if current_state == SchemaState.COMPLETED:
+        return CycleDetectionResult(False, None, CycleAction.RETURN_EXISTING)
+
+    # 2. If already a placeholder, reuse it
+    if current_state in [
+        SchemaState.PLACEHOLDER_CYCLE,
+        SchemaState.PLACEHOLDER_DEPTH,
+        SchemaState.PLACEHOLDER_SELF_REF,
+    ]:
+        return CycleDetectionResult(True, None, CycleAction.RETURN_PLACEHOLDER)
+
+    # 3. Check depth limit BEFORE checking cycles (dynamically check environment)
+    import os
+
+    max_depth = int(os.environ.get("PYOPENAPI_MAX_DEPTH", context.max_depth))
+    if context.recursion_depth > max_depth:
+        context.depth_exceeded_schemas.add(schema_name)
+        context.schema_states[schema_name] = SchemaState.PLACEHOLDER_DEPTH
+        context.cycle_detected = True  # Max depth exceeded is considered a form of cycle detection
+        placeholder = create_depth_placeholder(schema_name, max_depth)
+        context.parsed_schemas[schema_name] = placeholder
+        return CycleDetectionResult(
+            True, CycleType.MAX_DEPTH, CycleAction.CREATE_PLACEHOLDER, placeholder_schema=placeholder
+        )
+
+    # 4. Check for structural cycle
+    if schema_name in context.schema_stack:
+        cycle_info = analyze_cycle(schema_name, context.schema_stack)
+        context.cycle_detected = True
+
+        # For cycles, create a placeholder for the re-entrant reference, not the original schema
+        # This allows the original schema parsing to complete normally
+        # The re-entrant reference gets a circular placeholder
+
+        # Create a unique key for this specific cycle reference
+        cycle_ref_key = f"{schema_name}_cycle_ref_{len(context.detected_cycles)}"
+
+        # Determine if cycle is allowed
+        if context.allow_self_reference and cycle_info.is_direct_self_reference:
+            placeholder = create_self_ref_placeholder(schema_name, cycle_info)
+        else:
+            context.detected_cycles.append(cycle_info)
+            placeholder = create_cycle_placeholder(schema_name, cycle_info)
+
+        # Determine storage policy based on cycle characteristics
+        is_synthetic_schema = schema_name and (
+            "Item" in schema_name or "Property" in schema_name  # Array item schemas  # Property schemas
+        )
+
+        # Check for specific known patterns
+        cycle_path_str = " -> ".join(cycle_info.cycle_path)
+        is_direct_array_self_ref = (
+            "Children" in cycle_path_str
+            and "ChildrenItem" in cycle_path_str
+            and cycle_info.cycle_path[0] == cycle_info.cycle_path[-1]
+        )
+        is_nested_property_self_ref = (
+            any(
+                name.startswith(schema_name) and name != schema_name and not name.endswith("Item")
+                for name in cycle_info.cycle_path
+            )
+            and cycle_info.cycle_path[0] == cycle_info.cycle_path[-1]
+        )
+
+        should_store_placeholder = (
+            is_synthetic_schema
+            or cycle_info.is_direct_self_reference
+            or is_direct_array_self_ref
+            or is_nested_property_self_ref
+        )
+
+        if should_store_placeholder:
+            context.parsed_schemas[schema_name] = placeholder
+            # Mark schema state appropriately
+            if context.allow_self_reference and cycle_info.is_direct_self_reference:
+                context.schema_states[schema_name] = SchemaState.PLACEHOLDER_SELF_REF
+            else:
+                context.schema_states[schema_name] = SchemaState.PLACEHOLDER_CYCLE
+
+        # Don't mark the original schema as a placeholder - just return the placeholder for this reference
+        return CycleDetectionResult(
+            True,
+            (
+                cycle_info.cycle_type
+                if not (context.allow_self_reference and cycle_info.is_direct_self_reference)
+                else CycleType.SELF_REFERENCE
+            ),
+            CycleAction.CREATE_PLACEHOLDER,
+            cycle_info=cycle_info,
+            placeholder_schema=placeholder,
+        )
+
+    # 5. No cycle detected - proceed with parsing
+    context.schema_states[schema_name] = SchemaState.IN_PROGRESS
+    return CycleDetectionResult(False, None, CycleAction.CONTINUE_PARSING)
+
+
+def unified_enter_schema(schema_name: str | None, context: UnifiedCycleContext) -> CycleDetectionResult:
+    """Unified entry point that always maintains consistent state."""
+    context.recursion_depth += 1
+
+    result = unified_cycle_check(schema_name, context)
+
+    # Only add to stack if we're going to continue parsing
+    if result.action == CycleAction.CONTINUE_PARSING and schema_name:
+        context.schema_stack.append(schema_name)
+
+    return result
+
+
+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
+
+    if schema_name and schema_name in context.schema_stack:
+        context.schema_stack.remove(schema_name)
+
+    # Mark as completed if it was in progress (but don't change placeholder states)
+    if schema_name and context.schema_states.get(schema_name) == SchemaState.IN_PROGRESS:
+        context.schema_states[schema_name] = SchemaState.COMPLETED
+
+
+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

@@ -0,0 +1,260 @@
+import subprocess  # nosec B404 - Required for running code formatters (Black, Ruff) and mypy
+import sys
+from pathlib import Path
+from typing import List, Union
+
+SUCCESS_LINE = "Success: no issues found in 1 source file"
+
+
+def _print_filtered_stdout(stdout: str) -> None:
+    lines = [line for line in stdout.splitlines() if line.strip() and line.strip() != SUCCESS_LINE]
+    if lines:
+        print("\n".join(lines))
+
+
+class PostprocessManager:
+    """
+    Handles post-processing of generated Python files: import cleanup, formatting, and type checking.
+    Can be used programmatically or as a script.
+    """
+
+    def __init__(self, project_root: str):
+        self.project_root = project_root  # Store project root
+        pass
+
+    def run(self, targets: List[Union[str, Path]]) -> None:
+        """
+        Run Ruff checks on individual files, then run Mypy on the package root.
+        """
+        if not targets:
+            return
+
+        # Ensure all targets are Path objects
+        target_paths = [Path(t) for t in targets]
+
+        # 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()
+        for target_path in target_paths:
+            if target_path.is_file():
+                # Find the first ancestor directory *without* __init__.py
+                # (or stop at workspace root)
+                current = target_path.parent
+                package_root = current
+                while current != Path(self.project_root) and (current / "__init__.py").exists():
+                    package_root = current
+                    current = current.parent
+                package_roots.add(package_root)
+            elif target_path.is_dir():
+                # If a directory is passed, assume it's a package root or contains packages
+                # For simplicity, let's assume it *is* the root to run mypy on
+                package_roots.add(target_path)
+
+        # Run Mypy on each identified package root
+        # 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(  # nosec B603 - Controlled subprocess with hardcoded command
+            [
+                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(  # nosec B603 - Controlled subprocess with hardcoded command
+            [
+                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(  # nosec B603 - Controlled subprocess with hardcoded command
+            [
+                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."""
+        result = subprocess.run(  # nosec B603 - Controlled subprocess with hardcoded command
+            [
+                sys.executable,
+                "-m",
+                "ruff",
+                "check",
+                "--select=F401",
+                "--fix",
+                str(target),
+            ],
+            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(self, target: Union[str, Path]) -> None:
+        """Sort imports in the target using Ruff."""
+        result = subprocess.run(  # nosec B603 - Controlled subprocess with hardcoded command
+            [
+                sys.executable,
+                "-m",
+                "ruff",
+                "check",
+                "--select=I",
+                "--fix",
+                str(target),
+            ],
+            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(self, target: Union[str, Path]) -> None:
+        """Format code in the target using Ruff."""
+        result = subprocess.run(  # nosec B603 - Controlled subprocess with hardcoded command
+            [
+                sys.executable,
+                "-m",
+                "ruff",
+                "format",
+                str(target),
+            ],
+            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)
+            print(f"Formatting found and fixed issues in {target}.", file=sys.stderr)
+
+    def type_check(self, target_dir: Path) -> None:
+        """Type check the target directory using mypy."""
+        if not target_dir.is_dir():
+            print(f"Skipping Mypy on non-directory: {target_dir}", file=sys.stderr)
+            return
+
+        print(f"Running mypy on {target_dir}...")
+        # 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(  # nosec B603 - Controlled subprocess with hardcoded command
+                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)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Postprocess generated Python files/directories.")
+    parser.add_argument("targets", nargs="+", help="Files or directories to postprocess.")
+    args = parser.parse_args()
+    PostprocessManager(args.project_root).run(args.targets)

pyopenapi_gen/core/spec_fetcher.py

@@ -0,0 +1,148 @@
+"""Centralised OpenAPI specification loading from file paths or URLs.
+
+This module provides utilities for loading OpenAPI specifications from both
+local file paths and HTTP(S) URLs. It handles content parsing (JSON/YAML)
+and provides meaningful error messages for common failure scenarios.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import httpx
+import yaml
+
+from pyopenapi_gen.generator.exceptions import GenerationError
+
+
+def is_url(path_or_url: str) -> bool:
+    """Check if the input looks like an HTTP(S) URL.
+
+    Args:
+        path_or_url: String that may be a file path or URL.
+
+    Returns:
+        True if the string starts with http:// or https://, False otherwise.
+    """
+    return path_or_url.startswith(("http://", "https://"))
+
+
+def fetch_spec(path_or_url: str, timeout: float = 30.0) -> dict[str, Any]:
+    """Load an OpenAPI specification from a file path or URL.
+
+    Supports both local file paths and HTTP(S) URLs. For URLs, the content
+    type is inferred from the Content-Type header or URL extension.
+
+    Args:
+        path_or_url: Path to a local file or HTTP(S) URL to fetch.
+        timeout: Timeout in seconds for HTTP requests (default: 30.0).
+
+    Returns:
+        Parsed OpenAPI specification as a dictionary.
+
+    Raises:
+        GenerationError: If loading or parsing fails.
+    """
+    if is_url(path_or_url):
+        return _fetch_from_url(path_or_url, timeout)
+    return _load_from_file(path_or_url)
+
+
+def _fetch_from_url(url: str, timeout: float) -> dict[str, Any]:
+    """Fetch and parse an OpenAPI spec from a URL.
+
+    Args:
+        url: HTTP(S) URL to fetch.
+        timeout: Timeout in seconds for the request.
+
+    Returns:
+        Parsed specification dictionary.
+
+    Raises:
+        GenerationError: On network errors, HTTP errors, or parse failures.
+    """
+    try:
+        response = httpx.get(url, timeout=timeout, follow_redirects=True)
+        response.raise_for_status()
+    except httpx.TimeoutException:
+        raise GenerationError(f"Failed to fetch spec from URL: connection timed out after {timeout}s")
+    except httpx.HTTPStatusError as e:
+        raise GenerationError(f"Failed to fetch spec from URL: HTTP {e.response.status_code}")
+    except httpx.RequestError as e:
+        raise GenerationError(f"Failed to fetch spec from URL: {e}")
+
+    content = response.text
+    content_type = response.headers.get("content-type", "")
+
+    return _parse_content(content, content_type, url)
+
+
+def _load_from_file(path: str) -> dict[str, Any]:
+    """Load and parse an OpenAPI spec from a local file.
+
+    Args:
+        path: Path to the local file.
+
+    Returns:
+        Parsed specification dictionary.
+
+    Raises:
+        GenerationError: If file doesn't exist, isn't a file, or parse fails.
+    """
+    file_path = Path(path)
+
+    if not file_path.exists():
+        raise GenerationError(f"Specification file not found at {path}")
+
+    if not file_path.is_file():
+        raise GenerationError(f"Specified path {path} is not a file.")
+
+    content = file_path.read_text()
+    extension = file_path.suffix.lower()
+
+    # Determine format from extension
+    if extension == ".json":
+        content_type = "application/json"
+    else:
+        content_type = "application/yaml"
+
+    return _parse_content(content, content_type, path)
+
+
+def _parse_content(content: str, content_type: str, source: str) -> dict[str, Any]:
+    """Parse content as JSON or YAML.
+
+    Args:
+        content: Raw content string.
+        content_type: MIME type hint (may be empty).
+        source: Source path/URL for error messages.
+
+    Returns:
+        Parsed dictionary.
+
+    Raises:
+        GenerationError: If parsing fails or result is not a dictionary.
+    """
+    # Try JSON first if content type suggests it
+    if "json" in content_type.lower():
+        try:
+            data = json.loads(content)
+        except json.JSONDecodeError as e:
+            raise GenerationError(f"Failed to parse spec: invalid JSON content - {e}")
+    else:
+        # Try YAML (which also handles JSON)
+        try:
+            data = yaml.safe_load(content)
+        except yaml.YAMLError as e:
+            # Fallback to JSON in case content-type was misleading
+            try:
+                data = json.loads(content)
+            except json.JSONDecodeError:
+                raise GenerationError(f"Failed to parse spec: invalid YAML content - {e}")
+
+    if not isinstance(data, dict):
+        raise GenerationError(f"Loaded spec from {source} is not a dictionary (got {type(data).__name__}).")
+
+    return data