removed old code

_app.py

@@ -1,191 +0,0 @@
-import gradio as gr
-from gradio_pdf import PDF
-from pdf_text_extractor import PDFTextExtractor
-from dotenv import load_dotenv
-
-load_dotenv()
-
-def main():
-    """Main function to create and launch the interface."""
-    def process_pdf(pdf_file):
-        """Process PDF and extract text, then explanations, then audio, updating UI at each step."""
-        if pdf_file is None:
-            yield "", "No PDF uploaded", "", None, gr.update(visible=False)
-            return
-        
-        try:
-            extractor = PDFTextExtractor()
-            
-            # Step 1: Extract text
-            # Show "Extracting text..." message
-            yield "", gr.update(value="Extracting text..."), "", None, gr.update(visible=False)
-            extracted_text, status, images_data = extractor.extract_text_from_pdf(pdf_file)
-            
-            if not extracted_text or extracted_text.strip() == "":
-                yield extracted_text, status, "No text available to explain.", None, gr.update(visible=False)
-                return
-            
-            # Show extracted text immediately, explanations/audio loading
-            yield extracted_text, status, gr.update(value="Generating explanations..."), None, gr.update(visible=False)
-            
-            # Step 2: Generate explanations
-            try:
-                explanations = extractor.generate_explanations(extracted_text)
-                
-                # Show explanations immediately, update status for audio loading
-                yield extracted_text, gr.update(value="Generating audio..."), explanations, None, gr.update(visible=False)
-                
-                # Step 3: Generate audio
-                try:
-                    from ui.chatterbox.generate_tts_audio import generate_tts_audio
-                    
-                    # Clean up the text for better TTS
-                    clean_text = explanations.strip()
-                    
-                    # Limit text length for TTS (assuming 1000 character limit)
-                    if len(clean_text) > 1000:
-                        sentences = clean_text[:950].split('.')
-                        if len(sentences) > 1:
-                            clean_text = '.'.join(sentences[:-1]) + '.'
-                        else:
-                            clean_text = clean_text[:950]
-                        clean_text += " [Text has been truncated for audio generation]"
-                    
-                    audio_result = generate_tts_audio(clean_text, None)
-                    
-                    # Show everything, update status to complete
-                    yield extracted_text, gr.update(value="All steps complete!"), explanations, audio_result, gr.update(visible=True)
-                    
-                except Exception as audio_error:
-                    # Show explanations, update status with audio error
-                    yield extracted_text, gr.update(value=f"Audio generation failed: {str(audio_error)}"), explanations, None, gr.update(visible=False)
-                    
-            except Exception as explanation_error:
-                # Show extracted text, but indicate explanation error
-                yield extracted_text, status, f"Error generating explanations: {str(explanation_error)}", None, gr.update(visible=False)
-            
-        except Exception as e:
-            yield "", f"Error processing PDF: {str(e)}", "", None, gr.update(visible=False)
-    
-    def generate_explanations(extracted_text):
-        """Generate explanations for extracted text"""
-        if not extracted_text or extracted_text.strip() == "":
-            return "No text available to explain. Please extract text from a PDF first."
-        
-        try:
-            # Initialize extractor
-            extractor = PDFTextExtractor()
-            
-            # Generate explanations
-            explanations = extractor.generate_explanations(extracted_text)
-            return explanations
-            
-        except Exception as e:
-            return f"Error generating explanations: {str(e)}"
-    
-    def generate_audio(explanation_text):
-        """Generate TTS audio for explanations"""
-        if not explanation_text or explanation_text.strip() == "":
-            raise gr.Error("No explanations available to convert to audio. Please generate explanations first.")
-        
-        try:
-            # Import the TTS function
-            from ui.chatterbox.generate_tts_audio import generate_tts_audio
-            
-            # Clean up the text for better TTS
-            clean_text = explanation_text.strip()
-            
-            # Limit text length for TTS (assuming 1000 character limit)
-            if len(clean_text) > 1000:
-                # Truncate at sentence boundary if possible
-                sentences = clean_text[:950].split('.')
-                if len(sentences) > 1:
-                    clean_text = '.'.join(sentences[:-1]) + '.'
-                else:
-                    clean_text = clean_text[:950]
-                clean_text += " [Text has been truncated for audio generation]"
-            
-            # Generate audio and make it visible
-            audio_result = generate_tts_audio(clean_text, None)
-            return audio_result, gr.update(visible=True)
-            
-        except Exception as e:
-            raise gr.Error(f"Error generating audio: {str(e)}")
-      # Create the interface with side-by-side layout
-    with gr.Blocks(title="🔍 PDF Text Extractor", theme=gr.themes.Soft()) as demo:
-        # Inject fullscreen CSS
-        gr.HTML("""
-        <style>
-        html, body, #root, .gradio-container {
-            height: 100% !important;
-            width: 100% !important;
-            margin: 0 !important;
-            padding: 0 !important;
-        }
-        .gradio-container {
-            max-width: 100vw !important;
-            min-height: 100vh !important;
-            box-sizing: border-box;
-        }
-        </style>
-        """)
-        
-        gr.Markdown("# 🔍 PDF Text Extractor")
-        gr.Markdown("Upload a PDF on the left to automatically extract and view text on the right.")
-        
-        with gr.Row(equal_height=True):
-            # Left column - PDF Display
-            with gr.Column(scale=1):
-                gr.Markdown("### 📄 PDF Document")
-                pdf_input = PDF(
-                    label="Upload and View PDF",
-                    height=600,
-                    interactive=True
-                )
-                
-                status_output = gr.Textbox(
-                    label="Status",
-                    lines=2,
-                    placeholder="Upload a PDF to see status...",
-                    interactive=False
-                )
-              # Right column - Extracted Content with Tabs
-            with gr.Column(scale=1):
-                gr.Markdown("### 📝 Extracted Content")
-                
-                with gr.Tabs():
-                    with gr.TabItem("Extracted Text"):
-                        text_output = gr.Textbox(
-                            label="Extracted Text",
-                            lines=20,
-                            placeholder="Upload a PDF to automatically extract text...",
-                            show_copy_button=True,
-                            interactive=False
-                        )
-                    with gr.TabItem("Explanation Script"):
-                        explanation_output = gr.Textbox(
-                            label="Generated Explanation Script",
-                            lines=15,
-                            placeholder="Explanations will be automatically generated after text extraction...",
-                            show_copy_button=True,
-                            interactive=False
-                        )
-                
-                # Audio generation section (below tabs)
-                gr.Markdown("### 🔊 Audio Generation")
-                audio_output = gr.Audio(
-                    label="Generated Explanation Audio",
-                    interactive=False,
-                    visible=False
-                )        # Set up automatic processing on PDF upload (now handles all steps)
-        pdf_input.upload(
-            fn=process_pdf,
-            inputs=[pdf_input],
-            outputs=[text_output, status_output, explanation_output, audio_output, audio_output]
-        )
-    
-    return demo
-
-if __name__ == "__main__":
-    demo = main()
-    demo.launch()

api.py

@@ -1,48 +0,0 @@
-"""
-API for testing the TextExplainer using FastAPI.
-"""
-
-from fastapi import FastAPI, HTTPException, Form
-from pydantic import BaseModel
-from utils.text_explainer import TextExplainer
-import os
-from dotenv import load_dotenv
-
-# Load environment variables
-load_dotenv()
-
-app = FastAPI(title="Text Explainer API")
-
-class ExplainRequest(BaseModel):
-    text: str
-
-class ExplainResponseSection(BaseModel):
-    heading: str
-    content: str
-    explanation: str
-    level: int
-
-class ExplainResponse(BaseModel):
-    sections: list[ExplainResponseSection]
-    chat_history: list[dict]  # Add chat history to the response
-
-@app.post("/explain-text", response_model=ExplainResponse)
-def explain_text(request: ExplainRequest = None, text: str = Form(None)):
-    # Accept either JSON or form data
-    input_text = None
-    if request and request.text:
-        input_text = request.text
-    elif text:
-        input_text = text
-    if not input_text or not input_text.strip():
-        raise HTTPException(status_code=400, detail="Text is required.")
-    try:
-        explainer = TextExplainer()
-        explained_sections = explainer.explain_all_sections(input_text)
-        chat_history = explainer.get_chat_history()  # Get chat history
-        return {
-            "sections": explained_sections,
-            "chat_history": chat_history
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))

app.py

@@ -1,35 +1,17 @@
-"""
-PDF Text Extractor Application
-Main entry point for the PDF Text Extractor application.
-"""
+"""Main entry point for the PDF Explainer app."""
 
-import os
+import gradio as gr
+from src.processors.pdf_processor import PDFProcessor
+from src.ui_components.interface import build_interface
 from dotenv import load_dotenv
-from ui import create_interface
-from utils.config import check_api_key, get_app_config
+
+load_dotenv()
 
 def main():
-    """Main function to launch the application."""
-    
-    # Load environment variables from .env file
-    load_dotenv()
-    
-    # Check for API key
-    check_api_key()
-    
-    # Create and launch the interface
-    interface = create_interface()
-    
-    # Get application configuration
-    app_config = get_app_config()
-      
-    # Launch with appropriate settings
-    interface.launch(
-        # server_port=app_config["server_port"],
-        debug=app_config["debug"],
-        quiet=app_config["quiet"],
-        max_file_size=app_config["max_file_size"]
-    )
+    pdf_processor = PDFProcessor()
+    demo = build_interface(pdf_processor.process_pdf)
+    return demo
 
 if __name__ == "__main__":
