TubeScript-API/README.md

# TubeScript-API

## 🎥 Panel de Control de Retransmisión Multi-Plataforma

Sistema completo para capturar transmisiones en vivo de YouTube y retransmitirlas simultáneamente a múltiples plataformas (YouTube, Facebook, Twitch, X/Twitter, Instagram, TikTok) con monitoreo en tiempo real.

## ✨ Características

- 🔍 **Búsqueda de Videos en Vivo**: Busca transmisiones en vivo de YouTube o ingresa URL directa
- ⚙️ **Configuración Multi-Plataforma**: Configura fácilmente RTMP para múltiples redes sociales
- 🎛️ **Control Individual**: Activa/desactiva la retransmisión a cada plataforma independientemente
- 📊 **Monitoreo en Tiempo Real**: Semáforos visuales que indican el estado de cada transmisión
- ⏱️ **Métricas**: Tiempo de actividad y estado de salud de cada stream
- 🔄 **Auto-refresh**: Actualización automática del monitor cada 5 segundos
- 🐳 **Docker Ready**: Despliegue fácil con Docker y Docker Compose

## 🚀 Inicio Rápido con Docker (Recomendado)

La forma más rápida de empezar es usar Docker:

```bash
# 1. Dar permisos al script
chmod +x docker-start.sh

# 2. Iniciar servicios
./docker-start.sh

# 3. Abrir en navegador
# Panel Web: http://localhost:8501
# API: http://localhost:8282
```

📚 Ver [DOCKER_README.md](DOCKER_README.md) para más información.

## 🚀 Instalación

### Opción 1: Con Docker (Recomendado)

**Prerequisitos:**
- Docker Desktop instalado
- Docker Compose

**Pasos:**
```bash
# Iniciar stack completo (FastAPI + Streamlit)
./docker-start.sh
```

Esto iniciará:
- **Panel Web Streamlit**: http://localhost:8501
- **API FastAPI**: http://localhost:8282
- **Documentación API**: http://localhost:8282/docs

📚 Documentación completa: [DOCKER_GUIDE.md](DOCKER_GUIDE.md)

### Opción 2: Instalación Local

**Prerequisitos:**
- Python 3.11+
- FFmpeg
- yt-dlp

**Pasos:**

1. **Clonar el repositorio**
```bash
git clone <repository-url>
cd TubeScript-API
```

2. **Instalar dependencias**
```bash
pip install -r requirements.txt
```

3. **Instalar FFmpeg** (si no está instalado)

**macOS:**
```bash
brew install ffmpeg
```

**Linux:**
```bash
sudo apt-get install ffmpeg
```

