aiecs 1.0.0__py3-none-any.whl

aiecs/scripts/dependency_checker.py

@@ -0,0 +1,825 @@
+#!/usr/bin/env python3
+"""
+Comprehensive dependency checker for AIECS tools.
+
+This script checks all system dependencies, Python packages, and model files
+required by various AIECS tools and provides detailed status reports and
+installation instructions.
+"""
+
+import os
+import sys
+import subprocess
+import platform
+import shutil
+import logging
+from pathlib import Path
+from typing import Dict, List, Tuple, Optional, Any
+from dataclasses import dataclass
+from enum import Enum
+
+
+class DependencyStatus(Enum):
+    """Status of a dependency check."""
+    AVAILABLE = "available"
+    MISSING = "missing"
+    PARTIAL = "partial"
+    ERROR = "error"
+
+
+@dataclass
+class DependencyInfo:
+    """Information about a dependency."""
+    name: str
+    status: DependencyStatus
+    description: str
+    install_command: Optional[str] = None
+    install_url: Optional[str] = None
+    impact: str = ""
+    is_critical: bool = True
+
+
+@dataclass
+class ToolDependencies:
+    """Dependencies for a specific tool."""
+    tool_name: str
+    system_deps: List[DependencyInfo]
+    python_deps: List[DependencyInfo]
+    model_deps: List[DependencyInfo]
+    optional_deps: List[DependencyInfo]
+
+
+class DependencyChecker:
+    """Main dependency checker class."""
+    
+    def __init__(self):
+        self.logger = self._setup_logging()
+        self.system = platform.system().lower()
+        self.architecture = platform.machine().lower()
+        self.python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+        
+    def _setup_logging(self) -> logging.Logger:
+        """Setup logging configuration."""
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s',
+            handlers=[
+                logging.StreamHandler(sys.stdout),
+                logging.FileHandler('dependency_check.log')
+            ]
+        )
+        return logging.getLogger(__name__)
+    
+    def check_system_command(self, command: str, version_flag: str = "--version") -> DependencyStatus:
+        """Check if a system command is available."""
+        try:
+            result = subprocess.run(
+                [command, version_flag],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            if result.returncode == 0:
+                return DependencyStatus.AVAILABLE
+            else:
+                return DependencyStatus.MISSING
+        except (subprocess.TimeoutExpired, FileNotFoundError, subprocess.CalledProcessError):
+            return DependencyStatus.MISSING
+    
+    def check_python_package(self, package_name: str) -> DependencyStatus:
+        """Check if a Python package is installed."""
+        try:
+            __import__(package_name)
+            return DependencyStatus.AVAILABLE
+        except ImportError:
+            return DependencyStatus.MISSING
+    
+    def check_file_exists(self, file_path: str) -> DependencyStatus:
+        """Check if a file exists."""
+        if os.path.exists(file_path):
+            return DependencyStatus.AVAILABLE
+        else:
+            return DependencyStatus.MISSING
+    
+    def check_directory_exists(self, dir_path: str) -> DependencyStatus:
+        """Check if a directory exists."""
+        if os.path.isdir(dir_path):
+            return DependencyStatus.AVAILABLE
+        else:
+            return DependencyStatus.MISSING
+    
+    def get_system_package_manager(self) -> str:
+        """Get the appropriate package manager for the system."""
+        if self.system == "linux":
+            if shutil.which("apt-get"):
+                return "apt-get"
+            elif shutil.which("yum"):
+                return "yum"
+            elif shutil.which("dnf"):
+                return "dnf"
+            elif shutil.which("pacman"):
+                return "pacman"
+        elif self.system == "darwin":
+            if shutil.which("brew"):
+                return "brew"
+        elif self.system == "windows":
+            return "chocolatey"
+        return "unknown"
+    
+    def check_image_tool_dependencies(self) -> ToolDependencies:
+        """Check dependencies for Image Tool."""
+        system_deps = []
+        python_deps = []
+        model_deps = []
+        optional_deps = []
+        
+        # Tesseract OCR
+        tesseract_status = self.check_system_command("tesseract")
+        system_deps.append(DependencyInfo(
+            name="Tesseract OCR",
+            status=tesseract_status,
+            description="OCR engine for text extraction from images",
+            install_command=self._get_tesseract_install_command(),
+            impact="OCR functionality will be unavailable",
+            is_critical=True
+        ))
+        
+        # Pillow system dependencies
+        pillow_status = self._check_pillow_system_deps()
+        system_deps.append(DependencyInfo(
+            name="Pillow System Libraries",
+            status=pillow_status,
+            description="Image processing system libraries (libjpeg, libpng, etc.)",
+            install_command=self._get_pillow_system_deps_command(),
+            impact="Image processing may fail or be limited",
+            is_critical=True
+        ))
+        
+        # Python packages
+        python_packages = ["PIL", "pytesseract"]
+        for pkg in python_packages:
+            status = self.check_python_package(pkg)
+            python_deps.append(DependencyInfo(
+                name=pkg,
+                status=status,
+                description=f"Python package: {pkg}",
+                install_command=f"pip install {pkg}",
+                impact=f"{pkg} functionality will be unavailable",
+                is_critical=True
+            ))
+        
+        # Tesseract language packs
+        lang_packs = ["eng", "chi_sim", "chi_tra", "fra", "deu", "jpn", "kor", "rus", "spa"]
+        for lang in lang_packs:
+            status = self._check_tesseract_lang_pack(lang)
+            model_deps.append(DependencyInfo(
+                name=f"Tesseract {lang}",
+                status=status,
+                description=f"Tesseract language pack for {lang}",
+                install_command=self._get_tesseract_lang_install_command(lang),
+                impact=f"OCR in {lang} language will be unavailable",
+                is_critical=False
+            ))
+        
+        return ToolDependencies(
+            tool_name="Image Tool",
+            system_deps=system_deps,
+            python_deps=python_deps,
+            model_deps=model_deps,
+            optional_deps=optional_deps
+        )
+    
+    def check_classfire_tool_dependencies(self) -> ToolDependencies:
+        """Check dependencies for ClassFire Tool."""
+        system_deps = []
+        python_deps = []
+        model_deps = []
+        optional_deps = []
+        
+        # Python packages
+        python_packages = ["spacy", "transformers", "nltk", "rake_nltk", "spacy_pkuseg"]
+        for pkg in python_packages:
+            status = self.check_python_package(pkg)
+            is_critical = pkg != "spacy_pkuseg"  # spacy_pkuseg is optional
+            python_deps.append(DependencyInfo(
+                name=pkg,
+                status=status,
+                description=f"Python package: {pkg}",
+                install_command=f"pip install {pkg}",
+                impact=f"{pkg} functionality will be unavailable",
+                is_critical=is_critical
+            ))
+        
+        # spaCy models
+        spacy_models = ["en_core_web_sm", "zh_core_web_sm"]
+        for model in spacy_models:
+            status = self._check_spacy_model(model)
+            is_critical = model == "en_core_web_sm"  # Only English model is critical
+            model_deps.append(DependencyInfo(
+                name=f"spaCy {model}",
+                status=status,
+                description=f"spaCy model: {model}",
+                install_command=f"python -m spacy download {model}",
+                impact=f"Text processing in {model.split('_')[0]} language will be unavailable",
+                is_critical=is_critical
+            ))
+
+        # spaCy PKUSeg model (optional Chinese segmentation)
+        pkuseg_status = self._check_spacy_pkuseg_model()
+        model_deps.append(DependencyInfo(
+            name="spaCy PKUSeg",
+            status=pkuseg_status,
+            description="Chinese text segmentation model for spaCy",
+            install_command="pip install spacy_pkuseg",
+            impact="Advanced Chinese text segmentation will be unavailable",
+            is_critical=False
+        ))
+        
+        # Transformers models
+        transformers_models = ["facebook/bart-large-cnn", "t5-base"]
+        for model in transformers_models:
+            status = self._check_transformers_model(model)
+            model_deps.append(DependencyInfo(
+                name=f"Transformers {model}",
+                status=status,
+                description=f"Transformers model: {model}",
+                install_command="Models download automatically on first use",
+                impact=f"Text summarization with {model} will be unavailable",
+                is_critical=False
+            ))
+        
+        # NLTK data
+        nltk_data = ["stopwords", "punkt", "wordnet", "averaged_perceptron_tagger"]
+        for data in nltk_data:
+            status = self._check_nltk_data(data)
+            model_deps.append(DependencyInfo(
+                name=f"NLTK {data}",
+                status=status,
+                description=f"NLTK data: {data}",
+                install_command=f"python -c \"import nltk; nltk.download('{data}')\"",
+                impact=f"NLTK {data} functionality will be unavailable",
+                is_critical=True
+            ))
+        
+        return ToolDependencies(
+            tool_name="ClassFire Tool",
+            system_deps=system_deps,
+            python_deps=python_deps,
+            model_deps=model_deps,
+            optional_deps=optional_deps
+        )
+    
+    def check_office_tool_dependencies(self) -> ToolDependencies:
+        """Check dependencies for Office Tool."""
+        system_deps = []
+        python_deps = []
+        model_deps = []
+        optional_deps = []
+        
+        # Java Runtime Environment
+        java_status = self.check_system_command("java", "-version")
+        system_deps.append(DependencyInfo(
+            name="Java Runtime Environment",
+            status=java_status,
+            description="Java runtime for Apache Tika document parsing",
+            install_command=self._get_java_install_command(),
+            impact="Document parsing with Tika will be unavailable",
+            is_critical=True
+        ))
+        
+        # Tesseract OCR
+        tesseract_status = self.check_system_command("tesseract")
+        system_deps.append(DependencyInfo(
+            name="Tesseract OCR",
+            status=tesseract_status,
+            description="OCR engine for image text extraction",
+            install_command=self._get_tesseract_install_command(),
+            impact="OCR functionality will be unavailable",
+            is_critical=False
+        ))
+        
+        # Python packages
+        python_packages = ["tika", "python-docx", "python-pptx", "openpyxl", "pdfplumber", "pytesseract", "PIL"]
+        for pkg in python_packages:
+            status = self.check_python_package(pkg)
+            python_deps.append(DependencyInfo(
+                name=pkg,
+                status=status,
+                description=f"Python package: {pkg}",
+                install_command=f"pip install {pkg}",
+                impact=f"{pkg} functionality will be unavailable",
+                is_critical=True
+            ))
+        
+        return ToolDependencies(
+            tool_name="Office Tool",
+            system_deps=system_deps,
+            python_deps=python_deps,
+            model_deps=model_deps,
+            optional_deps=optional_deps
+        )
+    
+    def check_stats_tool_dependencies(self) -> ToolDependencies:
+        """Check dependencies for Stats Tool."""
+        system_deps = []
+        python_deps = []
+        model_deps = []
+        optional_deps = []
+        
+        # pyreadstat system dependencies
+        pyreadstat_status = self._check_pyreadstat_system_deps()
+        system_deps.append(DependencyInfo(
+            name="libreadstat",
+            status=pyreadstat_status,
+            description="System library for reading SAS, SPSS, Stata files",
+            install_command=self._get_pyreadstat_install_command(),
+            impact="SAS, SPSS, Stata file reading will be unavailable",
+            is_critical=False
+        ))
+        
+        # Excel system dependencies
+        excel_status = self._check_excel_system_deps()
+        system_deps.append(DependencyInfo(
+            name="Excel System Libraries",
+            status=excel_status,
+            description="System libraries for Excel file processing",
+            install_command=self._get_excel_system_deps_command(),
+            impact="Excel file processing may be limited",
+            is_critical=False
+        ))
+        
+        # Python packages
+        python_packages = ["pandas", "numpy", "scipy", "scikit-learn", "statsmodels", "pyreadstat", "openpyxl"]
+        for pkg in python_packages:
+            status = self.check_python_package(pkg)
+            python_deps.append(DependencyInfo(
+                name=pkg,
+                status=status,
+                description=f"Python package: {pkg}",
+                install_command=f"pip install {pkg}",
+                impact=f"{pkg} functionality will be unavailable",
+                is_critical=True
+            ))
+        
+        return ToolDependencies(
+            tool_name="Stats Tool",
+            system_deps=system_deps,
+            python_deps=python_deps,
+            model_deps=model_deps,
+            optional_deps=optional_deps
+        )
+    
+    def check_report_tool_dependencies(self) -> ToolDependencies:
+        """Check dependencies for Report Tool."""
+        system_deps = []
+        python_deps = []
+        model_deps = []
+        optional_deps = []
+        
+        # WeasyPrint system dependencies
+        weasyprint_status = self._check_weasyprint_system_deps()
+        system_deps.append(DependencyInfo(
+            name="WeasyPrint System Libraries",
+            status=weasyprint_status,
+            description="System libraries for PDF generation (cairo, pango, etc.)",
+            install_command=self._get_weasyprint_install_command(),
+            impact="PDF generation will be unavailable",
+            is_critical=False
+        ))
+        
+        # Matplotlib system dependencies
+        matplotlib_status = self._check_matplotlib_system_deps()
+        system_deps.append(DependencyInfo(
+            name="Matplotlib System Libraries",
+            status=matplotlib_status,
+            description="System libraries for chart generation",
+            install_command=self._get_matplotlib_system_deps_command(),
+            impact="Chart generation may be limited",
+            is_critical=False
+        ))
+        
+        # Python packages
+        python_packages = ["jinja2", "matplotlib", "weasyprint", "bleach", "markdown", "pandas", "openpyxl", "python-docx", "python-pptx"]
+        for pkg in python_packages:
+            status = self.check_python_package(pkg)
+            python_deps.append(DependencyInfo(
+                name=pkg,
+                status=status,
+                description=f"Python package: {pkg}",
+                install_command=f"pip install {pkg}",
+                impact=f"{pkg} functionality will be unavailable",
+                is_critical=True
+            ))
+        
+        return ToolDependencies(
+            tool_name="Report Tool",
+            system_deps=system_deps,
+            python_deps=python_deps,
+            model_deps=model_deps,
+            optional_deps=optional_deps
+        )
+    
+    def check_scraper_tool_dependencies(self) -> ToolDependencies:
+        """Check dependencies for Scraper Tool."""
+        system_deps = []
+        python_deps = []
+        model_deps = []
+        optional_deps = []
+        
+        # Playwright browsers
+        playwright_status = self._check_playwright_browsers()
+        system_deps.append(DependencyInfo(
+            name="Playwright Browsers",
+            status=playwright_status,
+            description="Browser binaries for JavaScript rendering",
+            install_command="playwright install",
+            impact="JavaScript rendering will be unavailable",
+            is_critical=False
+        ))
+        
+        # Playwright system dependencies
+        playwright_deps_status = self._check_playwright_system_deps()
+        system_deps.append(DependencyInfo(
+            name="Playwright System Dependencies",
+            status=playwright_deps_status,
+            description="System libraries for browser automation",
+            install_command="playwright install-deps",
+            impact="Browser automation may fail",
+            is_critical=False
+        ))
+        
+        # Python packages
+        python_packages = ["playwright", "scrapy", "httpx", "beautifulsoup4", "lxml"]
+        for pkg in python_packages:
+            status = self.check_python_package(pkg)
+            python_deps.append(DependencyInfo(
+                name=pkg,
+                status=status,
+                description=f"Python package: {pkg}",
+                install_command=f"pip install {pkg}",
+                impact=f"{pkg} functionality will be unavailable",
+                is_critical=True
+            ))
+        
+        return ToolDependencies(
+            tool_name="Scraper Tool",
+            system_deps=system_deps,
+            python_deps=python_deps,
+            model_deps=model_deps,
+            optional_deps=optional_deps
+        )
+    
+    def _check_pillow_system_deps(self) -> DependencyStatus:
+        """Check Pillow system dependencies."""
+        try:
+            from PIL import Image
+            # Try to create a simple image to test system libraries
+            img = Image.new('RGB', (10, 10), color='red')
+            img.save('/tmp/test_pillow.png')
+            os.remove('/tmp/test_pillow.png')
+            return DependencyStatus.AVAILABLE
+        except Exception:
+            return DependencyStatus.MISSING
+    
+    def _check_tesseract_lang_pack(self, lang: str) -> DependencyStatus:
+        """Check if a Tesseract language pack is installed."""
+        try:
+            result = subprocess.run(
+                ["tesseract", "--list-langs"],
+                capture_output=True,
+                text=True,
+                timeout=10
+            )
+            if result.returncode == 0 and lang in result.stdout:
+                return DependencyStatus.AVAILABLE
+            else:
+                return DependencyStatus.MISSING
+        except Exception:
+            return DependencyStatus.MISSING
+    
+    def _check_spacy_model(self, model: str) -> DependencyStatus:
+        """Check if a spaCy model is installed."""
+        try:
+            import spacy
+            spacy.load(model)
+            return DependencyStatus.AVAILABLE
+        except OSError:
+            return DependencyStatus.MISSING
+        except Exception:
+            return DependencyStatus.ERROR
+    
+    def _check_transformers_model(self, model: str) -> DependencyStatus:
+        """Check if a Transformers model is available."""
+        try:
+            from transformers import pipeline
+            # Try to load the model (this will download if not present)
+            pipe = pipeline("summarization", model=model)
+            return DependencyStatus.AVAILABLE
+        except Exception:
+            return DependencyStatus.MISSING
+    
+    def _check_nltk_data(self, data: str) -> DependencyStatus:
+        """Check if NLTK data is available."""
+        try:
+            import nltk
+            nltk.data.find(f'corpora/{data}')
+            return DependencyStatus.AVAILABLE
+        except LookupError:
+            return DependencyStatus.MISSING
+        except Exception:
+            return DependencyStatus.ERROR
+
+    def _check_spacy_pkuseg_model(self) -> DependencyStatus:
+        """Check if spaCy PKUSeg model is available."""
+        try:
+            import spacy_pkuseg
+            # Test basic functionality
+            seg = spacy_pkuseg.pkuseg()
+            test_result = list(seg.cut("测试"))
+            return DependencyStatus.AVAILABLE
+        except ImportError:
+            return DependencyStatus.MISSING
+        except Exception:
+            return DependencyStatus.ERROR
+    
+    def _check_pyreadstat_system_deps(self) -> DependencyStatus:
+        """Check pyreadstat system dependencies."""
+        try:
+            import pyreadstat
+            return DependencyStatus.AVAILABLE
+        except ImportError:
+            return DependencyStatus.MISSING
+        except Exception:
+            return DependencyStatus.ERROR
+    
+    def _check_excel_system_deps(self) -> DependencyStatus:
+        """Check Excel system dependencies."""
+        try:
+            import openpyxl
+            return DependencyStatus.AVAILABLE
+        except ImportError:
+            return DependencyStatus.MISSING
+        except Exception:
+            return DependencyStatus.ERROR
+    
+    def _check_weasyprint_system_deps(self) -> DependencyStatus:
+        """Check WeasyPrint system dependencies."""
+        try:
+            import weasyprint
+            return DependencyStatus.AVAILABLE
+        except ImportError:
+            return DependencyStatus.MISSING
+        except Exception:
+            return DependencyStatus.ERROR
+    
+    def _check_matplotlib_system_deps(self) -> DependencyStatus:
+        """Check Matplotlib system dependencies."""
+        try:
+            import matplotlib.pyplot as plt
+            plt.figure()
+            return DependencyStatus.AVAILABLE
+        except Exception:
+            return DependencyStatus.MISSING
+    
+    def _check_playwright_browsers(self) -> DependencyStatus:
+        """Check if Playwright browsers are installed."""
+        browsers_dir = Path.home() / ".cache" / "ms-playwright"
+        if browsers_dir.exists() and any(browsers_dir.iterdir()):
+            return DependencyStatus.AVAILABLE
+        else:
+            return DependencyStatus.MISSING
+    
+    def _check_playwright_system_deps(self) -> DependencyStatus:
+        """Check Playwright system dependencies."""
+        try:
+            from playwright.sync_api import sync_playwright
+            with sync_playwright() as p:
+                browser = p.chromium.launch(headless=True)
+                browser.close()
+            return DependencyStatus.AVAILABLE
+        except Exception:
+            return DependencyStatus.MISSING
+    
+    def _get_tesseract_install_command(self) -> str:
+        """Get Tesseract installation command for current system."""
+        if self.system == "linux":
+            return "sudo apt-get install tesseract-ocr tesseract-ocr-eng"
+        elif self.system == "darwin":
+            return "brew install tesseract"
+        elif self.system == "windows":
+            return "choco install tesseract"
+        return "Please install Tesseract OCR manually"
+    
+    def _get_pillow_system_deps_command(self) -> str:
+        """Get Pillow system dependencies installation command."""
+        if self.system == "linux":
+            return "sudo apt-get install libjpeg-dev zlib1g-dev libpng-dev libtiff-dev libwebp-dev libopenjp2-7-dev"
+        elif self.system == "darwin":
+            return "brew install libjpeg zlib libpng libtiff webp openjpeg"
+        return "Please install image processing libraries manually"
+    
+    def _get_tesseract_lang_install_command(self, lang: str) -> str:
+        """Get Tesseract language pack installation command."""
+        if self.system == "linux":
+            return f"sudo apt-get install tesseract-ocr-{lang}"
+        elif self.system == "darwin":
+            return f"brew install tesseract-lang-{lang}"
+        return f"Please install Tesseract {lang} language pack manually"
+    
+    def _get_java_install_command(self) -> str:
+        """Get Java installation command."""
+        if self.system == "linux":
+            return "sudo apt-get install openjdk-11-jdk"
+        elif self.system == "darwin":
+            return "brew install openjdk@11"
+        elif self.system == "windows":
+            return "choco install openjdk11"
+        return "Please install Java 11 or later manually"
+    
+    def _get_pyreadstat_install_command(self) -> str:
+        """Get pyreadstat installation command."""
+        if self.system == "linux":
+            return "sudo apt-get install libreadstat-dev && pip install pyreadstat"
+        elif self.system == "darwin":
+            return "brew install readstat && pip install pyreadstat"
+        return "Please install libreadstat and pyreadstat manually"
+    
+    def _get_excel_system_deps_command(self) -> str:
+        """Get Excel system dependencies installation command."""
+        if self.system == "linux":
+            return "sudo apt-get install libxml2-dev libxslt1-dev"
+        elif self.system == "darwin":
+            return "brew install libxml2 libxslt"
+        return "Please install XML processing libraries manually"
+    
+    def _get_weasyprint_install_command(self) -> str:
+        """Get WeasyPrint installation command."""
+        if self.system == "linux":
+            return "sudo apt-get install libcairo2-dev libpango1.0-dev libgdk-pixbuf2.0-dev libffi-dev shared-mime-info"
+        elif self.system == "darwin":
+            return "brew install cairo pango gdk-pixbuf libffi"
+        return "Please install WeasyPrint dependencies manually"
+    
+    def _get_matplotlib_system_deps_command(self) -> str:
+        """Get Matplotlib system dependencies installation command."""
+        if self.system == "linux":
+            return "sudo apt-get install libfreetype6-dev libpng-dev libjpeg-dev libtiff-dev libwebp-dev"
+        elif self.system == "darwin":
+            return "brew install freetype libpng libjpeg libtiff webp"
+        return "Please install image processing libraries manually"
+    
+    def check_all_dependencies(self) -> Dict[str, ToolDependencies]:
+        """Check all tool dependencies."""
+        self.logger.info("Starting comprehensive dependency check...")
+        
+        tools = {
+            "image": self.check_image_tool_dependencies(),
+            "classfire": self.check_classfire_tool_dependencies(),
+            "office": self.check_office_tool_dependencies(),
+            "stats": self.check_stats_tool_dependencies(),
+            "report": self.check_report_tool_dependencies(),
+            "scraper": self.check_scraper_tool_dependencies(),
+        }
+        
+        return tools
+    
+    def generate_report(self, tools: Dict[str, ToolDependencies]) -> str:
+        """Generate a comprehensive dependency report."""
+        report = []
+        report.append("=" * 80)
+        report.append("AIECS DEPENDENCY CHECK REPORT")
+        report.append("=" * 80)
+        report.append(f"System: {self.system.title()} {self.architecture}")
+        report.append(f"Python: {self.python_version}")
+        report.append(f"Package Manager: {self.get_system_package_manager()}")
+        report.append("")
+        
+        total_issues = 0
+        critical_issues = 0
+        
+        for tool_name, tool_deps in tools.items():
+            report.append(f"🔧 {tool_deps.tool_name.upper()}")
+            report.append("-" * 40)
+            
+            # System dependencies
+            if tool_deps.system_deps:
+                report.append("📦 System Dependencies:")
+                for dep in tool_deps.system_deps:
+                    status_icon = "✅" if dep.status == DependencyStatus.AVAILABLE else "❌" if dep.is_critical else "⚠️"
+                    report.append(f"  {status_icon} {dep.name}: {dep.status.value}")
+                    if dep.status != DependencyStatus.AVAILABLE:
+                        total_issues += 1
+                        if dep.is_critical:
+                            critical_issues += 1
+                        if dep.install_command:
+                            report.append(f"     Install: {dep.install_command}")
+                        if dep.impact:
+                            report.append(f"     Impact: {dep.impact}")
+                report.append("")
+            
+            # Python dependencies
+            if tool_deps.python_deps:
+                report.append("🐍 Python Dependencies:")
+                for dep in tool_deps.python_deps:
+                    status_icon = "✅" if dep.status == DependencyStatus.AVAILABLE else "❌"
+                    report.append(f"  {status_icon} {dep.name}: {dep.status.value}")
+                    if dep.status != DependencyStatus.AVAILABLE:
+                        total_issues += 1
+                        critical_issues += 1
+                        if dep.install_command:
+                            report.append(f"     Install: {dep.install_command}")
+                        if dep.impact:
+                            report.append(f"     Impact: {dep.impact}")
+                report.append("")
+            
+            # Model dependencies
+            if tool_deps.model_deps:
+                report.append("🤖 Model Dependencies:")
+                for dep in tool_deps.model_deps:
+                    status_icon = "✅" if dep.status == DependencyStatus.AVAILABLE else "❌" if dep.is_critical else "⚠️"
+                    report.append(f"  {status_icon} {dep.name}: {dep.status.value}")
+                    if dep.status != DependencyStatus.AVAILABLE:
+                        total_issues += 1
+                        if dep.is_critical:
+                            critical_issues += 1
+                        if dep.install_command:
+                            report.append(f"     Install: {dep.install_command}")
+                        if dep.impact:
+                            report.append(f"     Impact: {dep.impact}")
+                report.append("")
+            
+            # Optional dependencies
+            if tool_deps.optional_deps:
+                report.append("🔧 Optional Dependencies:")
+                for dep in tool_deps.optional_deps:
+                    status_icon = "✅" if dep.status == DependencyStatus.AVAILABLE else "⚠️"
+                    report.append(f"  {status_icon} {dep.name}: {dep.status.value}")
+                    if dep.status != DependencyStatus.AVAILABLE and dep.install_command:
+                        report.append(f"     Install: {dep.install_command}")
+                report.append("")
+        
+        # Summary
+        report.append("=" * 80)
+        report.append("SUMMARY")
+        report.append("=" * 80)
+        report.append(f"Total Issues: {total_issues}")
+        report.append(f"Critical Issues: {critical_issues}")
+        report.append(f"Optional Issues: {total_issues - critical_issues}")
+        
+        if critical_issues == 0:
+            report.append("")
+            report.append("🎉 All critical dependencies are available!")
+            report.append("AIECS is ready to use with full functionality.")
+        else:
+            report.append("")
+            report.append("⚠️  Some critical dependencies are missing.")
+            report.append("Please install the missing dependencies to enable full functionality.")
+        
+        return "\n".join(report)
+    
+    def save_report(self, report: str, filename: str = "dependency_report.txt"):
+        """Save the report to a file."""
+        with open(filename, 'w', encoding='utf-8') as f:
+            f.write(report)
+        self.logger.info(f"Report saved to {filename}")
+
+
+def main():
+    """Main function."""
+    checker = DependencyChecker()
+    
+    print("🔍 Checking AIECS dependencies...")
+    print("This may take a few minutes for model checks...")
+    print()
+    
+    # Check all dependencies
+    tools = checker.check_all_dependencies()
+    
+    # Generate and display report
+    report = checker.generate_report(tools)
+    print(report)
+    
+    # Save report
+    checker.save_report(report)
+    
+    # Return exit code based on critical issues
+    critical_issues = sum(
+        1 for tool_deps in tools.values()
+        for dep in tool_deps.system_deps + tool_deps.python_deps + tool_deps.model_deps
+        if dep.status != DependencyStatus.AVAILABLE and dep.is_critical
+    )
+    
+    if critical_issues == 0:
+        print("\n✅ All critical dependencies are available!")
+        return 0
+    else:
+        print(f"\n❌ {critical_issues} critical dependencies are missing.")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+
+
+
+