batch_processor.py

import argparse
import os 
import traceback
from dotenv import load_dotenv
from src.audio_processing import audio_transcription, analyze_transcript, save_json_gemini_response, save_txt_transcription
from datetime import datetime, timezone

load_dotenv(".env")
API_KEY = os.getenv("GEMINI_API_KEY")


def audio_proccess(input:str, output_txt:str, output_json:str,api_key:str)-> None:
    """Procesar todos los audios encontrados en una carpeta

    Args:
        input (str): Carpeta con los archivos a analizar
        output_txt (str): Carpeta donde se guarda las transcripción de los audios
        output_json (str): Carpeta donde se guarda el archivo json con las respuesta de Gemini
        api_key (str): API KEY para utilizar Gemini, se puede obtener desde el archivo .env
    """
    audios = [path for path in os.listdir(input) if path.endswith((".wav", ".mp3"))]
    json_analyze = []
    successful_prosecutions = 0
    errors = 0

    for audio_name in audios:
        audio_path = os.path.join(input, audio_name)
        try:
            name = os.path.splitext(os.path.basename(audio_path))[0]
            print(f"Procesando audio{name}"  )
            transcription = audio_transcription(audio_path=audio_path)
            total_duration = transcription["segments"][-1]["end"] if transcription["segments"] else 0
            analyze = analyze_transcript(transcription_text=transcription["text"], segments=transcription["segments"], total_duration=total_duration, api_key=api_key)
            save_txt_transcription(text= transcription["text"],file_path=os.path.join(output_txt,name + ".txt"))
            
            if not analyze:
                print("error al procesar archivo")
                errors+=1
                continue
            analyze_with_metadata = {
                    "nombre_archivo": audio_name,
                    "fecha_procesamiento": datetime.now(timezone.utc).isoformat(),
                    **analyze  # Incluir todo el análisis
                }
            json_analyze.append(analyze_with_metadata)
            successful_prosecutions+=1
            
        except Exception as e:
            print(f" Error procesando {audio_name}: {e}")
            print(f" Traceback: {traceback.format_exc()}")
            errors += 1
            continue

    if not json_analyze:
         print("\n No se pudo procesar ningún audio ")
         return
       
    json_path = os.path.join(output_json, "response_consolidate.json")
    save_json_gemini_response(response=json_analyze, file_path=json_path)
    print(f"\nProcesamiento completado!")
    print(f"Éxitos: {successful_prosecutions}")
    print(f"Errores: {errors}")
    print(f"JSON consolidado: {json_path}")


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description = "Procesar carpeta de audios con Whisper y Gemini",
                                     prog="Transcription audio and procces with gemini")
    parser.add_argument("--input", required=True, help="Carpeta con los archivos de audio")
    parser.add_argument("--output_txt",required=True, help="Carpeta para guardar los resultados de la transcripciónd de los audios con Whisper")
    parser.add_argument("--output_json", required=True, help="Carpeta para guardar los resultados de Gemini")
    parser.add_argument("--api_key",help="API KEY para usar GEMINI")

    arg = parser.parse_args()

    api_key = arg.api_key or API_KEY

    if not api_key:
        parser.error("Se requiere tener la API KEY de gemini, por favor pasarla como argumento o desde el archivo .env")
    
    if not os.path.exists(arg.input):
        parser.error(f"La carpeta de entrada '{arg.input}' no existe")
    
    os.makedirs(arg.output_txt, exist_ok=True)
    os.makedirs(arg.output_json, exist_ok=True)

    audio_proccess(input=arg.input, output_txt=arg.output_txt, output_json=arg.output_json, api_key=api_key)