Add basic test script for space connectivity

.gitignore

@@ -0,0 +1,20 @@
+# Arquivos de configuração com tokens
+test_config.py
+.env
+*.env
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.venv
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Arquivos temporários de teste
+test_audio_*.wav
+*.tmp 

README_TESTS.md

@@ -0,0 +1,173 @@
+# 🧪 Scripts de Teste - Pyannote Space
+
+Este diretório contém scripts para testar o funcionamento do Pyannote Speaker Diarization Space.
+
+## 📋 Scripts Disponíveis
+
+### 1. `test_simple.py` - Teste Básico (Recomendado)
+Script leve que testa apenas conectividade e API básica.
+
+**Dependências:**
+- `requests` (biblioteca padrão Python)
+
+**Uso:**
+```bash
+python test_simple.py
+```
+
+**O que testa:**
+- ✅ Conectividade com o space
+- ✅ API do Gradio funcionando  
+- ✅ Health check endpoint
+- ✅ Presença de elementos da interface
+
+### 2. `test_app.py` - Teste Completo
+Script completo que testa funcionalidade local e remota.
+
+**Dependências:**
+- `torch`
+- `pyannote.audio` 
+- `gradio`
+- `soundfile`
+- `numpy`
+- `requests`
+
+**Uso:**
+```bash
+# Instalar dependências primeiro
+pip install torch torchaudio pyannote.audio gradio soundfile numpy requests
+
+# Executar teste
+python test_app.py
+```
+
+**O que testa:**
+- ✅ Imports das dependências
+- ✅ Carregamento local do modelo
+- ✅ Diarização local com áudio sintético
+- ✅ Conectividade com space remoto
+- ✅ API remota do space
+- ✅ Diarização via API remota
+
+## 🚀 Como Usar
+
+### Teste Rápido (Recomendado)
+```bash
+python test_simple.py
+```
+
+### Teste Completo
+```bash
+python test_app.py
+```
+
+## 📊 Interpretação dos Resultados
+
+### Códigos de Saída
+- **0**: ✅ Todos os testes passaram
+- **1**: ⚠️ Alguns testes falharam (pode estar iniciando)
+- **2**: 🚨 Muitos testes falharam (problemas sérios)
+
+### Estados Típicos
+
+#### 🎉 Funcionando Perfeitamente
+```
+space_online     : ✅ PASSOU
+gradio_api       : ✅ PASSOU  
+health_check     : ✅ PASSOU
+space_info       : ✅ PASSOU
+
+🎯 RESULTADO: 4/4 testes passaram
+```
+
+#### ⏳ Iniciando
+```
+space_online     : ❌ FALHOU
+space_ready      : ✅ PASSOU
+gradio_api       : ✅ PASSOU
+health_check     : ❌ FALHOU
+
+🎯 RESULTADO: 2/4 testes passaram
+```
+
+#### 🚨 Com Problemas
+```
+space_online     : ❌ FALHOU
+space_ready      : ❌ FALHOU
+gradio_api       : ❌ FALHOU
+health_check     : ❌ FALHOU
+
+🎯 RESULTADO: 0/4 testes passaram
+```
+
+## 🔧 Troubleshooting
+
+### Erro de Conectividade
+```bash
+❌ Erro de conexão - Space pode estar offline
+```
+**Solução:** Aguarde alguns minutos, o space pode estar reiniciando.
+
+### Timeout
+```bash
+⏰ Timeout - Space pode estar iniciando  
+```
+**Solução:** Normal durante restart. Aguarde 2-5 minutos.
+
+### Health Check Falha
+```bash
+❌ Health check falhou com status: 500
+```
+**Possíveis causas:**
+- Token `HUGGINGFACE_TOKEN` não configurado
+- Modelo não conseguiu carregar
+- Erro interno no código
+
+**Solução:** 
+1. Verifique se o token foi configurado no space
+2. Verifique os logs do space no Hugging Face
+
+### API Não Responde
+```bash
+❌ API retornou status: 404
+```
+**Solução:** O space pode estar em modo de erro. Verifique os logs.
+
+## 🔑 Configuração Necessária
+
+### Token do Hugging Face
+O space precisa do token configurado como variável de ambiente:
+
+1. Acesse: https://huggingface.co/spaces/marcosremar2/pyannote-pt-diarization
+2. Vá em **Settings → Variables and secrets**
+3. Adicione:
+   - **Name:** `HUGGINGFACE_TOKEN`
+   - **Value:** `your_token_here`
+
+### Aceitar Termos do Modelo
+1. Acesse: https://huggingface.co/pyannote/speaker-diarization-3.1
+2. Aceite os termos de uso do modelo
+
+## 📝 Logs Úteis
+
+### Verificar Logs do Space
+1. Acesse o space no Hugging Face
+2. Vá na aba **"Logs"**
+3. Procure por erros como:
+   - `Authentication failed`
+   - `Token not found`
+   - `Model loading error`
+
+### Teste Manual
+Acesse diretamente: https://marcosremar2-pyannote-pt-diarization.hf.space
+
+Se a página carregar e mostrar a interface, o space está funcionando.
+
+## 🆘 Suporte
+
+Se os testes continuarem falhando:
+
+1. **Verifique os logs** do space no Hugging Face
+2. **Confirme o token** está configurado corretamente
+3. **Aguarde 5-10 minutos** após configurar o token
+4. **Teste manualmente** acessando a URL do space 

