Update app.py

app.py

@@ -23,41 +23,11 @@ vector_index = None
 query_log = []
 sentence_model = SentenceTransformer('all-MiniLM-L6-v2')
 
-# Define a fallback list of common OCR languages
-DEFAULT_LANGS = [
-    'eng',  # English
-    'fra',  # French
-    'deu',  # German
-    'spa',  # Spanish
-    'ita',  # Italian
-    'por',  # Portuguese
-    'nld',  # Dutch
-    'pol',  # Polish
-    'tur',  # Turkish
-    'rus',  # Russian
-    'ara',  # Arabic
-    'hin',  # Hindi
-    'jpn',  # Japanese
-    'kor',  # Korean
-    'chi_sim',  # Simplified Chinese
-    'chi_tra'   # Traditional Chinese
-]
-
-def get_available_languages():
-    """Get available Tesseract languages with fallback"""
-    try:
-        # Try to get languages from Tesseract
-        langs = os.popen('tesseract --list-langs').read().split('\n')[1:-1]
-        if langs and len(langs) > 0:
-            return sorted(langs)
-    except Exception as e:
-        logging.warning(f"Could not get Tesseract languages: {e}")
-    
-    # Fallback to default languages
-    return DEFAULT_LANGS
-
-# Get available languages once at startup
-AVAILABLE_LANGUAGES = get_available_languages()
+# 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"""
@@ -66,30 +36,111 @@ def create_temp_dir():
         os.makedirs(temp_dir)
     return temp_dir
 
-# [Previous helper functions remain the same...]
+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 create_summary_file(summary_text):
-    """Create a downloadable file from the summary text"""
-    if not summary_text:
-        return None
-        
+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()
-    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
+    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)}"
 
 def query_app(query, model_name, use_similarity_check, api_key):
-    """Process a query and return both the answer and the text for generation"""
     global vector_index, query_log
 
     if vector_index is None:
-        return "No documents indexed yet. Please upload documents first.", None
+        return "No documents indexed yet. Please upload documents first."
 
     if not api_key:
-        return "Please provide a valid OpenAI API Key.", None
+        return "Please provide a valid OpenAI API Key."
 
     try:
         llm = OpenAI(model=model_name, api_key=api_key)
@@ -98,31 +149,24 @@ def query_app(query, model_name, use_similarity_check, api_key):
         response = query_engine.query(query)
         
         generated_response = response.response
-        return generated_response, generated_response
+        return generated_response
 
     except Exception as e:
         logging.error(f"Error during query processing: {e}")
-        return f"Error during query processing: {str(e)}", None
+        return f"Error during query processing: {str(e)}"
 
 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=AVAILABLE_LANGUAGES,
-                label="Select OCR Language",
-                value='eng',
-                info="Select the primary language of your 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")
             upload_status = gr.Textbox(label="Status", interactive=False)
 
@@ -169,10 +213,8 @@ def create_gradio_interface():
             )
             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")
+            audio_output = gr.Audio(label="Generated Audio")
+            summary_output = gr.Textbox(label="Generated Summary Text")
 
         # Wire up the components
         upload_button.click(
@@ -184,16 +226,11 @@ def create_gradio_interface():
         query_button.click(
             fn=query_app,
             inputs=[query_input, model_dropdown, similarity_checkbox, api_key_input],
-            outputs=[answer_output, text_input]
+            outputs=[answer_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,
+            fn=generate_audio_and_text,
             inputs=[
                 api_key_input, text_input, model_dropdown, voice_type,
                 voice_speed, language, output_option, summary_length,
@@ -208,4 +245,60 @@ if __name__ == "__main__":
     demo = create_gradio_interface()
     demo.launch()
 else:
-    demo = create_gradio_interface()
+    demo = create_gradio_interface()/////////////////////////////////////openai_tts_tool.py// from openai import OpenAI
+import tempfile
+import os
+
+def generate_audio_and_text(api_key, input_text, model_name, voice_type, voice_speed, language, output_option, summary_length, additional_prompt):
+    if not input_text:
+        return None, "No input text provided"
+    
+    try:
+        client = OpenAI(api_key=api_key)
+        
+        # Generate summary if requested
+        summary_text = None
+        if output_option in ["summary_text", "both"]:
+            summary_prompt = f"Summarize the following text in approximately {summary_length} words. {additional_prompt or ''}\n\nText: {input_text}"
+            
+            summary_response = client.chat.completions.create(
+                model=model_name,
+                messages=[{"role": "user", "content": summary_prompt}]
+            )
+            summary_text = summary_response.choices[0].message.content
+        
+        # Generate audio if requested
+        audio_file = None
+        if output_option in ["audio", "both"]:
+            speech_response = client.audio.speech.create(
+                model="tts-1",  # or "tts-1-hd" for higher quality
+                voice=voice_type,
+                input=input_text,
+                speed=float(voice_speed)
+            )
+            
+            # Create temp 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)
+            
+            # Save the audio to a temporary file
+            audio_path = os.path.join(temp_dir, f"output_{hash(input_text)}.mp3")
+            with open(audio_path, "wb") as f:
+                for chunk in speech_response.iter_bytes():
+                    f.write(chunk)
+            
+            audio_file = audio_path
+        
+        # Return based on output option
+        if output_option == "summary_text":
+            return None, summary_text
+        elif output_option == "audio":
+            return audio_file, None
+        elif output_option == "both":
+            return audio_file, summary_text
+            
+    except Exception as e:
+        return None, f"Error: {str(e)}"
+    
+    return None, None