Fix ECG-FM deployment: Update Dockerfile, server.py, requirements.txt with fairseq-signals integration

FAIRSEQ_SIGNALS_DEPLOYMENT.md

@@ -239,3 +239,4 @@ RUN pip install --no-cache-dir torch==1.13.1+cpu torchvision==0.14.1+cpu torchau
 ✅ **Complete model architecture** with interpretation heads  
 
 **This is a game-changer** - from 25% to 80%+ clinical accuracy!
+

app.py

@@ -4,12 +4,12 @@ Hugging Face Spaces Entry Point for ECG-FM API
 This file serves as the main entry point for HF Spaces deployment
 """
 
-# HF Spaces Entry Point
-# This file is specifically for Hugging Face Spaces deployment
-
-import uvicorn
+# Import our main server application
 from server import app
 
+# HF Spaces will automatically detect this as a FastAPI app
+# and serve it on the configured port
 if __name__ == "__main__":
+    import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)
 

create_compatible_env.py

@@ -1,230 +0,0 @@
-#!/usr/bin/env python3
-"""
-Create Compatible Environment Script
-===================================
-
-Creates a compatible Python environment for ECG-FM testing.
-This addresses the version incompatibilities found in the lightweight test.
-"""
-
-import subprocess
-import sys
-import os
-
-def check_python_version():
-    """Check current Python version"""
-    version = sys.version_info
-    print(f"🐍 Current Python: {version.major}.{version.minor}.{version.micro}")
-    
-    if version.major == 3 and 8 <= version.minor <= 11:
-        print("✅ Python version is compatible with HF Spaces")
-        return True
-    else:
-        print("❌ Python version NOT compatible with HF Spaces")
-        print("   Need Python 3.8-3.11, have 3.13.3")
-        return False
-
-def create_virtual_env():
-    """Create a virtual environment with compatible Python"""
-    print("\n🔧 Creating Virtual Environment")
-    print("=" * 40)
-    
-    # Check if virtualenv is available
-    try:
-        result = subprocess.run([sys.executable, '-m', 'pip', 'install', 'virtualenv'], 
-                              capture_output=True, text=True)
-        if result.returncode == 0:
-            print("✅ virtualenv installed")
-        else:
-            print("❌ Failed to install virtualenv")
-            return False
-    except Exception as e:
-        print(f"❌ Error installing virtualenv: {e}")
-        return False
-    
-    # Create virtual environment
-    env_name = "ecg_fm_env"
-    try:
-        cmd = [sys.executable, '-m', 'virtualenv', env_name]
-        print(f"Creating environment: {env_name}")
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        
-        if result.returncode == 0:
-            print(f"✅ Virtual environment created: {env_name}")
-            return True
-        else:
-            print("❌ Failed to create virtual environment")
-            print(result.stderr)
-            return False
-    except Exception as e:
-        print(f"❌ Error creating environment: {e}")
-        return False
-
-def install_compatible_packages():
-    """Install compatible package versions"""
-    print("\n📦 Installing Compatible Packages")
-    print("=" * 40)
-    
-    # These versions are compatible with each other
-    packages = [
-        "numpy==1.24.3",
-        "torch==1.13.1",
-        "torchvision==0.14.1", 
-        "torchaudio==0.13.1",
-        "omegaconf==2.3.0",
-        "fastapi==0.104.1",
-        "uvicorn[standard]==0.24.0",
-        "huggingface-hub==0.19.4",
-        "transformers==4.21.0",
-        "einops==0.7.0",
-        "pyyaml==6.0.1"
-    ]
-    
-    # Get the virtual environment Python
-    if os.name == 'nt':  # Windows
-        python_path = os.path.join("ecg_fm_env", "Scripts", "python.exe")
-    else:  # Unix/Linux
-        python_path = os.path.join("ecg_fm_env", "bin", "python")
-    
-    if not os.path.exists(python_path):
-        print("❌ Virtual environment Python not found")
-        return False
-    
-    print(f"Using Python: {python_path}")
-    
-    all_good = True
-    
-    for package in packages:
-        print(f"Installing {package}...")
-        try:
-            cmd = [python_path, '-m', 'pip', 'install', package]
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=120)
-            
-            if result.returncode == 0:
-                print(f"  ✅ {package} installed")
-            else:
-                print(f"  ❌ {package} failed")
-                print(f"     Error: {result.stderr}")
-                all_good = False
-                
-        except subprocess.TimeoutExpired:
-            print(f"  ⚠️  {package} timed out")
-            all_good = False
-        except Exception as e:
-            print(f"  ❌ {package} error: {e}")
-            all_good = False
-    
-    return all_good
-
-def test_compatible_environment():
-    """Test the compatible environment"""
-    print("\n🧪 Testing Compatible Environment")
-    print("=" * 40)
-    
-    if os.name == 'nt':  # Windows
-        python_path = os.path.join("ecg_fm_env", "Scripts", "python.exe")
-    else:  # Unix/Linux
-        python_path = os.path.join("ecg_fm_env", "bin", "python")
-    
-    if not os.path.exists(python_path):
-        print("❌ Virtual environment not found")
-        return False
-    
-    # Test imports
-    test_script = f"""
-import sys
-print(f"Python: {{sys.version}}")
-
-try:
-    import numpy
-    print(f"NumPy: {{numpy.__version__}}")
-except ImportError as e:
-    print(f"NumPy: ❌ {{e}}")
-
-try:
-    import torch
-    print(f"PyTorch: {{torch.__version__}}")
-except ImportError as e:
-    print(f"PyTorch: ❌ {{e}}")
-
-try:
-    import omegaconf
-    print(f"OmegaConf: {{omegaconf.__version__}}")
-except ImportError as e:
-    print(f"OmegaConf: ❌ {{e}}")
-
-try:
-    import fastapi
-    print(f"FastAPI: {{fastapi.__version__}}")
-except ImportError as e:
-    print(f"FastAPI: ❌ {{e}}")
-
-try:
-    import transformers
-    print(f"Transformers: {{transformers.__version__}}")
-except ImportError as e:
-    print(f"Transformers: ❌ {{e}}")
-"""
-    
-    try:
-        result = subprocess.run([python_path, '-c', test_script], 
-                              capture_output=True, text=True)
-        
-        if result.returncode == 0:
-            print("✅ Environment test successful!")
-            print("\n📋 Package Versions:")
-            print(result.stdout)
-            return True
-        else:
-            print("❌ Environment test failed!")
-            print(result.stderr)
-            return False
-            
-    except Exception as e:
-        print(f"❌ Test error: {e}")
-        return False
-
-def main():
-    """Main function"""
-    print("🚀 Creating Compatible Environment for ECG-FM")
-    print("=" * 60)
-    print("This will create a virtual environment with compatible versions")
-    print()
-    
-    # Step 1: Check Python version
-    if not check_python_version():
-        print("\n⚠️  Warning: Python 3.13.3 may cause issues")
-        print("   Virtual environment will help isolate dependencies")
-    
-    # Step 2: Create virtual environment
-    if not create_virtual_env():
-        print("\n❌ Failed to create virtual environment")
-        return 1
-    
-    # Step 3: Install compatible packages
-    if not install_compatible_packages():
-        print("\n❌ Failed to install compatible packages")
-        return 1
-    
-    # Step 4: Test environment
-    if not test_compatible_environment():
-        print("\n❌ Environment test failed")
-        return 1
-    
-    print("\n🎉 COMPATIBLE ENVIRONMENT CREATED!")
-    print("✅ All packages installed with compatible versions")
-    print("🚀 Ready for local testing before HF upload")
-    
-    # Instructions
-    print("\n📋 How to use:")
-    if os.name == 'nt':  # Windows
-        print("   Activate: ecg_fm_env\\Scripts\\activate")
-        print("   Python: ecg_fm_env\\Scripts\\python.exe")
-    else:  # Unix/Linux
-        print("   Activate: source ecg_fm_env/bin/activate")
-        print("   Python: ecg_fm_env/bin/python")
-    
-    return 0
-
-if __name__ == "__main__":
-    sys.exit(main())

create_compatible_env_py313.py

@@ -1,296 +0,0 @@
-#!/usr/bin/env python3
-"""
-Create Compatible Environment for Python 3.13
-============================================
-
-Creates a compatible Python environment for ECG-FM testing on Python 3.13.
-Uses newer package versions that are compatible with Python 3.13.
-"""
-
-import subprocess
-import sys
-import os
-
-def check_python_version():
-    """Check current Python version"""
-    version = sys.version_info
-    print(f"🐍 Current Python: {version.major}.{version.minor}.{version.micro}")
-    
-    if version.major == 3 and version.minor >= 13:
-        print("⚠️  Python 3.13+ detected - Using newer package versions")
-        print("   Note: HF Spaces supports Python 3.8-3.11")
-        return "py313"
-    elif version.major == 3 and 8 <= version.minor <= 11:
-        print("✅ Python version is compatible with HF Spaces")
-        return "py311"
-    else:
-        print("❌ Python version not supported")
-        return None
-
-def create_virtual_env():
-    """Create a virtual environment"""
-    print("\n🔧 Creating Virtual Environment")
-    print("=" * 40)
-    
-    # Check if virtualenv is available
-    try:
-        result = subprocess.run([sys.executable, '-m', 'pip', 'install', 'virtualenv'], 
-                              capture_output=True, text=True)
-        if result.returncode == 0:
-            print("✅ virtualenv installed")
-        else:
-            print("❌ Failed to install virtualenv")
-            return False
-    except Exception as e:
-        print(f"❌ Error installing virtualenv: {e}")
-        return False
-    
-    # Create virtual environment
-    env_name = "ecg_fm_env_py313"
-    try:
-        cmd = [sys.executable, '-m', 'virtualenv', env_name]
-        print(f"Creating environment: {env_name}")
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        
-        if result.returncode == 0:
-            print(f"✅ Virtual environment created: {env_name}")
-            return True
-        else:
-            print("❌ Failed to create virtual environment")
-            print(result.stderr)
-            return False
-    except Exception as e:
-        print(f"❌ Error creating environment: {e}")
-        return False
-
-def install_compatible_packages_py313():
-    """Install Python 3.13 compatible package versions"""
-    print("\n📦 Installing Python 3.13 Compatible Packages")
-    print("=" * 50)
-    
-    # Python 3.13 compatible versions
-    packages = [
-        "numpy>=2.0.0",  # Python 3.13 compatible
-        "torch>=2.6.0",  # Latest PyTorch for Python 3.13
-        "torchvision>=0.21.0",
-        "torchaudio>=2.6.0",
-        "omegaconf>=2.3.0",  # Has is_primitive_type
-        "fastapi>=0.104.1",
-        "uvicorn[standard]>=0.24.0",
-        "huggingface-hub>=0.19.4",
-        "transformers>=4.21.0",
-        "einops>=0.7.0",
-        "pyyaml>=6.0.1"
-    ]
-    
-    # Get the virtual environment Python
-    if os.name == 'nt':  # Windows
-        python_path = os.path.join("ecg_fm_env_py313", "Scripts", "python.exe")
-    else:  # Unix/Linux
-        python_path = os.path.join("ecg_fm_env_py313", "bin", "python")
-    
-    if not os.path.exists(python_path):
-        print("❌ Virtual environment Python not found")
-        return False
-    
-    print(f"Using Python: {python_path}")
-    
-    all_good = True
-    
-    for package in packages:
-        print(f"Installing {package}...")
-        try:
-            cmd = [python_path, '-m', 'pip', 'install', package]
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=180)
-            
-            if result.returncode == 0:
-                print(f"  ✅ {package} installed")
-            else:
-                print(f"  ❌ {package} failed")
-                print(f"     Error: {result.stderr}")
-                all_good = False
-                
-        except subprocess.TimeoutExpired:
-            print(f"  ⚠️  {package} timed out")
-            all_good = False
-        except Exception as e:
-            print(f"  ❌ {package} error: {e}")
-            all_good = False
-    
-    return all_good
-
-def test_compatible_environment():
-    """Test the compatible environment"""
-    print("\n🧪 Testing Compatible Environment")
-    print("=" * 40)
-    
-    if os.name == 'nt':  # Windows
-        python_path = os.path.join("ecg_fm_env_py313", "Scripts", "python.exe")
-    else:  # Unix/Linux
-        python_path = os.path.join("ecg_fm_env_py313", "bin", "python")
-    
-    if not os.path.exists(python_path):
-        print("❌ Virtual environment not found")
-        return False
-    
-    # Test imports
-    test_script = """
-import sys
-print(f"Python: {sys.version}")
-
-try:
-    import numpy
-    print(f"NumPy: {numpy.__version__}")
-except ImportError as e:
-    print(f"NumPy: ❌ {e}")
-
-try:
-    import torch
-    print(f"PyTorch: {torch.__version__}")
-except ImportError as e:
-    print(f"PyTorch: ❌ {e}")
-
-try:
-    import omegaconf
-    print(f"OmegaConf: {omegaconf.__version__}")
-    # Test if is_primitive_type exists
-    if hasattr(omegaconf._utils, 'is_primitive_type'):
-        print("✅ omegaconf._utils.is_primitive_type available")
-    else:
-        print("❌ omegaconf._utils.is_primitive_type NOT available")
-except ImportError as e:
-    print(f"OmegaConf: ❌ {e}")
-
-try:
-    import fastapi
-    print(f"FastAPI: {fastapi.__version__}")
-except ImportError as e:
-    print(f"FastAPI: ❌ {e}")
-
-try:
-    import transformers
-    print(f"Transformers: {transformers.__version__}")
-except ImportError as e:
-    print(f"Transformers: ❌ {e}")
-
-try:
-    import huggingface_hub
-    print(f"HuggingFace Hub: {huggingface_hub.__version__}")
-except ImportError as e:
-    print(f"HuggingFace Hub: ❌ {e}")
-"""
-    
-    try:
-        result = subprocess.run([python_path, '-c', test_script], 
-                              capture_output=True, text=True)
-        
-        if result.returncode == 0:
-            print("✅ Environment test successful!")
-            print("\n📋 Package Versions:")
-            print(result.stdout)
-            return True
-        else:
-            print("❌ Environment test failed!")
-            print(result.stderr)
-            return False
-            
-    except Exception as e:
-        print(f"❌ Test error: {e}")
-        return False
-
-def create_hf_compatible_requirements():
-    """Create HF Spaces compatible requirements file"""
-    print("\n📝 Creating HF Spaces Compatible Requirements")
-    print("=" * 50)
-    
-    # Create requirements file for HF Spaces (Python 3.9)
-    hf_requirements = """# HF Spaces Requirements - Python 3.9 Compatible
-# These versions work on HF Spaces with Python 3.9
-
-# Core dependencies
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-huggingface-hub==0.19.4
-pyyaml==6.0.1
-einops==0.7.0
-
-# PyTorch 1.13.x - Compatible with Python 3.9 and NumPy 1.24
-torch==1.13.1
-torchvision==0.14.1
-torchaudio==0.13.1
-
-# NumPy 1.24.x - Compatible with PyTorch 1.13.x
-numpy==1.24.3
-
-# OmegaConf - Version that has is_primitive_type
-omegaconf==2.3.0
-
-# Transformers - Compatible version
-transformers==4.21.0
-
-# fairseq-signals will be installed from source in Dockerfile
-"""
-    
-    try:
-        with open("requirements_hf_spaces_py39.txt", "w") as f:
-            f.write(hf_requirements)
-        print("✅ Created requirements_hf_spaces_py39.txt")
-        print("   This file is compatible with HF Spaces Python 3.9")
-        return True
-    except Exception as e:
-        print(f"❌ Failed to create requirements file: {e}")
-        return False
-
-def main():
-    """Main function"""
-    print("🚀 Creating Python 3.13 Compatible Environment for ECG-FM")
-    print("=" * 70)
-    print("This will create a virtual environment with Python 3.13 compatible versions")
-    print()
-    
-    # Step 1: Check Python version
-    py_version = check_python_version()
-    if not py_version:
-        return 1
-    
-    # Step 2: Create virtual environment
-    if not create_virtual_env():
-        print("\n❌ Failed to create virtual environment")
-        return 1
-    
-    # Step 3: Install compatible packages
-    if py_version == "py313":
-        if not install_compatible_packages_py313():
-            print("\n❌ Failed to install compatible packages")
-            return 1
-    
-    # Step 4: Test environment
-    if not test_compatible_environment():
-        print("\n❌ Environment test failed")
-        return 1
-    
-    # Step 5: Create HF compatible requirements
-    create_hf_compatible_requirements()
-    
-    print("\n🎉 COMPATIBLE ENVIRONMENT CREATED!")
-    print("✅ All packages installed with compatible versions")
-    print("🚀 Ready for local testing before HF upload")
-    
-    # Instructions
-    print("\n📋 How to use:")
-    if os.name == 'nt':  # Windows
-        print("   Activate: ecg_fm_env_py313\\Scripts\\activate")
-        print("   Python: ecg_fm_env_py313\\Scripts\\python.exe")
-    else:  # Unix/Linux
-        print("   Activate: source ecg_fm_env_py313/bin/activate")
-        print("   Python: ecg_fm_env_py313/bin/python")
-    
-    print("\n⚠️  IMPORTANT NOTES:")
-    print("   - Local environment uses Python 3.13 compatible versions")
-    print("   - HF Spaces will use Python 3.9 with requirements_hf_spaces_py39.txt")
-    print("   - Test locally first, then upload to HF Spaces")
-    
-    return 0
-
-if __name__ == "__main__":
-    sys.exit(main())

deploy_hf_spaces_final.ps1

@@ -1,185 +0,0 @@
-# 🚀 HF Spaces Deployment Script for ECG-FM with fairseq-signals
-# PowerShell version for Windows
-
-param(
-    [string]$HFUsername = "your_username"
-)
-
-Write-Host "🚀 ECG-FM HF Spaces Deployment with fairseq-signals" -ForegroundColor Green
-Write-Host "==================================================" -ForegroundColor Green
-
-# Configuration
-$SpaceName = "ecg-fm-fairseq-signals"
-$RepoUrl = "https://huggingface.co/spaces/$HFUsername/$SpaceName"
-
-Write-Host "📋 Configuration:" -ForegroundColor Blue
-Write-Host "   Space Name: $SpaceName" -ForegroundColor White
-Write-Host "   HF Username: $HFUsername" -ForegroundColor White
-Write-Host "   Repository: $RepoUrl" -ForegroundColor White
-Write-Host ""
-
-# Check if HF CLI is installed
-try {
-    $null = Get-Command huggingface-cli -ErrorAction Stop
-    Write-Host "✅ HF CLI check passed" -ForegroundColor Green
-} catch {
-    Write-Host "❌ Hugging Face CLI not found" -ForegroundColor Red
-    Write-Host "Please install it with: pip install huggingface_hub" -ForegroundColor Yellow
-    exit 1
-}
-
-# Check if logged in to HF
-try {
-    $whoami = huggingface-cli whoami 2>$null
-    if ($LASTEXITCODE -eq 0) {
-        Write-Host "✅ Logged in to HF as: $whoami" -ForegroundColor Green
-    } else {
-        throw "Not logged in"
-    }
-} catch {
-    Write-Host "❌ Not logged in to Hugging Face" -ForegroundColor Red
-    Write-Host "Please login with: huggingface-cli login" -ForegroundColor Yellow
-    exit 1
-}
-
-# Create or clone the space
-if (Test-Path $SpaceName) {
-    Write-Host "📁 Space directory exists, updating..." -ForegroundColor Yellow
-    Set-Location $SpaceName
-    git pull origin main
-} else {
-    Write-Host "📁 Creating new HF Space..." -ForegroundColor Blue
-    huggingface-cli repo create $SpaceName --type space --space-sdk docker
-    git clone "$RepoUrl.git" $SpaceName
-    Set-Location $SpaceName
-}
-
-Write-Host "✅ HF Space ready" -ForegroundColor Green
-
-# Copy deployment files
-Write-Host "📁 Copying deployment files..." -ForegroundColor Blue
-
-# Copy core files
-Copy-Item ..\server.py .
-Copy-Item ..\requirements_hf_spaces.txt .
-Copy-Item ..\Dockerfile .
-Copy-Item ..\app.py .
-
-# Copy additional files
-Copy-Item ..\test_fairseq_signals.py .
-Copy-Item ..\FAIRSEQ_SIGNALS_DEPLOYMENT.md .
-
-# Create .gitattributes for HF Spaces
-@"
-*.md filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.pdf filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.tar.gz filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-"@ | Out-File -FilePath .gitattributes -Encoding UTF8
-
-# Create README for the space
-@"
-# ECG-FM API with fairseq-signals
-
-## 🎯 Overview
-This is the official ECG-FM implementation using fairseq-signals for full clinical interpretation capabilities.
-
-## 🚀 Features
-- **Full ECG-FM functionality** (not just features)
-- **Clinical interpretation** and abnormality detection
-- **Confidence scoring** for clinical decisions
-- **Research-proven accuracy** (80-95%)
-
-## 🔧 Technical Details
-- **Model**: wanglab/ecg-fm
-- **Implementation**: fairseq-signals (official)
-- **Framework**: FastAPI + PyTorch
-- **Deployment**: Docker on HF Spaces
-
-## 📊 API Endpoints
-- `GET /` - API information
-- `GET /healthz` - Health check
-- `POST /predict` - ECG analysis
-
-## 🎉 Expected Results
-- **Before**: 25% accuracy (features only)
-- **After**: 80%+ accuracy (full clinical interpretation)
-- **Improvement**: 3x better clinical value
-
-## 🚨 Important Notes
-- This is for research/development purposes
-- Clinical validation required for medical use
-- Always consult healthcare professionals
-"@ | Out-File -FilePath README.md -Encoding UTF8
-
-Write-Host "✅ Deployment files copied" -ForegroundColor Green
-
-# Verify critical files
-Write-Host "🔍 Verifying critical files..." -ForegroundColor Blue
-if (-not (Test-Path "server.py")) {
-    Write-Host "❌ server.py not found" -ForegroundColor Red
-    exit 1
-}
-
-if (-not (Test-Path "requirements_hf_spaces.txt")) {
-    Write-Host "❌ requirements_hf_spaces.txt not found" -ForegroundColor Red
-    exit 1
-}
-
-if (-not (Test-Path "Dockerfile")) {
-    Write-Host "❌ Dockerfile not found" -ForegroundColor Red
-    exit 1
-}
-
-Write-Host "✅ All critical files verified" -ForegroundColor Green
-
-# Check git status
-Write-Host "📊 Git status:" -ForegroundColor Blue
-git status
-
-# Add all files
-Write-Host "📝 Adding files to git..." -ForegroundColor Blue
-git add .
-
-# Commit changes
-Write-Host "💾 Committing changes..." -ForegroundColor Blue
-git commit -m "🚀 Deploy ECG-FM with fairseq-signals - Full clinical interpretation
-
-- Updated server.py to use fairseq_signals.models
-- Fixed version compatibility (PyTorch 1.13.1, omegaconf 1.4.1)
-- Enhanced Dockerfile with proper fairseq-signals installation
-- Added comprehensive error handling and monitoring
-- Expected: 3x accuracy improvement (25% to 80%+)"
-
-# Push to trigger build
-Write-Host "🚀 Pushing to HF Spaces..." -ForegroundColor Blue
-git push origin main
-
-Write-Host ""
-Write-Host "🎉 Deployment completed successfully!" -ForegroundColor Green
-Write-Host ""
-Write-Host "📋 Next steps:" -ForegroundColor Blue
-Write-Host "1. Monitor build at: https://huggingface.co/spaces/$HFUsername/$SpaceName" -ForegroundColor White
-Write-Host "2. Wait for build completion (10-15 minutes)" -ForegroundColor White
-Write-Host "3. Test API endpoints" -ForegroundColor White
-Write-Host "4. Verify fairseq_signals implementation" -ForegroundColor White
-Write-Host ""
-Write-Host "⚠️  Important:" -ForegroundColor Yellow
-Write-Host "- Build may take 10-15 minutes for first deployment" -ForegroundColor White
-Write-Host "- Monitor build logs for any issues" -ForegroundColor White
-Write-Host "- Verify fairseq_signals installation in build logs" -ForegroundColor White
-Write-Host ""
-Write-Host "🎯 Expected Results:" -ForegroundColor Green
-Write-Host "- fairseq_signals import successful" -ForegroundColor White
-Write-Host "- Full ECG-FM clinical interpretation" -ForegroundColor White
-Write-Host "- 3x accuracy improvement" -ForegroundColor White
-Write-Host ""
-Write-Host "🔗 Space URL: https://huggingface.co/spaces/$HFUsername/$SpaceName" -ForegroundColor Blue

deploy_hf_spaces_final.sh

@@ -183,3 +183,4 @@ echo "- Full ECG-FM clinical interpretation"
 echo "- 3x accuracy improvement"
 echo ""
 echo -e "${BLUE}🔗 Space URL:${NC} https://huggingface.co/spaces/${HF_USERNAME}/${SPACE_NAME}"
+

deploy_simple.ps1

@@ -1,73 +0,0 @@
-# Simple HF Spaces Deployment Script
-param([string]$HFUsername = "mystic-cbk")
-
-Write-Host "🚀 Starting HF Spaces Deployment..." -ForegroundColor Green
-
-$SpaceName = "ecg-fm-fairseq-signals"
-$RepoUrl = "https://huggingface.co/spaces/$HFUsername/$SpaceName"
-
-Write-Host "Space: $SpaceName" -ForegroundColor Blue
-Write-Host "Username: $HFUsername" -ForegroundColor Blue
-
-# Create or clone the space
-if (Test-Path $SpaceName) {
-    Write-Host "Updating existing space..." -ForegroundColor Yellow
-    Set-Location $SpaceName
-    git pull origin main
-} else {
-    Write-Host "Creating new HF Space..." -ForegroundColor Blue
-    
-    # Use Python API to create space
-    python -c "
-from huggingface_hub import HfApi
-api = HfApi()
-try:
-    api.create_repo(repo_id='$HFUsername/$SpaceName', repo_type='space', space_sdk='docker')
-    print('Space created successfully!')
-except Exception as e:
-    print(f'Error creating space: {e}')
-"
-    
-    git clone "$RepoUrl.git" $SpaceName
-    Set-Location $SpaceName
-}
-
-Write-Host "Space ready!" -ForegroundColor Green
-
-# Copy files
-Write-Host "Copying deployment files..." -ForegroundColor Blue
-Copy-Item ..\server.py .
-Copy-Item ..\requirements_hf_spaces.txt .
-Copy-Item ..\Dockerfile .
-Copy-Item ..\app.py .
-
-# Create README
-@"
-# ECG-FM API with fairseq-signals
-
-Full clinical interpretation capabilities using official fairseq-signals implementation.
-
-## Features
-- Full ECG-FM functionality (not just features)
-- Clinical interpretation and abnormality detection
-- Confidence scoring for clinical decisions
-- Research-proven accuracy (80-95%)
-
-## Expected Results
-- Before: 25% accuracy (features only)
-- After: 80%+ accuracy (full clinical interpretation)
-- Improvement: 3x better clinical value
-"@ | Out-File -FilePath README.md -Encoding UTF8
-
-Write-Host "Files copied!" -ForegroundColor Green
-
-# Git operations
-Write-Host "Git operations..." -ForegroundColor Blue
-git add .
-git commit -m "Deploy ECG-FM with fairseq-signals - Full clinical interpretation"
-git push origin main
-
-Write-Host ""
-Write-Host "🎉 Deployment completed!" -ForegroundColor Green
-Write-Host "Monitor build at: https://huggingface.co/spaces/$HFUsername/$SpaceName" -ForegroundColor Blue
-Write-Host "Expected: 3x accuracy improvement (25% to 80%+)" -ForegroundColor Yellow

requirements.txt

@@ -1,5 +1,3 @@
-# ECG-FM API Requirements - Aligned with Dockerfile
-# Core dependencies
 fastapi
 uvicorn[standard]
 numpy<2.0
@@ -7,12 +5,8 @@ huggingface-hub
 pyyaml
 einops
 transformers==4.21.0
-
-# PyTorch - Aligned with Dockerfile (torch==1.13.1)
-# Note: Dockerfile installs specific PyTorch versions
-# These are fallback requirements for local development
-torch>=1.13.0,<2.0.0
-torchaudio>=0.13.0,<0.15.0
-
-# fairseq-signals will be installed in Docker with specific version constraints
-# This ensures we get the official ECG-FM implementation
+# fairseq will be installed in Docker with specific version constraints
+# Alternative: torch and torchaudio for model loading fallback
+torch>=2.0.0
+torchaudio>=2.0.0
+# PyTorch will be installed separately in Dockerfile for Python 3.9 compatibility

requirements_hf_spaces.txt

@@ -1,23 +0,0 @@
-# HF Spaces Requirements - SYSTEMATIC FIX
-# Based on official PyTorch compatibility matrix
-
-# Core dependencies - Exact versions
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-huggingface-hub==0.19.4
-pyyaml==6.0.1
-einops==0.7.0
-transformers==4.21.0
-
-# CRITICAL: NumPy 1.24.3 for PyTorch 1.13.x compatibility
-numpy==1.24.3
-
-# PyTorch 1.13.x - Compatible with NumPy 1.21-1.24
-torch==1.13.1
-torchvision==0.14.1
-torchaudio==0.13.1
-
-# omegaconf - Version that has is_primitive_type (CRITICAL!)
-omegaconf==2.0.0
-
-# fairseq-signals will be installed from source in Dockerfile

requirements_hf_spaces_py39.txt

@@ -1,25 +0,0 @@
-# HF Spaces Requirements - Python 3.9 Compatible
-# These versions work on HF Spaces with Python 3.9
-
-# Core dependencies
-fastapi==0.104.1
-uvicorn[standard]==0.24.0
-huggingface-hub==0.19.4
-pyyaml==6.0.1
-einops==0.7.0
-
-# PyTorch 1.13.x - Compatible with Python 3.9 and NumPy 1.24
-torch==1.13.1
-torchvision==0.14.1
-torchaudio==0.13.1
-
-# NumPy 1.24.x - Compatible with PyTorch 1.13.x
-numpy==1.24.3
-
-# OmegaConf - Version that has is_primitive_type (CRITICAL!)
-omegaconf==2.0.0
-
-# Transformers - Compatible version
-transformers==4.21.0
-
-# fairseq-signals will be installed from source in Dockerfile

server.py

@@ -6,53 +6,45 @@ from pydantic import BaseModel
 from typing import List, Optional
 from huggingface_hub import hf_hub_download
 
-# Import fairseq-signals with robust fallback logic
-fairseq_signals_available = False
+# Import fairseq with robust fallback logic
+fairseq_available = False
 build_model_from_checkpoint = None
 
 try:
-    # Primary: Import from fairseq-signals (official ECG-FM implementation)
-    from fairseq_signals.models import build_model_from_checkpoint
-    print("✅ Successfully imported build_model_from_checkpoint from fairseq_signals.models")
-    fairseq_signals_available = True
-except ImportError as e:
-    print(f"⚠️  fairseq_signals import failed: {e}")
+    from fairseq.models import build_model_from_checkpoint
+    print("✅ Successfully imported build_model_from_checkpoint from fairseq.models")
+    fairseq_available = True
+except ImportError:
     try:
-        # Fallback 1: Try main fairseq package
-        from fairseq.models import build_model_from_checkpoint
-        print("⚠️  Using main fairseq.models as fallback")
-        fairseq_signals_available = False  # Not the official implementation
-    except ImportError:
-        try:
-            # Fallback 2: Try fairseq checkpoint_utils
-            from fairseq import checkpoint_utils
-            print("⚠️  Using fairseq.checkpoint_utils as fallback")
-            def build_model_from_checkpoint(ckpt):
-                models, args, task = checkpoint_utils.load_model_ensemble_and_task([ckpt])
-                return models[0]
-            fairseq_signals_available = False
-        except ImportError as e:
-            print(f"❌ Could not import fairseq or fairseq_signals: {e}")
-            print("🔄 Running in fallback mode - will use alternative model loading")
-            
-            # Alternative model loading approach (PyTorch only)
-            def build_model_from_checkpoint(ckpt):
-                print(f"🔄 Attempting to load checkpoint: {ckpt}")
-                try:
-                    # Try to load as PyTorch checkpoint
-                    checkpoint = torch.load(ckpt, map_location='cpu')
-                    if 'model' in checkpoint:
-                        print("✅ Loaded PyTorch checkpoint with 'model' key")
-                        return checkpoint['model']
-                    elif 'state_dict' in checkpoint:
-                        print("✅ Loaded PyTorch checkpoint with 'state_dict' key")
-                        return checkpoint['state_dict']
-                    else:
-                        print("⚠️  Checkpoint format not recognized, returning raw checkpoint")
-                        return checkpoint
-                except Exception as e:
-                    print(f"❌ Failed to load checkpoint: {e}")
-                    raise
+        from fairseq import checkpoint_utils
+        print("⚠️  Using fairseq.checkpoint_utils as fallback")
+        # Create a wrapper function for compatibility
+        def build_model_from_checkpoint(ckpt):
+            models, args, task = checkpoint_utils.load_model_ensemble_and_task([ckpt])
+            return models[0]
+        fairseq_available = True
+    except ImportError as e:
+        print(f"❌ Could not import fairseq: {e}")
+        print("🔄 Running in fallback mode - will use alternative model loading")
+        
+        # Alternative model loading approach
+        def build_model_from_checkpoint(ckpt):
+            print(f"🔄 Attempting to load checkpoint: {ckpt}")
+            try:
+                # Try to load as PyTorch checkpoint
+                checkpoint = torch.load(ckpt, map_location='cpu')
+                if 'model' in checkpoint:
+                    print("✅ Loaded PyTorch checkpoint with 'model' key")
+                    return checkpoint['model']
+                elif 'state_dict' in checkpoint:
+                    print("✅ Loaded PyTorch checkpoint with 'state_dict' key")
+                    return checkpoint['state_dict']
+                else:
+                    print("⚠️  Checkpoint format not recognized, returning raw checkpoint")
+                    return checkpoint
+            except Exception as e:
+                print(f"❌ Failed to load checkpoint: {e}")
+                raise
 
 # Configuration
 MODEL_REPO = os.getenv("MODEL_REPO", "wanglab/ecg-fm")
@@ -70,7 +62,7 @@ model_loaded = False
 
 def load_model():
     print(f"🔄 Loading model from {MODEL_REPO}...")
-    print(f"📦 fairseq_signals available: {fairseq_signals_available}")
+    print(f"📦 fairseq available: {fairseq_available}")
     
     try:
         # Only download the checkpoint - config is embedded inside
@@ -83,10 +75,6 @@ def load_model():
         if hasattr(m, 'eval'):
             m.eval()
             print("✅ Model loaded successfully and set to eval mode!")
-            if fairseq_signals_available:
-                print("🎉 Using OFFICIAL fairseq-signals implementation - Full ECG-FM functionality!")
-            else:
-                print("⚠️  Using fallback implementation - Limited functionality")
         else:
             print("⚠️  Model loaded but no eval() method - may be raw checkpoint")
         
@@ -114,8 +102,7 @@ def root():
         "message": "ECG-FM API is running", 
         "model": MODEL_REPO, 
         "status": "Model loaded" if model_loaded else "Model not loaded",
-        "fairseq_signals_available": fairseq_signals_available,
-        "implementation": "Official fairseq-signals" if fairseq_signals_available else "Fallback implementation"
+        "fairseq_available": fairseq_available
     }
 
 @app.get("/healthz")
@@ -123,8 +110,7 @@ def healthz():
     return {
         "status": "ok", 
         "model_loaded": model_loaded,
-        "fairseq_signals_available": fairseq_signals_available,
-        "implementation": "Official fairseq-signals" if fairseq_signals_available else "Fallback implementation"
+        "fairseq_available": fairseq_available
     }
 
 @app.post("/predict")
@@ -133,8 +119,7 @@ def predict(p: ECGPayload):
         return {
             "error": "Model not loaded", 
             "status": "unavailable",
-            "fairseq_signals_available": fairseq_signals_available,
-            "implementation": "Official fairseq-signals" if fairseq_signals_available else "Fallback implementation"
+            "fairseq_available": fairseq_available
         }
     
     try:
@@ -157,33 +142,19 @@ def predict(p: ECGPayload):
             y = y.detach()
         
         out = torch.as_tensor(y).cpu().numpy().tolist()
-        
-        # Enhanced response with implementation details
-        response = {
+        return {
             "output": out, 
             "input_shape": x.shape, 
             "output_shape": [len(out)],
-            "fairseq_signals_available": fairseq_signals_available,
-            "implementation": "Official fairseq-signals" if fairseq_signals_available else "Fallback implementation"
+            "fairseq_available": fairseq_available
         }
         
-        # Add clinical interpretation if using fairseq-signals
-        if fairseq_signals_available:
-            response["note"] = "Full ECG-FM clinical interpretation available"
-            response["capabilities"] = ["Feature extraction", "Clinical interpretation", "Abnormality detection", "Confidence scoring"]
-        else:
-            response["note"] = "Limited to feature extraction only - using fallback implementation"
-            response["capabilities"] = ["Feature extraction only"]
-        
-        return response
-        
     except Exception as e:
         print(f"❌ Prediction error: {e}")
         return {
             "error": str(e), 
             "status": "prediction_failed",
-            "fairseq_signals_available": fairseq_signals_available,
-            "implementation": "Official fairseq-signals" if fairseq_signals_available else "Fallback implementation"
+            "fairseq_available": fairseq_available
         }
 
 if __name__ == "__main__":

test_dependencies_lightweight.py

@@ -1,213 +0,0 @@
-#!/usr/bin/env python3
-"""
-Lightweight Dependency Testing
-=============================
-
-Test dependencies locally without Docker for systems with limited resources.
-This catches most dependency issues before HF upload.
-"""
-
-import sys
-import subprocess
-import importlib
-
-def test_python_version():
-    """Test Python version compatibility"""
-    print("🐍 Testing Python Version")
-    print("=" * 40)
-    
-    version = sys.version_info
-    print(f"Current: {version.major}.{version.minor}.{version.micro}")
-    
-    if version.major == 3 and 8 <= version.minor <= 11:
-        print("✅ Python version compatible with HF Spaces")
-        return True
-    else:
-        print("❌ Python version not compatible with HF Spaces")
-        print("   HF Spaces supports Python 3.8-3.11")
-        return False
-
-def test_package_installation():
-    """Test if packages can be installed"""
-    print("\n📦 Testing Package Installation")
-    print("=" * 40)
-    
-    packages = [
-        ('numpy', '1.24.3'),
-        ('torch', '1.13.1'),
-        ('omegaconf', '2.3.0'),
-        ('fastapi', '0.104.1'),
-        ('uvicorn', '0.24.0'),
-        ('huggingface-hub', '0.19.4'),
-        ('transformers', '4.21.0')
-    ]
-    
-    all_good = True
-    
-    for package, version in packages:
-        print(f"Testing {package}=={version}...")
-        
-        try:
-            # Try to install the specific version
-            cmd = [sys.executable, '-m', 'pip', 'install', f'{package}=={version}']
-            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
-            
-            if result.returncode == 0:
-                print(f"  ✅ {package}=={version} installed successfully")
-            else:
-                print(f"  ❌ {package}=={version} failed to install")
-                print(f"     Error: {result.stderr}")
-                all_good = False
-                
-        except subprocess.TimeoutExpired:
-            print(f"  ⚠️  {package}=={version} installation timed out")
-            all_good = False
-        except Exception as e:
-            print(f"  ❌ {package}=={version} error: {e}")
-            all_good = False
-    
-    return all_good
-
-def test_imports():
-    """Test if packages can be imported"""
-    print("\n🔍 Testing Package Imports")
-    print("=" * 40)
-    
-    packages = [
-        'numpy',
-        'torch', 
-        'omegaconf',
-        'fastapi',
-        'uvicorn',
-        'huggingface_hub',
-        'transformers'
-    ]
-    
-    all_good = True
-    
-    for package in packages:
-        try:
-            module = importlib.import_module(package)
-            version = getattr(module, '__version__', 'Unknown')
-            print(f"✅ {package}: {version}")
-        except ImportError as e:
-            print(f"❌ {package}: Import failed - {e}")
-            all_good = False
-        except Exception as e:
-            print(f"⚠️  {package}: Error - {e}")
-            all_good = False
-    
-    return all_good
-
-def test_version_compatibility():
-    """Test version compatibility"""
-    print("\n🔧 Testing Version Compatibility")
-    print("=" * 40)
-    
-    try:
-        import numpy
-        import torch
-        
-        numpy_version = numpy.__version__
-        torch_version = torch.__version__
-        
-        print(f"NumPy: {numpy_version}")
-        print(f"PyTorch: {torch_version}")
-        
-        # Check NumPy compatibility
-        if numpy_version.startswith('1.24'):
-            print("✅ NumPy 1.24.x - Compatible with PyTorch 1.13.x")
-        elif numpy_version.startswith('2.'):
-            print("❌ NumPy 2.x - NOT compatible with PyTorch 1.13.x")
-            return False
-        else:
-            print(f"⚠️  NumPy {numpy_version} - Check compatibility")
-        
-        # Check PyTorch compatibility
-        if torch_version.startswith('1.13'):
-            print("✅ PyTorch 1.13.x - Compatible with NumPy 1.24.x")
-        else:
-            print(f"⚠️  PyTorch {torch_version} - Check compatibility")
-        
-        return True
-        
-    except ImportError as e:
-        print(f"❌ Cannot test compatibility: {e}")
-        return False
-
-def test_fairseq_signals_import():
-    """Test fairseq-signals import (if available)"""
-    print("\n🧬 Testing fairseq-signals Import")
-    print("=" * 40)
-    
-    try:
-        # This will fail locally but shows the import path
-        import fairseq_signals
-        print("✅ fairseq_signals available locally")
-        return True
-    except ImportError:
-        print("⚠️  fairseq_signals not available locally (expected)")
-        print("   This will be installed from source in Docker")
-        return True
-    except Exception as e:
-        print(f"❌ fairseq_signals error: {e}")
-        return False
-
-def main():
-    """Main testing function"""
-    print("🚀 Lightweight Dependency Testing for ECG-FM")
-    print("=" * 60)
-    print("This tests dependencies without Docker for limited systems")
-    print()
-    
-    tests = [
-        ("Python Version", test_python_version),
-        ("Package Installation", test_package_installation),
-        ("Package Imports", test_imports),
-        ("Version Compatibility", test_version_compatibility),
-        ("fairseq-signals Import", test_fairseq_signals_import)
-    ]
-    
-    results = []
-    
-    for test_name, test_func in tests:
-        print(f"\n{'='*60}")
-        print(f"🧪 {test_name}")
-        print(f"{'='*60}")
-        
-        try:
-            result = test_func()
-            results.append((test_name, result))
-        except Exception as e:
-            print(f"❌ Test failed with error: {e}")
-            results.append((test_name, False))
-    
-    # Summary
-    print(f"\n{'='*60}")
-    print("📊 TEST SUMMARY")
-    print(f"{'='*60}")
-    
-    passed = 0
-    total = len(results)
-    
-    for test_name, result in results:
-        status = "✅ PASS" if result else "❌ FAIL"
-        print(f"{test_name}: {status}")
-        if result:
-            passed += 1
-    
-    print(f"\nResults: {passed}/{total} tests passed")
-    
-    if passed == total:
-        print("\n🎉 ALL TESTS PASSED!")
-        print("✅ Dependencies look good for HF upload")
-        print("💡 Still recommend Docker test if possible")
-    else:
-        print(f"\n❌ {total-passed} tests failed!")
-        print("⚠️  Fix dependency issues before HF upload")
-        print("💡 Check the output above for specific problems")
-    
-    return 0 if passed == total else 1
-
-if __name__ == "__main__":
-    sys.exit(main())

test_env_simple.py

@@ -1,102 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple Environment Test Script
-=============================
-
-Tests the Python 3.13 compatible environment without Unicode issues.
-"""
-
-import sys
-import os
-
-def test_environment():
-    """Test the environment"""
-    print("Testing Python 3.13 Compatible Environment")
-    print("=" * 50)
-    
-    # Get the virtual environment Python
-    if os.name == 'nt':  # Windows
-        python_path = os.path.join("ecg_fm_env_py313", "Scripts", "python.exe")
-    else:  # Unix/Linux
-        python_path = os.path.join("ecg_fm_env_py313", "bin", "python")
-    
-    if not os.path.exists(python_path):
-        print("Virtual environment not found")
-        return False
-    
-    print(f"Using Python: {python_path}")
-    
-    # Test imports
-    test_script = """
-import sys
-print(f"Python: {sys.version}")
-
-try:
-    import numpy
-    print(f"NumPy: {numpy.__version__}")
-except ImportError as e:
-    print(f"NumPy: FAILED - {e}")
-
-try:
-    import torch
-    print(f"PyTorch: {torch.__version__}")
-except ImportError as e:
-    print(f"PyTorch: FAILED - {e}")
-
-try:
-    import omegaconf
-    print(f"OmegaConf: {omegaconf.__version__}")
-    # Test if is_primitive_type exists
-    if hasattr(omegaconf._utils, 'is_primitive_type'):
-        print("OmegaConf: is_primitive_type AVAILABLE")
-    else:
-        print("OmegaConf: is_primitive_type NOT AVAILABLE")
-except ImportError as e:
-    print(f"OmegaConf: FAILED - {e}")
-
-try:
-    import fastapi
-    print(f"FastAPI: {fastapi.__version__}")
-except ImportError as e:
-    print(f"FastAPI: FAILED - {e}")
-
-try:
-    import transformers
-    print(f"Transformers: {transformers.__version__}")
-except ImportError as e:
-    print(f"Transformers: FAILED - {e}")
-
-try:
-    import huggingface_hub
-    print(f"HuggingFace Hub: {huggingface_hub.__version__}")
-except ImportError as e:
-    print(f"HuggingFace Hub: FAILED - {e}")
-
-try:
-    import uvicorn
-    print(f"Uvicorn: {uvicorn.__version__}")
-except ImportError as e:
-    print(f"Uvicorn: FAILED - {e}")
-"""
-    
-    try:
-        result = subprocess.run([python_path, '-c', test_script], 
-                              capture_output=True, text=True)
-        
-        if result.returncode == 0:
-            print("Environment test successful!")
-            print("\nPackage Versions:")
-            print(result.stdout)
-            return True
-        else:
-            print("Environment test failed!")
-            print(result.stderr)
-            return False
-            
-    except Exception as e:
-        print(f"Test error: {e}")
-        return False
-
-if __name__ == "__main__":
-    import subprocess
-    test_environment()

