Update app.py

app.py

@@ -10,23 +10,31 @@ 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 dotenv import load_dotenv
 from sentence_transformers import SentenceTransformer, util
 import logging
-from openai_tts_tool import generate_audio_and_text  # Importing the TTS tool
+from openai_tts_tool import generate_audio_and_text
+import tempfile
 
 # Set up logging configuration
 logging.basicConfig(level=logging.INFO, format='%(asctime)s | %(levelname)s | %(message)s')
 
-# Load environment variables from .env file
-load_dotenv()
-
 # Initialize global variables
 vector_index = None
 query_log = []
 sentence_model = SentenceTransformer('all-MiniLM-L6-v2')
 
-langs = os.popen('tesseract --list-langs').read().split('\n')[1:-1]
+# Get available languages for OCR
+try:
+    langs = os.popen('tesseract --list-langs').read().split('\n')[1:-1]
+except:
+    langs = ['eng']  # Fallback to English if tesseract isn't properly configured
+
+def create_temp_dir():
+    """Create temporary directory if it doesn't exist"""
+    temp_dir = os.path.join(os.getcwd(), 'temp')
+    if not os.path.exists(temp_dir):
+        os.makedirs(temp_dir)
+    return temp_dir
 
 def preprocess_image(image_path):
     img = cv2.imread(image_path)
@@ -34,18 +42,24 @@ def preprocess_image(image_path):
     gray = cv2.equalizeHist(gray)
     gray = cv2.GaussianBlur(gray, (5, 5), 0)
     processed_image = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
-                                            cv2.THRESH_BINARY, 11, 2)
-    temp_filename = "processed_image.png"
+                                          cv2.THRESH_BINARY, 11, 2)
+    temp_dir = create_temp_dir()
+    temp_filename = os.path.join(temp_dir, "processed_image.png")
     cv2.imwrite(temp_filename, processed_image)
     return temp_filename
 
 def extract_text_from_image(image_path, lang='eng'):
     processed_image_path = preprocess_image(image_path)
     text = pytesseract.image_to_string(Image.open(processed_image_path), lang=lang)
+    try:
+        os.remove(processed_image_path)
+    except:
+        pass
     return text
 
 def extract_text_from_pdf(pdf_path, lang='eng'):
     text = ""
+    temp_dir = create_temp_dir()
     try:
         with open(pdf_path, 'rb') as file:
             pdf_reader = PyPDF2.PdfReader(file)
@@ -57,9 +71,14 @@ def extract_text_from_pdf(pdf_path, lang='eng'):
                 else:
                     images = convert_from_path(pdf_path, first_page=page_num + 1, last_page=page_num + 1)
                     for image in images:
-                        image.save('temp_image.png', 'PNG')
-                        text += extract_text_from_image('temp_image.png', lang=lang)
+                        temp_image_path = os.path.join(temp_dir, f'temp_image_{page_num}.png')
+                        image.save(temp_image_path, 'PNG')
+                        text += extract_text_from_image(temp_image_path, lang=lang)
                         text += f"\n[OCR applied on page {page_num + 1}]\n"
+                        try:
+                            os.remove(temp_image_path)
+                        except:
+                            pass
     except Exception as e:
         return f"Error processing PDF: {str(e)}"
     return text
@@ -77,10 +96,10 @@ def process_upload(api_key, files, lang):
     global vector_index
 
     if not api_key:
-        return "Please provide a valid OpenAI API Key.", None
+        return "Please provide a valid OpenAI API Key."
 
     if not files:
-        return "No files uploaded.", None
+        return "No files uploaded."
 
     documents = []
     error_messages = []
@@ -93,7 +112,7 @@ def process_upload(api_key, files, lang):
                 image_heavy_docs.append(os.path.basename(file_path))
             documents.append(Document(text=text))
         except Exception as e:
-            error_message = f"Error processing file {file_path}: {str(e)}"
+            error_message = f"Error processing file {os.path.basename(file_path)}: {str(e)}"
             logging.error(error_message)
             error_messages.append(error_message)
 
@@ -108,118 +127,122 @@ def process_upload(api_key, files, lang):
             if error_messages:
                 success_message += f"\nErrors: {'; '.join(error_messages)}"
             
-            return success_message, vector_index
+            return success_message
         except Exception as e:
-            return f"Error creating index: {str(e)}", None
+            return f"Error creating index: {str(e)}"
     else:
-        return f"No valid documents were indexed. Errors: {'; '.join(error_messages)}", None
-
-def calculate_similarity(response, ground_truth):
-    response_embedding = sentence_model.encode(response, convert_to_tensor=True)
-    truth_embedding = sentence_model.encode(ground_truth, convert_to_tensor=True)
-
-    response_embedding = response_embedding / np.linalg.norm(response_embedding)
-    truth_embedding = truth_embedding / np.linalg.norm(truth_embedding)
-
-    similarity = np.dot(response_embedding, truth_embedding)
-    similarity_percentage = (similarity + 1) / 2 * 100
-
-    return similarity_percentage
+        return f"No valid documents were indexed. Errors: {'; '.join(error_messages)}"
 
-def query_app(query, model_name, use_similarity_check, openai_api_key, answer_state):
+def query_app(query, model_name, use_similarity_check, api_key):
     global vector_index, query_log
 
     if vector_index is None:
