Update app.py

app.py

@@ -3,26 +3,45 @@ import os
 from src.processing.gemini_processor import GeminiProcessor
 from src.analysis.coverage_generator import CoverageGenerator
 from pathlib import Path
+import logging
+
+class ConsoleOutput:
+    def __init__(self):
+        self.messages = []
+        
+    def write(self, message):
+        self.messages.append(str(message))
+        return "\n".join(self.messages)
+        
+    def get_output(self):
+        return "\n".join(self.messages)
 
 def process_pdf(pdf_file, progress=gr.Progress()):
     if pdf_file is None:
         raise gr.Error("Please upload a PDF file")
     
-    console_output = []
+    console = ConsoleOutput()
     
-    def update_console(message):
-        console_output.append(message)
-        return "\n".join(console_output)
+    # Set up logging to console
+    logging.basicConfig(level=logging.DEBUG,
+                       format='%(asctime)s - %(levelname)s - %(message)s')
+    
+    logger = logging.getLogger()
+    logger.handlers = []  # Remove existing handlers
+    
+    class GradioHandler(logging.Handler):
+        def emit(self, record):
+            msg = self.format(record)
+            console.write(msg)
+            
+    logger.addHandler(GradioHandler())
     
     try:
-        # Initialize processors
-        progress(0.1, desc="Initializing...")
         processor = GeminiProcessor()
         coverage_gen = CoverageGenerator()
         
         # Clean screenplay
         progress(0.2, desc="Processing screenplay...")
-        update_console("Starting screenplay processing...")
         cleaned_path = Path("cleaned_screenplay_long.txt")
         success = processor.process_screenplay(pdf_file.name, str(cleaned_path))
         if not success:
@@ -30,25 +49,22 @@ def process_pdf(pdf_file, progress=gr.Progress()):
         
         with open(cleaned_path, 'r') as f:
             cleaned_text = f.read()
-        update_console("Screenplay processing complete!")
         
         # Generate coverage
         progress(0.6, desc="Generating coverage...")
-        update_console("Starting coverage generation...")
         success = coverage_gen.generate_coverage(cleaned_path)
         if not success:
             raise gr.Error("Failed to generate coverage")
             
         with open(Path("coverage.txt"), 'r') as f:
             coverage = f.read()
-        update_console("Coverage generation complete!")
             
         progress(1.0, desc="Complete!")
-        return cleaned_text, coverage, "\n".join(console_output)
+        return cleaned_text, coverage, console.get_output()
         
     except Exception as e:
         error_msg = f"Error: {str(e)}"
-        update_console(error_msg)
+        console.write(error_msg)
         raise gr.Error(error_msg)
 
 with gr.Blocks(title="Screenplay Coverage Generator") as demo:
@@ -61,13 +77,30 @@ with gr.Blocks(title="Screenplay Coverage Generator") as demo:
         process_btn = gr.Button("Process Screenplay")
     
     with gr.Row():
-        console = gr.Textbox(label="Console Output", lines=5)
+        console = gr.Textbox(
+            label="Console Output",
+            lines=10,
+            max_lines=30,
+            autoscroll=True,
+            container=True,
+            show_copy_button=True
+        )
     
     with gr.Tabs():
         with gr.TabItem("Cleaned Screenplay"):
-            cleaned_output = gr.Textbox(label="Cleaned Screenplay", lines=10)
+            cleaned_output = gr.Textbox(
+                label="Cleaned Screenplay",
+                lines=10,
+                max_lines=30,
+                show_copy_button=True
+            )
         with gr.TabItem("Coverage"):
-            coverage_output = gr.Textbox(label="Coverage Document", lines=10)
+            coverage_output = gr.Textbox(
+                label="Coverage Document",
+                lines=10,
+                max_lines=30,
+                show_copy_button=True
+            )
     
     process_btn.click(
         fn=process_pdf,