Upload 3 files

Dockerfile.dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.9-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    poppler-utils \
+    libgl1-mesa-glx \
+    fonts-dejavu \
+    fonts-liberation \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app code
+COPY app.py .
+
+# Expose port
+EXPOSE 7860
+
+# Run the app
+CMD ["python", "app.py"]

app.py

@@ -4,6 +4,8 @@ from pdf2image import convert_from_path
 from PIL import Image, ImageDraw, ImageFont
 import json
 import tempfile
+import subprocess
+import sys
 
 # Colors for annotations
 PARA_COLOR = (255, 0, 0)    # Red for paragraph
@@ -15,6 +17,64 @@ paragraph_data = {}
 current_display_data = {}
 temp_files = []
 
+def get_poppler_path():
+    """Find poppler path in common locations"""
+    possible_paths = [
+        '/usr/bin',
+        '/usr/local/bin',
+        '/bin',
+        '/opt/homebrew/bin',  # macOS
+        '/usr/lib/x86_64-linux-gnu',  # Ubuntu/Debian
+    ]
+    
+    for path in possible_paths:
+        pdftoppm_path = os.path.join(path, 'pdftoppm')
+        if os.path.exists(pdftoppm_path):
+            return path
+    
+    # Try to find it using which
+    try:
+        result = subprocess.run(['which', 'pdftoppm'], 
+                              capture_output=True, text=True)
+        if result.returncode == 0:
+            return os.path.dirname(result.stdout.strip())
+    except:
+        pass
+    
+    return None
+
+def convert_pdf_to_images(pdf_path, dpi=150):
+    """Convert PDF to images with explicit poppler path"""
+    poppler_path = get_poppler_path()
+    
+    print(f"DEBUG: Looking for poppler...")
+    print(f"DEBUG: PDF path: {pdf_path}")
+    print(f"DEBUG: Poppler path found: {poppler_path}")
+    
+    # Check if poppler tools exist
+    if poppler_path:
+        pdftoppm_path = os.path.join(poppler_path, 'pdftoppm')
+        print(f"DEBUG: pdftoppm path: {pdftoppm_path}")
+        print(f"DEBUG: Exists: {os.path.exists(pdftoppm_path)}")
+    
+    try:
+        if poppler_path and os.path.exists(os.path.join(poppler_path, 'pdftoppm')):
+            print(f"DEBUG: Using poppler path: {poppler_path}")
+            images = convert_from_path(
+                pdf_path, 
+                dpi=dpi,
+                poppler_path=poppler_path
+            )
+        else:
+            print(f"DEBUG: Trying without explicit poppler path")
+            images = convert_from_path(pdf_path, dpi=dpi)
+        
+        print(f"DEBUG: Successfully converted PDF, got {len(images)} pages")
+        return images
+    except Exception as e:
+        print(f"DEBUG: PDF conversion error: {str(e)}")
+        raise Exception(f"PDF conversion failed: {str(e)}")
+
 def cleanup_temp_files():
     """Clean up temporary files"""
     global temp_files