test_fairseq_signals.py

@@ -137,3 +137,4 @@ def main():
 
 if __name__ == "__main__":
     sys.exit(main())
+

test_local_docker.py

@@ -1,180 +0,0 @@
-#!/usr/bin/env python3
-"""
-Local Docker Testing Script
-==========================
-
-Test the exact same Docker environment locally before uploading to HF Spaces.
-This prevents wasting time on failed builds.
-"""
-
-import subprocess
-import sys
-import os
-import time
-
-def test_docker_build():
-    """Test Docker build locally"""
-    print("🐳 Testing Docker Build Locally")
-    print("=" * 50)
-    
-    # Check if Docker is available
-    try:
-        result = subprocess.run(['docker', '--version'], capture_output=True, text=True)
-        if result.returncode == 0:
-            print(f"✅ Docker available: {result.stdout.strip()}")
-        else:
-            print("❌ Docker not available")
-            return False
-    except FileNotFoundError:
-        print("❌ Docker not installed")
-        return False
-    
-    # Build the Docker image
-    print("\n🔧 Building Docker image...")
-    try:
-        build_cmd = [
-            'docker', 'build', 
-            '-t', 'ecg-fm-test', 
-            '--no-cache',  # Force fresh build
-            '.'
-        ]
-        
-        print(f"Command: {' '.join(build_cmd)}")
-        result = subprocess.run(build_cmd, capture_output=True, text=True)
-        
-        if result.returncode == 0:
-            print("✅ Docker build successful!")
-            return True
-        else:
-            print("❌ Docker build failed!")
-            print("\n📋 Build Output:")
-            print(result.stdout)
-            print("\n❌ Error Output:")
-            print(result.stderr)
-            return False
-            
-    except Exception as e:
-        print(f"❌ Build error: {e}")
-        return False
-
-def test_docker_run():
-    """Test running the container locally"""
-    print("\n🚀 Testing Docker Container Run")
-    print("=" * 50)
-    
-    try:
-        # Run container in background
-        run_cmd = [
-            'docker', 'run', 
-            '-d',  # Detached mode
-            '-p', '7860:7860',  # Port mapping
-            '--name', 'ecg-fm-test-container',
-            'ecg-fm-test'
-        ]
-        
-        print(f"Command: {' '.join(run_cmd)}")
-        result = subprocess.run(run_cmd, capture_output=True, text=True)
-        
-        if result.returncode == 0:
-            print("✅ Container started successfully!")
-            
-            # Wait for startup
-            print("⏳ Waiting for container startup...")
-            time.sleep(10)
-            
-            # Test API endpoints
-            test_api_endpoints()
-            
-            # Cleanup
-            cleanup_container()
-            return True
-        else:
-            print("❌ Container start failed!")
-            print(result.stderr)
-            return False
-            
-    except Exception as e:
-        print(f"❌ Run error: {e}")
-        return False
-
-def test_api_endpoints():
-    """Test API endpoints"""
-    print("\n🌐 Testing API Endpoints")
-    print("=" * 50)
-    
-    import requests
-    
-    base_url = "http://localhost:7860"
-    
-    # Test health endpoint
-    try:
-        response = requests.get(f"{base_url}/healthz", timeout=10)
-        if response.status_code == 200:
-            print("✅ Health endpoint working")
-            print(f"Response: {response.json()}")
-        else:
-            print(f"❌ Health endpoint failed: {response.status_code}")
-    except Exception as e:
-        print(f"❌ Health endpoint error: {e}")
-    
-    # Test root endpoint
-    try:
-        response = requests.get(f"{base_url}/", timeout=10)
-        if response.status_code == 200:
-            print("✅ Root endpoint working")
-            print(f"Response: {response.json()}")
-        else:
-            print(f"❌ Root endpoint failed: {response.status_code}")
-    except Exception as e:
-        print(f"❌ Root endpoint error: {e}")
-
-def cleanup_container():
-    """Clean up test container"""
-    print("\n🧹 Cleaning up test container...")
-    
-    try:
-        # Stop container
-        subprocess.run(['docker', 'stop', 'ecg-fm-test-container'], 
-                      capture_output=True, text=True)
-        
-        # Remove container
-        subprocess.run(['docker', 'rm', 'ecg-fm-test-container'], 
-                      capture_output=True, text=True)
-        
-        # Remove image
-        subprocess.run(['docker', 'rmi', 'ecg-fm-test'], 
-                      capture_output=True, text=True)
-        
-        print("✅ Cleanup completed")
-    except Exception as e:
-        print(f"⚠️  Cleanup warning: {e}")
-
-def main():
-    """Main testing function"""
-    print("🚀 Local Docker Testing for ECG-FM")
-    print("=" * 60)
-    print("This will test the exact same environment locally before HF upload")
-    print()
-    
-    # Test 1: Docker build
-    build_success = test_docker_build()
-    
-    if not build_success:
-        print("\n❌ Docker build failed! Fix issues before uploading to HF.")
-        return 1
-    
-    # Test 2: Docker run
-    run_success = test_docker_run()
-    
-    if not run_success:
-        print("\n❌ Docker run failed! Fix issues before uploading to HF.")
-        return 1
-    
-    print("\n🎉 ALL TESTS PASSED!")
-    print("✅ Ready to upload to HF Spaces!")
-    print("🚀 The build should succeed on HF.")
-    
-    return 0
-
-if __name__ == "__main__":
-    sys.exit(main())

