audio_classifier.py

import streamlit as st
import os
import shutil
from pathlib import Path
import random
from datetime import datetime

# Configuración de la página
st.set_page_config(
    page_title="Clasificador de Audios - Cotorras",
    page_icon="🎵",
    layout="wide"
)

# Configuración de directorios
@st.cache_data
def get_directories():
    """Obtiene la configuración de directorios"""
    return {
        'input_dir': './clips/1_grabacion_inia',  # Directorio de entrada
        'cotorra_dir': './clips/cotorra_inia',  # Cotorras
        'no_cotorra_aves_dir': './clips/no_cotorra/aves',  # Otras aves
        'no_cotorra_generico_dir': './clips/no_cotorra'  # Otros sonidos
    }

def create_directories():
    """Crea los directorios de clasificación si no existen"""
    dirs = get_directories()
    for dir_path in dirs.values():
        if dir_path != dirs['input_dir']:
            Path(dir_path).mkdir(parents=True, exist_ok=True)

def get_audio_files():
    """Obtiene la lista de archivos de audio del directorio de entrada"""
    dirs = get_directories()
    input_dir = dirs['input_dir']
    
    if not os.path.exists(input_dir):
        st.error(f"El directorio de entrada no existe: {input_dir}")
        return []
    
    # Extensiones de audio soportadas
    audio_extensions = {'.wav', '.mp3', '.m4a', '.flac', '.ogg'}
    
    audio_files = []
    for file in os.listdir(input_dir):
        if Path(file).suffix.lower() in audio_extensions:
            audio_files.append(file)
    
    return sorted(audio_files)

def move_audio_file(filename, destination_dir):
    """Mueve un archivo de audio a la carpeta de destino"""
    dirs = get_directories()
    source_path = os.path.join(dirs['input_dir'], filename)
    dest_path = os.path.join(destination_dir, filename)
    
    try:
        shutil.move(source_path, dest_path)
        
        # Log en terminal
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        
        # Lógica corregida para detectar categoría
        if destination_dir == dirs['cotorra_dir']:
            category = "COTORRA"
        elif destination_dir == dirs['no_cotorra_aves_dir']:
            category = "OTRAS AVES"
        elif destination_dir == dirs['no_cotorra_generico_dir']:
            category = "OTROS SONIDOS"
        else:
            category = "DESCONOCIDO"
        
        print(f"[{timestamp}] ✅ MOVIDO: {filename} → {category}")
        print(f"   📁 Origen: {source_path}")
        print(f"   📁 Destino: {dest_path}")
        print(f"   📊 Categoría: {category}")
        print("-" * 80)
        
        return True
    except Exception as e:
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{timestamp}] ❌ ERROR al mover: {filename}")
        print(f"   Error: {e}")
        print("-" * 80)
        st.error(f"Error al mover el archivo: {e}")
        return False

def get_audio_file_path(filename):
    """Obtiene la ruta completa del archivo de audio"""
    dirs = get_directories()
    return os.path.join(dirs['input_dir'], filename)

