transcriber.py

import os
import google.generativeai as genai
from dotenv import load_dotenv
import time

# Carga las variables de entorno desde el archivo .env
load_dotenv()

def configure_gemini_api():
    """Configura la API de Gemini con la clave desde las variables de entorno."""
    api_key = os.getenv("GEMINI_API_KEY")
    if not api_key:
        raise ValueError("No se encontró la GEMINI_API_KEY en el archivo .env")
    genai.configure(api_key=api_key)

def create_directory(directory="transcripts"):
    """Crea un directorio si no existe."""
    if not os.path.exists(directory):
        os.makedirs(directory)

def transcribe_audio(audio_file_path):
    """Sube un archivo de audio a Gemini y solicita la transcripción completa."""
    print(f"Subiendo archivo: {audio_file_path}...")
    audio_file = genai.upload_file(path=audio_file_path)

    # Espera a que el archivo esté procesado por la API
    while audio_file.state.name == "PROCESSING":
        print("Esperando que el archivo sea procesado...")
        time.sleep(10)
        audio_file = genai.get_file(audio_file.name)

    if audio_file.state.name == "FAILED":
        raise ValueError(f"El procesamiento del archivo {audio_file_path} falló.")

    print(f"Transcribiendo {os.path.basename(audio_file_path)}...")
    model = genai.GenerativeModel(model_name="gemini-1.5-pro-latest")
    response = model.generate_content(
        ["Por favor, transcribe el siguiente audio.", audio_file]
    )
    
    # Libera el archivo de la API
    genai.delete_file(audio_file.name)
    
    return response.text


def main():
    """Función principal para procesar los audios."""
    try:
        configure_gemini_api()
    except ValueError as e:
        print(f"Error de configuración: {e}")
        print("Asegúrate de crear un archivo .env con tu GEMINI_API_KEY.")
        return

    audio_directory = "audios"
    transcript_directory = "transcripts"
    create_directory(transcript_directory)

    # Obtener los nombres base (sin extensión) de los audios y transcripciones
    audio_basenames = {
        os.path.splitext(f)[0] for f in os.listdir(audio_directory)
        if f.endswith((".mp3", ".wav", ".m4a"))
    }
    
    transcribed_basenames = {
        os.path.splitext(f)[0] for f in os.listdir(transcript_directory)
        if f.endswith(".txt")
    }

    # Determinar los archivos a procesar comparando los conjuntos de nombres base
    basenames_to_process = audio_basenames - transcribed_basenames

    if not basenames_to_process:
        print("No hay archivos nuevos para transcribir.")
        return

    # Reconstruir la lista de nombres de archivo completos para procesar
    files_to_process = [f for f in os.listdir(audio_directory) if os.path.splitext(f)[0] in basenames_to_process]

    print(f"Se encontraron {len(files_to_process)} archivos de audio para transcribir.")
    for audio_filename in files_to_process:
        try:
            audio_path = os.path.join(audio_directory, audio_filename)
            transcript_text = transcribe_audio(audio_path)
            
            transcript_filename = os.path.splitext(audio_filename)[0] + ".txt"
            transcript_path = os.path.join(transcript_directory, transcript_filename)

            with open(transcript_path, 'w', encoding='utf-8') as f:
                f.write(transcript_text)
            
            print(f"Transcripción guardada en: {transcript_path}")

        except Exception as e:
            print(f"No se pudo procesar {audio_filename}. Error: {e}")

if __name__ == "__main__":
    main()