app.py

import os
import cv2
import numpy as np
from PIL import Image
import pytesseract
import gradio as gr
from pdf2image import convert_from_path
import PyPDF2
from llama_index.core import VectorStoreIndex, Document
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.llms.openai import OpenAI
from llama_index.core import get_response_synthesizer
from sentence_transformers import SentenceTransformer, util
import logging
from openai_tts_tool import generate_audio_and_text
import tempfile

# [Previous imports and initialization code remains the same...]

def create_summary_file(summary_text):
    """Create a downloadable file from the summary text"""
    if not summary_text:
        return None
        
    temp_dir = os.path.join(os.getcwd(), 'temp')
    if not os.path.exists(temp_dir):
        os.makedirs(temp_dir)
        
    # Create a unique filename
    summary_file = os.path.join(temp_dir, f"summary_{hash(summary_text)}.txt")
    
    with open(summary_file, 'w', encoding='utf-8') as f:
        f.write(summary_text)
        
    return summary_file

def query_app(query, model_name, use_similarity_check, api_key):
    global vector_index, query_log

    if vector_index is None:
        return "No documents indexed yet. Please upload documents first.", None

    if not api_key:
        return "Please provide a valid OpenAI API Key.", None

    try:
        llm = OpenAI(model=model_name, api_key=api_key)
        response_synthesizer = get_response_synthesizer(llm=llm)
        query_engine = vector_index.as_query_engine(llm=llm, response_synthesizer=response_synthesizer)
        response = query_engine.query(query)
        
        generated_response = response.response
        # Return both the response and the same response (to update the text generation input)
        return generated_response, generated_response

    except Exception as e:
        logging.error(f"Error during query processing: {e}")
        return f"Error during query processing: {str(e)}", None

def create_gradio_interface():
    with gr.Blocks(title="Document Processing and TTS App") as demo:
        gr.Markdown("# 📄 Document Processing, Text & Audio Generation App")
        
        # Store API key at the top level to share across tabs
        api_key_input = gr.Textbox(
            label="Enter OpenAI API Key",
            placeholder="Paste your OpenAI API Key here",
            type="password"
        )
        
        with gr.Tab("📤 Upload Documents"):
            file_upload = gr.File(label="Upload Files", file_count="multiple", type="filepath")
            lang_dropdown = gr.Dropdown(choices=langs, label="Select OCR Language", value='eng')
            upload_button = gr.Button("Upload and Index")
            upload_status = gr.Textbox(label="Status", interactive=False)

        with gr.Tab("❓ Ask a Question"):
            query_input = gr.Textbox(label="Enter your question")
            model_dropdown = gr.Dropdown(
                choices=["gpt-4-0125-preview", "gpt-3.5-turbo-0125"],
                label="Select Model",
                value="gpt-3.5-turbo-0125"
            )
            similarity_checkbox = gr.Checkbox(label="Use Similarity Check", value=False)
            query_button = gr.Button("Ask")
            answer_output = gr.Textbox(label="Answer", interactive=False)

        with gr.Tab("🗣️ Generate Audio and Text"):
            text_input = gr.Textbox(label="Enter text for generation")
            voice_type = gr.Dropdown(
                choices=["alloy", "echo", "fable", "onyx", "nova", "shimmer"],
                label="Voice Type",
                value="alloy"
            )
            voice_speed = gr.Slider(
                minimum=0.25,
                maximum=4.0,
                value=1.0,
                label="Voice Speed"
            )
            language = gr.Dropdown(
                choices=["en", "ar", "de", "hi", "es", "fr", "it", "ja", "ko", "pt"],
                label="Language",
                value="en"
            )
            output_option = gr.Radio(
                choices=["audio", "summary_text", "both"],
                label="Output Option",
                value="both"
            )
            summary_length = gr.Slider(
                minimum=50,
                maximum=500,
                value=100,
                step=10,
                label="Summary Length (words)"
            )
            additional_prompt = gr.Textbox(label="Additional Prompt (Optional)")
            generate_button = gr.Button("Generate")
            
            with gr.Row():
                audio_output = gr.Audio(label="Generated Audio")
                summary_output = gr.File(label="Generated Summary Text")

        # Wire up the components
        upload_button.click(
            fn=process_upload,
            inputs=[api_key_input, file_upload, lang_dropdown],
            outputs=[upload_status]
        )
        
        # Modified to update both answer output and text generation input
        query_button.click(
            fn=query_app,
            inputs=[query_input, model_dropdown, similarity_checkbox, api_key_input],
            outputs=[answer_output, text_input]  # Now updates both outputs
        )
        
        # Modified to handle file output
        def process_generation(*args):
            audio_file, summary_text = generate_audio_and_text(*args)
            summary_file = create_summary_file(summary_text) if summary_text else None
            return audio_file, summary_file
            
        generate_button.click(
            fn=process_generation,
            inputs=[
                api_key_input, text_input, model_dropdown, voice_type,
                voice_speed, language, output_option, summary_length,
                additional_prompt
            ],
            outputs=[audio_output, summary_output]
        )

    return demo

if __name__ == "__main__":
    demo = create_gradio_interface()
    demo.launch()
else:
    demo = create_gradio_interface()