app/app.py

"""
Main application file for Phi-3.5-MoE Hugging Face Space.

This is the entry point that orchestrates all components:
- Environment detection and validation
- Model loading with proper configuration
- Gradio interface creation and launch
"""

import os
import sys
import logging
from pathlib import Path

# Add the project root to Python path
project_root = Path(__file__).parent.parent
sys.path.insert(0, str(project_root))

from app.model_loader import ModelLoader
from app.interface import GradioInterface
from app.config.model_config import EnvironmentDetector, DependencyValidator

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format='[%(asctime)s] %(name)s - %(levelname)s: %(message)s',
    handlers=[
        logging.StreamHandler(sys.stdout)
    ]
)
logger = logging.getLogger(__name__)


def setup_environment():
    """Setup and validate the environment."""
    logger.info("🔧 Setting up environment...")
    
    # Load environment variables from .env if it exists
    env_file = Path(".env")
    if env_file.exists():
        logger.info("📄 Loading environment variables from .env")
        from dotenv import load_dotenv
        load_dotenv()
    
    # Log environment info
    env_info = EnvironmentDetector.detect_environment()
    logger.info("📊 Environment Information:")
    for key, value in env_info.items():
        logger.info(f"   {key}: {value}")
    
    # Validate dependencies
    missing_deps = DependencyValidator.get_missing_required_packages()
    if missing_deps:
        logger.error(f"❌ Missing required dependencies: {missing_deps}")
        logger.error("Please run the prestart.sh script to install dependencies")
        return False
    
    logger.info("✅ Environment setup completed")
    return True


def create_application():
    """Create and configure the application."""
    logger.info("🚀 Creating Phi-3.5-MoE application...")
    
    try:
        # Setup environment
        if not setup_environment():
            logger.error("❌ Environment setup failed")
            return None, None
        
        # Create model loader
        logger.info("🤖 Initializing model loader...")
        model_loader = ModelLoader()
        
        # Attempt to load the model
        logger.info("📥 Loading model (this may take several minutes)...")
        model_loaded = model_loader.load_complete_model()
        
        if model_loaded:
            logger.info("✅ Model loaded successfully!")
        else:
            logger.warning("⚠️ Model loading failed - running in fallback mode")
        
        # Create Gradio interface
        logger.info("🎨 Creating Gradio interface...")
        interface = GradioInterface(model_loader)
        
        logger.info("🎉 Application created successfully!")
        return model_loader, interface
        
    except Exception as e:
        logger.error(f"❌ Failed to create application: {e}")
        return None, None


def main():
    """Main application entry point."""
    logger.info("=" * 60)
    logger.info("🚀 Starting Phi-3.5-MoE Expert Assistant")
    logger.info("=" * 60)
    
    try:
        # Create application
        model_loader, interface = create_application()
        
        if interface is None:
            logger.error("❌ Failed to create application")
            sys.exit(1)
        
        # Launch interface
        logger.info("🌐 Launching web interface...")
        interface.launch(
            server_name="0.0.0.0",
            server_port=7860,
            share=False,
            show_error=True
        )
        
    except KeyboardInterrupt:
        logger.info("👋 Application stopped by user")
    except Exception as e:
        logger.error(f"❌ Application failed: {e}")
        sys.exit(1)
    finally:
        logger.info("🏁 Application shutdown complete")


if __name__ == "__main__":
    main()