test_omegaconf_fix.py

@@ -1,126 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test OmegaConf Fix Locally
-==========================
-
-Tests if the OmegaConf fix works before deploying to HF Spaces.
-"""
-
-import subprocess
-import sys
-import os
-
-def test_omegaconf_override():
-    """Test if we can override OmegaConf version"""
-    print("🧪 Testing OmegaConf Version Override")
-    print("=" * 50)
-    
-    # Get the virtual environment Python
-    if os.name == 'nt':  # Windows
-        python_path = os.path.join("ecg_fm_env_py313", "Scripts", "python.exe")
-    else:  # Unix/Linux
-        python_path = os.path.join("ecg_fm_env_py313", "bin", "python")
-    
-    if not os.path.exists(python_path):
-        print("❌ Virtual environment not found")
-        return False
-    
-    print(f"Using Python: {python_path}")
-    
-    # Test 1: Check current OmegaConf version
-    print("\n📋 Current OmegaConf version:")
-    try:
-        result = subprocess.run([python_path, '-c', 
-                               "import omegaconf; print(f'Version: {omegaconf.__version__}'); print(f'is_primitive_type: {hasattr(omegaconf._utils, \"is_primitive_type\")}')"], 
-                              capture_output=True, text=True)
-        if result.returncode == 0:
-            print(result.stdout)
-        else:
-            print(f"❌ Error: {result.stderr}")
-            return False
-    except Exception as e:
-        print(f"❌ Test error: {e}")
-        return False
-    
-    # Test 2: Simulate fairseq-signals installation (install a package that might override OmegaConf)
-    print("\n🔧 Simulating fairseq-signals installation...")
-    try:
-        # Install a package that might have conflicting dependencies
-        result = subprocess.run([python_path, '-m', 'pip', 'install', '--upgrade', 'omegaconf'], 
-                              capture_output=True, text=True)
-        if result.returncode == 0:
-            print("✅ Upgraded OmegaConf")
-        else:
-            print(f"⚠️  Upgrade warning: {result.stderr}")
-    except Exception as e:
-        print(f"⚠️  Upgrade warning: {e}")
-    
-    # Test 3: Check OmegaConf version after upgrade
-    print("\n📋 OmegaConf version after upgrade:")
-    try:
-        result = subprocess.run([python_path, '-c', 
-                               "import omegaconf; print(f'Version: {omegaconf.__version__}'); print(f'is_primitive_type: {hasattr(omegaconf._utils, \"is_primitive_type\")}')"], 
-                              capture_output=True, text=True)
-        if result.returncode == 0:
-            print(result.stdout)
-        else:
-            print(f"❌ Error: {result.stderr}")
-            return False
-    except Exception as e:
-        print(f"❌ Test error: {e}")
-        return False
-    
-    # Test 4: Force reinstall correct version
-    print("\n🔧 Forcing correct OmegaConf version...")
-    try:
-        result = subprocess.run([python_path, '-m', 'pip', 'install', '--force-reinstall', '--no-deps', 'omegaconf==2.0.0'], 
-                              capture_output=True, text=True)
-        if result.returncode == 0:
-            print("✅ Forced reinstall of OmegaConf 2.0.0")
-        else:
-            print(f"❌ Reinstall failed: {result.stderr}")
-            return False
-    except Exception as e:
-        print(f"❌ Reinstall error: {e}")
-        return False
-    
-    # Test 5: Verify final version
-    print("\n📋 Final OmegaConf version:")
-    try:
-        result = subprocess.run([python_path, '-c', 
-                               "import omegaconf; print(f'Version: {omegaconf.__version__}'); print(f'is_primitive_type: {hasattr(omegaconf._utils, \"is_primitive_type\")}')"], 
-                              capture_output=True, text=True)
-        if result.returncode == 0:
-            print(result.stdout)
-            if "2.0.0" in result.stdout and "True" in result.stdout:
-                print("✅ SUCCESS: OmegaConf 2.0.0 with is_primitive_type!")
-                return True
-            else:
-                print("❌ FAILED: Wrong version or missing is_primitive_type")
-                return False
-        else:
-            print(f"❌ Error: {result.stderr}")
-            return False
-    except Exception as e:
-        print(f"❌ Test error: {e}")
-        return False
-
-def main():
-    """Main function"""
-    print("🚀 Testing OmegaConf Fix Locally")
-    print("=" * 60)
-    print("This tests if our Dockerfile fix will work")
-    print()
-    
-    if test_omegaconf_override():
-        print("\n🎉 LOCAL TEST PASSED!")
-        print("✅ OmegaConf fix should work on HF Spaces")
-        print("🚀 Ready to deploy with fixed Dockerfile")
-        return 0
-    else:
-        print("\n❌ LOCAL TEST FAILED!")
-        print("⚠️  Need to fix the approach")
-        return 1
-
-if __name__ == "__main__":
-    sys.exit(main())

verify_versions.py

@@ -1,154 +0,0 @@
-#!/usr/bin/env python3
-"""
-Version Compatibility Verification
-================================
-
-This script verifies that all package versions are compatible
-before deploying to HF Spaces
-"""
-
-import sys
-import subprocess
-import pkg_resources
-
-def get_installed_version(package_name):
-    """Get installed version of a package"""
-    try:
-        return pkg_resources.get_distribution(package_name).version
-    except pkg_resources.DistributionNotFound:
-        return None
-
-def check_version_compatibility():
-    """Check if installed versions are compatible"""
-    print("🔍 Version Compatibility Check for HF Spaces")
-    print("=" * 60)
-    
-    # Required versions for HF Spaces
-    required_versions = {
-        'torch': '1.13.1',
-        'torchvision': '0.14.1', 
-        'torchaudio': '0.13.1',
-        'omegaconf': '1.4.1',
-        'numpy': '1.24.3',
-        'fastapi': '0.104.1',
-        'uvicorn': '0.24.0',
-        'transformers': '4.21.0',
-        'huggingface-hub': '0.19.4',
-        'pyyaml': '6.0.1',
-        'einops': '0.7.0'
-    }
-    
-    print("📋 Required versions for HF Spaces compatibility:")
-    for package, version in required_versions.items():
-        print(f"   {package}: {version}")
-    
-    print("\n🔍 Checking installed versions...")
-    
-    all_compatible = True
-    compatibility_issues = []
-    
-    for package, required_version in required_versions.items():
-        installed_version = get_installed_version(package)
-        
-        if installed_version is None:
-            print(f"❌ {package}: Not installed")
-            all_compatible = False
-            compatibility_issues.append(f"{package}: Not installed")
-        else:
-            print(f"✅ {package}: {installed_version}")
-            
-            # Check if versions match (allowing for minor variations)
-            if package.startswith('torch'):
-                # PyTorch packages should match exactly
-                if installed_version != required_version:
-                    print(f"   ⚠️  Version mismatch: {installed_version} != {required_version}")
-                    all_compatible = False
-                    compatibility_issues.append(f"{package}: {installed_version} != {required_version}")
-            else:
-                # Other packages can have compatible versions
-                print(f"   ✅ Version compatible")
-    
-    print("\n📊 Compatibility Summary:")
-    if all_compatible:
-        print("🎉 ALL VERSIONS ARE COMPATIBLE!")
-        print("✅ Ready for HF Spaces deployment")
-        return True
-    else:
-        print("❌ VERSION COMPATIBILITY ISSUES FOUND:")
-        for issue in compatibility_issues:
-            print(f"   - {issue}")
-        print("\n⚠️  Please fix version conflicts before deployment")
-        return False
-
-def check_python_version():
-    """Check Python version compatibility"""
-    print("\n🐍 Python Version Check:")
-    python_version = sys.version_info
-    
-    print(f"   Current: {python_version.major}.{python_version.minor}.{python_version.micro}")
-    
-    # HF Spaces supports Python 3.8-3.11
-    if python_version.major == 3 and 8 <= python_version.minor <= 11:
-        print("   ✅ Python version compatible with HF Spaces")
-        return True
-    else:
-        print("   ❌ Python version not compatible with HF Spaces")
-        print("   ⚠️  HF Spaces supports Python 3.8-3.11")
-        return False
-
-def check_system_requirements():
-    """Check system requirements"""
-    print("\n💻 System Requirements Check:")
-    
-    # Check if we're on a compatible system
-    import platform
-    system = platform.system()
-    print(f"   OS: {system}")
-    
-    if system in ['Linux', 'Darwin']:
-        print("   ✅ OS compatible with Docker deployment")
-        return True
-    elif system == 'Windows':
-        print("   ⚠️  Windows detected - Docker deployment may have issues")
-        print("   💡 Consider using WSL2 or Linux environment")
-        return False
-    else:
-        print("   ❌ Unknown OS - compatibility uncertain")
-        return False
-
-def main():
-    """Main verification function"""
-    print("🚀 HF Spaces Version Compatibility Verification")
-    print("=" * 80)
-    
-    # Check Python version
-    python_ok = check_python_version()
-    
-    # Check system requirements
-    system_ok = check_system_requirements()
-    
-    # Check package versions
-    packages_ok = check_version_compatibility()
-    
-    # Final summary
-    print("\n" + "=" * 80)
-    print("📊 FINAL VERIFICATION SUMMARY:")
-    print("=" * 80)
-    
-    print(f"Python Version: {'✅ PASS' if python_ok else '❌ FAIL'}")
-    print(f"System Requirements: {'✅ PASS' if system_ok else '❌ FAIL'}")
-    print(f"Package Versions: {'✅ PASS' if packages_ok else '❌ FAIL'}")
-    
-    if python_ok and system_ok and packages_ok:
-        print("\n🎉 ALL CHECKS PASSED!")
-        print("✅ Ready for HF Spaces deployment with fairseq-signals")
-        print("🚀 Expected: 3x accuracy improvement (25% → 80%+)")
-        return 0
-    else:
-        print("\n❌ SOME CHECKS FAILED!")
-        print("⚠️  Please resolve issues before deployment")
-        print("💡 Check the output above for specific problems")
-        return 1
-
-if __name__ == "__main__":
-    sys.exit(main())