-        logging.error("No documents indexed yet. Please upload documents first.")
-        return "No documents indexed yet. Please upload documents first.", None
+        return "No documents indexed yet. Please upload documents first."
 
-    if not openai_api_key:
-        logging.error("No OpenAI API Key provided.")
-        return "Please provide a valid OpenAI API Key.", None
-
-    try:
-        llm = OpenAI(model=model_name, api_key=openai_api_key)
-    except Exception as e:
-        logging.error(f"Error initializing the OpenAI model: {e}")
-        return f"Error initializing the OpenAI model: {e}", None
-
-    response_synthesizer = get_response_synthesizer(llm=llm)
-    query_engine = vector_index.as_query_engine(llm=llm, response_synthesizer=response_synthesizer)
+    if not api_key:
+        return "Please provide a valid OpenAI API Key."
 
     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 generated_response
+
     except Exception as e:
         logging.error(f"Error during query processing: {e}")
-        return f"Error during query processing: {e}", None
+        return f"Error during query processing: {str(e)}"
 
-    generated_response = response.response
-    query_log.append({
-        "query_id": str(len(query_log) + 1),
-        "query": query,
-        "gt_answer": "Placeholder ground truth answer",
-        "response": generated_response,
-        "retrieved_context": [{"text": doc.text} for doc in response.source_nodes]
-    })
-
-    metrics = {}
-
-    if use_similarity_check:
-        try:
-            logging.info("Similarity check is enabled. Calculating similarity.")
-            similarity = calculate_similarity(generated_response, "Placeholder ground truth answer")
-            metrics['similarity'] = similarity
-            logging.info(f"Similarity calculated: {similarity}")
-        except Exception as e:
-            logging.error(f"Error during similarity calculation: {e}")
-            metrics['error'] = f"Error during similarity calculation: {e}"
-
-    if answer_state is None:
-        answer_state = gr.State()
-
-    answer_state.value = generated_response
-
-    return generated_response, metrics if use_similarity_check else None
-
-def process_tts(api_key, text, model_name, voice_type, voice_speed, language, output_option, summary_length, additional_prompt):
-    return generate_audio_and_text(api_key, text, model_name, voice_type, voice_speed, language, output_option, summary_length, additional_prompt)
-
-def main():
+def create_gradio_interface():
     with gr.Blocks(title="Document Processing and TTS App") as demo:
         gr.Markdown("# 📄 Document Processing, Text & Audio Generation App")
-
-        # Upload documents and chat functionality
+        
         with gr.Tab("📤 Upload Documents"):
-            api_key_input = gr.Textbox(label="Enter OpenAI API Key", placeholder="Paste your OpenAI API Key here")
+            api_key_input = gr.Textbox(
+                label="Enter OpenAI API Key",
+                placeholder="Paste your OpenAI API Key here",
+                type="password"
+            )
             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)
-            upload_button.click(fn=process_upload, inputs=[api_key_input, file_upload, lang_dropdown], outputs=[upload_status])
 
-        answer_state = gr.State()  # Initialize answer state here
         with gr.Tab("❓ Ask a Question"):
             query_input = gr.Textbox(label="Enter your question")
-            model_dropdown = gr.Dropdown(choices=["gpt-4o", "gpt-4o-mini"], label="Select Model", value="gpt-4o")
+            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)
-            metrics_output = gr.JSON(label="Metrics")
-            query_button.click(fn=query_app, inputs=[query_input, model_dropdown, similarity_checkbox, api_key_input, answer_state], outputs=[answer_output, metrics_output])
 
         with gr.Tab("🗣️ Generate Audio and Text"):
-            text_input = gr.Textbox(label="Enter text for generation", value=answer_state)
-            voice_type = gr.Dropdown(choices=["alloy", "echo", "fable", "onyx"], label="Voice Type", value="alloy")
-            voice_speed = gr.Dropdown(choices=["normal", "slow", "fast"], label="Voice Speed", value="normal")
-            language = gr.Dropdown(choices=["en", "ar", "de", "hi"], label="Language", value="en")
-            output_option = gr.Radio(choices=["audio", "summary_text", "both"], label="Output Option", value="both")
-            summary_length = gr.Number(label="Summary Length", value=100)
+            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")
-            audio_output = gr.Audio(label="Generated Audio", interactive=False)
-            summary_output = gr.Textbox(label="Generated Summary Text", interactive=False)
-            generate_button.click(fn=process_tts, inputs=[api_key_input, text_input, model_dropdown, voice_type, voice_speed, language, output_option, summary_length, additional_prompt], outputs=[audio_output, summary_output])
-
-    demo.launch()
+            audio_output = gr.Audio(label="Generated Audio")
+            summary_output = gr.Textbox(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]
+        )
+        
+        query_button.click(
+            fn=query_app,
+            inputs=[query_input, model_dropdown, similarity_checkbox, api_key_input],
+            outputs=[answer_output]
+        )
+        
+        generate_button.click(
+            fn=generate_audio_and_text,
+            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__":
-    main()
+    demo = create_gradio_interface()
+    demo.launch()
+else:
+    demo = create_gradio_interface()