app/main.py

# app/main.py
import os
import logging
import argparse
import yaml
from typing import Dict, Any

# Import utility classes
from utils.token_manager import TokenManager
from utils.cache_manager import CacheManager
from utils.metrics_calculator import MetricsCalculator

# Import model managers
from models.text_models import TextModelManager
from models.image_models import ImageModelManager
from models.summary_models import SummaryModelManager

# Import agents
from agents.text_analysis_agent import TextAnalysisAgent
from agents.image_processing_agent import ImageProcessingAgent
from agents.report_generation_agent import ReportGeneratorAgent
from agents.metrics_agent import MetricsAgent
from agents.coordinator_agent import CoordinatorAgent

# Import application components
from app.orchestrator import Orchestrator
from app.data_manager import DataManager
from app.error_handler import ErrorHandler
from app.synchronizer import Synchronizer
from app.gradio_interface import GradioInterface

def load_config(config_path: str) -> Dict[str, Any]:
    """Load configuration from YAML file."""
    try:
        with open(config_path, 'r') as f:
            config = yaml.safe_load(f)
        return config
    except Exception as e:
        logging.error(f"Error loading configuration: {e}")
        return {}

def setup_logging(log_level: str = "INFO"):
    """Set up logging configuration."""
    numeric_level = getattr(logging, log_level.upper(), None)
    if not isinstance(numeric_level, int):
        numeric_level = logging.INFO
        
    logging.basicConfig(
        level=numeric_level,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        handlers=[
            logging.StreamHandler(),
            logging.FileHandler("app.log")
        ]
    )

def build_application(config: Dict[str, Any]):
    """Build the application components based on configuration."""
    # Create utility instances
    token_manager = TokenManager(config.get("token_manager", {}))
    cache_manager = CacheManager(config.get("cache_manager", {}))
    metrics_calculator = MetricsCalculator(config.get("metrics_calculator", {}))
    
    # Create model managers
    text_model_manager = TextModelManager(
        token_manager=token_manager,
        cache_manager=cache_manager,
        metrics_calculator=metrics_calculator
    )
    
    image_model_manager = ImageModelManager(
        token_manager=token_manager,
        cache_manager=cache_manager,
        metrics_calculator=metrics_calculator
    )
    
    summary_model_manager = SummaryModelManager(
        token_manager=token_manager,
        cache_manager=cache_manager,
        metrics_calculator=metrics_calculator
    )
    
    # Create agents
    text_analysis_agent = TextAnalysisAgent(
        text_model_manager=text_model_manager,
        summary_model_manager=summary_model_manager,
        token_manager=token_manager,
        cache_manager=cache_manager,
        metrics_calculator=metrics_calculator
    )
    
    image_processing_agent = ImageProcessingAgent(
        image_model_manager=image_model_manager,
        text_model_manager=text_model_manager,
        token_manager=token_manager,
        cache_manager=cache_manager,
        metrics_calculator=metrics_calculator
    )
    
    report_generation_agent = ReportGeneratorAgent(
        summary_model_manager=summary_model_manager,
        token_manager=token_manager,
        cache_manager=cache_manager,
        metrics_calculator=metrics_calculator
    )
    
    metrics_agent = MetricsAgent(
        metrics_calculator=metrics_calculator,
        token_manager=token_manager,
        cache_manager=cache_manager
    )
    
    # Create data manager
    data_manager = DataManager(cache_manager=cache_manager)
    
    # Create coordinator agent
    coordinator_agent = CoordinatorAgent(
        text_analysis_agent=text_analysis_agent,
        image_processing_agent=image_processing_agent,
        report_generation_agent=report_generation_agent,
        metrics_agent=metrics_agent,
        token_manager=token_manager,
        cache_manager=cache_manager,
        metrics_calculator=metrics_calculator
    )
    
    # Create orchestrator
    orchestrator = Orchestrator(
        coordinator_agent=coordinator_agent,
        text_analysis_agent=text_analysis_agent,  # Add this
        image_processing_agent=image_processing_agent,  # Add this
        report_generation_agent=report_generation_agent,  # Add this
        metrics_agent=metrics_agent,  # Add this
        text_model_manager=text_model_manager,
        image_model_manager=image_model_manager,
        summary_model_manager=summary_model_manager,
        token_manager=token_manager,
        cache_manager=cache_manager,
        metrics_calculator=metrics_calculator
    )
    
    # Create Gradio interface
    interface = GradioInterface(orchestrator=orchestrator)
    
    return {
        "token_manager": token_manager,
        "cache_manager": cache_manager,
        "metrics_calculator": metrics_calculator,
        "text_model_manager": text_model_manager,
        "image_model_manager": image_model_manager,
        "summary_model_manager": summary_model_manager,
        "text_analysis_agent": text_analysis_agent,
        "image_processing_agent": image_processing_agent,
        "report_generation_agent": report_generation_agent,
        "metrics_agent": metrics_agent,
        "data_manager": data_manager,
        "coordinator_agent": coordinator_agent,
        "orchestrator": orchestrator,
        "interface": interface
    }

def main():
    """Main entry point for the application."""
    # Parse command line arguments
    parser = argparse.ArgumentParser(description="Deep Dive Analysis with Sustainable AI")
    parser.add_argument("--config", type=str, default="config/config.yaml", help="Path to configuration file")
    parser.add_argument("--log-level", type=str, default="INFO", help="Logging level")
    parser.add_argument("--port", type=int, default=7860, help="Port for Gradio interface")
    parser.add_argument("--share", action="store_true", help="Create a shareable link")
    args = parser.parse_args()
    
    # Setup logging
    setup_logging(args.log_level)
    
    # Load configuration
    config = load_config(args.config)
    
    # Build application
    app = build_application(config)
    
    # Launch interface
    try:
        app["interface"].launch(server_port=args.port, share=args.share)
    except KeyboardInterrupt:
        logging.info("Application shutdown requested")
    finally:
        # Cleanup
        app["interface"].cleanup()
        logging.info("Application shutdown complete")

if __name__ == "__main__":
    main()