test_app.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+"""
+Script de teste para o Pyannote Speaker Diarization Space
+Testa tanto funcionamento local quanto remoto via API
+"""
+
+import os
+import sys
+import time
+import json
+import requests
+import tempfile
+import numpy as np
+from pathlib import Path
+import soundfile as sf
+from typing import Dict, Any
+
+# Configurações
+try:
+    from test_config import HF_TOKEN, SPACE_URL
+except ImportError:
+    # Fallback se test_config.py não existir
+    SPACE_URL = "https://marcosremar2-pyannote-pt-diarization.hf.space"
+    HF_TOKEN = os.getenv("HUGGINGFACE_TOKEN", "your_token_here")
+
+def create_test_audio(duration: int = 10, sample_rate: int = 22050) -> str:
+    """Cria um arquivo de áudio de teste com dois tons diferentes"""
+    print(f"🎵 Criando áudio de teste ({duration}s)...")
+    
+    # Gerar dois tons diferentes para simular diferentes speakers
+    t = np.linspace(0, duration, duration * sample_rate)
+    
+    # Tom 1 (440 Hz) - primeiros 5 segundos
+    tone1 = 0.3 * np.sin(2 * np.pi * 440 * t[:len(t)//2])
+    
+    # Tom 2 (880 Hz) - últimos 5 segundos  
+    tone2 = 0.3 * np.sin(2 * np.pi * 880 * t[len(t)//2:])
+    
+    # Combinar os tons
+    audio = np.concatenate([tone1, tone2])
+    
+    # Salvar arquivo temporário
+    temp_file = tempfile.NamedTemporaryFile(suffix='.wav', delete=False)
+    sf.write(temp_file.name, audio, sample_rate)
+    
+    print(f"✅ Áudio de teste criado: {temp_file.name}")
+    return temp_file.name
+
+def test_local_import():
+    """Testa se consegue importar as dependências localmente"""
+    print("\n🔍 Testando imports locais...")
+    
+    try:
+        import torch
+        print(f"✅ PyTorch: {torch.__version__}")
+        print(f"✅ CUDA disponível: {torch.cuda.is_available()}")
+        
+        import gradio as gr
+        print(f"✅ Gradio: {gr.__version__}")
+        
+        from pyannote.audio import Pipeline
+        print(f"✅ Pyannote Audio importado")
+        
+        return True
+    except ImportError as e:
+        print(f"❌ Erro de import: {e}")
+        return False
+
+def test_local_model_loading():
+    """Testa carregamento do modelo localmente"""
+    print("\n🤖 Testando carregamento do modelo...")
+    
+    try:
+        # Configurar token
+        os.environ["HUGGINGFACE_TOKEN"] = HF_TOKEN
+        
+        from pyannote.audio import Pipeline
+        import torch
+        
+        print("📥 Carregando modelo pyannote/speaker-diarization-3.1...")
+        pipeline = Pipeline.from_pretrained(
+            "pyannote/speaker-diarization-3.1",
+            token=HF_TOKEN
+        )
+        
+        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        pipeline = pipeline.to(device)
+        
+        print(f"✅ Modelo carregado com sucesso no device: {device}")
+        return pipeline
+        
+    except Exception as e:
+        print(f"❌ Erro ao carregar modelo: {e}")
+        return None
+
+def test_local_diarization(pipeline, audio_file: str):
+    """Testa diarização localmente"""
+    print(f"\n🎭 Testando diarização local com: {audio_file}")
+    
+    try:
+        start_time = time.time()
+        
+        # Aplicar diarization
+        diarization = pipeline(audio_file)
+        
+        # Processar resultados
+        segments = []
+        speakers = set()
+        
+        for turn, _, speaker in diarization.itertracks(yield_label=True):
+            speakers.add(speaker)
+            segments.append({
+                "start": round(turn.start, 2),
+                "end": round(turn.end, 2),
+                "duration": round(turn.end - turn.start, 2),
+                "speaker": speaker
+            })
+        
+        processing_time = time.time() - start_time
+        
+        result = {
+            "status": "success",
+            "segments": len(segments),
+            "num_speakers": len(speakers),
+            "speakers": sorted(list(speakers)),
+            "processing_time": round(processing_time, 2)
+        }
+        
+        print(f"✅ Diarização concluída:")
+        print(f"   📊 Speakers: {result['num_speakers']}")
+        print(f"   📋 Segmentos: {result['segments']}")
+        print(f"   ⏱️  Tempo: {result['processing_time']}s")
+        
+        return result
+        
+    except Exception as e:
+        print(f"❌ Erro na diarização: {e}")
+        return None
+
+def test_space_health():
+    """Testa se o space está rodando"""
+    print(f"\n🌐 Testando conexão com space: {SPACE_URL}")
+    
+    try:
+        response = requests.get(f"{SPACE_URL}/", timeout=10)
+        if response.status_code == 200:
+            print("✅ Space está online")
+            return True
+        else:
+            print(f"❌ Space retornou status: {response.status_code}")
+            return False
+    except Exception as e:
+        print(f"❌ Erro ao conectar: {e}")
+        return False
+
+def test_space_api():
+    """Testa a API do space"""
+    print(f"\n🔗 Testando API do space...")
+    
+    try:
+        # Testar health check primeiro
+        health_url = f"{SPACE_URL}/api/predict"
+        
+        # Criar payload para health check
+        payload = {
+            "data": [],
+            "fn_index": 1  # Index da função health_check
+        }
+        
+        response = requests.post(health_url, json=payload, timeout=30)
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ API funcionando")
+            print(f"   📊 Resposta: {result}")
+            return True
+        else:
+            print(f"❌ API retornou status: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Erro na API: {e}")
+        return False
+
+def test_space_diarization(audio_file: str):
+    """Testa diarização via API do space"""
+    print(f"\n🎭 Testando diarização via API...")
+    
+    try:
+        # Upload do arquivo
+        with open(audio_file, 'rb') as f:
+            files = {'data': f}
+            
+            # Fazer request para o endpoint de diarização
+            response = requests.post(
+                f"{SPACE_URL}/api/predict",
+                files=files,
+                data={"fn_index": 0},  # Index da função process_audio
+                timeout=60
+            )
+            
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ Diarização via API concluída")
+            print(f"   📊 Resposta: {result}")
+            return True
+        else:
+            print(f"❌ API retornou status: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Erro na diarização via API: {e}")
+        return False
+
+def run_all_tests():
+    """Executa todos os testes"""
+    print("🧪 INICIANDO TESTES DO PYANNOTE SPACE")
+    print("=" * 50)
+    
+    results = {}
+    
+    # Teste 1: Imports locais
+    results['imports'] = test_local_import()
+    
+    # Teste 2: Criar áudio de teste
+    audio_file = create_test_audio()
+    
+    # Teste 3: Carregamento do modelo local
+    if results['imports']:
+        pipeline = test_local_model_loading()
+        results['model_loading'] = pipeline is not None
+        
+        # Teste 4: Diarização local
+        if pipeline:
+            results['local_diarization'] = test_local_diarization(pipeline, audio_file) is not None
+        else:
+            results['local_diarization'] = False
+    else:
+        results['model_loading'] = False
+        results['local_diarization'] = False
+    
+    # Teste 5: Space online
+    results['space_health'] = test_space_health()
+    
+    # Teste 6: API do space
+    if results['space_health']:
+        results['space_api'] = test_space_api()
+        
+        # Teste 7: Diarização via API
+        if results['space_api']:
+            results['space_diarization'] = test_space_diarization(audio_file)
+        else:
+            results['space_diarization'] = False
+    else:
+        results['space_api'] = False
+        results['space_diarization'] = False
+    
+    # Limpar arquivo temporário
+    try:
+        os.unlink(audio_file)
+        print(f"\n🗑️  Arquivo temporário removido: {audio_file}")
+    except:
+        pass
+    
+    # Resumo final
+    print("\n" + "=" * 50)
+    print("📊 RESUMO DOS TESTES:")
+    print("=" * 50)
+    
+    for test_name, result in results.items():
+        status = "✅ PASSOU" if result else "❌ FALHOU"
+        print(f"{test_name:<20}: {status}")
+    
+    # Status geral
+    total_tests = len(results)
+    passed_tests = sum(results.values())
+    
+    print(f"\n🎯 RESULTADO GERAL: {passed_tests}/{total_tests} testes passaram")
+    
+    if passed_tests == total_tests:
+        print("🎉 TODOS OS TESTES PASSARAM!")
+        return 0
+    elif passed_tests >= total_tests // 2:
+        print("⚠️  ALGUNS TESTES FALHARAM - Verificar configuração")
+        return 1
+    else:
+        print("🚨 MUITOS TESTES FALHARAM - Verificar instalação e configuração")
+        return 2
+
+if __name__ == "__main__":
+    exit_code = run_all_tests()
+    sys.exit(exit_code) 

test_simple.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+"""
+Script de teste simples para verificar se o Space está funcionando
+Não requer dependências pesadas - apenas requests
+"""
+
+import requests
+import time
+import json
+
+# Configurações
+SPACE_URL = "https://marcosremar2-pyannote-pt-diarization.hf.space"
+
+def test_space_online():
+    """Testa se o space está online"""
+    print("🌐 Testando se o space está online...")
+    
+    try:
+        response = requests.get(SPACE_URL, timeout=15)
+        
+        if response.status_code == 200:
+            print("✅ Space está online e respondendo")
+            return True
+        else:
+            print(f"❌ Space retornou status code: {response.status_code}")
+            return False
+            
+    except requests.exceptions.Timeout:
+        print("⏰ Timeout - Space pode estar iniciando")
+        return False
+    except requests.exceptions.ConnectionError:
+        print("❌ Erro de conexão - Space pode estar offline")
+        return False
+    except Exception as e:
+        print(f"❌ Erro inesperado: {e}")
+        return False
+
+def test_gradio_api():
+    """Testa se a API do Gradio está respondendo"""
+    print("🔗 Testando API do Gradio...")
+    
+    try:
+        # Tentar acessar a informação da API
+        api_url = f"{SPACE_URL}/api"
+        response = requests.get(api_url, timeout=10)
+        
+        if response.status_code == 200:
+            print("✅ API do Gradio está respondendo")
+            return True
+        else:
+            print(f"❌ API retornou status: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Erro na API: {e}")
+        return False
+
+def test_health_endpoint():
+    """Testa o endpoint de health check"""
+    print("🏥 Testando health check...")
+    
+    try:
+        # Tentar fazer request para o health check
+        health_url = f"{SPACE_URL}/api/predict"
+        
+        payload = {
+            "data": [],
+            "fn_index": 1  # Index da função health_check
+        }
+        
+        response = requests.post(
+            health_url, 
+            json=payload, 
+            timeout=30,
+            headers={'Content-Type': 'application/json'}
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ Health check funcionando")
+            
+            # Tentar extrair informações úteis
+            if 'data' in result and len(result['data']) > 0:
+                health_data = result['data'][0]
+                if isinstance(health_data, str):
+                    try:
+                        health_info = json.loads(health_data)
+                        print(f"   📊 Status: {health_info.get('status', 'N/A')}")
+                        print(f"   🖥️  Device: {health_info.get('device', 'N/A')}")
+                        print(f"   🔧 GPU: {health_info.get('gpu_available', 'N/A')}")
+                        print(f"   🤖 Modelo carregado: {health_info.get('model_loaded', 'N/A')}")
+                    except:
+                        print(f"   📄 Resposta: {health_data[:100]}...")
+            
+            return True
+        else:
+            print(f"❌ Health check falhou com status: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Erro no health check: {e}")
+        return False
+
+def test_space_logs():
+    """Verifica se consegue acessar informações básicas do space"""
+    print("📋 Verificando informações do space...")
+    
+    try:
+        # Fazer request para a página principal e procurar por indicadores
+        response = requests.get(SPACE_URL, timeout=10)
+        
+        if response.status_code == 200:
+            content = response.text.lower()
+            
+            # Verificar indicadores de funcionamento
+            indicators = {
+                "gradio_running": "gradio" in content,
+                "pyannote_mentioned": "pyannote" in content,
+                "diarization_mentioned": "diarization" in content,
+                "audio_upload": "audio" in content
+            }
+            
+            print("   🔍 Indicadores encontrados:")
+            for indicator, found in indicators.items():
+                status = "✅" if found else "❌"
+                print(f"      {status} {indicator}")
+            
+            return any(indicators.values())
+        else:
+            print(f"❌ Não conseguiu acessar a página: {response.status_code}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Erro ao verificar logs: {e}")
+        return False
+
+def wait_for_space_ready(max_wait: int = 300):
+    """Aguarda o space ficar pronto, com timeout"""
+    print(f"⏳ Aguardando space ficar pronto (máximo {max_wait}s)...")
+    
+    start_time = time.time()
+    
+    while time.time() - start_time < max_wait:
+        if test_space_online():
+            print("✅ Space está pronto!")
+            return True
+        
+        print("   ⏳ Aguardando 10 segundos...")
+        time.sleep(10)
+    
+    print(f"⏰ Timeout após {max_wait}s - Space pode estar com problemas")
+    return False
+
+def run_basic_tests():
+    """Executa testes básicos de conectividade"""
+    print("🧪 TESTE BÁSICO DO PYANNOTE SPACE")
+    print("=" * 40)
+    
+    results = {}
+    
+    # Teste 1: Space online
+    results['space_online'] = test_space_online()
+    
+    if not results['space_online']:
+        print("\n⏳ Space parece estar offline, tentando aguardar...")
+        results['space_ready'] = wait_for_space_ready(120)  # 2 minutos
+    else:
+        results['space_ready'] = True
+    
+    if results['space_ready'] or results['space_online']:
+        # Teste 2: API Gradio
+        results['gradio_api'] = test_gradio_api()
+        
+        # Teste 3: Health check
+        results['health_check'] = test_health_endpoint()
+        
+        # Teste 4: Informações básicas
+        results['space_info'] = test_space_logs()
+    else:
+        results['gradio_api'] = False
+        results['health_check'] = False
+        results['space_info'] = False
+    
+    # Resumo
+    print("\n" + "=" * 40)
+    print("📊 RESUMO DOS TESTES:")
+    print("=" * 40)
+    
+    for test_name, result in results.items():
+        status = "✅ PASSOU" if result else "❌ FALHOU"
+        print(f"{test_name:<15}: {status}")
+    
+    # Status geral
+    passed = sum(results.values())
+    total = len(results)
+    
+    print(f"\n🎯 RESULTADO: {passed}/{total} testes passaram")
+    
+    if passed == total:
+        print("🎉 TODOS OS TESTES BÁSICOS PASSARAM!")
+        print("   💡 O space parece estar funcionando corretamente")
+        return 0
+    elif passed >= total // 2:
+        print("⚠️  ALGUNS TESTES FALHARAM")
+        print("   💡 O space pode estar iniciando ou com problemas menores")
+        return 1
+    else:
+        print("🚨 MUITOS TESTES FALHARAM")
+        print("   💡 O space provavelmente tem problemas ou está offline")
+        return 2
+
+if __name__ == "__main__":
+    try:
+        exit_code = run_basic_tests()
+        
+        print(f"\n📝 PRÓXIMOS PASSOS:")
+        if exit_code == 0:
+            print("   ✅ Space funcionando - pode testar upload de áudio")
+            print("   🔗 Acesse: https://marcosremar2-pyannote-pt-diarization.hf.space")
+        elif exit_code == 1:
+            print("   ⏳ Aguarde alguns minutos e teste novamente")
+            print("   🔧 Verifique se o token HUGGINGFACE_TOKEN foi configurado")
+        else:
+            print("   🔧 Verifique os logs do space no Hugging Face")
+            print("   🔑 Confirme se o token foi configurado corretamente")
+        
+        exit(exit_code)
+        
+    except KeyboardInterrupt:
+        print("\n⛔ Teste interrompido pelo usuário")
+        exit(130)
+    except Exception as e:
+        print(f"\n💥 Erro inesperado: {e}")
+        exit(1) 

test_status.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""
+Script de diagnóstico rápido para verificar status do Space
+"""
+
+import requests
+import subprocess
+import sys
+
+SPACE_URL = "https://marcosremar2-pyannote-pt-diarization.hf.space"
+
+def check_status():
+    """Verifica status HTTP e interpreta o resultado"""
+    print("🔍 DIAGNÓSTICO RÁPIDO DO SPACE")
+    print("=" * 40)
+    print(f"🌐 URL: {SPACE_URL}")
+    
+    try:
+        response = requests.get(SPACE_URL, timeout=10)
+        status_code = response.status_code
+        
+        print(f"📊 Status HTTP: {status_code}")
+        
+        if status_code == 200:
+            print("✅ FUNCIONANDO - Space está online e operacional")
+            return "working"
+        elif status_code == 503:
+            print("⚠️ SERVICE UNAVAILABLE - Space existe mas tem erro interno")
+            print("   💡 Causas possíveis:")
+            print("      • Token HUGGINGFACE_TOKEN não configurado")
+            print("      • Erro no código da aplicação")
+            print("      • Modelo não conseguiu carregar")
+            return "error"
+        elif status_code == 404:
+            print("❌ NOT FOUND - Space não existe ou URL incorreta")
+            return "not_found"
+        elif status_code == 502:
+            print("⏳ BAD GATEWAY - Space está reiniciando")
+            return "restarting"
+        else:
+            print(f"❓ STATUS DESCONHECIDO: {status_code}")
+            return "unknown"
+            
+    except requests.exceptions.Timeout:
+        print("⏰ TIMEOUT - Space não responde (pode estar carregando)")
+        return "timeout"
+    except requests.exceptions.ConnectionError:
+        print("❌ CONNECTION ERROR - Problema de rede ou space offline")
+        return "connection_error"
+    except Exception as e:
+        print(f"💥 ERRO INESPERADO: {e}")
+        return "unexpected_error"
+
+def provide_solution(status):
+    """Fornece soluções baseadas no status"""
+    print("\n🔧 PRÓXIMOS PASSOS:")
+    
+    if status == "working":
+        print("   🎉 Space funcionando perfeitamente!")
+        print(f"   🔗 Acesse: {SPACE_URL}")
+        
+    elif status == "error":
+        print("   🔑 Configurar token do Hugging Face:")
+        print("      1. Acesse: https://huggingface.co/spaces/marcosremar2/pyannote-pt-diarization")
+        print("      2. Vá em Settings → Variables and secrets")
+        print("      3. Adicione HUGGINGFACE_TOKEN com o valor do seu token")
+        print("      4. Aguarde 2-5 minutos para restart automático")
+        
+    elif status == "not_found":
+        print("   ❗ Verificar se o space foi criado corretamente")
+        print("   📝 URL esperada: https://huggingface.co/spaces/marcosremar2/pyannote-pt-diarization")
+        
+    elif status in ["restarting", "timeout"]:
+        print("   ⏳ Aguardar alguns minutos e tentar novamente")
+        print("   🔄 Space pode estar reiniciando após mudanças")
+        
+    else:
+        print("   🔍 Verificar logs do space no Hugging Face")
+        print("   🆘 Se problema persistir, revisar configuração")
+
+def main():
+    status = check_status()
+    provide_solution(status)
+    
+    # Códigos de saída para automação
+    exit_codes = {
+        "working": 0,
+        "error": 1,
+        "not_found": 2,
+        "restarting": 1,
+        "timeout": 1,
+        "connection_error": 2,
+        "unexpected_error": 3
+    }
+    
+    return exit_codes.get(status, 3)
+
+if __name__ == "__main__":
+    exit_code = main()
+    print(f"\n📋 Exit Code: {exit_code}")
+    sys.exit(exit_code)