@@ -38,7 +98,24 @@ def draw_paragraphs_and_dates(page_img, paragraphs, hover_para_id=None, font_sca
     """Draw annotations with optional hover highlighting"""
     draw = ImageDraw.Draw(page_img)
     try:
-        font = ImageFont.truetype("arial.ttf", 12 * font_scale)
+        # Try different font paths
+        font_paths = [
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+            "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
+            "/usr/share/fonts/truetype/freefont/FreeSans.ttf",
+        ]
+        
+        font = None
+        for font_path in font_paths:
+            if os.path.exists(font_path):
+                try:
+                    font = ImageFont.truetype(font_path, 12 * font_scale)
+                    break
+                except:
+                    continue
+        
+        if font is None:
+            font = ImageFont.load_default()
     except:
         font = ImageFont.load_default()
     
@@ -67,10 +144,15 @@ def annotate_pdf_paragraphs(pdf_path, json_path, img_dpi=150):
     """Load PDF and JSON, prepare data for display"""
     global paragraph_data
     
+    print(f"DEBUG: Starting PDF annotation")
+    print(f"DEBUG: PDF: {pdf_path}")
+    print(f"DEBUG: JSON: {json_path}")
+    
     with open(json_path, "r") as f:
         data = json.load(f)
+        print(f"DEBUG: JSON loaded successfully, keys: {list(data.keys())[:3]}")
     
-    pages = convert_from_path(pdf_path, dpi=img_dpi)
+    pages = convert_pdf_to_images(pdf_path, dpi=img_dpi)
     pdf_name = os.path.splitext(os.path.basename(pdf_path))[0]
     
     paragraph_data = {}
@@ -110,6 +192,7 @@ def annotate_pdf_paragraphs(pdf_path, json_path, img_dpi=150):
         annotated_img = draw_paragraphs_and_dates(page_img.copy(), paragraphs)
         annotated_pages.append(annotated_img)
     
+    print(f"DEBUG: Annotation complete, {len(annotated_pages)} pages processed")
     return annotated_pages, data, len(pages)
 
 def get_page_text_html(page_num, highlight_id=None):
@@ -130,14 +213,14 @@ def get_page_text_html(page_num, highlight_id=None):
         text = para['text']
         dates = para['dates']
         
-        # Simple hover style
+        # Simple highlight style
         if str(para_id) == str(highlight_id):
-            style = "background-color: #fff3cd; padding: 10px; margin: 5px; border-left: 4px solid #ffc107;"
+            style = "background-color: #fff3cd; padding: 10px; margin: 5px; border-left: 4px solid #ffc107; cursor: pointer;"
         else:
-            style = "background-color: #f8f9fa; padding: 10px; margin: 5px; border-left: 2px solid #ddd;"
+            style = "background-color: #f8f9fa; padding: 10px; margin: 5px; border-left: 2px solid #ddd; cursor: pointer;"
         
         html_parts.append(f"""
-        <div style="{style}" class="para-{para_id}" data-page="{page_num}" data-para="{para_id}">
+        <div style="{style}" onclick="highlightParagraph({page_num}, {para_id})">
             <div style="font-weight: bold; color: #d9534f; margin-bottom: 5px;">
                 Paragraph {para_id}
             </div>
@@ -174,6 +257,19 @@ def get_page_text_html(page_num, highlight_id=None):
         
         html_parts.append("</div>")
     
+    # Add JavaScript for highlighting
+    html_parts.append("""
+    <script>
+    function highlightParagraph(pageNum, paraId) {
+        // Create a custom event to trigger Python function
+        const event = new CustomEvent('highlightPara', { 
+            detail: { page: pageNum, para: paraId }
+        });
+        window.dispatchEvent(event);
+    }
+    </script>
+    """)
+    
     return "".join(html_parts)
 
 def update_image_with_hover(page_num, hover_para_id):
@@ -204,12 +300,12 @@ def update_image_with_hover(page_num, hover_para_id):
     temp_path = create_temp_image(highlighted_img)
     return temp_path
 
-# Gradio App - Simplified version
-with gr.Blocks(title="PDF Annotation Viewer") as app:
-    gr.Markdown("## PDF Annotation Viewer")
-    gr.Markdown("Upload a PDF and JSON file to view annotations.")
+# Create the Gradio app
+with gr.Blocks(title="PDF Annotation Viewer", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# PDF Annotation Viewer")
+    gr.Markdown("Upload a PDF file and its corresponding JSON annotations to view highlighted paragraphs and dates.")
     
-    # Store current state
+    # State variables
     state_pages = gr.State()
     state_data = gr.State()
     state_total_pages = gr.State(1)
@@ -217,56 +313,53 @@ with gr.Blocks(title="PDF Annotation Viewer") as app:
     state_current_hover = gr.State(None)
     
     with gr.Row():
-        with gr.Column():
-            pdf_file = gr.File(label="PDF Journal", type="filepath")
-            json_file = gr.File(label="JSON Predictions", type="filepath")
-            apply_btn = gr.Button("Load & Annotate", variant="primary")
+        with gr.Column(scale=1):
+            pdf_file = gr.File(label="PDF File", file_types=[".pdf"])
+            json_file = gr.File(label="JSON File", file_types=[".json"])
+            load_btn = gr.Button("Load Files", variant="primary")
     
     with gr.Row():
-        # Left side: Image display
+        # Image display
         with gr.Column(scale=2):
             with gr.Row():
-                prev_btn = gr.Button("◀ Previous")
-                page_counter = gr.Number(
-                    label="Page", 
-                    value=1, 
-                    minimum=1,
-                    interactive=True,
-                    precision=0
-                )
-                next_btn = gr.Button("Next ▶")
-                total_pages = gr.Textbox("1", label="of", interactive=False)
+                prev_btn = gr.Button("← Previous", size="sm")
+                page_num = gr.Number(value=1, label="Page", minimum=1, interactive=True)
+                next_btn = gr.Button("Next →", size="sm")
+                total_pages_disp = gr.Textbox("1", label="of", interactive=False)
             
-            page_display = gr.Image(
+            image_display = gr.Image(
                 label="Annotated Page",
                 type="filepath",
                 height=600
             )
         
-        # Right side: Text display
+        # Text display
         with gr.Column(scale=1):
             text_display = gr.HTML(
-                label="Paragraph Text with Dates",
+                label="Paragraphs with Dates",
                 value="<div style='padding: 20px; text-align: center; color: #666;'>Upload files to begin</div>"
             )
     
-    # Hidden inputs for hover
-    hover_page = gr.Number(visible=False, value=1)
-    hover_para = gr.Textbox(visible=False)
+    # Hidden input for hover
+    hover_input = gr.Textbox(visible=False)
     
     # Main load function
-    def load_pdf_and_json(pdf_file_obj, json_file_obj):
+    def load_files(pdf_file_obj, json_file_obj):
         """Load and process files"""
         cleanup_temp_files()
         
         if not pdf_file_obj or not json_file_obj:
-            return [None, None, 1, 1, "1", None, 
-                   "<div>Please upload both files</div>", None]
-        
-        pdf_path = pdf_file_obj.name
-        json_path = json_file_obj.name
+            return [None, None, 1, "1", 
+                   "<div style='color: #666; text-align: center; padding: 20px;'>Please upload both files</div>", 
+                   None, None, None]
         
         try:
+            pdf_path = pdf_file_obj.name
+            json_path = json_file_obj.name
+            
+            print(f"Processing PDF: {pdf_path}")
+            print(f"Processing JSON: {json_path}")
+            
             # Annotate PDF
             pages, data, total_pages = annotate_pdf_paragraphs(pdf_path, json_path)
             
@@ -285,14 +378,18 @@ with gr.Blocks(title="PDF Annotation Viewer") as app:
             # Get text for first page
             text_html = get_page_text_html(1)
             
-            return [pages, data, total_pages, 1, 
-                    str(total_pages), first_page_path, text_html, None]
+            print(f"Successfully loaded: {total_pages} pages")
+            
+            return [pages, data, total_pages, str(total_pages), 
+                    first_page_path, text_html, None, 1]
+            
         except Exception as e:
-            return [None, None, 1, 1, "1", None, 
-                   f"<div style='color: red;'>Error: {str(e)}</div>", None]
+            error_msg = f"<div style='color: red; padding: 20px;'><b>Error:</b> {str(e)}</div>"
+            print(f"Error loading files: {str(e)}")
+            return [None, None, 1, "1", None, error_msg, None, 1]
     
     # Page navigation
-    def navigate_page(direction, current_page, total_pages):
+    def navigate_page(direction, current_page, total_pages, hover_id):
         current_page = int(current_page)
         total_pages = int(total_pages)
         
@@ -304,98 +401,103 @@ with gr.Blocks(title="PDF Annotation Viewer") as app:
             new_page = current_page
         
         # Get text for new page
-        text_html = get_page_text_html(new_page)
+        text_html = get_page_text_html(new_page, hover_id)
         
         # Update image
         if current_display_data and 'pages' in current_display_data:
             pages = current_display_data['pages']
             if 0 < new_page <= len(pages):
-                temp_path = create_temp_image(pages[new_page - 1])
-                return [temp_path, text_html, new_page, new_page]
+                if hover_id:
+                    temp_path = update_image_with_hover(new_page, hover_id)
+                else:
+                    temp_path = create_temp_image(pages[new_page - 1])
+                return [temp_path, text_html, new_page, new_page, hover_id]
         
-        return [None, text_html, new_page, new_page]
+        return [None, text_html, new_page, new_page, hover_id]
     
     # Page change
-    def change_page(page_num):
+    def change_page(page_num, hover_id):
         page_num = int(page_num)
-        text_html = get_page_text_html(page_num)
+        text_html = get_page_text_html(page_num, hover_id)
         
         if current_display_data and 'pages' in current_display_data:
             pages = current_display_data['pages']
             if 0 < page_num <= len(pages):
-                temp_path = create_temp_image(pages[page_num - 1])
-                return [temp_path, text_html, page_num]
+                if hover_id:
+                    temp_path = update_image_with_hover(page_num, hover_id)
+                else:
+                    temp_path = create_temp_image(pages[page_num - 1])
+                return [temp_path, text_html, page_num, hover_id]
         
-        return [None, text_html, page_num]
-    
-    # Simple hover using Gradio events
-    def handle_hover(evt: gr.SelectData):
-        """Handle click on text to simulate hover"""
-        if evt.value:
-            # Parse the paragraph ID from the clicked element
-            # This is a simple approach - in production you'd want to use data attributes
-            import re
-            match = re.search(r'para-(\d+)', evt.value)
-            if match:
-                para_id = match.group(1)
-                current_page = int(page_counter.value) if page_counter.value else 1
-                
-                # Update image with highlight
-                if current_display_data:
-                    temp_path = update_image_with_hover(current_page, para_id)
-                    if temp_path:
-                        # Update text with highlight
-                        text_html = get_page_text_html(current_page, para_id)
-                        return [temp_path, text_html, para_id]
+        return [None, text_html, page_num, hover_id]
+    
+    # Handle hover/click
+    def handle_click(para_id, current_page):
+        if not para_id:
+            # No hover - return current page without highlight
+            if current_display_data and 'pages' in current_display_data:
+                pages = current_display_data['pages']
+                if 0 < current_page <= len(pages):
+                    temp_path = create_temp_image(pages[current_page - 1])
+                    text_html = get_page_text_html(current_page)
+                    return [temp_path, text_html, None]
         
-        return [page_display.value, text_display.value, None]
+        # With highlight
+        temp_path = update_image_with_hover(current_page, para_id)
+        if temp_path:
+            text_html = get_page_text_html(current_page, para_id)
+            return [temp_path, text_html, para_id]
+        
+        return [None, get_page_text_html(current_page), para_id]
     
     # Connect events
-    apply_btn.click(
-        load_pdf_and_json,
+    load_btn.click(
+        load_files,
         inputs=[pdf_file, json_file],
         outputs=[
             state_pages, 
             state_data, 
             state_total_pages,
-            state_current_page,
-            total_pages,
-            page_display,
+            total_pages_disp,
+            image_display,
             text_display,
-            state_current_hover
+            hover_input,
+            state_current_page
         ]
     )
     
     next_btn.click(
         navigate_page,
-        inputs=[gr.Text("next", visible=False), page_counter, state_total_pages],
-        outputs=[page_display, text_display, state_current_page, page_counter]
+        inputs=[gr.Text("next", visible=False), state_current_page, state_total_pages, hover_input],
+        outputs=[image_display, text_display, state_current_page, page_num, hover_input]
     )
     
     prev_btn.click(
         navigate_page,
-        inputs=[gr.Text("prev", visible=False), page_counter, state_total_pages],
-        outputs=[page_display, text_display, state_current_page, page_counter]
+        inputs=[gr.Text("prev", visible=False), state_current_page, state_total_pages, hover_input],
+        outputs=[image_display, text_display, state_current_page, page_num, hover_input]
     )
     
-    page_counter.change(
+    page_num.change(
         change_page,
-        inputs=[page_counter],
-        outputs=[page_display, text_display, state_current_page]
+        inputs=[page_num, hover_input],
+        outputs=[image_display, text_display, state_current_page, hover_input]
     )
     
-    # Simple click-to-highlight instead of hover
+    # Handle text click (hover simulation)
     text_display.select(
-        handle_hover,
+        lambda evt: (evt.index, 1) if hasattr(evt, 'index') else (None, 1),
         None,
-        [page_display, text_display, hover_para]
+        [hover_input, state_current_page]
+    ).then(
+        handle_click,
+        [hover_input, state_current_page],
+        [image_display, text_display, hover_input]
     )
 
-# Add this at the end of the file
+# Add cleanup on exit
+import atexit
+atexit.register(cleanup_temp_files)
+
 if __name__ == "__main__":
-    # Clean up on exit
-    import atexit
-    atexit.register(cleanup_temp_files)
-    
-    # Launch for HuggingFace Spaces
-    app.launch(debug=False)
+    app.launch(debug=True, server_name="0.0.0.0")