Update app.py

app.py

@@ -15,132 +15,33 @@ import logging
 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')
+# [Previous imports and initialization code remains the same...]
 
-# Initialize global variables
-vector_index = None
-query_log = []
-sentence_model = SentenceTransformer('all-MiniLM-L6-v2')
-
-# 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"""
+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)
-    return temp_dir
-
-def preprocess_image(image_path):
-    img = cv2.imread(image_path)
-    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-    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_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)
-            for page_num in range(len(pdf_reader.pages)):
-                page = pdf_reader.pages[page_num]
-                page_text = page.extract_text()
-                if page_text.strip():
-                    text += page_text
-                else:
-                    images = convert_from_path(pdf_path, first_page=page_num + 1, last_page=page_num + 1)
-                    for image in images:
-                        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
-
-def extract_text(file_path, lang='eng'):
-    file_ext = file_path.lower().split('.')[-1]
-    if file_ext in ['pdf']:
-        return extract_text_from_pdf(file_path, lang)
-    elif file_ext in ['png', 'jpg', 'jpeg']:
-        return extract_text_from_image(file_path, lang)
-    else:
-        return f"Unsupported file type: {file_ext}"
-
-def process_upload(api_key, files, lang):
-    global vector_index
-
-    if not api_key:
-        return "Please provide a valid OpenAI API Key."
-
-    if not files:
-        return "No files uploaded."
-
-    documents = []
-    error_messages = []
-    image_heavy_docs = []
-
-    for file_path in files:
-        try:
-            text = extract_text(file_path, lang)
-            if "This document consists of" in text and "page(s) of images" in text:
-                image_heavy_docs.append(os.path.basename(file_path))
-            documents.append(Document(text=text))
-        except Exception as e:
-            error_message = f"Error processing file {os.path.basename(file_path)}: {str(e)}"
-            logging.error(error_message)
-            error_messages.append(error_message)
-
-    if documents:
-        try:
-            embed_model = OpenAIEmbedding(model="text-embedding-3-large", api_key=api_key)
-            vector_index = VectorStoreIndex.from_documents(documents, embed_model=embed_model)
-            
-            success_message = f"Successfully indexed {len(documents)} files."
-            if image_heavy_docs:
-                success_message += f"\nNote: The following documents consist mainly of images and may require manual review: {', '.join(image_heavy_docs)}"
-            if error_messages:
-                success_message += f"\nErrors: {'; '.join(error_messages)}"
-            
-            return success_message
-        except Exception as e:
-            return f"Error creating index: {str(e)}"
-    else:
-        return f"No valid documents were indexed. Errors: {'; '.join(error_messages)}"
+        
+    # 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."
+        return "No documents indexed yet. Please upload documents first.", None
 
     if not api_key:
-        return "Please provide a valid OpenAI API Key."
+        return "Please provide a valid OpenAI API Key.", None
 
     try:
         llm = OpenAI(model=model_name, api_key=api_key)
@@ -149,22 +50,25 @@ def query_app(query, model_name, use_similarity_check, api_key):
         response = query_engine.query(query)
         
         generated_response = response.response
-        return generated_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)}"
+        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"):
-            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")
@@ -213,8 +117,10 @@ def create_gradio_interface():
             )
             additional_prompt = gr.Textbox(label="Additional Prompt (Optional)")
             generate_button = gr.Button("Generate")
-            audio_output = gr.Audio(label="Generated Audio")
-            summary_output = gr.Textbox(label="Generated Summary Text")
+            
+            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(
@@ -223,14 +129,21 @@ def create_gradio_interface():
             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]
+            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=generate_audio_and_text,
+            fn=process_generation,
             inputs=[
                 api_key_input, text_input, model_dropdown, voice_type,
                 voice_speed, language, output_option, summary_length,