aiecs 1.0.0__py3-none-any.whl

aiecs/scripts/fix_weasel_validator.py

@@ -0,0 +1,121 @@
+#!/usr/bin/env python3
+"""
+Script to fix weasel library duplicate validator function error.
+This script patches the weasel schemas.py file to add allow_reuse=True to duplicate validators.
+"""
+
+import os
+import sys
+import subprocess
+import shutil
+from datetime import datetime
+import re
+
+def get_weasel_path():
+    """Get the weasel package path in the current Python environment."""
+    try:
+        import weasel
+        import inspect
+        weasel_file = inspect.getfile(weasel)
+        weasel_dir = os.path.dirname(weasel_file)
+        return os.path.join(weasel_dir, 'schemas.py')
+    except ImportError:
+        print("❌ Error: weasel package not found")
+        print("Please install aiecs with all dependencies")
+        return None
+    except Exception as e:
+        print(f"❌ Error finding weasel package: {e}")
+        return None
+
+def backup_file(file_path):
+    """Create a backup of the file."""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    backup_path = f"{file_path}.backup.{timestamp}"
+    shutil.copy2(file_path, backup_path)
+    return backup_path
+
+def fix_weasel_schemas(schemas_file_path):
+    """Fix the weasel schemas.py file by adding allow_reuse=True to validators."""
+
+    print(f"📁 Processing file: {schemas_file_path}")
+
+    # Read the original file
+    with open(schemas_file_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    # Check if already patched
+    if 'allow_reuse=True' in content:
+        print("✅ File already patched with allow_reuse=True")
+        return True
+
+    # Create backup
+    backup_path = backup_file(schemas_file_path)
+    print(f"💾 Created backup at: {backup_path}")
+
+    # Show current problematic area
+    lines = content.split('\n')
+    print("\n📖 Current content around line 89:")
+    for i, line in enumerate(lines[84:94], 85):
+        print(f"{i:3d} | {line}")
+
+    # Pattern to match both @validator and @root_validator decorators without allow_reuse
+    validator_pattern = r'(@(?:root_)?validator\([^)]*)\)(?!\s*,\s*allow_reuse=True)'
+
+    # Replace @validator(...) or @root_validator(...) with allow_reuse=True if not already present
+    def replace_validator(match):
+        validator_call = match.group(1)
+        # Check if allow_reuse is already in the parameters
+        if 'allow_reuse' in validator_call:
+            return match.group(0)  # Return unchanged
+        else:
+            return f"{validator_call}, allow_reuse=True)"
+
+    # Apply the fix
+    fixed_content = re.sub(validator_pattern, replace_validator, content)
+
+    # Write the fixed content back
+    with open(schemas_file_path, 'w', encoding='utf-8') as f:
+        f.write(fixed_content)
+
+    # Show the fixed content
+    fixed_lines = fixed_content.split('\n')
+    print("\n📖 Patched content around line 89:")
+    for i, line in enumerate(fixed_lines[84:94], 85):
+        print(f"{i:3d} | {line}")
+
+    # Verify the fix
+    if 'allow_reuse=True' in fixed_content:
+        print("✅ Verification successful: allow_reuse=True found in file")
+        return True
+    else:
+        print("⚠️  Warning: allow_reuse=True not found after patching")
+        return False
+
+def main():
+    """Main function to execute the patch."""
+    print("🔧 Starting weasel library patch for duplicate validator function...")
+
+    # Get weasel schemas.py path
+    schemas_file = get_weasel_path()
+    if not schemas_file:
+        sys.exit(1)
+
+    print(f"📍 Found weasel schemas.py at: {schemas_file}")
+
+    if not os.path.exists(schemas_file):
+        print(f"❌ Error: weasel schemas.py file not found at {schemas_file}")
+        sys.exit(1)
+
+    # Apply the fix
+    success = fix_weasel_schemas(schemas_file)
+
+    if success:
+        print("\n🎉 Weasel library patch completed successfully!")
+        print("\nYou can now run your tests again.")
+        print(f"\nIf you need to revert the changes, restore from the backup file.")
+    else:
+        print("\n❌ Patch may not have been applied correctly. Please check manually.")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

aiecs/scripts/fix_weasel_validator.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+
+# Script to fix weasel library duplicate validator function error
+# This script patches the weasel schemas.py file to add allow_reuse=True
+
+set -e
+
+echo "🔧 Starting weasel library patch for duplicate validator function..."
+
+# Get the poetry virtual environment path
+VENV_PATH=$(poetry env info --path 2>/dev/null || echo "")
+
+if [ -z "$VENV_PATH" ]; then
+    echo "❌ Error: Could not find poetry virtual environment"
+    echo "Please make sure you're in the project directory and poetry is installed"
+    exit 1
+fi
+
+echo "📍 Found virtual environment at: $VENV_PATH"
+
+# Path to the problematic weasel schemas.py file
+WEASEL_SCHEMAS_FILE="$VENV_PATH/lib/python3.10/site-packages/weasel/schemas.py"
+
+if [ ! -f "$WEASEL_SCHEMAS_FILE" ]; then
+    echo "❌ Error: weasel schemas.py file not found at $WEASEL_SCHEMAS_FILE"
+    exit 1
+fi
+
+echo "📁 Found weasel schemas.py at: $WEASEL_SCHEMAS_FILE"
+
+# Create backup of original file
+BACKUP_FILE="${WEASEL_SCHEMAS_FILE}.backup.$(date +%Y%m%d_%H%M%S)"
+cp "$WEASEL_SCHEMAS_FILE" "$BACKUP_FILE"
+echo "💾 Created backup at: $BACKUP_FILE"
+
+# Check if the file already has allow_reuse=True
+if grep -q "allow_reuse=True" "$WEASEL_SCHEMAS_FILE"; then
+    echo "✅ File already patched with allow_reuse=True"
+    exit 0
+fi
+
+# Apply the patch using sed
+# Look for @validator and @root_validator decorators and add allow_reuse=True if not present
+echo "🔨 Applying patch..."
+
+# First, let's check the current content around the problematic line
+echo "📖 Current content around line 89:"
+sed -n '85,95p' "$WEASEL_SCHEMAS_FILE"
+
+# Apply the patch - add allow_reuse=True to validator decorators that don't have it
+sed -i.tmp '
+/^[[:space:]]*@\(root_\)\?validator(/,/^[[:space:]]*def/ {
+    /^[[:space:]]*@\(root_\)\?validator(/ {
+        # If the line contains @validator or @root_validator but not allow_reuse, add it
+        /allow_reuse/! {
+            s/@\(root_\)\?validator(\([^)]*\))/@\1validator(\2, allow_reuse=True)/
+        }
+    }
+}
+' "$WEASEL_SCHEMAS_FILE"
+
+# Remove the temporary file
+rm -f "${WEASEL_SCHEMAS_FILE}.tmp"
+
+echo "✅ Patch applied successfully!"
+
+# Show the patched content
+echo "📖 Patched content around line 89:"
+sed -n '85,95p' "$WEASEL_SCHEMAS_FILE"
+
+# Verify the patch by checking if allow_reuse=True is now present
+if grep -q "allow_reuse=True" "$WEASEL_SCHEMAS_FILE"; then
+    echo "✅ Verification successful: allow_reuse=True found in file"
+else
+    echo "⚠️  Warning: allow_reuse=True not found after patching"
+fi
+
+echo "🎉 Weasel library patch completed!"
+echo "📝 Backup saved at: $BACKUP_FILE"
+echo ""
+echo "You can now run your tests again. If you need to revert the changes:"
+echo "cp '$BACKUP_FILE' '$WEASEL_SCHEMAS_FILE'"

aiecs/scripts/patch_weasel_library.sh

@@ -0,0 +1,188 @@
+#!/bin/bash
+
+# Comprehensive script to fix weasel library duplicate validator function error
+# This script provides multiple approaches to patch the issue
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+
+echo "🔧 Weasel Library Patcher"
+echo "========================="
+echo "Project directory: $PROJECT_DIR"
+echo ""
+
+# Function to check if we're in the right directory
+check_project_structure() {
+    if [ ! -f "$PROJECT_DIR/pyproject.toml" ]; then
+        echo "❌ Error: pyproject.toml not found. Please run this script from the python-middleware directory"
+        exit 1
+    fi
+}
+
+# Function to get poetry virtual environment path
+get_venv_path() {
+    cd "$PROJECT_DIR"
+    local venv_path
+    venv_path=$(poetry env info --path 2>/dev/null || echo "")
+
+    if [ -z "$venv_path" ]; then
+        echo "❌ Error: Could not find poetry virtual environment"
+        echo "Please make sure poetry is installed and the virtual environment is created"
+        echo "Try running: poetry install"
+        exit 1
+    fi
+
+    echo "$venv_path"
+}
+
+# Function to apply the patch
+apply_patch() {
+    local venv_path="$1"
+    local schemas_file="$venv_path/lib/python3.10/site-packages/weasel/schemas.py"
+
+    echo "📁 Target file: $schemas_file"
+
+    if [ ! -f "$schemas_file" ]; then
+        echo "❌ Error: weasel schemas.py file not found"
+        echo "The weasel package might not be installed or in a different location"
+        exit 1
+    fi
+
+    # Create backup
+    local backup_file="${schemas_file}.backup.$(date +%Y%m%d_%H%M%S)"
+    cp "$schemas_file" "$backup_file"
+    echo "💾 Backup created: $backup_file"
+
+    # Check if already patched
+    if grep -q "allow_reuse=True" "$schemas_file"; then
+        echo "✅ File already contains allow_reuse=True - may already be patched"
+        echo "Checking if the specific issue is resolved..."
+    fi
+
+    # Show current problematic content
+    echo ""
+    echo "📖 Current content around the problematic area:"
+    echo "------------------------------------------------"
+    sed -n '85,95p' "$schemas_file" | nl -ba -v85
+    echo "------------------------------------------------"
+    echo ""
+
+    # Apply the patch using Python for more precise control
+    python3 << EOF
+import re
+import sys
+
+schemas_file = "$schemas_file"
+
+try:
+    with open(schemas_file, 'r') as f:
+        content = f.read()
+
+    # Pattern to find @validator and @root_validator decorators that need allow_reuse=True
+    # Look for the specific problematic validator
+    pattern = r'(@(?:root_)?validator\([^)]*\))\s*\n(\s*def\s+check_legacy_keys)'
+
+    def fix_validator(match):
+        decorator = match.group(1)
+        func_def = match.group(2)
+
+        # Add allow_reuse=True if not present
+        if 'allow_reuse' not in decorator:
+            # Remove the closing parenthesis and add allow_reuse=True
+            fixed_decorator = decorator[:-1] + ', allow_reuse=True)'
+            return fixed_decorator + '\n' + func_def
+        return match.group(0)
+
+    # Apply the fix
+    fixed_content = re.sub(pattern, fix_validator, content)
+
+    # Also fix any other @validator or @root_validator decorators that might have the same issue
+    general_pattern = r'(@(?:root_)?validator\([^)]*)\)(?=\s*\n\s*def)'
+
+    def fix_general_validator(match):
+        decorator = match.group(1)
+        if 'allow_reuse' not in decorator:
+            return decorator + ', allow_reuse=True)'
+        return match.group(0)
+
+    fixed_content = re.sub(general_pattern, fix_general_validator, fixed_content)
+
+    # Write back the fixed content
+    with open(schemas_file, 'w') as f:
+        f.write(fixed_content)
+
+    print("✅ Patch applied successfully")
+
+except Exception as e:
+    print(f"❌ Error applying patch: {e}")
+    sys.exit(1)
+EOF
+
+    # Show the patched content
+    echo ""
+    echo "📖 Patched content:"
+    echo "-------------------"
+    sed -n '85,95p' "$schemas_file" | nl -ba -v85
+    echo "-------------------"
+    echo ""
+
+    # Verify the patch
+    if grep -q "allow_reuse=True" "$schemas_file"; then
+        echo "✅ Verification: allow_reuse=True found in the file"
+    else
+        echo "⚠️  Warning: allow_reuse=True not found after patching"
+    fi
+
+    echo "💾 Original file backed up to: $backup_file"
+}
+
+# Function to test the fix
+test_fix() {
+    echo ""
+    echo "🧪 Testing the fix..."
+    cd "$PROJECT_DIR"
+
+    # Try to import the problematic module
+    if python3 -c "
+import sys
+sys.path.insert(0, '.')
+try:
+    from app.tools.task_tools.research_tool import *
+    print('✅ Import successful - fix appears to work!')
+except Exception as e:
+    print(f'❌ Import still fails: {e}')
+    sys.exit(1)
+" 2>/dev/null; then
+        echo "✅ Fix verification successful!"
+    else
+        echo "⚠️  Fix verification failed - you may need to restart your Python environment"
+    fi
+}
+
+# Main execution
+main() {
+    echo "Starting patch process..."
+
+    check_project_structure
+
+    local venv_path
+    venv_path=$(get_venv_path)
+    echo "📍 Virtual environment: $venv_path"
+
+    apply_patch "$venv_path"
+
+    test_fix
+
+    echo ""
+    echo "🎉 Weasel library patch completed!"
+    echo ""
+    echo "Next steps:"
+    echo "1. Try running your tests again"
+    echo "2. If the issue persists, you may need to restart your Python environment"
+    echo "3. To revert changes, restore from the backup file shown above"
+}
+
+# Run the main function
+main "$@"

aiecs/scripts/quick_dependency_check.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""
+Quick dependency checker for AIECS post-installation.
+
+This script performs a fast check of critical dependencies and provides
+installation guidance for missing components.
+"""
+
+import os
+import sys
+import subprocess
+import platform
+import logging
+from typing import Dict, List, Tuple, Optional
+
+
+class QuickDependencyChecker:
+    """Quick dependency checker for post-installation."""
+    
+    def __init__(self):
+        self.logger = self._setup_logging()
+        self.system = platform.system().lower()
+        self.issues = []
+        self.critical_issues = []
+        
+    def _setup_logging(self) -> logging.Logger:
+        """Setup logging configuration."""
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(levelname)s: %(message)s'
+        )
+        return logging.getLogger(__name__)
+    
+    def check_command(self, command: str, version_flag: str = "--version") -> bool:
+        """Check if a system command is available."""
+        try:
+            result = subprocess.run(
+                [command, version_flag],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            return result.returncode == 0
+        except (subprocess.TimeoutExpired, FileNotFoundError, subprocess.CalledProcessError):
+            return False
+    
+    def check_python_package(self, package_name: str) -> bool:
+        """Check if a Python package is installed."""
+        try:
+            __import__(package_name)
+            return True
+        except ImportError:
+            return False
+    
+    def check_critical_dependencies(self) -> Dict[str, bool]:
+        """Check critical dependencies that affect core functionality."""
+        results = {}
+        
+        # Core Python packages
+        core_packages = [
+            "fastapi", "uvicorn", "pydantic", "httpx", "celery", "redis",
+            "pandas", "numpy", "scipy", "scikit-learn", "matplotlib"
+        ]
+        
+        for pkg in core_packages:
+            results[f"python_{pkg}"] = self.check_python_package(pkg)
+            if not results[f"python_{pkg}"]:
+                self.critical_issues.append(f"Missing Python package: {pkg}")
+        
+        # System dependencies for tools
+        system_deps = {
+            "java": ("Java Runtime Environment", "java", "-version"),
+            "tesseract": ("Tesseract OCR", "tesseract", "--version"),
+        }
+        
+        for key, (name, cmd, flag) in system_deps.items():
+            results[f"system_{key}"] = self.check_command(cmd, flag)
+            if not results[f"system_{key}"]:
+                self.issues.append(f"Missing system dependency: {name}")
+        
+        return results
+    
+    def check_tool_specific_dependencies(self) -> Dict[str, Dict[str, bool]]:
+        """Check dependencies for specific tools."""
+        tool_results = {}
+        
+        # Image Tool dependencies
+        image_deps = {
+            "tesseract": self.check_command("tesseract"),
+            "PIL": self.check_python_package("PIL"),
+            "pytesseract": self.check_python_package("pytesseract"),
+        }
+        tool_results["image"] = image_deps
+        
+        # ClassFire Tool dependencies
+        classfire_deps = {
+            "spacy": self.check_python_package("spacy"),
+            "nltk": self.check_python_package("nltk"),
+            "transformers": self.check_python_package("transformers"),
+        }
+        tool_results["classfire"] = classfire_deps
+        
+        # Office Tool dependencies
+        office_deps = {
+            "java": self.check_command("java"),
+            "tika": self.check_python_package("tika"),
+            "python-docx": self.check_python_package("python-docx"),
+            "openpyxl": self.check_python_package("openpyxl"),
+        }
+        tool_results["office"] = office_deps
+        
+        # Stats Tool dependencies
+        stats_deps = {
+            "pandas": self.check_python_package("pandas"),
+            "pyreadstat": self.check_python_package("pyreadstat"),
+            "statsmodels": self.check_python_package("statsmodels"),
+        }
+        tool_results["stats"] = stats_deps
+        
+        # Report Tool dependencies
+        report_deps = {
+            "jinja2": self.check_python_package("jinja2"),
+            "matplotlib": self.check_python_package("matplotlib"),
+            "weasyprint": self.check_python_package("weasyprint"),
+        }
+        tool_results["report"] = report_deps
+        
+        # Scraper Tool dependencies
+        scraper_deps = {
+            "playwright": self.check_python_package("playwright"),
+            "beautifulsoup4": self.check_python_package("beautifulsoup4"),
+            "scrapy": self.check_python_package("scrapy"),
+        }
+        tool_results["scraper"] = scraper_deps
+        
+        return tool_results
+    
+    def get_installation_commands(self) -> Dict[str, List[str]]:
+        """Get installation commands for missing dependencies."""
+        commands = {
+            "system": [],
+            "python": [],
+            "models": []
+        }
+        
+        # System dependencies
+        if self.system == "linux":
+            if not self.check_command("java"):
+                commands["system"].append("sudo apt-get install openjdk-11-jdk")
+            if not self.check_command("tesseract"):
+                commands["system"].append("sudo apt-get install tesseract-ocr tesseract-ocr-eng")
+        elif self.system == "darwin":
+            if not self.check_command("java"):
+                commands["system"].append("brew install openjdk@11")
+            if not self.check_command("tesseract"):
+                commands["system"].append("brew install tesseract")
+        
+        # Python packages (these should already be installed via pip)
+        missing_packages = []
+        for issue in self.critical_issues:
+            if "Missing Python package:" in issue:
+                pkg = issue.split(": ")[1]
+                missing_packages.append(pkg)
+        
+        if missing_packages:
+            commands["python"].append(f"pip install {' '.join(missing_packages)}")
+        
+        # Models and data
+        commands["models"].append("python -m aiecs.scripts.download_nlp_data")
+        commands["models"].append("playwright install")
+        
+        return commands
+    
+    def generate_quick_report(self) -> str:
+        """Generate a quick dependency report."""
+        report = []
+        report.append("🔍 AIECS Quick Dependency Check")
+        report.append("=" * 50)
+        
+        # Check critical dependencies
+        critical_results = self.check_critical_dependencies()
+        tool_results = self.check_tool_specific_dependencies()
+        
+        # Critical dependencies status
+        report.append("\n📦 Critical Dependencies:")
+        critical_ok = all(critical_results.values())
+        if critical_ok:
+            report.append("✅ All critical dependencies are available")
+        else:
+            report.append("❌ Some critical dependencies are missing")
+            for key, available in critical_results.items():
+                if not available:
+                    dep_name = key.replace("python_", "").replace("system_", "")
+                    report.append(f"   ❌ {dep_name}")
+        
+        # Tool-specific dependencies
+        report.append("\n🔧 Tool-Specific Dependencies:")
+        for tool, deps in tool_results.items():
+            tool_ok = all(deps.values())
+            status = "✅" if tool_ok else "⚠️"
+            report.append(f"   {status} {tool.title()} Tool")
+            
+            if not tool_ok:
+                for dep, available in deps.items():
+                    if not available:
+                        report.append(f"      ❌ {dep}")
+        
+        # Installation commands
+        commands = self.get_installation_commands()
+        if any(commands.values()):
+            report.append("\n🛠️  Installation Commands:")
+            
+            if commands["system"]:
+                report.append("   System Dependencies:")
+                for cmd in commands["system"]:
+                    report.append(f"      {cmd}")
+            
+            if commands["python"]:
+                report.append("   Python Packages:")
+                for cmd in commands["python"]:
+                    report.append(f"      {cmd}")
+            
+            if commands["models"]:
+                report.append("   Models and Data:")
+                for cmd in commands["models"]:
+                    report.append(f"      {cmd}")
+        
+        # Summary
+        total_issues = len(self.issues) + len(self.critical_issues)
+        if total_issues == 0:
+            report.append("\n🎉 All dependencies are available!")
+            report.append("AIECS is ready to use with full functionality.")
+        else:
+            report.append(f"\n⚠️  Found {total_issues} dependency issues.")
+            if self.critical_issues:
+                report.append(f"   Critical: {len(self.critical_issues)}")
+            if self.issues:
+                report.append(f"   Optional: {len(self.issues)}")
+            report.append("Please install missing dependencies for full functionality.")
+        
+        return "\n".join(report)
+    
+    def run_check(self) -> int:
+        """Run the quick dependency check."""
+        print("🔍 Running quick dependency check...")
+        
+        # Generate and display report
+        report = self.generate_quick_report()
+        print(report)
+        
+        # Return exit code
+        if self.critical_issues:
+            return 1
+        else:
+            return 0
+
+
+def main():
+    """Main function."""
+    checker = QuickDependencyChecker()
+    return checker.run_check()
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+
+
+