**Windows:**
Descarga desde [ffmpeg.org](https://ffmpeg.org/download.html)

## 📖 Uso

### 1. Iniciar el Panel Web

```bash
streamlit run streamlit_app.py
```

El panel se abrirá automáticamente en tu navegador en `http://localhost:8501`

### 2. Iniciar la API (Opcional)

```bash
python main.py
```

O con uvicorn:
```bash
uvicorn main:app --reload --host 0.0.0.0 --port 8000
```

### 3. Configurar Plataformas

En la barra lateral del panel web:

1. Expande la sección de cada plataforma
2. Ingresa la **RTMP URL** de la plataforma
3. Ingresa tu **Stream Key** (clave de transmisión)
4. Haz clic en **Guardar Configuración**

#### Plantillas RTMP Comunes:

**YouTube:**
```
RTMP URL: rtmp://a.rtmp.youtube.com/live2
Stream Key: Tu clave desde YouTube Studio > Emisión en directo
```

**Facebook:**
```
RTMP URL: rtmps://live-api-s.facebook.com:443/rtmp/
Stream Key: Tu clave desde Creator Studio > Video en directo
```

**Twitch:**
```
RTMP URL: rtmp://live.twitch.tv/app
Stream Key: Tu clave desde Dashboard > Configuración > Preferencias de stream
```

**X (Twitter):**
```
RTMP URL: rtmps://fa.contribute.live-video.net/app
Stream Key: Tu clave desde Media Studio
```

### 4. Buscar y Seleccionar Video

En la pestaña **"🔍 Búsqueda"**:

1. **Opción A - Buscar**: Ingresa términos de búsqueda (ej: "noticias", "deportes") y haz clic en "Buscar"
2. **Opción B - URL Directa**: Pega la URL del video de YouTube directamente
3. Selecciona el video deseado de los resultados

### 5. Controlar Transmisiones

En la pestaña **"🎛️ Control"**:

1. Verás tarjetas para cada plataforma configurada
2. Cada tarjeta muestra:
   - 🟢 **Verde**: Transmitiendo correctamente
   - 🔴 **Rojo**: Error en la transmisión
   - ⚫ **Gris**: Detenido
3. Haz clic en **▶️ Iniciar** para comenzar a transmitir a esa plataforma
4. Haz clic en **⏹️ Detener** para detener la transmisión

### 6. Monitorear Estado

En la pestaña **"📊 Monitor"**:

- Visualiza todas las transmisiones activas
- Ver tiempo de actividad de cada stream
- Estado en tiempo real con actualización automática cada 5 segundos
- Detener streams individuales desde el monitor

## 🐳 Uso con Docker

### Método 1: Script Automático (Recomendado)

```bash
# Dar permisos
chmod +x docker-start.sh docker-stop.sh docker-logs.sh

# Iniciar servicios
./docker-start.sh

# Ver logs
./docker-logs.sh

# Detener servicios
./docker-stop.sh
```

### Método 2: Docker Compose Manual

```bash
# Construir imágenes
docker-compose build

# Iniciar servicios en background
docker-compose up -d

# Ver logs
docker-compose logs -f

# Ver estado
docker-compose ps

# Detener servicios
docker-compose down
```

### Servicios Disponibles

Esto iniciará:
- **Panel Streamlit**: http://localhost:8501 (Frontend)
- **API FastAPI**: http://localhost:8282 (Backend)
- **Docs API**: http://localhost:8282/docs (Swagger UI)

### Volumen de configuración: `./data`

A partir de la configuración actual, el proyecto monta una única carpeta local `./data` dentro del contenedor en `/app/data`.
Coloca ahí los archivos de configuración y persistencia (por ejemplo: `cookies.txt`, `stream_config.json`, `streams_state.json`).

- Ventajas:
  - Mantener todos los archivos de configuración en un solo lugar
  - Puedes reemplazar `cookies.txt` desde fuera del servidor (host) sin editar el compose
  - Evita montajes individuales de archivos que generen conflictos de permisos

- Ejemplo (crear la carpeta si no existe):

```bash
mkdir -p ./data
chmod 755 ./data
```

## 📁 Estructura del Proyecto

```
TubeScript-API/
├── main.py                 # API FastAPI con endpoints
├── streamlit_app.py        # Panel web de control
├── requirements.txt        # Dependencias Python
├── Dockerfile              # Imagen Docker optimizada
├── docker-compose.yml      # Orquestación de servicios (monta ./data -> /app/data)
├── docker-start.sh         # Script de inicio automático
├── docker-stop.sh          # Script para detener
├── docker-logs.sh          # Script para ver logs
├── data/                   # Carpeta montada en el contenedor (/app/data) para configuración persistente
│   ├── stream_config.json  # Configuración de plataformas (generado/gestionado aquí)
│   ├── streams_state.json  # Estado de transmisiones (generado/gestionado aquí)
│   └── cookies.txt         # Cookies de YouTube (opcional — poner aquí o subir vía endpoint)
└── README.md               # Documentación
```

## 🔧 Configuración Avanzada

### Cookies de YouTube

Para acceder a videos con restricciones, puedes proporcionar cookies:

1. Instala la extensión "Get cookies.txt" en tu navegador
2. Visita youtube.com e inicia sesión
3. Exporta las cookies como `cookies.txt`
4. Coloca el archivo en `./data/cookies.txt` o súbelo mediante el endpoint `/upload_cookies`

Ejemplo: copiar manualmente al volumen montado:

```bash
cp /ruta/local/cookies.txt ./data/cookies.txt
# (si el servicio ya está corriendo, reinicia el contenedor para que los procesos usen la nueva cookie si es necesario)
```

O usar el endpoint de la API (si la API está expuesta en el host):

```bash
# Si usas docker-compose.yml (puerto 8282)
curl -v -X POST "http://127.0.0.1:8282/upload_cookies" -F "file=@/ruta/a/cookies.txt" -H "Accept: application/json"

# Si usas docker-compose.local.yml y expones en 8000, ajusta el puerto a 8000
```

### Personalizar Calidad de Video

Edita el comando FFmpeg en `streamlit_app.py` función `start_ffmpeg_stream()`:

```python
command = [
    "ffmpeg",
    "-re",
    "-i", source_url,
    "-c:v", "libx264",      # Codificar video con x264
    "-preset", "veryfast",   # Preset de codificación
    "-b:v", "4000k",        # Bitrate de video
    "-maxrate", "4000k",
    "-bufsize", "8000k",
    "-c:a", "aac",          # Codificar audio con AAC
    "-b:a", "128k",         # Bitrate de audio
    "-f", "flv",
    full_rtmp
]
```

## 🔐 Seguridad

- Las Stream Keys se guardan localmente en `stream_config.json`
- **IMPORTANTE**: Agrega `stream_config.json` a `.gitignore` para no subir tus claves al repositorio
- No compartas tus Stream Keys con nadie

## 🐛 Solución de Problemas

### Error: "No se pudo obtener la URL del stream"

- Verifica que el video esté realmente en vivo
- Intenta agregar cookies de YouTube (colocando `./data/cookies.txt` o subiéndolas vía `/upload_cookies`)
- Verifica tu conexión a internet

### Error: "Transmisión con estado error"

- Verifica que la RTMP URL y Stream Key sean correctas
- Asegúrate de que FFmpeg esté instalado
- Revisa que la plataforma permita transmisiones desde aplicaciones externas

### El video se corta o tiene problemas

- Verifica tu ancho de banda de subida
- Reduce la calidad del stream en la configuración de FFmpeg
- Limita el número de plataformas simultáneas

## 📊 API Endpoints

### GET /transcript/{video_id}

Obtiene la transcripción de un video de YouTube.

**Parámetros:**
- `video_id`: ID del video de YouTube
- `lang`: Idioma de subtítulos (default: "es")

**Respuesta:**
```json
{
  "video_id": "abc123",
  "count": 150,
  "segments": [
    {
      "start": 0.0,
      "duration": 2.5,
      "text": "Hola mundo"
    }
  ]
}
```

### GET /stream/{video_id}

Obtiene la URL del stream de un video de YouTube.

**Parámetros:**
- `video_id`: ID del video de YouTube

**Respuesta:**
```json
{
  "video_id": "abc123",
  "stream_url": "https://manifest.googlevideo.com/..."
}
```

## 🤝 Contribuciones

Las contribuciones son bienvenidas. Por favor:

1. Fork el proyecto
2. Crea una rama para tu feature (`git checkout -b feature/AmazingFeature`)
3. Commit tus cambios (`git commit -m 'Add some AmazingFeature'`)
4. Push a la rama (`git push origin feature/AmazingFeature`)
5. Abre un Pull Request

## 📄 Licencia

Este proyecto es de código abierto y está disponible bajo la licencia MIT.

## 📧 Contacto

Para preguntas o soporte, abre un issue en el repositorio.

---

**⚠️ Advertencia Legal**: Asegúrate de tener los derechos necesarios para retransmitir el contenido. Este software es solo para uso educativo y personal. El uso indebido puede violar los términos de servicio de las plataformas.

# Nota: Streamlit eliminado

> El panel Streamlit ha sido eliminado en esta rama. El proyecto ahora se centra en la API (FastAPI). Las referencias previas a Streamlit se mantienen solo para histórico.