def main():
    st.title("🎵 Clasificador de Audios - Cotorras")
    st.markdown("---")
    
    # Log de inicio
    if 'app_started' not in st.session_state:
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{timestamp}] 🚀 INICIANDO Clasificador de Audios - Cotorras")
        print("=" * 80)
        st.session_state.app_started = True
    
    # Crear directorios si no existen
    create_directories()
    
    # Obtener archivos de audio
    audio_files = get_audio_files()
    
    if not audio_files:
        st.warning("No se encontraron archivos de audio en el directorio de entrada.")
        st.info("Asegúrate de que el directorio './clips/1_grabacion_inia' contenga archivos de audio.")
        return
    
    # Inicializar estado de la sesión
    if 'current_file_index' not in st.session_state:
        st.session_state.current_file_index = 0
        st.session_state.processed_files = 0
        st.session_state.cotorra_count = 0
        st.session_state.no_cotorra_aves_count = 0
        st.session_state.no_cotorra_generico_count = 0
        st.session_state.skipped_count = 0
        
        # Log de archivos encontrados
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{timestamp}] 📂 Encontrados {len(audio_files)} archivos de audio para clasificar")
        print("=" * 80)
    
    # Obtener directorios
    dirs = get_directories()
    
    # Mostrar estadísticas
    col1, col2, col3, col4 = st.columns(4)
    with col1:
        st.metric("Archivos Restantes", len(audio_files) - st.session_state.processed_files)
    with col2:
        st.metric("Cotorras", st.session_state.cotorra_count)
    with col3:
        st.metric("Otras Aves", st.session_state.no_cotorra_aves_count)
    with col4:
        st.metric("Otros Sonidos", st.session_state.no_cotorra_generico_count)
    
    st.markdown("---")
    
    # Verificar si hay archivos para procesar
    if st.session_state.current_file_index >= len(audio_files):
        # Log de finalización
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{timestamp}] 🎉 CLASIFICACIÓN COMPLETADA!")
        print(f"   📊 Total procesados: {st.session_state.processed_files}")
        print(f"   🦜 Cotorras: {st.session_state.cotorra_count}")
        print(f"   🐦 Otras Aves: {st.session_state.no_cotorra_aves_count}")
        print(f"   🔊 Otros Sonidos: {st.session_state.no_cotorra_generico_count}")
        print(f"   ⏭️ Saltados: {st.session_state.skipped_count}")
        print("=" * 80)
        
        st.success("🎉 ¡Todos los archivos han sido clasificados!")
        return
    
    # Obtener archivo actual
    current_file = audio_files[st.session_state.current_file_index]
    audio_path = get_audio_file_path(current_file)
    
    # Mostrar información del archivo actual
    st.subheader(f"📁 Archivo actual: {current_file}")
    
    # Información del archivo
    file_info = os.stat(audio_path)
    file_size_mb = file_info.st_size / (1024 * 1024)
    
    col1, col2 = st.columns(2)
    with col1:
        st.info(f"**Tamaño:** {file_size_mb:.2f} MB")
    with col2:
        st.info(f"**Progreso:** {st.session_state.current_file_index + 1} de {len(audio_files)}")
    
    # Reproductor de audio
    st.markdown("### 🔊 Reproducir Audio")
    
    try:
        with open(audio_path, "rb") as audio_file:
            audio_bytes = audio_file.read()
            st.audio(audio_bytes, format=f'audio/{Path(current_file).suffix[1:]}')
    except Exception as e:
        st.error(f"Error al cargar el audio: {e}")
        return
    
    st.markdown("---")
    
    # Botones de clasificación
    st.markdown("### 🏷️ Clasificar Audio")
    
    col1, col2, col3 = st.columns(3)
    
    with col1:
        if st.button("🦜 **COTORRA**", type="primary", use_container_width=True):
            if move_audio_file(current_file, dirs['cotorra_dir']):
                st.session_state.cotorra_count += 1
                st.session_state.processed_files += 1
                st.session_state.current_file_index += 1
                st.rerun()
    
    with col2:
        if st.button("🐦 **OTRAS AVES**", type="secondary", use_container_width=True):
            if move_audio_file(current_file, dirs['no_cotorra_aves_dir']):
                st.session_state.no_cotorra_aves_count += 1
                st.session_state.processed_files += 1
                st.session_state.current_file_index += 1
                st.rerun()
    
    with col3:
        if st.button("🔊 **OTROS SONIDOS**", use_container_width=True):
            if move_audio_file(current_file, dirs['no_cotorra_generico_dir']):
                st.session_state.no_cotorra_generico_count += 1
                st.session_state.processed_files += 1
                st.session_state.current_file_index += 1
                st.rerun()
    
    # Botón para saltar archivo (opcional)
    st.markdown("---")
    if st.button("⏭️ Saltar archivo (sin clasificar)", use_container_width=True):
        # Log de archivo saltado
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        print(f"[{timestamp}] ⏭️ SALTADO: {current_file}")
        print(f"   📁 Archivo: {current_file}")
        print(f"   📊 Progreso: {st.session_state.current_file_index + 1} de {len(audio_files)}")
        print("-" * 80)
        
        st.session_state.skipped_count += 1
        st.session_state.current_file_index += 1
        st.rerun()
    
    # Información adicional
    st.markdown("---")
    st.markdown("### 📊 Información de Directorios")
    
    col1, col2, col3 = st.columns(3)
    
    with col1:
        st.info(f"**Entrada:** {dirs['input_dir']}")
    with col2:
        st.info(f"**Cotorras:** {dirs['cotorra_dir']}")
    with col3:
        st.info(f"**Otras Aves:** {dirs['no_cotorra_aves_dir']}")
    
    st.info(f"**Otros Sonidos:** {dirs['no_cotorra_generico_dir']}")

if __name__ == "__main__":
    main()