fixed cache hf_spaces issue

.dockerignore

@@ -0,0 +1,58 @@
+# Ignore cache and temporary files
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Ignore model cache (will be downloaded fresh)
+model_cache/
+outputs/
+uploads/
+temp_files/
+demo_results/
+
+# Ignore development files
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Ignore OS files
+.DS_Store
+Thumbs.db
+
+# Ignore IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Ignore git
+.git/
+.gitignore
+
+# Ignore documentation
+*.md
+!README.md
+
+# Ignore test files
+test_*.py
+*_test.py
+tests/
+
+# Ignore temporary files
+*.tmp
+*.temp
+*.log

Dockerfile

@@ -68,7 +68,11 @@ ENV PYTHONPATH=/app \
     CTRANSLATE2_FORCE_CPU_ISA=generic \
     # Disable problematic features
     TF_CPP_MIN_LOG_LEVEL=2 \
-    TOKENIZERS_PARALLELISM=false
+    TOKENIZERS_PARALLELISM=false \
+    # Fix executable stack issues
+    ONNX_EXECUTION_PROVIDER=cpu \
+    # Disable problematic optimizations
+    OMP_NUM_THREADS=1
 
 # Expose port for Hugging Face Spaces
 EXPOSE 7860

requirements.txt

@@ -24,7 +24,8 @@ pyannote.metrics==3.2.1
 
 # Performance & Optimization
 numba==0.58.1
-onnxruntime==1.16.3
+# Use CPU-only onnxruntime to avoid executable stack issues
+onnxruntime-cpu==1.16.3
 accelerate==0.20.3
 
 # Core Utilities

run_app.py

@@ -1,180 +1,42 @@
 #!/usr/bin/env python3
 """
-Consolidated Audio Intelligence System Runner
-
-This script provides a unified way to run the system with different modes:
-- Web App Mode: Interactive web interface
-- Demo Mode: Test system capabilities
-- CLI Mode: Command-line processing
-- Test Mode: System validation
-
-Usage:
-    python run_app.py [--mode web|demo|cli|test] [--port PORT] [--host HOST]
+Simple startup script for local development.
+This is the main entry point for running the application locally.
 """
 
+import uvicorn
 import os
 import sys
-import argparse
-import logging
 from pathlib import Path
 
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-def run_web_app(host: str = "0.0.0.0", port: int = 8000, debug: bool = False):
-    """Run the web application."""
-    logger.info("🌐 Starting Web Application...")
-    
-    try:
-        # Use the working web_app.py directly
-        import uvicorn
-        from web_app import app
-        
-        uvicorn.run(app, host=host, port=port, log_level="info" if debug else "warning")
-        
-    except Exception as e:
-        logger.error(f"❌ Failed to start web app: {e}")
-        sys.exit(1)
-
-def run_demo():
-    """Run the demo system."""
-    logger.info("🎵 Starting Demo System...")
-    
-    try:
-        from src.demo import main
-        main()
-        
-    except Exception as e:
-        logger.error(f"❌ Failed to run demo: {e}")
-        sys.exit(1)
-
-def run_tests():
-    """Run system tests."""
-    logger.info("🧪 Running System Tests...")
-    
-    try:
-        from src.test_system import main
-        main()
-        
-    except Exception as e:
-        logger.error(f"❌ Failed to run tests: {e}")
-        sys.exit(1)
-
-def run_cli_mode():
-    """Run CLI processing mode."""
-    logger.info("💻 Starting CLI Mode...")
-    
-    try:
-        from src.main import main
-        main()
-        
-    except Exception as e:
-        logger.error(f"❌ Failed to start CLI mode: {e}")
-        sys.exit(1)
-
-def check_dependencies():
-    """Check if all required dependencies are available."""
-    logger.info("🔍 Checking dependencies...")
-    
-    required_modules = [
-        'src.translator',
-        'src.audio_processor',
-        'src.main', 
-        'web_app'
-    ]
-    
-    missing = []
-    for module in required_modules:
-        try:
-            __import__(module)
-            logger.info(f"✅ {module}")
-        except ImportError as e:
-            logger.error(f"❌ {module}: {e}")
-            missing.append(module)
-    
-    if missing:
-        logger.error(f"❌ Missing modules: {', '.join(missing)}")
-        logger.error("Install dependencies with: pip install -r requirements.txt")
-        return False
-    
-    logger.info("✅ All dependencies available")
-    return True
-
 def main():