-    main()
+    demo = main()
+    demo.launch()

pdf_text_extractor.py

@@ -1,287 +0,0 @@
-import base64
-import os
-from typing import Optional, Tuple, List, Dict, Any
-from mistralai import Mistral
-from utils.text_explainer import TextExplainer
-
-class PDFTextExtractor:
-    """PDF text extraction using Mistral AI OCR."""
-    
-    def __init__(self):
-        """Initialize the PDF text extractor with Mistral AI client."""
-        self.api_key = os.environ.get("MISTRAL_API_KEY")
-        if not self.api_key:
-            raise ValueError("MISTRAL_API_KEY environment variable is required")
-        self.client = Mistral(api_key=self.api_key)
-        self.text_explainer = TextExplainer()
-    
-    def encode_pdf(self, pdf_path: str) -> Optional[str]:
-        """
-        Encode the PDF file to base64.
-        
-        Args:
-            pdf_path: Path to the PDF file
-            
-        Returns:
-            Base64 encoded string or None if error
-        """
-        try:
-            with open(pdf_path, "rb") as pdf_file:
-                return base64.b64encode(pdf_file.read()).decode('utf-8')
-        except FileNotFoundError:
-            print(f"Error: The file {pdf_path} was not found.")
-            return None
-        except Exception as e:
-            print(f"Error encoding PDF: {e}")
-            return None
-    
-    def extract_text_from_pdf(self, pdf_file) -> Tuple[str, str, List[Dict[str, Any]]]:
-        """
-        Extract text and images from uploaded PDF using Mistral AI OCR.
-        
-        Args:
-            pdf_file: Gradio file object
-            
-        Returns:
-            Tuple of (extracted_text, status_message, images_data)
-        """
-        if pdf_file is None:
-            return "", "Please upload a PDF file.", []
-        
-        try:
-            # Get the file path from Gradio file object
-            pdf_path = pdf_file.name if hasattr(pdf_file, 'name') else pdf_file
-            
-            # Encode PDF to base64
-            base64_pdf = self.encode_pdf(pdf_path)
-            if base64_pdf is None:
-                return "", "Failed to encode PDF file.", []
-            
-            # Process with Mistral OCR
-            print(f"🔄 Processing PDF with Mistral OCR...")
-            ocr_response = self.client.ocr.process(
-                model="mistral-ocr-latest",
-                document={
-                    "type": "document_url",
-                    "document_url": f"data:application/pdf;base64,{base64_pdf}" 
-                },
-                include_image_base64=True
-            )
-            
-            # Enhanced debugging and response parsing
-            print("🔍 Analyzing OCR Response Structure...")
-            print(f"  Type: {type(ocr_response)}")
-            print(f"  String representation: {str(ocr_response)[:500]}...")
-            
-            # Check if it's a simple object with attributes
-            if hasattr(ocr_response, '__dict__'):
-                print(f"  Object attributes: {list(ocr_response.__dict__.keys())}")
-                for key, value in ocr_response.__dict__.items():
-                    print(f"    {key}: {type(value)} = {str(value)[:100]}...")
-            
-            # Check if it has commonly expected attributes
-            common_attrs = ['text', 'content', 'result', 'data', 'output', 'extracted_text', 'ocr_text', 'choices', 'message']
-            for attr in common_attrs:
-                if hasattr(ocr_response, attr):
-                    value = getattr(ocr_response, attr)
-                    print(f"  Has '{attr}': {type(value)} = {str(value)[:100]}...")
-            
-            # Check if it's iterable but not a string
-            try:
-                if hasattr(ocr_response, '__iter__') and not isinstance(ocr_response, str):
-                    print(f"  Iterable with {len(list(ocr_response))} items")
-                    for i, item in enumerate(ocr_response):
-                        if i < 3:  # Show first 3 items
-                            print(f"    Item {i}: {type(item)} = {str(item)[:100]}...")
-            except Exception as e:
-                print(f"  Error checking iteration: {e}")
-            
-            # Advanced text extraction with multiple strategies
-            extracted_text = ""
-            extraction_method = "none"
-            extracted_images = []
-            
-            # Strategy 1: Mistral OCR specific - pages with markdown content and images
-            if hasattr(ocr_response, 'pages') and ocr_response.pages:
-                pages = ocr_response.pages
-                if isinstance(pages, list) and len(pages) > 0:
-                    page_texts = []
-                    
-                    for i, page in enumerate(pages):
-                        # Extract text
-                        if hasattr(page, 'markdown') and page.markdown:
-                            page_texts.append(page.markdown)
-                            print(f"✅ Found text in page {i} markdown: {len(page.markdown)} characters")
-                        
-                        # Extract images
-                        if hasattr(page, 'images') and page.images:
-                            for j, img in enumerate(page.images):
-                                image_data = {
-                                    'page': i,
-                                    'image_id': f"img-{i}-{j}",
-                                    'top_left_x': getattr(img, 'top_left_x', 0),
-                                    'top_left_y': getattr(img, 'top_left_y', 0),
-                                    'bottom_right_x': getattr(img, 'bottom_right_x', 0),
-                                    'bottom_right_y': getattr(img, 'bottom_right_y', 0),
-                                    'base64': getattr(img, 'image_base64', '')
-                                }
-                                extracted_images.append(image_data)
-                                print(f"✅ Found image in page {i}, image {j}: coordinates ({image_data['top_left_x']}, {image_data['top_left_y']}) to ({image_data['bottom_right_x']}, {image_data['bottom_right_y']})")
-                    
-                    if page_texts:
-                        extracted_text = "\n\n".join(page_texts)
-                        extraction_method = f"pages_markdown_{len(page_texts)}_pages"
-            
-            # Try to extract images from other response structures if no images found yet
-            if not extracted_images:
-                # Check if response has images attribute directly
-                if hasattr(ocr_response, 'images') and ocr_response.images:
-                    for j, img in enumerate(ocr_response.images):
-                        image_data = {
-                            'page': 0,
-                            'image_id': getattr(img, 'id', f"img-{j}"),
-                            'top_left_x': getattr(img, 'top_left_x', 0),
-                            'top_left_y': getattr(img, 'top_left_y', 0),
-                            'bottom_right_x': getattr(img, 'bottom_right_x', 0),
-                            'bottom_right_y': getattr(img, 'bottom_right_y', 0),
-                            'base64': getattr(img, 'image_base64', '')
-                        }
-                        extracted_images.append(image_data)
-                        print(f"✅ Found image {j}: coordinates ({image_data['top_left_x']}, {image_data['top_left_y']}) to ({image_data['bottom_right_x']}, {image_data['bottom_right_y']})")
-            
-            # Continue with fallback strategies for text extraction
-            if not extracted_text:
-                # Strategy 2: Direct text attribute (fallback)
-                if hasattr(ocr_response, 'text') and ocr_response.text:
-                    extracted_text = str(ocr_response.text)
-                    extraction_method = "direct_text_attribute"
-                
-                # Strategy 3: Content attribute (fallback)
-                elif hasattr(ocr_response, 'content') and ocr_response.content:
-                    content = ocr_response.content
-                    if isinstance(content, str):
-                        extracted_text = content
-                        extraction_method = "content_attribute_string"
-                    elif hasattr(content, 'text'):
-                        extracted_text = str(content.text)
-                        extraction_method = "content_text_attribute"
-                    else:
-                        extracted_text = str(content)
-                        extraction_method = "content_attribute_converted"
-                
-                # Strategy 4: Result attribute (fallback)
-                elif hasattr(ocr_response, 'result'):
-                    result = ocr_response.result
-                    if isinstance(result, str):
-                        extracted_text = result
-                        extraction_method = "result_string"
-                    elif hasattr(result, 'text'):
-                        extracted_text = str(result.text)
-                        extraction_method = "result_text_attribute"
-                    elif isinstance(result, dict) and 'text' in result:
-                        extracted_text = str(result['text'])
-                        extraction_method = "result_dict_text"
-                    else:
-                        extracted_text = str(result)
-                        extraction_method = "result_converted"
-                
-                # Strategy 5: Choices attribute (ChatGPT-style response - fallback)
-                elif hasattr(ocr_response, 'choices') and ocr_response.choices:
-                    choices = ocr_response.choices
-                    if isinstance(choices, list) and len(choices) > 0:
-                        choice = choices[0]
-                        if hasattr(choice, 'message') and hasattr(choice.message, 'content'):
-                            extracted_text = str(choice.message.content)
-                            extraction_method = "choices_message_content"
-                        elif hasattr(choice, 'text'):
-                            extracted_text = str(choice.text)
-                            extraction_method = "choices_text"
-                        else:
-                            extracted_text = str(choice)
-                            extraction_method = "choices_converted"
-                
-                # Strategy 6: Dict-like access (fallback)
-                elif hasattr(ocr_response, 'get') or isinstance(ocr_response, dict):
-                    for key in ['text', 'content', 'result', 'extracted_text', 'ocr_text', 'output']:
-                        if hasattr(ocr_response, 'get'):
-                            value = ocr_response.get(key)
-                        else:
-                            value = ocr_response.get(key) if isinstance(ocr_response, dict) else None
-                        
-                        if value:
-                            extracted_text = str(value)
-                            extraction_method = f"dict_key_{key}"
-                            break
-                
-                # Strategy 7: Inspect all attributes for string-like content (fallback)
-                elif hasattr(ocr_response, '__dict__'):
-                    for key, value in ocr_response.__dict__.items():
-                        if isinstance(value, str) and len(value) > 20:  # Likely text content
-                            extracted_text = value
-                            extraction_method = f"attribute_{key}"
-                            break
-                        elif hasattr(value, 'text') and isinstance(value.text, str):
-                            extracted_text = str(value.text)
-                            extraction_method = f"nested_text_in_{key}"
-                            break
-                
-                # Strategy 8: Convert entire response to string if it seems to contain text (fallback)
-                if not extracted_text:
-                    response_str = str(ocr_response)
-                    if len(response_str) > 50 and not response_str.startswith('<'):  # Not an object reference
-                        extracted_text = response_str
-                        extraction_method = "full_response_string"
-            
-            print(f"🎯 Extraction method used: {extraction_method}")
-            print(f"📏 Extracted text length: {len(extracted_text)} characters")
-            print(f"🖼️ Extracted images: {len(extracted_images)}")
-            
-            if extracted_text:
-                status = f"✅ Successfully extracted text from PDF ({len(extracted_text)} characters)"
-                if extracted_images:
-                    status += f" and {len(extracted_images)} image(s)"
-            else:
-                extracted_text = "No text could be extracted from this PDF."
-                status = "⚠️ OCR completed but no text was found in response."
-                if extracted_images:
-                    status = f"✅ Successfully extracted {len(extracted_images)} image(s) from PDF, but no text was found."
-                print(f"❌ No extractable text found in OCR response")
-            
-            return extracted_text, status, extracted_images
-            
-        except Exception as e:
-            error_msg = f"Error processing PDF: {str(e)}"
-            print(error_msg)
-            return "", f"❌ {error_msg}", []
-    
-    def generate_explanations(self, extracted_text: str) -> str:
-        """
-        Generate explanations for the extracted text sections.
-        
-        Args:
-            extracted_text: The extracted text from PDF
-            
-        Returns:
-            Formatted explanations for all sections
-        """
-        try:
-            if not extracted_text or extracted_text.strip() == "":
-                return "No text available to explain."
-            
-            if extracted_text.startswith("No text could be extracted"):
-                return "Cannot generate explanations - no text was extracted from the PDF."
-            
-            print("🤖 Generating explanations for extracted text...")
-            explained_sections = self.text_explainer.explain_all_sections(extracted_text)
-            
-            if not explained_sections:
-                return "No sections found to explain in the extracted text."
-            
-            formatted_explanations = self.text_explainer.format_explanations_for_display(explained_sections)
-            return formatted_explanations
-            
-        except Exception as e:
-            error_msg = f"Error generating explanations: {str(e)}"
-            print(error_msg)
-            return f"❌ {error_msg}"
-

