Update app.py

app.py

@@ -170,36 +170,43 @@ def send_to_model(*args, **kwargs):
 
 def send_to_model_impl(prompt, model_selection, hf_model_choice, hf_custom_model, hf_api_key,
                     groq_model_choice, groq_api_key, openai_api_key):
-    """Implementation of send to model functionality"""
-    if model_selection == "HuggingFace Inference":
-        if not hf_api_key:
-            return "HuggingFace API key required.", []
-        
-        model_id = hf_custom_model if hf_model_choice == "Custom Model" else model_registry.hf_models[hf_model_choice]
-        summary = send_to_hf_inference(prompt, model_id, hf_api_key)
-    
-    elif model_selection == "Groq API":
-        if not groq_api_key:
-            return "Groq API key required.", []
-        summary = send_to_groq(prompt, groq_model_choice, groq_api_key)
+    try:
+        if model_selection == "Clipboard only":
+            return "Use copy/paste for processing", []
+            
+        if model_selection == "HuggingFace Inference":
+            if not hf_api_key:
+                return "Error: HuggingFace API key required", []
+            if not hf_model_choice:
+                return "Error: Select a HuggingFace model", []
+            model_id = hf_custom_model if hf_model_choice == "Custom Model" else model_registry.hf_models[hf_model_choice]
+            summary = send_to_hf_inference(prompt, model_id, hf_api_key)
+            
+        elif model_selection == "Groq API":
+            if not groq_api_key:
+                return "Error: Groq API key required", []
+            if not groq_model_choice:
+                return "Error: Select a Groq model", []
+            summary = send_to_groq(prompt, groq_model_choice, groq_api_key)
+            
+        elif model_selection == "OpenAI ChatGPT":
+            if not openai_api_key:
+                return "Error: OpenAI API key required", []
+            summary = send_to_openai(prompt, openai_api_key)
+            
+        else:
+            return "Error: Invalid model selection", []
         
-    elif model_selection == "OpenAI ChatGPT":
-        if not openai_api_key:
-            return "OpenAI API key required.", []
-        summary = send_to_openai(prompt, openai_api_key)
+        # Save summary for download
+        with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as f:
+            f.write(summary)
+            
+        return summary, [f.name]
+    except Exception as e:
+        error_msg = f"Error processing request: {str(e)}"
+        logging.error(error_msg)
+        return error_msg, []
     
-    else:
-        return "Invalid model selection.", []
-        
-    if summary.startswith("Error"):
-        return summary, []
-        
-    # Save summary for download
-    with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as f:
-        f.write(summary)
-        
-    return summary, [f.name]
-
 def send_to_hf_inference(prompt: str, model_name: str, api_key: str) -> str:
     """Send prompt to HuggingFace using Inference API"""
     try:
@@ -266,21 +273,17 @@ def send_to_openai(prompt: str, api_key: str) -> str:
         return f"Error with OpenAI API: {e}"
 
 def copy_text_js(element_id: str) -> str:
-    return f"""
-        () => {{
-            try {{
-                const elem = document.querySelector('#{element_id} textarea');
-                if (!elem) throw new Error('Element not found');
-                const text = elem.value;
-                if (!text) throw new Error('No text to copy');
-                navigator.clipboard.writeText(text);
-                return "Copied to clipboard!";
-            }} catch (e) {{
-                console.error(e);
-                return "Failed to copy: " + e.message;
-            }}
+    return f"""function() {{
+        let textarea = document.getElementById('{element_id}');
+        if (!textarea) return 'Element not found';
+        textarea.select();
+        try {{
+            document.execCommand('copy');
+            return 'Copied to clipboard!';
+        }} catch(err) {{
+            return 'Failed to copy: ' + err;
         }}
-    """
+    }}"""
 
 def open_chatgpt() -> str:
     """Open ChatGPT in new browser tab"""
@@ -354,44 +357,16 @@ def generate_prompt(text, template, snippet_idx=None):
         logging.error(f"Error generating prompt: {e}")
         return f"Error generating prompt: {str(e)}", "", None
 
-def download_file(content: str, prefix: str = "file") -> List[str]:
-    """Create a downloadable file with content and better error handling"""
-    if not content:
-        return []
-    try:
-        with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt', prefix=prefix) as f:
-            f.write(content)
-            return [f.name]
-    except Exception as e:
-        logging.error(f"Error creating download file: {e}")
-        return []
-
 # Main Interface
-with gr.Blocks(theme=gr.themes.Default()) as demo:
+with gr.Blocks(css="""
+    .gradio-container {max-width: 90%; margin: 0 auto;}
+    @media (max-width: 768px) {.gradio-container {max-width: 98%; padding: 10px;} .gr-row {flex-direction: column;} .gr-col {width: 100%; margin-bottom: 10px;}}
+""") as demo:
+    gr.Markdown("# 📄 Smart PDF Summarizer")
+
     # State variables
     pdf_content = gr.State("")
     snippets = gr.State([])
-
-    # CSS for responsiveness
-    demo.css = """
-    .gradio-container {
-        max-width: 90%; /* Adjust as needed */
-        margin: 0 auto; /* Center the container */
-    }
-    @media (max-width: 768px) { /* Example breakpoint for smaller screens */
-        .gradio-container {
-            max-width: 98%;
-            padding: 10px; /* Add padding for better mobile experience */
-        }
-        .gr-row {
-            flex-direction: column; /* Stack elements vertically */
-        }
-        .gr-col {
-            width: 100%; /* Make columns full width */
-            margin-bottom: 10px; /* Add spacing between columns */
-        }
-    }
-    """
     
     # Header
     gr.Markdown("# 📄 Smart PDF Summarizer")
@@ -421,14 +396,15 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
                         label="Context Size"
                     )
                     
+                    gr.Markdown("### Context Size")
                     with gr.Row():
                         for size_name, size_value in CONTEXT_SIZES.items():
                             gr.Button(
-                                size_name, 
+                                size_name,
                                 size="sm",
                                 scale=1
                             ).click(
-                                lambda v=size_value: v,  # Simplified
+                                lambda v=size_value: gr.update(value=v),
                                 None,
                                 context_size
                             )
@@ -487,10 +463,10 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
             with gr.Row():
                 with gr.Column(scale=1):
                     model_choice = gr.Radio(
-                        choices=["OpenAI ChatGPT", "HuggingFace Inference", "Groq API"],
-                        value="OpenAI ChatGPT",
-                        label="🤖 Model Selection"
-                    )
+                    choices=["Clipboard only", "OpenAI ChatGPT", "HuggingFace Inference", "Groq API"],
+                    value="Clipboard only",
+                    label="🤖 Model Selection"
+                )
                     
                     with gr.Column(visible=False) as openai_options:
                         openai_api_key = gr.Textbox(
@@ -581,8 +557,15 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
         )
 
     def refresh_groq_models_list():