-    """Main entry point."""
-    parser = argparse.ArgumentParser(
-        description="Audio Intelligence System Runner",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  python run_app.py                    # Run web app (default)
-  python run_app.py --mode demo       # Run demo system
-  python run_app.py --mode test       # Run system tests
-  python run_app.py --mode cli        # Run CLI mode
-  python run_app.py --port 8080       # Run web app on port 8080
-  python run_app.py --host localhost  # Run web app on localhost only
-        """
-    )
-    
-    parser.add_argument(
-        "--mode", 
-        choices=["web", "demo", "cli", "test"], 
-        default="web",
-        help="Run mode (default: web)"
-    )
-    
-    parser.add_argument(
-        "--port", 
-        type=int, 
-        default=8000,
-        help="Port for web app (default: 8000)"
-    )
-    
-    parser.add_argument(
-        "--host", 
-        default="0.0.0.0",
-        help="Host for web app (default: 0.0.0.0)"
-    )
-    
-    parser.add_argument(
-        "--debug", 
-        action="store_true",
-        help="Enable debug mode"
-    )
+    """Main function for local development."""
+    print("🚀 Starting Audio Intelligence System (Local Development)")
+    
+    # Create necessary directories
+    dirs = ['uploads', 'outputs', 'model_cache', 'temp_files', 'demo_results']
+    for d in dirs:
+        Path(d).mkdir(exist_ok=True)
+        print(f"✅ Created directory: {d}")
+    
+    # Check if web_app.py exists
+    if not Path("web_app.py").exists():
+        print("❌ web_app.py not found!")
+        sys.exit(1)
     
-    parser.add_argument(
-        "--skip-deps", 
-        action="store_true",
-        help="Skip dependency checking"
+    print("🌐 Starting web application...")
+    print("📍 Access the application at: http://127.0.0.1:8000")
+    print("📚 API documentation at: http://127.0.0.1:8000/docs")
+    print("🛑 Press Ctrl+C to stop the server")
+    
+    # Start the server with reload for development
+    uvicorn.run(
+        "web_app:app",
+        host="127.0.0.1",
+        port=8000,
+        reload=True,
+        log_level="info"
     )
-    
-    args = parser.parse_args()
-    
-    logger.info("🎵 Audio Intelligence System")
-    logger.info("=" * 50)
-    
-    # Check dependencies unless skipped
-    if not args.skip_deps:
-        if not check_dependencies():
-            logger.error("❌ Critical dependencies missing. Exiting.")
-            sys.exit(1)
-    
-    # Run selected mode
-    if args.mode == "web":
-        run_web_app(host=args.host, port=args.port, debug=args.debug)
-    elif args.mode == "demo":
-        run_demo()
-    elif args.mode == "test":
-        run_tests()
-    elif args.mode == "cli":
-        run_cli_mode()
-    else:
-        logger.error(f"❌ Unknown mode: {args.mode}")
-        sys.exit(1)
 
 if __name__ == "__main__":
-    main()
+    main()

startup.py

@@ -1,18 +1,23 @@
 #!/usr/bin/env python3
 """
 Startup script for Hugging Face Spaces deployment.
+Handles model preloading and graceful fallbacks for containerized environments.
 """
 
 import os
 import subprocess
-import time
 import sys
+import logging
 
-def main():
-    """Main startup function."""
-    print('🚀 Starting Multilingual Audio Intelligence System...')
-    
-    # Create necessary directories
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+def create_directories():
+    """Create necessary directories with proper permissions."""
     dirs = [
         'uploads', 'outputs', 'model_cache', 'temp_files', 
         'demo_results', '/tmp/matplotlib', '/tmp/fontconfig'
@@ -21,37 +26,105 @@ def main():
     for d in dirs:
         try:
             os.makedirs(d, mode=0o777, exist_ok=True)
-            print(f'✅ Created directory: {d}')
+            logger.info(f'✅ Created directory: {d}')
         except Exception as e:
-            print(f'⚠️ Failed to create directory {d}: {e}')
+            logger.warning(f'⚠️ Failed to create directory {d}: {e}')
+
+def check_dependencies():
+    """Check if critical dependencies are available."""
+    critical_deps = ['fastapi', 'uvicorn', 'torch', 'transformers']
+    missing_deps = []
+    
+    for dep in critical_deps:
+        try:
+            __import__(dep)
+            logger.info(f'✅ {dep} available')
+        except ImportError:
+            missing_deps.append(dep)
+            logger.warning(f'⚠️ {dep} not available')
+    
+    if missing_deps:
+        logger.error(f'❌ Missing critical dependencies: {missing_deps}')
+        return False
+    
+    return True
+
+def preload_models():
+    """Attempt to preload models with graceful fallback."""
+    logger.info('🔄 Attempting model preloading...')
     
-    # Try to preload models
     try:
-        print('🔄 Preloading models...')
-        result = subprocess.run(['python', 'model_preloader.py'], 
-                              check=True, capture_output=True, text=True)
-        print('✅ Models loaded successfully')
-        if result.stdout:
-            print(f'Model preloader output: {result.stdout}')
-    except subprocess.CalledProcessError as e:
-        print(f'⚠️ Model preloading failed: {e}')
-        if e.stdout:
-            print(f'Model preloader stdout: {e.stdout}')
-        if e.stderr:
-            print(f'Model preloader stderr: {e.stderr}')
-        print('🔄 Continuing without preloaded models...')
+        # Check if model_preloader.py exists and is importable
+        import model_preloader
+        logger.info('✅ Model preloader module found')
+        
+        # Try to run the preloader
+        result = subprocess.run(
+            ['python', 'model_preloader.py'], 
+            capture_output=True, 
+            text=True, 
+            timeout=300  # 5 minute timeout
+        )
+        
+        if result.returncode == 0:
+            logger.info('✅ Models loaded successfully')
+            if result.stdout:
+                logger.info(f'Preloader output: {result.stdout[:500]}...')
+            return True
+        else:
+            logger.warning(f'⚠️ Model preloading failed with return code {result.returncode}')
+            if result.stderr:
+                logger.warning(f'Preloader stderr: {result.stderr[:500]}...')
+            return False
+            
+    except subprocess.TimeoutExpired:
+        logger.warning('⚠️ Model preloading timed out, continuing...')
+        return False
     except Exception as e:
-        print(f'⚠️ Model preloading failed: {e}')
-        print('🔄 Continuing without preloaded models...')
+        logger.warning(f'⚠️ Model preloading failed: {e}')
+        return False
+
+def start_web_app():
+    """Start the web application."""
+    logger.info('🌐 Starting web application...')
     
-    # Start the web application
-    print('🌐 Starting web application...')
     try:
         import uvicorn
-        uvicorn.run('web_app:app', host='0.0.0.0', port=7860, workers=1, log_level='info')
+        logger.info('✅ Uvicorn imported successfully')
+        
+        # Start the server
+        uvicorn.run(
+            'web_app:app', 
+            host='0.0.0.0', 
+            port=7860, 
+            workers=1, 
+            log_level='info',
+            access_log=True
+        )
+    except ImportError as e:
+        logger.error(f'❌ Failed to import uvicorn: {e}')
+        sys.exit(1)
     except Exception as e:
-        print(f'❌ Failed to start web application: {e}')
+        logger.error(f'❌ Failed to start web application: {e}')
+        sys.exit(1)
+
+def main():
+    """Main startup function."""
+    logger.info('🚀 Starting Multilingual Audio Intelligence System...')
+    
+    # Check critical dependencies
+    if not check_dependencies():
+        logger.error('❌ Critical dependencies missing, exiting...')
         sys.exit(1)
+    
+    # Create necessary directories
+    create_directories()
+    
+    # Attempt model preloading (non-blocking)
+    preload_models()
+    
+    # Start the web application
+    start_web_app()
 
 if __name__ == '__main__':
     main()