sample_text.md

@@ -1,15 +0,0 @@
-# Sporting Exchanges between China and the United States, 1980-1984: Inevitable Politics and Excessive Political Strings
-
-Y. Andrew Hao and Thomas M. Hunt<br>Department of Kinesiology and Health Education, The University of Texas at Austin, Austin, TX, USA
-
-#### Abstract
-
-Sino-US sporting exchanges between 1980 and 1984 largely paralleled the patterns of the larger bilateral relations between the two nations. The over-politicization of sports by the two governments - and especially by the PRC - created the parallelism. Curiously, scholars of sport and international relations have paid little attention to Sino-US athletic interactions in this period, an oversight that needs to be remedied in light of the reciprocal correlations between international sport and international politics. Indeed, Sino-US athletic exchanges in the context of their bilateral relations underscores the mutual connections between sport and diplomacy.
-
-On January 1, 1979 - eight years after the initiation of the 'Ping-pong diplomacy' and seven after then-US President Richard Nixon's visit to China - the United States diplomatically recognized the People's Republic of China (PRC) with its capital in Beijing and rescinded its recognition of the Republic of China (ROC). At the end of the same year, the International Olympic Committee (IOC) welcomed the Chinese Olympic Committee back to the Olympic Movement. ${ }^{1}$ The Republic of China Olympic Committee, which previously monopolized the seat of China but only governed the sporting affairs of Taiwan and surrounding breakaway islands, was forced to change its name, flag and anthem.
-
-The two incidents' proximity in time was more a coincidence than not - the US recognition did not directly cause China's reinstatement into the Olympics. Rather, both were trophies that Beijing garnered thanks to its rising power and strategic advantage in world politics. The Sino-US rapprochement resulted from changing power dynamics within the Sino-USSR-US strategic triangle in the 1970s: having parted way with the Soviet Union, China befriended the United States, which, under the 'Nixon doctrine', had offered an olive branch; the ensuing deterioration of SovietUS relations drove Beijing and Washington to enter into a closer relationship after 1978. ${ }^{2}$ The Olympic reinstatement, however, took place directly as the result of
-
-[^0]
-[^0]: CONTACT Thomas M. Hunt (1) [email protected] (2) Department of Kinesiology and Health Education, The University of Texas at Austin, 2109 San Jacinto Blvd, Stop D3700, Austin, TX 78712-1415, USA
-(C) 2019 Informa UK Limited, trading as Taylor \& Francis Group

src/app.py

@@ -1,17 +0,0 @@
-"""Main entry point for the PDF Explainer app."""
-
-import gradio as gr
-from processors.pdf_processor import PDFProcessor
-from ui_components.interface import build_interface
-from dotenv import load_dotenv
-
-load_dotenv()
-
-def main():
-    pdf_processor = PDFProcessor()
-    demo = build_interface(pdf_processor.process_pdf)
-    return demo
-
-if __name__ == "__main__":
-    demo = main()
-    demo.launch()

src/ui_components/interface.py