-        updated_models = model_registry.refresh_groq_models()
-        return gr.update(choices=list(updated_models.keys()))
+        try:
+            with gr.Progress() as progress:
+                progress(0, "Refreshing Groq models...")
+                updated_models = model_registry.refresh_groq_models()
+                progress(1, "Complete!")
+                return gr.update(choices=list(updated_models.keys()))
+        except Exception as e:
+            logging.error(f"Error refreshing models: {e}")
+            return gr.update()
 
     def toggle_custom_model(model_name):
         return gr.update(visible=model_name == "Custom Model")
@@ -601,14 +584,12 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
         return update_context_size("Groq API", model_name)
 
     def handle_model_selection(choice):
-        """Handle model selection and update UI"""
-        ctx_size = get_model_context_size(choice)
-        return (
-            gr.update(visible=choice == "HuggingFace Inference"),  # hf_options
-            gr.update(visible=choice == "Groq API"),              # groq_options
-            gr.update(visible=choice == "OpenAI ChatGPT"),        # openai_options
-            gr.update(value=ctx_size)                            # context_size
-        )
+        return [
+            gr.update(visible=choice == "HuggingFace Inference"),
+            gr.update(visible=choice == "Groq API"),
+            gr.update(visible=choice == "OpenAI ChatGPT"),
+            gr.update(value=get_model_context_size(choice))
+        ]
     
     # PDF Processing Handlers
     def handle_pdf_process(pdf, fmt, ctx_size):
@@ -699,24 +680,24 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
         
     # Copy button handlers
     def handle_prompt_generation(snippet_text, template, snippet_choice, snippets_list):
-        """Generate prompt from selected snippet"""
-        if not snippet_text or not snippets_list:
-            return "No text available for prompt generation.", "", None
-                
         try:
+            if not snippets_list:
+                return "No text available.", "", None
+                
             idx = get_snippet_index(snippet_choice)
-            prompt = generate_prompt(snippets_list[idx], template or "Summarize the following text:")
+            base_prompt = template if template else "Summarize the following text:"
+            content = snippets_list[idx]
             
-            # Create downloadable prompt
+            prompt = f"{base_prompt}\n---\n{content}\n---"
+            
+            # Save prompt for download
             with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as f:
                 f.write(prompt)
                 
-            return "Prompt generated successfully!", prompt, [f.name]
-            
+            return "Prompt generated!", prompt, [f.name]
         except Exception as e:
-            error_msg = f"Error generating prompt: {str(e)}"
-            logging.error(error_msg)
-            return error_msg, "", None
+            logging.error(f"Error generating prompt: {e}")
+            return f"Error: {str(e)}", "", None
 
     def handle_copy_action(text):
         """Handle copy to clipboard action"""
@@ -784,42 +765,29 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
         outputs=[context_size]
     )
 
-    # Context size buttons
-    for size_name, size_value in CONTEXT_SIZES.items():
-        gr.Button(
-            size_name, 
-            size="sm",
-            scale=1
-        ).click(
-            lambda v=size_value: gr.update(value=v),
-            None,
-            context_size
-        )
-
-    # Download handlers (simplified)
-    for btn, content in [
-        (download_full_text, pdf_content),
-        (download_snippet, generated_prompt),
-        (download_prompt, generated_prompt),
-        (download_summary, summary_output)
+    # Download handlers
+    for btn, content, prefix in [
+        (download_full_text, pdf_content, "full_text"),
+        (download_snippet, generated_prompt, "snippet"),
+        (download_prompt, generated_prompt, "prompt"),
+        (download_summary, summary_output, "summary")
     ]:
         btn.click(
-            lambda x: [x] if x else None,
+            lambda x, p=prefix: download_file(x, p) if x else [],
             inputs=[content],
             outputs=[download_files]
         )
 
-    # Copy button handlers
-    for btn, elem_id in [
-        (copy_prompt_button, "generated_prompt"),
-        (copy_summary_button, "summary_output")
-    ]:
-        btn.click(
-            fn=lambda _: f"const text = document.querySelector('#{elem_id} textarea').value; navigator.clipboard.writeText(text); return 'Copied to clipboard!';",
-            inputs=None,
-            outputs=progress_status,
-            js=True
-        )
+    def download_file(content: str, prefix: str) -> List[str]:
+        if not content:
+            return []
+        try:
+            with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt', prefix=prefix) as f:
+                f.write(content)
+                return [f.name]
+        except Exception as e:
+            logging.error(f"Error creating download file: {e}")
+            return []
 
     # ChatGPT handler
     open_chatgpt_button.click(