Add GCP testing options and Python API launcher

## New Files

1. **GCP_TESTING_OPTIONS.md**: Complete guide with 4 options
- Option 1: Cloud Shell (FREE + easiest) ⭐
- Option 2: Web Console (visual)
- Option 3: gcloud CLI local
- Option 4: Python API (no CLI needed)

2. **launch_gcp_python.py**: Python-based GCP launcher
- Uses Google Cloud Compute API
- No gcloud CLI required
- Works with service account or default credentials
- Creates e2-medium spot instance (~$0.01/hr)

3. **launch_gcp_manual.md**: Detailed manual instructions
- Step-by-step for each option
- Troubleshooting
- Cost comparisons

## Recommended: Use Cloud Shell (FREE!)

```bash
# Open: https://shell.cloud.google.com/
curl -O https://huggingface.co/marcosremar2/ensemble-tts-annotation/raw/main/scripts/test/launch_gcp_spot.sh
chmod +x launch_gcp_spot.sh
./launch_gcp_spot.sh
```

Cost: ~$0.003 total (less than 1 cent!)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

GCP_TESTING_OPTIONS.md

@@ -0,0 +1,251 @@
+# 🚀 Opções para Testar no GCP
+
+Você tem **4 opções** para testar o sistema no GCP. Escolha a mais conveniente:
+
+---
+
+## ⭐ OPÇÃO 1: Google Cloud Shell (RECOMENDADO - GRÁTIS!)
+
+**Vantagens**:
+- ✅ **100% Grátis** (Cloud Shell é grátis)
+- ✅ Já tem gcloud instalado
+- ✅ Não precisa instalar nada local
+- ✅ Mais rápido e fácil
+
+**Como fazer**:
+
+1. Abra o Cloud Shell: https://shell.cloud.google.com/
+
+2. No terminal do Cloud Shell, rode:
+
+```bash
+# Download do script
+curl -O https://huggingface.co/marcosremar2/ensemble-tts-annotation/raw/main/scripts/test/launch_gcp_spot.sh
+
+# Tornar executável
+chmod +x launch_gcp_spot.sh
+
+# Rodar
+./launch_gcp_spot.sh
+```
+
+3. O script vai:
+   - ✅ Buscar instância mais barata (~e2-medium)
+   - ✅ Criar instância spot
+   - ✅ Instalar dependências
+   - ✅ Rodar teste
+   - ✅ Mostrar resultados
+
+4. Quando terminar, delete a instância:
+```bash
+gcloud compute instances delete ensemble-test-XXX --zone=us-central1-a --quiet
+```
+
+**Custo**: $0 (Cloud Shell) + ~$0.003 (instância por 20min) = **~$0.003 total**
+
+---
+
+## 🌐 OPÇÃO 2: Console Web (Interface Gráfica)
+
+**Vantagens**:
+- ✅ Visual e intuitivo
+- ✅ Não precisa de terminal
+- ✅ Fácil para iniciantes
+
+**Como fazer**:
+
+1. Acesse: https://console.cloud.google.com/compute/instances
+
+2. Click **CREATE INSTANCE**
+
+3. Configure:
+   - Nome: `ensemble-test`
+   - Região: `us-central1 (Iowa)`
+   - Zona: `us-central1-a`
+   - Tipo: `e2-medium` (2 vCPU, 4GB RAM)
+   - ✅ **Marcar**: Spot (Preemptible)
+   - Disco: Ubuntu 22.04 LTS, 20GB
+
+4. Em **Management → Automation**, cole este script:
+
+```bash
+#!/bin/bash
+apt-get update && apt-get install -y python3-pip git
+pip3 install --upgrade pip
+cd /home && git clone https://huggingface.co/marcosremar2/ensemble-tts-annotation
+cd ensemble-tts-annotation
+pip3 install torch --index-url https://download.pytorch.org/whl/cpu
+pip3 install transformers datasets librosa soundfile numpy pandas tqdm scikit-learn
+python3 test_local.py > /tmp/test-results.log 2>&1
+echo "✅ Done. Results: cat /tmp/test-results.log"
+```
+
+5. Click **CREATE**
+
+6. Após 2 minutos, click **SSH** e rode:
+```bash
+cat /tmp/test-results.log
+```
+
+7. **Delete** a instância quando terminar!
+
+**Custo**: ~$0.003 (20 minutos)
+
+---
+
+## 💻 OPÇÃO 3: Instalar gcloud CLI Localmente
+
+**Vantagens**:
+- ✅ Controle total do terminal
+- ✅ Automação completa
+- ✅ Reutilizável para outros projetos
+
+**Como fazer**:
+
+1. Instalar gcloud:
+
+```bash
+# macOS
+brew install google-cloud-sdk
+
+# Ou download direto
+curl https://sdk.cloud.google.com | bash
+exec -l $SHELL
+```
+
+2. Configurar:
+```bash
+gcloud init
+```
+
+3. Rodar o script:
+```bash
+cd ensemble-tts-annotation
+bash scripts/test/launch_gcp_spot.sh
+```
+
+**Custo**: ~$0.003
+
+---
+
+## 🐍 OPÇÃO 4: Script Python (Sem gcloud CLI)
+
+**Vantagens**:
+- ✅ Não precisa de gcloud CLI
+- ✅ Usa API do GCP diretamente
+- ✅ Programático
+
+**Como fazer**:
+
+1. Instalar biblioteca:
+```bash
+pip install google-cloud-compute google-auth
+```
+
+2. Autenticar:
+
+**Opção A** - Application Default Credentials (se tem gcloud):
+```bash
+gcloud auth application-default login
+```
+
+**Opção B** - Service Account (sem gcloud):
+1. Console: https://console.cloud.google.com/iam-admin/serviceaccounts
+2. Create Service Account
+3. Grant role: **Compute Instance Admin**
+4. Create key → Download JSON
+5. Set environment:
+```bash
+export GOOGLE_APPLICATION_CREDENTIALS="/path/to/key.json"
+export GCP_PROJECT_ID="seu-projeto-id"
+```
+
+3. Rodar script:
+```bash
+python scripts/test/launch_gcp_python.py
+```
+
+**Custo**: ~$0.003
+
+---
+
+## 📊 Comparação das Opções
+
+| Opção | Setup | Facilidade | Custo | Tempo |
+|-------|-------|------------|-------|-------|
+| **1. Cloud Shell** | 0 min | ⭐⭐⭐⭐⭐ | $0.003 | 5 min |
+| **2. Console Web** | 0 min | ⭐⭐⭐⭐ | $0.003 | 10 min |
+| **3. gcloud CLI** | 5 min | ⭐⭐⭐ | $0.003 | 5 min |
+| **4. Python API** | 10 min | ⭐⭐ | $0.003 | 5 min |
+
+---
+
+## 🎯 Minha Recomendação
+
+**Use a OPÇÃO 1 (Cloud Shell)**:
+
+1. É **grátis** (Cloud Shell não cobra)
+2. É **mais rápido** (já tem tudo instalado)
+3. É **mais fácil** (só copiar e colar)
+
+```bash
+# Literalmente 3 comandos:
+curl -O https://huggingface.co/marcosremar2/ensemble-tts-annotation/raw/main/scripts/test/launch_gcp_spot.sh
+chmod +x launch_gcp_spot.sh
+./launch_gcp_spot.sh
+```
+
+---
+
+## ⚠️ IMPORTANTE: Deletar Instância
+
+**Não esqueça de deletar** quando terminar!
+
+```bash
+# Via gcloud
+gcloud compute instances delete ensemble-test-XXX --zone=us-central1-a --quiet
+
+# Via console
+https://console.cloud.google.com/compute/instances
+→ Selecionar instância → DELETE
+```
+
+Se esquecer rodando, custo máximo:
+- $0.01/hora × 24 horas = **$0.24/dia**
+- GCP vai enviar alerta de cobrança
+
+---
+
+## 📝 Checklist
+
+Antes de começar, certifique-se:
+
+- [ ] Tem conta GCP (gratuita serve: https://cloud.google.com/free)
+- [ ] Tem projeto criado
+- [ ] Compute Engine API está habilitada
+- [ ] Tem créditos ou cartão configurado (custo: ~$0.003)
+
+Se primeira vez usando GCP:
+1. https://console.cloud.google.com/
+2. Create new project
+3. Enable Compute Engine API
+4. Seguir OPÇÃO 1 (Cloud Shell)
+
+---
+
+## 🚀 Quick Start
+
+**Para começar AGORA (5 minutos)**:
+
+1. Abrir: https://shell.cloud.google.com/
+2. Colar:
+```bash
+curl -O https://huggingface.co/marcosremar2/ensemble-tts-annotation/raw/main/scripts/test/launch_gcp_spot.sh && chmod +x launch_gcp_spot.sh && ./launch_gcp_spot.sh
+```
+3. Seguir instruções
+4. Ver resultados
+5. Deletar instância
+
+**Pronto!** 🎉
+
+Custo total: **menos de 1 centavo** 💰

scripts/test/launch_gcp_manual.md

@@ -0,0 +1,182 @@
+# Manual GCP Spot Instance Launch
+
+Como você não tem gcloud instalado localmente, aqui estão as opções:
+
+## Opção 1: Instalar gcloud CLI (Recomendado)
+
+```bash
+# macOS
+brew install google-cloud-sdk
+
+# Ou download direto
+curl https://sdk.cloud.google.com | bash
+exec -l $SHELL
+gcloud init
+
+# Depois rodar o script
+bash scripts/test/launch_gcp_spot.sh
+```
+
+## Opção 2: Usar GCP Console (Interface Web)
+
+### Passo 1: Acesse o Console
+https://console.cloud.google.com/compute/instances
+
+### Passo 2: Criar Instância Spot
+1. Click "CREATE INSTANCE"
+2. Configure:
+   - **Nome**: `ensemble-test`
+   - **Região**: `us-central1 (Iowa)` - Mais barato
+   - **Zona**: `us-central1-a`
+   - **Tipo de máquina**: `e2-medium` (2 vCPU, 4GB RAM)
+   - **Modelo de provisionamento**: ✅ **Spot** (Preemptible)
+   - **Disco de inicialização**:
+     - OS: `Ubuntu 22.04 LTS`
+     - Tamanho: `20 GB`
+   - **Firewall**: ✅ Permitir tráfego HTTP/HTTPS (opcional)
+
+### Passo 3: Script de Inicialização
+
+Na seção "Management, security, disks, networking, sole tenancy", vá em **Automation** e cole este script:
+
+```bash
+#!/bin/bash
+
+# Update system
+apt-get update
+apt-get install -y python3-pip git
+
+# Install dependencies
+pip3 install --upgrade pip
+
+# Clone repository
+cd /home
+git clone https://huggingface.co/marcosremar2/ensemble-tts-annotation
+cd ensemble-tts-annotation
+
+# Install requirements (CPU-only torch)
+pip3 install -q torch --index-url https://download.pytorch.org/whl/cpu
+pip3 install -q transformers datasets librosa soundfile numpy pandas tqdm scikit-learn
+
+# Run test
+python3 test_local.py > /tmp/test-results.log 2>&1
+
+echo "✅ Test completed. Results in /tmp/test-results.log"
+echo "To see results: cat /tmp/test-results.log"
+```
+
+### Passo 4: Criar e Aguardar
+
+1. Click **CREATE**
+2. Aguarde ~2 minutos para inicialização
+3. Click no botão **SSH** na lista de instâncias
+4. No terminal SSH, rode:
+
+```bash
+# Ver status do setup
+tail -f /var/log/syslog | grep startup-script
+
+# Ver resultado do teste
+cat /tmp/test-results.log
+
+# Ou rodar teste manualmente
+cd /home/ensemble-tts-annotation
+python3 test_local.py
+```
+
+### Passo 5: Deletar Instância
+
+⚠️ **IMPORTANTE**: Não esqueça de deletar para não gerar custos!
+
+1. Volte para Console → Compute Engine → VM Instances
+2. Selecione `ensemble-test`
+3. Click **DELETE**
+
+**Custo estimado**: ~$0.003 se deletar em 20 minutos
+
+---
+
+## Opção 3: Usar Google Cloud Shell (Grátis!)
+
+Google Cloud Shell já tem gcloud instalado e é **GRÁTIS**!
+
+### Passo 1: Abrir Cloud Shell
+https://shell.cloud.google.com/
+
+### Passo 2: Rodar comandos
+
+```bash
+# Clone o script
+curl -O https://huggingface.co/marcosremar2/ensemble-tts-annotation/raw/main/scripts/test/launch_gcp_spot.sh
+
+# Tornar executável
+chmod +x launch_gcp_spot.sh
+
+# Rodar
+./launch_gcp_spot.sh
+```
+
+O script vai:
+1. ✅ Buscar a instância mais barata
+2. ✅ Criar instância spot (e2-medium)
+3. ✅ Instalar tudo automaticamente
+4. ✅ Rodar os testes
+5. ✅ Mostrar comandos para acessar e deletar
+
+---
+
+## Opção 4: Usar Script Python (Sem gcloud CLI)
+
+Vou criar um script Python que usa a API do GCP diretamente...
+
+### Passo 1: Instalar biblioteca
+
+```bash
+pip install google-cloud-compute
+```
+
+### Passo 2: Autenticar
+
+```bash
+# Download credentials JSON do console
+# https://console.cloud.google.com/apis/credentials
+
+export GOOGLE_APPLICATION_CREDENTIALS="/path/to/credentials.json"
+```
+
+### Passo 3: Rodar script
+
+```bash
+python scripts/test/launch_gcp_python.py
+```
+
+---
+
+## Resumo de Custos
+
+| Opção | Custo | Facilidade |
+|-------|-------|------------|
+| Cloud Shell | $0 (grátis!) | ⭐⭐⭐⭐⭐ Mais fácil |
+| Console Web | ~$0.003 | ⭐⭐⭐⭐ Fácil |
+| gcloud CLI local | ~$0.003 | ⭐⭐⭐ Médio |
+| Python API | ~$0.003 | ⭐⭐ Avançado |
+
+---
+
+## Recomendação
+
+**Melhor opção**: Use **Google Cloud Shell** (Opção 3)
+- ✅ Grátis
+- ✅ Já tem gcloud instalado
+- ✅ Não precisa instalar nada local
+- ✅ Script funciona direto
+
+```bash
+# 1. Abrir https://shell.cloud.google.com/
+# 2. Rodar:
+curl -O https://huggingface.co/marcosremar2/ensemble-tts-annotation/raw/main/scripts/test/launch_gcp_spot.sh
+chmod +x launch_gcp_spot.sh
+./launch_gcp_spot.sh
+```
+
+Qual opção você prefere? Posso criar o script Python (Opção 4) se preferir não instalar gcloud.

scripts/test/launch_gcp_python.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""
+Launch GCP spot instance using Python API (no gcloud CLI needed).
+
+Requirements:
+    pip install google-cloud-compute google-auth
+
+Setup:
+    1. Create service account: https://console.cloud.google.com/iam-admin/serviceaccounts
+    2. Download JSON key
+    3. Set environment variable:
+       export GOOGLE_APPLICATION_CREDENTIALS="/path/to/key.json"
+
+    Or use: gcloud auth application-default login
+"""
+
+import os
+import sys
+import time
+from google.cloud import compute_v1
+from google.oauth2 import service_account
+import logging
+
+logging.basicConfig(level=logging.INFO, format='%(message)s')
+logger = logging.getLogger(__name__)
+
+# Configuration
+PROJECT_ID = os.getenv('GCP_PROJECT_ID', None)
+ZONE = 'us-central1-a'
+INSTANCE_NAME = f'ensemble-test-{int(time.time())}'
+MACHINE_TYPE = 'e2-medium'
+IMAGE_FAMILY = 'ubuntu-2204-lts'
+IMAGE_PROJECT = 'ubuntu-os-cloud'
+
+STARTUP_SCRIPT = """#!/bin/bash
+apt-get update
+apt-get install -y python3-pip git
+
+pip3 install --upgrade pip
+
+cd /home
+git clone https://huggingface.co/marcosremar2/ensemble-tts-annotation
+cd ensemble-tts-annotation
+
+pip3 install -q torch --index-url https://download.pytorch.org/whl/cpu
+pip3 install -q transformers datasets librosa soundfile numpy pandas tqdm scikit-learn
+
+python3 test_local.py > /tmp/test-results.log 2>&1
+
+echo "✅ Test completed" >> /tmp/test-results.log
+"""
+
+
+def get_credentials():
+    """Get GCP credentials."""
+    creds_path = os.getenv('GOOGLE_APPLICATION_CREDENTIALS')
+
+    if creds_path and os.path.exists(creds_path):
+        logger.info(f"Using credentials from: {creds_path}")
+        return service_account.Credentials.from_service_account_file(creds_path)
+    else:
+        logger.info("Using default credentials (gcloud auth application-default login)")
+        from google.auth import default
+        credentials, project = default()
+        return credentials
+
+
+def get_project_id():
+    """Get GCP project ID."""
+    if PROJECT_ID:
+        return PROJECT_ID
+
+    # Try to get from gcloud config
+    try:
+        import subprocess
+        result = subprocess.run(
+            ['gcloud', 'config', 'get-value', 'project'],
+            capture_output=True,
+            text=True
+        )
+        if result.returncode == 0:
+            project = result.stdout.strip()
+            if project:
+                return project
+    except:
+        pass
+
+    # Ask user
+    project = input("Enter GCP Project ID: ").strip()
+    return project
+
+
+def create_instance(project_id, zone, instance_name, machine_type):
+    """Create spot instance."""
+    logger.info("=" * 60)
+    logger.info("Creating GCP Spot Instance")
+    logger.info("=" * 60)
+    logger.info(f"Project: {project_id}")
+    logger.info(f"Zone: {zone}")
+    logger.info(f"Instance: {instance_name}")
+    logger.info(f"Machine Type: {machine_type}")
+    logger.info(f"Estimated cost: ~$0.01/hr")
+    logger.info("")
+
+    # Get credentials
+    credentials = get_credentials()
+
+    # Create compute client
+    instance_client = compute_v1.InstancesClient(credentials=credentials)
+
+    # Get image
+    logger.info("Getting Ubuntu image...")
+    image_client = compute_v1.ImagesClient(credentials=credentials)
+    image = image_client.get_from_family(
+        project=IMAGE_PROJECT,
+        family=IMAGE_FAMILY
+    )
+
+    # Configure instance
+    logger.info("Configuring instance...")
+
+    disk = compute_v1.AttachedDisk()
+    disk.boot = True
+    disk.auto_delete = True
+    disk.initialize_params = compute_v1.AttachedDiskInitializeParams()
+    disk.initialize_params.source_image = image.self_link
+    disk.initialize_params.disk_size_gb = 20
+
+    network_interface = compute_v1.NetworkInterface()
+    network_interface.name = "global/networks/default"
+    access_config = compute_v1.AccessConfig()
+    access_config.name = "External NAT"
+    access_config.type_ = "ONE_TO_ONE_NAT"
+    network_interface.access_configs = [access_config]
+
+    metadata = compute_v1.Metadata()
+    metadata.items = [
+        compute_v1.Items(key="startup-script", value=STARTUP_SCRIPT)
+    ]
+
+    scheduling = compute_v1.Scheduling()
+    scheduling.preemptible = True
+    scheduling.automatic_restart = False
+    scheduling.on_host_maintenance = "TERMINATE"
+
+    instance = compute_v1.Instance()
+    instance.name = instance_name
+    instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
+    instance.disks = [disk]
+    instance.network_interfaces = [network_interface]
+    instance.metadata = metadata
+    instance.scheduling = scheduling
+
+    # Create instance
+    logger.info("Launching instance...")
+    operation = instance_client.insert(
+        project=project_id,
+        zone=zone,
+        instance_resource=instance
+    )
+
+    # Wait for operation to complete
+    logger.info("Waiting for instance to be created...")
+    while operation.status != compute_v1.Operation.Status.DONE:
+        time.sleep(2)
+        operation = compute_v1.ZoneOperationsClient(credentials=credentials).get(
+            project=project_id,
+            zone=zone,
+            operation=operation.name
+        )
+
+    if operation.error:
+        logger.error(f"Error creating instance: {operation.error}")
+        return None
+
+    # Get instance details
+    instance = instance_client.get(
+        project=project_id,
+        zone=zone,
+        instance=instance_name
+    )
+
+    external_ip = instance.network_interfaces[0].access_configs[0].nat_i_p
+
+    logger.info("")
+    logger.info("=" * 60)
+    logger.info("✅ Instance created successfully!")
+    logger.info("=" * 60)
+    logger.info(f"Instance Name: {instance_name}")
+    logger.info(f"External IP: {external_ip}")
+    logger.info(f"Zone: {zone}")
+    logger.info("")
+    logger.info("SSH Command:")
+    logger.info(f"  gcloud compute ssh {instance_name} --zone={zone} --project={project_id}")
+    logger.info("")
+    logger.info("Or from console:")
+    logger.info(f"  https://console.cloud.google.com/compute/instances?project={project_id}")
+    logger.info("")
+    logger.info("Check test results (wait ~2 min for setup):")
+    logger.info(f"  gcloud compute ssh {instance_name} --zone={zone} --command='cat /tmp/test-results.log'")
+    logger.info("")
+    logger.info("Delete instance:")
+    logger.info(f"  gcloud compute instances delete {instance_name} --zone={zone} --project={project_id} --quiet")
+    logger.info("")
+    logger.info("=" * 60)
+    logger.info("⚠️  Remember to delete the instance to avoid charges!")
+    logger.info("=" * 60)
+
+    return instance_name
+
+
+def main():
+    """Main function."""
+    logger.info("GCP Spot Instance Launcher (Python API)")
+    logger.info("")
+
+    # Get project
+    project_id = get_project_id()
+    if not project_id:
+        logger.error("No project ID provided")
+        return 1
+
+    # Create instance
+    try:
+        instance_name = create_instance(
+            project_id=project_id,
+            zone=ZONE,
+            instance_name=INSTANCE_NAME,
+            machine_type=MACHINE_TYPE
+        )
+
+        if instance_name:
+            logger.info("\n✅ Success! Instance is launching.")
+            logger.info("\nNext steps:")
+            logger.info("1. Wait ~2 minutes for setup to complete")
+            logger.info("2. SSH to instance and check results")
+            logger.info("3. Delete instance when done")
+            return 0
+        else:
+            logger.error("\n❌ Failed to create instance")
+            return 1
+
+    except Exception as e:
+        logger.error(f"\n❌ Error: {e}")
+        logger.error("\nMake sure you have:")
+        logger.error("1. Installed: pip install google-cloud-compute")
+        logger.error("2. Set credentials:")
+        logger.error("   - Option A: export GOOGLE_APPLICATION_CREDENTIALS='/path/to/key.json'")
+        logger.error("   - Option B: gcloud auth application-default login")
+        logger.error("3. Enabled Compute Engine API in your project")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())