@@ -46,7 +46,7 @@ def build_interface(process_pdf_fn):
                 audio_output = gr.Audio(
                     label="Generated Explanation Audio",
                     interactive=False,
-                    visible=False
+                    visible=False,
                 )
         
         pdf_input.upload(

tests/test_ocr_direct.py

@@ -1,234 +0,0 @@
-"""
-Quick OCR Test Script
-Tests the Mistral AI OCR functionality directly without the Gradio interface.
-"""
-
-import base64
-import os
-import tempfile
-from mistralai import Mistral
-from dotenv import load_dotenv
-
-# Load environment variables
-load_dotenv()
-
-def create_simple_pdf_content():
-    """Create a minimal PDF in memory for testing."""
-    # Simple PDF content (this is a basic PDF structure)
-    pdf_content = """%PDF-1.4
-1 0 obj
-<<
-/Type /Catalog
-/Pages 2 0 R
->>
-endobj
-
-2 0 obj
-<<
-/Type /Pages
-/Kids [3 0 R]
-/Count 1
->>
-endobj
-
-3 0 obj
-<<
-/Type /Page
-/Parent 2 0 R
-/MediaBox [0 0 612 792]
-/Contents 4 0 R
-/Resources <<
-/Font <<
-/F1 5 0 R
->>
->>
->>
-endobj
-
-4 0 obj
-<<
-/Length 44
->>
-stream
-BT
-/F1 12 Tf
-72 720 Td
-(Hello World! Test OCR) Tj
-ET
-endstream
-endobj
-
-5 0 obj
-<<
-/Type /Font
-/Subtype /Type1
-/BaseFont /Helvetica
->>
-endobj
-
-xref
-0 6
-0000000000 65535 f 
-0000000010 00000 n 
-0000000079 00000 n 
-0000000173 00000 n 
-0000000301 00000 n 
-0000000380 00000 n 
-trailer
-<<
-/Size 6
-/Root 1 0 R
->>
-startxref
-456
-%%EOF"""
-    
-    return pdf_content.encode('utf-8')
-
-def test_mistral_ocr():
-    """Test the Mistral OCR functionality directly."""
-    
-    print("🧪 Starting Mistral OCR Test...")
-    
-    # Check API key
-    api_key = os.environ.get("MISTRAL_API_KEY")
-    if not api_key:
-        print("❌ MISTRAL_API_KEY environment variable not found")
-        print("   Please set it in your .env file or environment")
-        return False
-    
-    print(f"✅ API key found: {api_key[:8]}...")
-    
-    try:
-        # Initialize Mistral client
-        client = Mistral(api_key=api_key)
-        print("✅ Mistral client initialized")
-        
-        # Create a simple test PDF
-        pdf_content = create_simple_pdf_content()
-        base64_pdf = base64.b64encode(pdf_content).decode('utf-8')
-        print(f"✅ Test PDF created ({len(pdf_content)} bytes)")
-        
-        # Test the OCR endpoint
-        print("🔄 Sending OCR request to Mistral...")
-        
-        response = client.ocr.process(
-            model="mistral-ocr-latest", 
-            document={
-                "type": "document_url",
-                "document_url": f"data:application/pdf;base64,{base64_pdf}"
-            },
-            include_image_base64=True
-        )
-        
-        print("✅ OCR request completed")
-        
-        # Analyze the response
-        print("\n🔍 RESPONSE ANALYSIS:")
-        print(f"Response type: {type(response)}")
-        print(f"Response string: {str(response)[:200]}...")
-        
-        if hasattr(response, '__dict__'):
-            print(f"Response attributes: {list(response.__dict__.keys())}")
-            for key, value in response.__dict__.items():
-                print(f"  {key}: {type(value)} = {str(value)[:100]}...")
-          # Test all possible text extraction methods
-        print("\n🎯 TESTING TEXT EXTRACTION METHODS:")
-        
-        methods = [
-            ("response.pages[].markdown", lambda r: "\n".join([page.markdown for page in r.pages]) if hasattr(r, 'pages') and r.pages and all(hasattr(p, 'markdown') for p in r.pages) else None),
-            ("response.text", lambda r: getattr(r, 'text', None)),
-            ("response.content", lambda r: getattr(r, 'content', None)),
-            ("response.result", lambda r: getattr(r, 'result', None)),
-            ("response.data", lambda r: getattr(r, 'data', None)),
-            ("response['text']", lambda r: r.get('text') if hasattr(r, 'get') else None),
-            ("response['content']", lambda r: r.get('content') if hasattr(r, 'get') else None),
-        ]
-        
-        extracted_text = None
-        successful_method = None
-        
-        for method_name, method_func in methods:
-            try:
-                result = method_func(response)
-                if result:
-                    print(f"✅ {method_name}: Found content ({len(str(result))} chars)")
-                    print(f"   Content: {str(result)[:100]}...")
-                    if not extracted_text:  # Use the first successful method
-                        extracted_text = str(result)
-                        successful_method = method_name
-                else:
-                    print(f"❌ {method_name}: No content found")
-            except Exception as e:
-                print(f"❌ {method_name}: Error - {e}")
-        
-        if extracted_text:
-            print(f"\n🎉 SUCCESSFULLY EXTRACTED TEXT using {successful_method}:")
-            print(f"📝 Full extracted text: '{extracted_text}'")
-        else:
-            print(f"\n❌ NO TEXT EXTRACTED from any method")
-        
-        return True
-        
-    except Exception as e:
-        print(f"❌ OCR test failed: {e}")
-        print(f"   Error type: {type(e)}")
-        
-        # If it's a 401 error, the API key might be invalid
-        if "401" in str(e) or "unauthorized" in str(e).lower():
-            print("   This might be an API key issue. Please check your MISTRAL_API_KEY")
-        
-        return False
-
-def test_api_connectivity():
-    """Test basic connectivity to Mistral API."""
-    
-    print("🌐 Testing API connectivity...")
-    
-    api_key = os.environ.get("MISTRAL_API_KEY")
-    if not api_key:
-        print("❌ No API key found")
-        return False
-    
-    try:
-        client = Mistral(api_key=api_key)
-        
-        # Try a simple API call (if available) 
-        # Note: This might fail if the endpoint doesn't exist, but it tests connectivity
-        print("🔄 Testing API connection...")
-        
-        # The exact method to test connectivity may vary based on Mistral's API
-        # For now, we'll just try to initialize and catch any immediate errors
-        print("✅ Mistral client appears to be working")
-        return True
-        
-    except Exception as e:
-        print(f"❌ API connectivity test failed: {e}")
-        return False
-
-def main():
-    """Main test function."""
-    
-    print("🚀 Mistral OCR Quick Test")
-    print("=" * 40)
-    
-    # Test API connectivity first
-    if not test_api_connectivity():
-        print("\n❌ Basic connectivity test failed")
-        return
-    
-    print("\n" + "="*40)
-    
-    # Test OCR functionality
-    if test_mistral_ocr():
-        print("\n✅ OCR test completed - check the response analysis above")
-    else:
-        print("\n❌ OCR test failed")
-    
-    print("\n💡 Next steps:")
-    print("   1. If the test worked, run: python main.py")
-    print("   2. If there were errors, check the API key and try again")
-    print("   3. Use the response analysis to improve text extraction")
-
-if __name__ == "__main__":
-    main()

tests/test_setup.py

@@ -1,62 +0,0 @@
-"""
-Test script for PDF Extractor setup validation
-"""
-
-import sys
-import os
-from dotenv import load_dotenv
-
-def test_imports():
-    """Test if all required packages are importable."""
-    try:
-        import gradio as gr
-        print("✅ Gradio imported successfully")
-        
-        import mistralai
-        print("✅ Mistral AI imported successfully")
-        
-        from dotenv import load_dotenv
-        print("✅ python-dotenv imported successfully")
-        
-        return True
-    except ImportError as e:
-        print(f"❌ Import error: {e}")
-        return False
-
-def test_environment():
-    """Test environment variable setup."""
-    load_dotenv()
-    
-    api_key = os.environ.get("MISTRAL_API_KEY")
-    if api_key:
-        # Don't print the actual key, just confirm it exists
-        print("✅ MISTRAL_API_KEY environment variable is set")
-        return True
-    else:
-        print("⚠️  MISTRAL_API_KEY not found in environment")
-        print("   Please copy .env.example to .env and add your API key")
-        return False
-
-def main():
-    """Run all tests."""
-    print("🔍 PDF Extractor Setup Validation")
-    print("=" * 40)
-    
-    import_success = test_imports()
-    env_success = test_environment()
-    
-    print("\n" + "=" * 40)
-    if import_success:
-        print("✅ All packages are properly installed")
-        if env_success:
-            print("✅ Environment is configured correctly")
-            print("🚀 Ready to run: python main.py")
-        else:
-            print("⚠️  Environment needs configuration")
-            print("📝 Next step: Set up your .env file")
-    else:
-        print("❌ Package installation incomplete")
-        print("📝 Next step: pip install -r requirements.txt")
-
-if __name__ == "__main__":
-    main()

ui/__init__.py

@@ -1,15 +0,0 @@
-"""UI components for PDF Text Extractor."""
-from ui.interface import create_interface
-from ui.handlers import copy_text, download_text, process_images_for_display
-from ui.components import (
-    create_header, create_upload_section, create_action_button,
-    create_text_display, create_action_buttons, create_image_gallery,
-    apply_custom_css
-)
-
-__all__ = [
-    "create_interface", "copy_text", "download_text", "process_images_for_display",
-    "create_header", "create_upload_section", "create_action_button",
-    "create_text_display", "create_action_buttons", "create_image_gallery", 
-    "apply_custom_css"
-]

ui/chatterbox/check_api_health.py

@@ -1,13 +0,0 @@
-def check_api_health():
-    import requests
-    import os
-    HEALTH_ENDPOINT = os.getenv("HEALTH_ENDPOINT", "YOUR-MODAL-ENDPOINT-URL/health")
-    try:
-        response = requests.get(HEALTH_ENDPOINT, timeout=10)
-        if response.status_code == 200:
-            data = response.json()
-            return f"✅ API Status: {data.get('status', 'Unknown')} | Model Loaded: {data.get('model_loaded', False)}"
-        else:
-            return f"⚠️ API returned status code: {response.status_code}"
-    except Exception as e:
-        return f"❌ API Health Check Failed: {str(e)}"

ui/chatterbox/custom_css.py

@@ -1,9 +0,0 @@
-custom_css = """
-.gradio-container {
-    max-width: 1200px !important;
-}
-.status-box {
-    padding: 10px;
-    border-radius: 5px;
-}
-"""

ui/chatterbox/generate_sample_text.py

@@ -1,10 +0,0 @@
-def generate_sample_text():
-    import random
-    samples = [
-        "Hello! This is a test of the Chatterbox TTS system running on Modal.",
-        "The quick brown fox jumps over the lazy dog.",
-        "Welcome to the future of text-to-speech technology.",
-        "Now let's make my mum's favourite. So three mars bars into the pan. Then we add the tuna and just stir for a bit, just let the chocolate and fish infuse.",
-        "This is an example of voice cloning using artificial intelligence.",
-    ]
-    return random.choice(samples)

ui/chatterbox/generate_tts_audio.py

@@ -1,113 +0,0 @@
-def generate_tts_audio(text_input: str, audio_prompt_input, progress=None):
-    import os
-    import requests
-    import tempfile
-    import soundfile as sf
-    import numpy as np
-    import gradio as gr
-    
-    GENERATE_AUDIO_ENDPOINT = os.getenv("GENERATE_AUDIO_ENDPOINT", "YOUR-MODAL-ENDPOINT-URL/generate_audio")
-    GENERATE_WITH_FILE_ENDPOINT = os.getenv("GENERATE_WITH_FILE_ENDPOINT", "YOUR-MODAL-ENDPOINT-URL/generate_with_file")
-    
-    if not text_input or len(text_input.strip()) == 0:
-        raise gr.Error("Please enter some text to synthesize.")
-    if len(text_input) > 1000:
-        raise gr.Error("Text is too long. Maximum 1000 characters allowed.")
-    
-    if progress: progress(0.1, desc="Preparing request...")
-    
-    try:
-        if audio_prompt_input is None:
-            if progress: progress(0.3, desc="Sending request to API...")
-            payload = {"text": text_input}
-            response = requests.post(
-                GENERATE_AUDIO_ENDPOINT,
-                json=payload,
-                headers={"Content-Type": "application/json"},
-                timeout=120,
-                stream=True
-            )
-            if response.status_code != 200:
-                raise gr.Error(f"API Error: {response.status_code} - {response.text}")
-            
-            if progress: progress(0.6, desc="Streaming audio response...")
-            
-            # Get content length if available for progress tracking
-            content_length = response.headers.get('content-length')
-            if content_length:
-                content_length = int(content_length)
-            
-            bytes_downloaded = 0
-            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
-                for chunk in response.iter_content(chunk_size=8192):
-                    if chunk:
-                        temp_file.write(chunk)
-                        bytes_downloaded += len(chunk)
-                        
-                        # Update progress based on bytes downloaded
-                        if content_length and progress:
-                            download_progress = min(0.3, (bytes_downloaded / content_length) * 0.3)
-                            progress(0.6 + download_progress, desc=f"Downloading audio... ({bytes_downloaded // 1024}KB)")
-                        elif progress:
-                            # If no content length, just show bytes downloaded
-                            progress(0.6, desc=f"Downloading audio... ({bytes_downloaded // 1024}KB)")
-                            
-                temp_path = temp_file.name
-                
-            if progress: progress(0.9, desc="Processing audio...")
-            audio_data, sample_rate = sf.read(temp_path)
-            os.unlink(temp_path)
-            if progress: progress(1.0, desc="Complete!")
-            return (sample_rate, audio_data)
-            
-        else:
-            if progress: progress(0.3, desc="Preparing voice prompt...")
-            files = {'text': (None, text_input)}
-            with open(audio_prompt_input, 'rb') as f:
-                audio_content = f.read()
-            files['voice_prompt'] = ('voice_prompt.wav', audio_content, 'audio/wav')
-            
-            if progress: progress(0.5, desc="Sending request with voice cloning...")
-            response = requests.post(
-                GENERATE_WITH_FILE_ENDPOINT,
-                files=files,
-                timeout=180,
-                stream=True
-            )
-            if response.status_code != 200:
-                raise gr.Error(f"API Error: {response.status_code} - {response.text}")
-            
-            if progress: progress(0.8, desc="Streaming cloned voice response...")
-            
-            # Get content length if available for progress tracking
-            content_length = response.headers.get('content-length')
-            if content_length:
-                content_length = int(content_length)
-            
-            bytes_downloaded = 0
-            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
-                for chunk in response.iter_content(chunk_size=8192):
-                    if chunk:
-                        temp_file.write(chunk)
-                        bytes_downloaded += len(chunk)
-                        
-                        # Update progress based on bytes downloaded for voice cloning
-                        if content_length and progress:
-                            download_progress = min(0.15, (bytes_downloaded / content_length) * 0.15)
-                            progress(0.8 + download_progress, desc=f"Downloading cloned audio... ({bytes_downloaded // 1024}KB)")
-                        elif progress:
-                            progress(0.8, desc=f"Downloading cloned audio... ({bytes_downloaded // 1024}KB)")
-                            
-                temp_path = temp_file.name
-                
-            audio_data, sample_rate = sf.read(temp_path)
-            os.unlink(temp_path)
-            if progress: progress(1.0, desc="Voice cloning complete!")
-            return (sample_rate, audio_data)
-            
-    except requests.exceptions.Timeout:
-        raise gr.Error("Request timed out. The API might be under heavy load. Please try again.")
-    except requests.exceptions.ConnectionError:
-        raise gr.Error("Unable to connect to the API. Please check if the endpoint URL is correct.")
-    except Exception as e:
-        raise gr.Error(f"Error generating audio: {str(e)}")

ui/chatterbox/update_char_count.py

@@ -1,3 +0,0 @@
-def update_char_count(text):
-    count = len(text) if text else 0
-    return f"{count}/1000"

ui/components/apply_custom_css.py

@@ -1,23 +0,0 @@
-import gradio as gr
-
-def apply_custom_css() -> gr.HTML:
-    """
-    Apply custom CSS styling.
-    
-    Returns:
-        gr.HTML: HTML component with CSS styles
-    """
-    return gr.HTML("""
-    <style>
-    .gradio-container {
-        max-width: 900px !important;
-    }
-    .output-markdown {
-        font-family: 'Courier New', monospace;
-    }
-    .image-gallery-caption {
-        text-align: center;
-        font-size: 0.9em;
-    }
-    </style>
-    """)

ui/components/create_action_button.py

@@ -1,10 +0,0 @@
-import gradio as gr
-
-def create_action_button() -> gr.Button:
-    """
-    Create the extract text action button.
-    
-    Returns:
-        gr.Button: Action button component
-    """
-    return gr.Button("Extract Text & Images", variant="primary")

ui/components/create_action_buttons.py

@@ -1,14 +0,0 @@
-import gradio as gr
-from typing import Tuple
-
-def create_action_buttons() -> Tuple[gr.Button, gr.Button]:
-    """
-    Create copy and download action buttons.
-    
-    Returns:
-        Tuple[gr.Button, gr.Button]: Copy and download button components
-    """
-    copy_btn = gr.Button("📋 Copy to Clipboard")
-    download_btn = gr.Button("📥 Download as Text File")
-    
-    return copy_btn, download_btn

ui/components/create_header.py

@@ -1,25 +0,0 @@
-
-import gradio as gr
-
-def create_header() -> gr.Markdown:
-    """
-    Create the application header.
-    
-    Returns:
-        gr.Markdown: Header component
-    """
-    return gr.Markdown("""
-    # 🔍 PDF Text Extractor with AI Explanations
-    
-    Extract text and images from PDF files using Mistral AI's OCR technology, then get simple explanations for each section.
-    
-    **Instructions:**
-    1. Upload a PDF file using the file selector below
-    2. Wait for processing to complete
-    3. View the extracted text and images
-    4. Click "Generate Explanations" to get AI-powered explanations of each section
-    5. Use the Copy or Download buttons to save the extracted text or explanations
-    
-    **Supported:** PDF files up to 10MB
-    """)
-

ui/components/create_image_gallery.py

@@ -1,19 +0,0 @@
-import gradio as gr
-
-def create_image_gallery() -> gr.Gallery:
-    """
-    Create the image gallery component.
-    
-    Returns:
-        gr.Gallery: Image gallery component
-    """
-    return gr.Gallery(
-        label="Extracted Images",
-        columns=3,
-        rows=2,
-        object_fit="contain",
-        height="auto",
-        visible=True,
-        show_label=True,
-        elem_id="image_gallery"
-    )

ui/components/create_text_display.py

@@ -1,25 +0,0 @@
-import gradio as gr
-from typing import Tuple
-
-def create_text_display() -> Tuple[gr.Textbox, gr.Textbox]:
-    """
-    Create the text output and status display components.
-    
-    Returns:
-        Tuple[gr.Textbox, gr.Textbox]: Text output and status components
-    """
-    text_output = gr.Textbox(
-        label="Extracted Text", 
-        lines=10,
-        max_lines=20,
-        placeholder="Extracted text will appear here...",
-        show_copy_button=True
-    )
-    
-    status_output = gr.Textbox(
-        label="Status", 
-        lines=2,
-        placeholder="Upload a PDF to see status..."
-    )
-    
-    return text_output, status_output

ui/components/create_upload_section.py

@@ -1,14 +0,0 @@
-import gradio as gr
-
-def create_upload_section() -> gr.File:
-    """
-    Create the file upload component.
-    
-    Returns:
-        gr.File: File upload component
-    """
-    return gr.File(
-        label="Upload PDF File", 
-        file_types=[".pdf"],
-        file_count="single"
-    )

ui/handlers.py

@@ -1,104 +0,0 @@
-"""
-Event handlers for UI components.
-Contains functions that handle user interactions with the interface.
-"""
-
-import os
-import tempfile
-from typing import Optional, List, Dict, Any
-from utils.pdf_image_extractor import PDFImageExtractor
-
-def copy_text(text: str) -> str:
-    """
-    Handle Copy button click.
-    
-    Args:
-        text: Text to copy to clipboard
-        
-    Returns:
-        str: The input text (unchanged)
-    """
-    return text
-
-def download_text(text: str) -> Optional[str]:
-    """
-    Handle Download button click.
-    
-    Args:
-        text: Text to download
-        
-    Returns:
-        Optional[str]: Path to the created text file or None if text is empty
-    """
-    import tempfile
-    import os
-    
-    if not text:
-        return None
-    
-    # Create a temporary file to hold the text
-    temp_dir = tempfile.gettempdir()
-    filename = "extracted_text.txt"
-    file_path = os.path.join(temp_dir, filename)
-    
-    # Write the text to the file
-    with open(file_path, "w", encoding="utf-8") as f:
-        f.write(text)
-    
-    return file_path
-
-def process_images_for_display(images_data: List[Dict[str, Any]], pdf_path: str = None) -> List:
-    """
-    Process images for display in the Gradio gallery.
-    
-    Args:
-        images_data: List of image data dictionaries from OCR response
-        pdf_path: Path to the original PDF file for image extraction
-        
-    Returns:
-        List: List of image paths for gallery display
-    """
-    if not images_data:
-        return []
-    
-    # If we have PDF path and bounding box data, extract images from PDF
-    if pdf_path and os.path.exists(pdf_path):
-        print("🖼️ Extracting images from PDF using bounding box coordinates...")
-        extracted_paths = PDFImageExtractor.extract_images_from_pdf(pdf_path, images_data)
-        if extracted_paths:
-            return extracted_paths
-        
-        # Fallback: extract all images from PDF if bounding box extraction failed
-        print("🔄 Fallback: Extracting all images from PDF...")
-        extracted_paths = PDFImageExtractor.extract_all_images_from_pdf(pdf_path)
-        if extracted_paths:
-            return extracted_paths[:len(images_data)]  # Limit to expected number of images
-    
-    # Fallback: use base64 data from OCR response
-    print("🔄 Using base64 image data from OCR response...")
-    gallery_images = []
-    temp_dir = tempfile.gettempdir()
-    
-    for index, img_data in enumerate(images_data):
-        try:
-            # Get image base64 data
-            base64_data = img_data.get('base64', '')
-            if not base64_data:
-                continue
-                
-            # Create a temporary file to save the image
-            img_filename = f"extracted_image_fallback_{index}.jpg"
-            img_path = os.path.join(temp_dir, img_filename)
-            
-            # Convert base64 to image file
-            import base64
-            with open(img_path, "wb") as img_file:
-                img_file.write(base64.b64decode(base64_data))
-            
-            # Add path to gallery list (Gradio Gallery expects a list of paths)
-            gallery_images.append(img_path)
-            
-        except Exception as e:
-            print(f"Error processing image {index}: {str(e)}")
-    
-    return gallery_images

ui/interface.py

@@ -1,223 +0,0 @@
-"""
-Interface creation module for PDF Text Extractor.
-Defines the Gradio interface components and layout.
-"""
-
-import gradio as gr
-from gradio_pdf import PDF
-from pdf_text_extractor import PDFTextExtractor
-from ui.handlers import process_images_for_display
-from .components.create_header import create_header
-from .components.create_upload_section import create_upload_section
-from .components.create_action_button import create_action_button
-from .components.create_image_gallery import create_image_gallery
-from .components.apply_custom_css import apply_custom_css
-from .chatterbox.generate_tts_audio import generate_tts_audio
-
-def create_dummy_interface() -> gr.Blocks:
-    """
-    Create a simple interface for when the API key is not configured.
-    
-    Returns:
-        gr.Blocks: Gradio interface with disabled functionality
-    """
-    with gr.Blocks(title="PDF Text Extractor") as interface:
-        gr.Markdown("""
-        # 🔍 PDF Text Extractor
-        
-        ⚠️ **API key not configured.** Please set MISTRAL_API_KEY environment variable and restart the application.
-        """)
-        
-        # Create layout similar to main interface but disabled
-        with gr.Row(equal_height=True):
-            # Left column - PDF Display
-            with gr.Column(scale=1):
-                gr.Markdown("### 📄 PDF Document")
-                PDF(
-                    label="Upload and View PDF (Disabled)",
-                    height=700,
-                    interactive=False
-                )
-                
-                gr.Textbox(
-                    label="Status", 
-                    lines=2,
-                    value="❌ MISTRAL_API_KEY environment variable is not set. Please set it and restart the application.",
-                    interactive=False
-                )
-            
-            # Right column - Extracted Content
-            with gr.Column(scale=1):
-                gr.Markdown("### 📝 Extracted Content")
-                
-                gr.Textbox(
-                    label="Extracted Text", 
-                    lines=25,
-                    value="API key not configured. Text extraction is unavailable.",
-                    interactive=False
-                )
-    
-    return interface
-
-def create_main_interface(extractor: PDFTextExtractor) -> gr.Blocks:
-    """
-    Create the main application interface.
-    
-    Args:
-        extractor: PDFTextExtractor instance
-        
-    Returns:
-        gr.Blocks: Gradio interface with full functionality
-    """
-    
-    def process_pdf_wrapper(pdf_file):
-        """Process PDF with the extractor from closure"""
-        extracted_text, status, images_data = extractor.extract_text_from_pdf(pdf_file)
-        # Get PDF file path for image extraction
-        pdf_path = pdf_file.name if hasattr(pdf_file, 'name') else pdf_file if pdf_file else None
-        gallery_images = process_images_for_display(images_data, pdf_path)
-        return extracted_text, status, gallery_images
-    
-    def generate_explanations_wrapper(extracted_text):
-        """Generate explanations for extracted text"""
-        if not extracted_text or extracted_text.strip() == "":
-            return "No text available to explain. Please extract text from a PDF first."
-        
-        explanations = extractor.generate_explanations(extracted_text)
-        # The explanation_status is now implicitly handled by the content of 'explanations'
-        return explanations
-    
-    def generate_explanation_audio_wrapper(explanations_text):
-        """Generate TTS audio for explanations using Chatterbox API"""
-        if not explanations_text or explanations_text.strip() == "":
-            raise gr.Error("No explanations available to convert to audio. Please generate explanations first.")
-        
-        # Clean up the text for better TTS
-        clean_text = explanations_text.strip()
-        
-        # Limit text length for TTS (Chatterbox has a 1000 character limit)
-        if len(clean_text) > 1000:
-            # Truncate at sentence boundary if possible
-            sentences = clean_text[:950].split('.')
-            if len(sentences) > 1:
-                clean_text = '.'.join(sentences[:-1]) + '.'
-            else:
-                clean_text = clean_text[:950]
-            clean_text += " [Text has been truncated for audio generation]"
-        
-        # Call the TTS function directly - it already handles gr.Error exceptions properly
-        return generate_tts_audio(clean_text, None)
-    def tts_click_handler(explanations_text):
-        """Handle TTS button click with proper output handling"""
-        try:
-            audio_result = generate_explanation_audio_wrapper(explanations_text)
-            return audio_result, gr.update(visible=True)
-        except gr.Error:
-            # Re-raise Gradio errors as-is (they're already properly formatted)
-            raise
-        except Exception as e:
-            # Only wrap non-Gradio exceptions
-            raise gr.Error(f"Unexpected error generating audio: {str(e)}")
-    
-    with gr.Blocks(title="🔍 PDF Text Extractor", theme=gr.themes.Soft()) as interface:
-        # Add the header
-        create_header()
-        
-        # Create main layout with PDF on left and content on right
-        with gr.Row(equal_height=True):
-            # Left column - PDF Display
-            with gr.Column(scale=1):
-                gr.Markdown("### 📄 PDF Document")
-                pdf_input = PDF(
-                    label="Upload and View PDF",
-                    height=700,
-                    interactive=True
-                )
-                
-                # Status display below PDF
-                status_output = gr.Textbox(
-                    label="Status", 
-                    lines=2,
-                    placeholder="Upload a PDF to see status...",
-                    interactive=False
-                )
-            
-            # Right column - Extracted Content
-            with gr.Column(scale=1):
-                gr.Markdown("### 📝 Extracted Content")
-                
-                # Create tabs for text, explanations, and images
-                with gr.Tabs():
-                    with gr.TabItem("Extracted Text"):
-                        text_output = gr.Textbox(
-                            label="Extracted Text", 
-                            lines=25,
-                            max_lines=30,
-                            placeholder="Upload a PDF to automatically extract text...",
-                            show_copy_button=True
-                        )
-                    
-                    with gr.TabItem("📚 Explanations"):
-                        with gr.Row():
-                            explain_btn = gr.Button("🤖 Generate Explanations", variant="secondary", size="lg")
-                            tts_btn = gr.Button("🔊 Generate Audio", variant="secondary", size="lg")
-                        
-                        explanations_output = gr.Textbox(
-                            label="Text Explanations", 
-                            lines=20,
-                            max_lines=25,
-                            placeholder="Click 'Generate Explanations' after extracting text to get simple explanations of each section...",
-                            show_copy_button=True
-                        )
-                        
-                        # Add audio output for explanations
-                        explanation_audio_output = gr.Audio(
-                            label="Explanation Audio",
-                            interactive=False,
-                            visible=False
-                        )
-
-                    with gr.TabItem("Extracted Images"):
-                        image_gallery = create_image_gallery()
-                        image_info = gr.Markdown("Images extracted from the PDF will appear here.")        
-        # Set up automatic PDF processing on upload
-        pdf_input.upload(
-            fn=process_pdf_wrapper,
-            inputs=[pdf_input],
-            outputs=[text_output, status_output, image_gallery]
-        )
-        
-        # Handle explanation generation
-        explain_btn.click(
-            fn=generate_explanations_wrapper,
-            inputs=[text_output],
-            outputs=[explanations_output], # Removed explanation_status from outputs
-            show_progress=True
-        )
-        
-        # Handle TTS generation for explanations
-        tts_btn.click(
-            fn=tts_click_handler,
-            inputs=[explanations_output],
-            outputs=[explanation_audio_output, explanation_audio_output],
-            show_progress=True
-        )
-        # Apply custom CSS styling
-        apply_custom_css()
-    
-    return interface
-
-def create_interface() -> gr.Blocks:
-    """
-    Create and configure the Gradio interface.
-    
-    Returns:
-        gr.Blocks: Configured Gradio interface
-    """
-    # Initialize the PDF extractor
-    try:
-        extractor = PDFTextExtractor()
-        return create_main_interface(extractor)
-    except ValueError as e:
-        # Create a dummy interface if API key is missing
-        return create_dummy_interface()

utils/__init__.py

@@ -1,5 +0,0 @@
-"""Utility functions for PDF Text Extractor."""
-from utils.config import check_api_key, get_app_config
-from utils.text_explainer import TextExplainer
-
-__all__ = ["check_api_key", "get_app_config", "TextExplainer"]

utils/config.py

@@ -1,40 +0,0 @@
-"""
-Configuration utilities for PDF Text Extractor.
-Contains functions for handling environment variables and app configuration.
-"""
-
-import os
-from typing import Dict, Any
-
-def check_api_key() -> bool:
-    """
-    Check if the Mistral API key is set in environment variables.
-    
-    Returns:
-        bool: True if API key is set, False otherwise
-    """
-    api_key = os.environ.get("MISTRAL_API_KEY")
-    if not api_key:
-        print("⚠️  Warning: MISTRAL_API_KEY environment variable is not set.")
-        print("   Please set it before using the PDF extraction functionality.")
-        print("   Example: export MISTRAL_API_KEY='your-api-key-here'")
-        print()
-        return False
-    return True
-
-def get_app_config() -> Dict[str, Any]:
-    """
-    Get application configuration settings.
-    
-    Returns:
-        Dict[str, Any]: Application configuration settings
-    """
-    return {
-        "server_port": 7862,       # Use a different port to avoid conflicts
-        "debug": True,             # Enable debug mode for development
-        "quiet": False,            # Show startup messages
-        "max_file_size": "10mb"    # Limit PDF file size
-        # Uncomment the following to enable external access and public link sharing:
-        # "server_name": "0.0.0.0",  # Allow external access
-        # "share": True,            # Create public link
-    }

utils/pdf_image_extractor.py

@@ -1,155 +0,0 @@
-"""
-PDF Image Extraction utilities.
-Extracts images from PDF using bounding box coordinates.
-"""
-
-import os
-import tempfile
-from typing import List, Dict, Any, Optional
-import fitz  # PyMuPDF
-from PIL import Image
-import base64
-import io
-
-
-class PDFImageExtractor:
-    """Extract images from PDF using bounding box coordinates."""
-    
-    @staticmethod
-    def extract_images_from_pdf(pdf_path: str, images_data: List[Dict[str, Any]]) -> List[str]:
-        """
-        Extract images from PDF using bounding box coordinates.
-        
-        Args:
-            pdf_path: Path to the PDF file
-            images_data: List of image data with bounding box coordinates
-            
-        Returns:
-            List[str]: List of paths to extracted image files
-        """
-        if not images_data:
-            return []
-        
-        try:
-            # Open the PDF document
-            pdf_doc = fitz.open(pdf_path)
-            extracted_image_paths = []
-            temp_dir = tempfile.gettempdir()
-            
-            for index, img_data in enumerate(images_data):
-                try:
-                    page_num = img_data.get('page', 0)
-                    
-                    # Ensure page number is valid
-                    if page_num >= len(pdf_doc):
-                        print(f"Warning: Page {page_num} not found in PDF (max: {len(pdf_doc)-1})")
-                        continue
-                    
-                    # Get the page
-                    page = pdf_doc[page_num]
-                    
-                    # Get bounding box coordinates
-                    top_left_x = img_data.get('top_left_x', 0)
-                    top_left_y = img_data.get('top_left_y', 0)
-                    bottom_right_x = img_data.get('bottom_right_x', 0)
-                    bottom_right_y = img_data.get('bottom_right_y', 0)
-                    
-                    # Create a rectangle for the bounding box
-                    # PyMuPDF uses (x0, y0, x1, y1) format
-                    bbox = fitz.Rect(top_left_x, top_left_y, bottom_right_x, bottom_right_y)
-                    
-                    # Render the page as a pixmap with high resolution
-                    mat = fitz.Matrix(2.0, 2.0)  # 2x zoom for better quality
-                    pix = page.get_pixmap(matrix=mat, clip=bbox)
-                    
-                    # Convert pixmap to PIL Image
-                    img_data_bytes = pix.tobytes("png")
-                    img = Image.open(io.BytesIO(img_data_bytes))
-                    
-                    # Save the image to a temporary file
-                    img_filename = f"extracted_image_page{page_num}_{index}.png"
-                    img_path = os.path.join(temp_dir, img_filename)
-                    img.save(img_path, "PNG")
-                    
-                    extracted_image_paths.append(img_path)
-                    print(f"✅ Extracted image {index} from page {page_num}: {img_path}")
-                    
-                except Exception as e:
-                    print(f"Error extracting image {index}: {str(e)}")
-                    
-                    # Fallback: try to use base64 data if available
-                    base64_data = img_data.get('base64', '')
-                    if base64_data:
-                        try:
-                            img_filename = f"extracted_image_base64_{index}.jpg"
-                            img_path = os.path.join(temp_dir, img_filename)
-                            
-                            with open(img_path, "wb") as img_file:
-                                img_file.write(base64.b64decode(base64_data))
-                            
-                            extracted_image_paths.append(img_path)
-                            print(f"✅ Used base64 data for image {index}: {img_path}")
-                        except Exception as e2:
-                            print(f"Error using base64 data for image {index}: {str(e2)}")
-            
-            pdf_doc.close()
-            return extracted_image_paths
-            
-        except Exception as e:
-            print(f"Error opening PDF file: {str(e)}")
-            return []
-    
-    @staticmethod
-    def extract_all_images_from_pdf(pdf_path: str) -> List[str]:
-        """
-        Extract all images from PDF without using bounding boxes.
-        This is a fallback method when no bounding box data is available.
-        
-        Args:
-            pdf_path: Path to the PDF file
-            
-        Returns:
-            List[str]: List of paths to extracted image files
-        """
-        try:
-            pdf_doc = fitz.open(pdf_path)
-            extracted_image_paths = []
-            temp_dir = tempfile.gettempdir()
-            
-            for page_num in range(len(pdf_doc)):
-                page = pdf_doc[page_num]
-                image_list = page.get_images()
-                
-                for img_index, img in enumerate(image_list):
-                    try:
-                        # Get image data
-                        xref = img[0]
-                        pix = fitz.Pixmap(pdf_doc, xref)
-                        
-                        # Convert to PNG if CMYK
-                        if pix.n - pix.alpha < 4:  # GRAY or RGB
-                            img_data = pix.tobytes("png")
-                        else:  # CMYK: convert to RGB first
-                            pix1 = fitz.Pixmap(fitz.csRGB, pix)
-                            img_data = pix1.tobytes("png")
-                            pix1 = None
-                        
-                        # Save image
-                        img_filename = f"all_images_page{page_num}_img{img_index}.png"
-                        img_path = os.path.join(temp_dir, img_filename)
-                        
-                        with open(img_path, "wb") as f:
-                            f.write(img_data)
-                        
-                        extracted_image_paths.append(img_path)
-                        pix = None
-                        
-                    except Exception as e:
-                        print(f"Error extracting image {img_index} from page {page_num}: {str(e)}")
-            
-            pdf_doc.close()
-            return extracted_image_paths
-            
-        except Exception as e:
-            print(f"Error extracting all images from PDF: {str(e)}")
-            return []

utils/text_explainer.py

@@ -1,341 +0,0 @@
-"""
-Text Explanation utilities using Mistral AI.
-Splits text by markdown headings and generates contextual explanations for each section.
-Maintains chat history to provide coherent explanations that build upon previous sections.
-"""
-
-import os
-import re
-from typing import List, Dict, Tuple, Optional
-from mistralai import Mistral
-
-
-class TextExplainer:
-    """Generate explanations for text sections using Mistral AI."""
-    
-    def __init__(self):
-        """Initialize the text explainer with Mistral AI client."""
-        self.api_key = os.environ.get("MISTRAL_API_KEY")
-        if not self.api_key:
-            raise ValueError("MISTRAL_API_KEY environment variable is required")
-        self.client = Mistral(api_key=self.api_key)
-        self.chat_history = []
-
-    def get_topic(self, text: str) -> Optional[str]:
-        """
-        Extract the main topic from the text using Mistral AI with structured output.
-        
-        Args:
-            text: Input text to analyze
-            
-        Returns:
-            Main topic as a string or None if not found
-        """
-        try:
-            # Define the JSON schema for structured output
-            topic_schema = {
-                "type": "json_schema",
-                "json_schema": {
-                    "schema": {
-                        "type": "object",
-                        "properties": {
-                            "main_topic": {
-                                "type": "string",
-                                "title": "Main Topic",
-                                "description": "The primary / general topic or subject of the text"
-                            },
-                        },
-                        "required": ["main_topic"],
-                        "additionalProperties": False
-                    },
-                    "name": "topic_extraction",
-                    "strict": True
-                }
-            }
-            
-            response = self.client.chat.complete(
-                model="ministral-8b-2410",  # Using a more recent model that supports structured output
-                messages=[
-                    {
-                        "role": "system",
-                        "content": "You are an expert in summarizing texts. Extract the main topic from the provided text."
-                    },
-                    {
-                        "role": "user",
-                        "content": f"Analyze this text and extract the main topic:\n\n{text[:2000]}..."  # Limit to first 2000 characters for performance
-                    }
-                ],
-                temperature=0.3,  # Lower temperature for more consistent structured output
-                max_tokens=200,
-                response_format=topic_schema
-            )
-            
-            if hasattr(response, 'choices') and response.choices:
-                # Parse the structured JSON response
-                import json
-                try:
-                    topic_data = json.loads(response.choices[0].message.content)
-                    main_topic = topic_data.get("main_topic", "").strip()
-                    confidence = topic_data.get("confidence", 0.0)
-                    secondary_topics = topic_data.get("secondary_topics", [])
-                    
-                    # Log the structured output for debugging
-                    print(f"📊 Topic extraction - Main: '{main_topic}', Confidence: {confidence:.2f}")
-                    if secondary_topics:
-                        print(f"🔍 Secondary topics: {', '.join(secondary_topics)}")
-                    
-                    return main_topic if main_topic else None
-                except json.JSONDecodeError as json_err:
-                    print(f"Error parsing JSON response: {json_err}")
-                    # Fallback to raw content if JSON parsing fails
-                    return response.choices[0].message.content.strip()
-            return None
-        except Exception as e:
-            print(f"Error extracting topic: {str(e)}")
-            return None
-
-    def split_text_by_headings(self, text: str) -> List[Dict[str, str]]:
-        """
-        Split text into sections based on markdown headings.
-        
-        Args:
-            text: Input text with markdown headings
-            
-        Returns:
-            List of dictionaries with 'heading' and 'content' keys
-        """
-        if not text:
-            return []
-        
-        # Split by markdown headings (# ## ### etc.)
-        sections = []
-        
-        # Regex to find headings and their content
-        # Matches: # Heading, ## Heading, ### Heading, etc.
-        heading_pattern = r'^(#{1,6})\s+(.+?)$'
-        
-        lines = text.split('\n')
-        current_heading = None
-        current_content = []
-        current_level = 0
-        
-        for line in lines:
-            heading_match = re.match(heading_pattern, line.strip())
-            
-            if heading_match:
-                # Save previous section if it exists
-                if current_heading and current_content:
-                    content_text = '\n'.join(current_content).strip()
-                    if content_text:  # Only add if there's actual content
-                        sections.append({
-                            'heading': current_heading,
-                            'content': content_text,
-                            'level': current_level
-                        })
-                
-                # Start new section
-                level = len(heading_match.group(1))  # Count the # characters
-                current_heading = heading_match.group(2).strip()
-                current_level = level
-                current_content = []
-            else:
-                # Add line to current content if we have a heading
-                if current_heading is not None:
-                    current_content.append(line)
-        
-        # Don't forget the last section
-        if current_heading and current_content:
-            content_text = '\n'.join(current_content).strip()
-            if content_text:
-                sections.append({
-                    'heading': current_heading,
-                    'content': content_text,
-                    'level': current_level
-                })
-        
-        # If no headings found, treat entire text as one section
-        if not sections and text.strip():
-            sections.append({
-                'heading': 'Document Content',
-                'content': text.strip(),
-                'level': 1
-            })
-        return sections
-
-    def generate_explanation(self, topic: str, heading: str, content: str, section_number: int = 1, total_sections: int = 1) -> str:
-        """
-        Generate an explanation for a text section using Mistral AI with chat history context.
-        
-        Args:
-            topic: General topic of the document
-            heading: Section heading
-            content: Section content
-            section_number: Current section number (for context)
-            total_sections: Total number of sections (for context)
-            
-        Returns:
-            Generated explanation in simple terms
-        """
-        try:
-            # Build the current user message
-            prompt = f"""
-            **Section {section_number} of {total_sections}**
-            **Section Heading:** {heading}
-
-            **Section Content:**
-            {content}
-
-            **Your Explanation:**"""
-
-            # If this is the first section, initialize with system prompt
-            if section_number == 1:
-                system_prompt = f"""You are an expert teacher who explains complex topics in simple, easy-to-understand terms.
-
-                I will give you sections of text with their headings on the topic of "{topic}", and I want you to explain what each section is about in simple language, by breaking down any complex concepts or terminology. You should also explain why this information might be important or useful, use examples or analogies when helpful, and keep the explanation engaging and educational.
-
-                Make your explanation clear enough for someone without prior knowledge of the topic to understand. As you explain each section, consider how it relates to the previous sections you've already explained to provide coherent, contextual explanations throughout the document.
-
-                Do not mention anything far irrelevant from the topic of "{topic}". Do not repeat information unnecessarily, but build on previous explanations to create a comprehensive understanding of the topic. Avoid using the term 'section' and use the actual section heading instead. No need to mention the section number in your explanation.
-                """
-                
-                # Initialize chat history with system message
-                self.chat_history = [
-                    {
-                        "role": "system",
-                        "content": system_prompt
-                    }
-                ]
-
-            # Check if content is too small (less than 200 characters)
-            if len(content) < 200:
-                print(f"📋 Skipping API call for short content in '{heading}' ({len(content)} chars < 200)")
-                # Add the user prompt to chat history for context in subsequent queries
-                self.chat_history.append({
-                    "role": "user",
-                    "content": prompt
-                })
-                # Return a simple message indicating the content was too short
-                return f"This section contains minimal content ({len(content)} characters). The information has been noted for context in subsequent explanations."
-
-            # Add the current user message to chat history
-            self.chat_history.append({
-                "role": "user",
-                "content": prompt
-            })
-
-            # Call Mistral AI for explanation with full chat history
-            response = self.client.chat.complete(
-                model="mistral-small-2503",
-                messages=self.chat_history,
-                temperature=0.7,  # Some creativity but still focused
-                # max_tokens=1000   # Reasonable explanation length
-            )
-            
-            # Extract the explanation from response
-            if hasattr(response, 'choices') and response.choices:
-                explanation = response.choices[0].message.content
-                
-                # Add the assistant's response to chat history
-                self.chat_history.append({
-                    "role": "assistant",
-                    "content": explanation
-                })
-                
-                return explanation.strip()
-            else:
-                return f"Could not generate explanation for section: {heading}"
-        
-        except Exception as e:
-            print(f"Error generating explanation for '{heading}': {str(e)}")
-            return f"Error generating explanation for this section: {str(e)}"
-        
-    def explain_all_sections(self, text: str) -> List[Dict[str, str]]:
-        """
-        Split text by headings and generate explanations for all sections with chat history context.
-        
-        Args:
-            text: Input text with markdown headings
-            
-        Returns:
-            List of dictionaries with 'heading', 'content', 'explanation', and 'level' keys
-        """
-        sections = self.split_text_by_headings(text)
-        
-        if not sections:
-            return []
-        
-        print(f"🔍 Found {len(sections)} sections to explain...")
-        
-        # Extract the main topic from the text
-        print("🎯 Extracting main topic...")
-        topic = self.get_topic(text)
-        if topic:
-            print(f"📋 Main topic identified: {topic}")
-        else:
-            topic = "General Content"  # Fallback topic
-            print("⚠️ Could not identify main topic, using fallback")
-        
-        # Reset chat history for new document
-        self.chat_history = []
-        
-        explained_sections = []
-        
-        for i, section in enumerate(sections, 1):
-            print(f"📝 Generating explanation for section {i}/{len(sections)}: {section['heading'][:50]}...")
-            
-            # Pass topic, section content, and context information
-            explanation = self.generate_explanation(
-                topic,
-                section['heading'], 
-                section['content'], 
-                section_number=i, 
-                total_sections=len(sections)
-            )
-            
-            explained_sections.append({
-                'heading': section['heading'],
-                'content': section['content'],
-                'explanation': explanation,
-                'level': section['level']
-            })
-        
-        print(f"✅ Generated explanations for all {len(explained_sections)} sections")
-        return explained_sections
-    
-    def reset_chat_history(self):
-        """Reset the chat history for a new document or conversation."""
-        self.chat_history = []
-    
-    def get_chat_history(self) -> List[Dict[str, str]]:
-        """Get the current chat history for debugging purposes."""
-        return self.chat_history.copy()
-    
-    def get_chat_history_summary(self) -> str:
-        """Get a summary of the current chat history."""
-        if not self.chat_history:
-            return "No chat history available."
-        
-        summary = f"Chat history contains {len(self.chat_history)} messages:\n"
-        for i, message in enumerate(self.chat_history, 1):
-            role = message['role']
-            content_preview = message['content'][:100] + "..." if len(message['content']) > 100 else message['content']
-            summary += f"{i}. {role.upper()}: {content_preview}\n"
-        
-        return summary
-
-    def format_explanations_for_display(self, explained_sections: List[Dict[str, str]]) -> str:
-        """
-        Concatenate only the explanations from all sections for display, filtering out placeholder explanations for minimal content.
-        Args:
-            explained_sections: List of sections with explanations
-        Returns:
-            Concatenated explanations as a single string
-        """
-        if not explained_sections:
-            return "No sections found to explain."
-        skip_phrase = "This section contains minimal content"
-        return "\n\n".join(
-            section['explanation']
-            for section in explained_sections
-            if section.get('explanation') and not section['explanation'].strip().startswith(skip_phrase)
-        )