amd-gaia 0.15.0__py3-none-any.whl → 0.15.2__py3-none-any.whl

gaia/agents/code/validators/requirements_validator.py

@@ -1,145 +1,145 @@
-#!/usr/bin/env python
-# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
-# SPDX-License-Identifier: MIT
-"""Requirements.txt validation to detect hallucinated packages."""
-
-import re
-from pathlib import Path
-from typing import Any, Dict, List
-
-
-class RequirementsValidator:
-    """Validates requirements.txt files for hallucinated packages."""
-
-    # Patterns indicating hallucinated packages
-    HALLUCINATION_PATTERNS = [
-        r".*-ibm-cloud-ibm-cloud.*",  # Recursive IBM
-        r".*-azure-.*-azure.*",  # Recursive Azure
-        r".*-gcp-.*-gcp.*",  # Recursive GCP
-        r".*(\\w{4,})-\\1-\\1.*",  # Same word 3+ times
-        r"flask-graphql-.*-.*-.*-.*-.*",  # 5+ segments
-    ]
-
-    def validate(self, req_file: Path, fix: bool = False) -> Dict[str, Any]:
-        """Validate requirements.txt for hallucinated packages.
-
-        Args:
-            req_file: Path to requirements.txt file
-            fix: Whether to auto-fix issues
-
-        Returns:
-            Dictionary with validation results
-        """
-        content = req_file.read_text()
-        errors = []
-        warnings = []
-        lines = content.strip().split("\n")
-        valid_lines = []
-        seen_packages = set()
-
-        for line_num, line in enumerate(lines, 1):
-            line = line.strip()
-            if not line or line.startswith("#"):
-                valid_lines.append(line)
-                continue
-
-            # Extract package name
-            package_match = re.match(r"^([a-zA-Z0-9][a-zA-Z0-9._-]*)", line)
-            if not package_match:
-                errors.append(f"Line {line_num}: Invalid format")
-                continue
-
-            package_name = package_match.group(1).lower()
-
-            # Check for hallucination
-            is_hallucinated = False
-            for pattern in self.HALLUCINATION_PATTERNS:
-                if re.match(pattern, package_name):
-                    errors.append(
-                        f"Line {line_num}: Hallucinated package: {package_name[:50]}..."
-                    )
-                    is_hallucinated = True
-                    break
-
-            if is_hallucinated:
-                continue
-
-            # Check for excessive length
-            if len(package_name) > 60:
-                errors.append(
-                    f"Line {line_num}: Package name too long ({len(package_name)} chars)"
-                )
-                continue
-
-            # Check duplicates
-            if package_name in seen_packages:
-                warnings.append(f"Line {line_num}: Duplicate package: {package_name}")
-                continue
-
-            seen_packages.add(package_name)
-            valid_lines.append(line)
-
-        # Check total count
-        if len(seen_packages) > 50:
-            errors.append(
-                f"Too many packages ({len(seen_packages)}). Likely hallucinated."
-            )
-        elif len(seen_packages) > 30:
-            warnings.append(f"Many packages ({len(seen_packages)})")
-
-        # Auto-fix if requested
-        fixed_content = None
-        if fix and errors:
-            fixed_content = "\n".join(valid_lines)
-            req_file.write_text(fixed_content)
-
-        return {
-            "is_valid": len(errors) == 0,
-            "errors": errors,
-            "warnings": warnings,
-            "packages": len(seen_packages),
-            "fixed_content": fixed_content,
-        }
-
-    def check_package_validity(self, package_name: str) -> bool:
-        """Check if a package name appears valid.
-
-        Args:
-            package_name: Name of the package to check
-
-        Returns:
-            True if package name appears valid
-        """
-        # Check against hallucination patterns
-        for pattern in self.HALLUCINATION_PATTERNS:
-            if re.match(pattern, package_name.lower()):
-                return False
-
-        # Check length
-        if len(package_name) > 60:
-            return False
-
-        # Check for valid characters
-        if not re.match(r"^[a-zA-Z0-9][a-zA-Z0-9._-]*$", package_name):
-            return False
-
-        return True
-
-    def suggest_common_packages(self, project_type: str) -> List[str]:
-        """Suggest common packages for a project type.
-
-        Args:
-            project_type: Type of project (e.g., 'web', 'data', 'ml')
-
-        Returns:
-            List of suggested package names
-        """
-        suggestions = {
-            "web": ["flask", "django", "fastapi", "requests", "beautifulsoup4"],
-            "data": ["pandas", "numpy", "matplotlib", "seaborn", "jupyter"],
-            "ml": ["scikit-learn", "tensorflow", "torch", "transformers", "datasets"],
-            "test": ["pytest", "pytest-cov", "mock", "hypothesis", "tox"],
-            "general": ["black", "pylint", "mypy", "python-dotenv", "pyyaml"],
-        }
-
-        return suggestions.get(project_type, suggestions["general"])
+#!/usr/bin/env python
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Requirements.txt validation to detect hallucinated packages."""
+
+import re
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+class RequirementsValidator:
+    """Validates requirements.txt files for hallucinated packages."""
+
+    # Patterns indicating hallucinated packages
+    HALLUCINATION_PATTERNS = [
+        r".*-ibm-cloud-ibm-cloud.*",  # Recursive IBM
+        r".*-azure-.*-azure.*",  # Recursive Azure
+        r".*-gcp-.*-gcp.*",  # Recursive GCP
+        r".*(\\w{4,})-\\1-\\1.*",  # Same word 3+ times
+        r"flask-graphql-.*-.*-.*-.*-.*",  # 5+ segments
+    ]
+
+    def validate(self, req_file: Path, fix: bool = False) -> Dict[str, Any]:
+        """Validate requirements.txt for hallucinated packages.
+
+        Args:
+            req_file: Path to requirements.txt file
+            fix: Whether to auto-fix issues
+
+        Returns:
+            Dictionary with validation results
+        """
+        content = req_file.read_text()
+        errors = []
+        warnings = []
+        lines = content.strip().split("\n")
+        valid_lines = []
+        seen_packages = set()
+
+        for line_num, line in enumerate(lines, 1):
+            line = line.strip()
+            if not line or line.startswith("#"):
+                valid_lines.append(line)
+                continue
+
+            # Extract package name
+            package_match = re.match(r"^([a-zA-Z0-9][a-zA-Z0-9._-]*)", line)
+            if not package_match:
+                errors.append(f"Line {line_num}: Invalid format")
+                continue
+
+            package_name = package_match.group(1).lower()
+
+            # Check for hallucination
+            is_hallucinated = False
+            for pattern in self.HALLUCINATION_PATTERNS:
+                if re.match(pattern, package_name):
+                    errors.append(
+                        f"Line {line_num}: Hallucinated package: {package_name[:50]}..."
+                    )
+                    is_hallucinated = True
+                    break
+
+            if is_hallucinated:
+                continue
+
+            # Check for excessive length
+            if len(package_name) > 60:
+                errors.append(
+                    f"Line {line_num}: Package name too long ({len(package_name)} chars)"
+                )
+                continue
+
+            # Check duplicates
+            if package_name in seen_packages:
+                warnings.append(f"Line {line_num}: Duplicate package: {package_name}")
+                continue
+
+            seen_packages.add(package_name)
+            valid_lines.append(line)
+
+        # Check total count
+        if len(seen_packages) > 50:
+            errors.append(
+                f"Too many packages ({len(seen_packages)}). Likely hallucinated."
+            )
+        elif len(seen_packages) > 30:
+            warnings.append(f"Many packages ({len(seen_packages)})")
+
+        # Auto-fix if requested
+        fixed_content = None
+        if fix and errors:
+            fixed_content = "\n".join(valid_lines)
+            req_file.write_text(fixed_content)
+
+        return {
+            "is_valid": len(errors) == 0,
+            "errors": errors,
+            "warnings": warnings,
+            "packages": len(seen_packages),
+            "fixed_content": fixed_content,
+        }
+
+    def check_package_validity(self, package_name: str) -> bool:
+        """Check if a package name appears valid.
+
+        Args:
+            package_name: Name of the package to check
+
+        Returns:
+            True if package name appears valid
+        """
+        # Check against hallucination patterns
+        for pattern in self.HALLUCINATION_PATTERNS:
+            if re.match(pattern, package_name.lower()):
+                return False
+
+        # Check length
+        if len(package_name) > 60:
+            return False
+
+        # Check for valid characters
+        if not re.match(r"^[a-zA-Z0-9][a-zA-Z0-9._-]*$", package_name):
+            return False
+
+        return True
+
+    def suggest_common_packages(self, project_type: str) -> List[str]:
+        """Suggest common packages for a project type.
+
+        Args:
+            project_type: Type of project (e.g., 'web', 'data', 'ml')
+
+        Returns:
+            List of suggested package names
+        """
+        suggestions = {
+            "web": ["flask", "django", "fastapi", "requests", "beautifulsoup4"],
+            "data": ["pandas", "numpy", "matplotlib", "seaborn", "jupyter"],
+            "ml": ["scikit-learn", "tensorflow", "torch", "transformers", "datasets"],
+            "test": ["pytest", "pytest-cov", "mock", "hypothesis", "tox"],
+            "general": ["black", "pylint", "mypy", "python-dotenv", "pyyaml"],
+        }
+
+        return suggestions.get(project_type, suggestions["general"])

gaia/agents/code/validators/syntax_validator.py

@@ -1,171 +1,171 @@
-#!/usr/bin/env python
-# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
-# SPDX-License-Identifier: MIT
-"""Python syntax validation module."""
-
-import ast
-from typing import Any, Dict, List
-
-from ..models import ValidationResult
-
-
-class SyntaxValidator:
-    """Validates Python code syntax."""
-
-    def validate(self, code: str) -> ValidationResult:
-        """Validate Python code syntax.
-
-        Args:
-            code: Python code to validate
-
-        Returns:
-            ValidationResult with validation details
-        """
-        result = ValidationResult(is_valid=True)
-
-        try:
-            # Try to compile the code
-            compile(code, "<string>", "exec")
-
-            # Also try to parse with AST for more detailed checking
-            ast.parse(code)
-
-            return result
-
-        except SyntaxError as e:
-            result.is_valid = False
-            result.errors.append(f"Line {e.lineno}: {e.msg}")
-            if e.text:
-                result.errors.append(f"  {e.text.rstrip()}")
-                if e.offset:
-                    result.errors.append(f"  {' ' * (e.offset - 1)}^")
-            return result
-
-        except Exception as e:
-            result.is_valid = False
-            result.errors.append(f"Parse error: {str(e)}")
-            return result
-
-    def validate_dict(self, code: str) -> Dict[str, Any]:
-        """Validate Python code and return as dictionary (legacy format).
-
-        Args:
-            code: Python code to validate
-
-        Returns:
-            Dictionary with validation results
-        """
-        result = self.validate(code)
-
-        return {
-            "status": "success" if result.is_valid else "error",
-            "is_valid": result.is_valid,
-            "errors": result.errors,
-            "message": "Syntax is valid" if result.is_valid else "Syntax errors found",
-        }
-
-    def get_syntax_errors(self, code: str) -> List[SyntaxError]:
-        """Get all syntax errors from code.
-
-        Args:
-            code: Python code to check
-
-        Returns:
-            List of SyntaxError objects
-        """
-        errors = []
-        try:
-            compile(code, "<string>", "exec")
-        except SyntaxError as e:
-            errors.append(e)
-
-        return errors
-
-    def check_indentation(self, code: str) -> List[str]:
-        """Check for indentation issues in code.
-
-        Args:
-            code: Python code to check
-
-        Returns:
-            List of indentation warnings
-        """
-        warnings = []
-        lines = code.split("\n")
-
-        for i, line in enumerate(lines, 1):
-            if line and line[0] in " \t":
-                # Check for mixed tabs and spaces
-                if " " in line and "\t" in line:
-                    warnings.append(f"Line {i}: Mixed tabs and spaces in indentation")
-
-                # Check for non-standard indentation (not multiples of 4)
-                if line.startswith(" "):
-                    spaces = len(line) - len(line.lstrip())
-                    if spaces % 4 != 0:
-                        warnings.append(
-                            f"Line {i}: Non-standard indentation ({spaces} spaces)"
-                        )
-
-        return warnings
-
-    def validate_imports(self, code: str) -> List[str]:
-        """Validate import statements in code.
-
-        Args:
-            code: Python code to check
-
-        Returns:
-            List of import-related warnings
-        """
-        warnings = []
-
-        try:
-            tree = ast.parse(code)
-
-            # Check for wildcard imports
-            for node in ast.walk(tree):
-                if isinstance(node, ast.ImportFrom):
-                    for alias in node.names:
-                        if alias.name == "*":
-                            warnings.append(
-                                f"Line {node.lineno}: Wildcard import 'from {node.module} import *' is discouraged"
-                            )
-
-            # Check for duplicate imports
-            imports_seen = set()
-            for node in ast.walk(tree):
-                if isinstance(node, ast.Import):
-                    for alias in node.names:
-                        if alias.name in imports_seen:
-                            warnings.append(
-                                f"Line {node.lineno}: Duplicate import '{alias.name}'"
-                            )
-                        imports_seen.add(alias.name)
-
-        except SyntaxError:
-            # Syntax errors will be caught by main validation
-            pass
-
-        return warnings
-
-    def check_line_length(self, code: str, max_length: int = 88) -> List[str]:
-        """Check for lines exceeding maximum length.
-
-        Args:
-            code: Python code to check
-            max_length: Maximum allowed line length (default: 88 for Black)
-
-        Returns:
-            List of line length warnings
-        """
-        warnings = []
-        lines = code.split("\n")
-
-        for i, line in enumerate(lines, 1):
-            if len(line) > max_length:
-                warnings.append(
-                    f"Line {i}: Line too long ({len(line)} > {max_length} characters)"
-                )
-
-        return warnings
+#!/usr/bin/env python
+# Copyright(C) 2024-2025 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Python syntax validation module."""
+
+import ast
+from typing import Any, Dict, List
+
+from ..models import ValidationResult
+
+
+class SyntaxValidator:
+    """Validates Python code syntax."""
+
+    def validate(self, code: str) -> ValidationResult:
+        """Validate Python code syntax.
+
+        Args:
+            code: Python code to validate
+
+        Returns:
+            ValidationResult with validation details
+        """
+        result = ValidationResult(is_valid=True)
+
+        try:
+            # Try to compile the code
+            compile(code, "<string>", "exec")
+
+            # Also try to parse with AST for more detailed checking
+            ast.parse(code)
+
+            return result
+
+        except SyntaxError as e:
+            result.is_valid = False
+            result.errors.append(f"Line {e.lineno}: {e.msg}")
+            if e.text:
+                result.errors.append(f"  {e.text.rstrip()}")
+                if e.offset:
+                    result.errors.append(f"  {' ' * (e.offset - 1)}^")
+            return result
+
+        except Exception as e:
+            result.is_valid = False
+            result.errors.append(f"Parse error: {str(e)}")
+            return result
+
+    def validate_dict(self, code: str) -> Dict[str, Any]:
+        """Validate Python code and return as dictionary (legacy format).
+
+        Args:
+            code: Python code to validate
+
+        Returns:
+            Dictionary with validation results
+        """
+        result = self.validate(code)
+
+        return {
+            "status": "success" if result.is_valid else "error",
+            "is_valid": result.is_valid,
+            "errors": result.errors,
+            "message": "Syntax is valid" if result.is_valid else "Syntax errors found",
+        }
+
+    def get_syntax_errors(self, code: str) -> List[SyntaxError]:
+        """Get all syntax errors from code.
+
+        Args:
+            code: Python code to check
+
+        Returns:
+            List of SyntaxError objects
+        """
+        errors = []
+        try:
+            compile(code, "<string>", "exec")
+        except SyntaxError as e:
+            errors.append(e)
+
+        return errors
+
+    def check_indentation(self, code: str) -> List[str]:
+        """Check for indentation issues in code.
+
+        Args:
+            code: Python code to check
+
+        Returns:
+            List of indentation warnings
+        """
+        warnings = []
+        lines = code.split("\n")
+
+        for i, line in enumerate(lines, 1):
+            if line and line[0] in " \t":
+                # Check for mixed tabs and spaces
+                if " " in line and "\t" in line:
+                    warnings.append(f"Line {i}: Mixed tabs and spaces in indentation")
+
+                # Check for non-standard indentation (not multiples of 4)
+                if line.startswith(" "):
+                    spaces = len(line) - len(line.lstrip())
+                    if spaces % 4 != 0:
+                        warnings.append(
+                            f"Line {i}: Non-standard indentation ({spaces} spaces)"
+                        )
+
+        return warnings
+
+    def validate_imports(self, code: str) -> List[str]:
+        """Validate import statements in code.
+
+        Args:
+            code: Python code to check
+
+        Returns:
+            List of import-related warnings
+        """
+        warnings = []
+
+        try:
+            tree = ast.parse(code)
+
+            # Check for wildcard imports
+            for node in ast.walk(tree):
+                if isinstance(node, ast.ImportFrom):
+                    for alias in node.names:
+                        if alias.name == "*":
+                            warnings.append(
+                                f"Line {node.lineno}: Wildcard import 'from {node.module} import *' is discouraged"
+                            )
+
+            # Check for duplicate imports
+            imports_seen = set()
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        if alias.name in imports_seen:
+                            warnings.append(
+                                f"Line {node.lineno}: Duplicate import '{alias.name}'"
+                            )
+                        imports_seen.add(alias.name)
+
+        except SyntaxError:
+            # Syntax errors will be caught by main validation
+            pass
+
+        return warnings
+
+    def check_line_length(self, code: str, max_length: int = 88) -> List[str]:
+        """Check for lines exceeding maximum length.
+
+        Args:
+            code: Python code to check
+            max_length: Maximum allowed line length (default: 88 for Black)
+
+        Returns:
+            List of line length warnings
+        """
+        warnings = []
+        lines = code.split("\n")
+
+        for i, line in enumerate(lines, 1):
+            if len(line) > max_length:
+                warnings.append(
+                    f"Line {i}: Line too long ({len(line)} > {max_length} characters)"
+                )
+
+        return warnings

gaia/agents/docker/__init__.py

@@ -1,7 +1,7 @@
-# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
-# SPDX-License-Identifier: MIT
-"""Docker agent for GAIA."""
-
-from gaia.agents.docker.agent import DockerAgent
-
-__all__ = ["DockerAgent"]
+# Copyright(C) 2025-2026 Advanced Micro Devices, Inc. All rights reserved.
+# SPDX-License-Identifier: MIT
+"""Docker agent for GAIA."""
+
+from gaia.agents.docker.agent import DockerAgent
+
+__all__ = ["DockerAgent"]