Update app.py

app.py

@@ -31,13 +31,19 @@ class ModelRegistry:
         self.groq_models = self._fetch_groq_models()
 
     def _fetch_groq_models(self) -> Dict[str, str]:
-        """Fetch available Groq models"""
+        """Fetch available Groq models with proper error handling"""
         try:
+            groq_api_key = os.getenv('GROQ_API_KEY')
+            if not groq_api_key:
+                logging.warning("No GROQ_API_KEY found in environment")
+                return self._get_default_groq_models()
+
             headers = {
-                "Authorization": f"Bearer {os.getenv('GROQ_API_KEY')}",
+                "Authorization": f"Bearer {groq_api_key}",
                 "Content-Type": "application/json"
             }
             response = requests.get("https://api.groq.com/openai/v1/models", headers=headers)
+            
             if response.status_code == 200:
                 models = response.json().get("data", [])
                 return {model["id"]: model["id"] for model in models}
@@ -142,6 +148,38 @@ def build_prompts(snippets: List[str], prompt_instruction: str, custom_prompt: O
     
     return "\n\n".join(prompts)
 
+def send_to_model(prompt, model_selection, hf_model_choice, hf_custom_model, hf_api_key,
+                 groq_model_choice, groq_api_key, openai_api_key):
+    """Send prompt to selected model"""
+    try:
+        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)
+            
+        elif model_selection == "OpenAI ChatGPT":
+            if not openai_api_key:
+                return "OpenAI API key required.", []
+            # Implement OpenAI API call here
+            
+        # Save summary for download
+        with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as summary_file:
+            summary_file.write(summary)
+            
+        return summary, [summary_file.name]
+        
+    except Exception as e:
+        logging.error(f"Error sending to model: {e}")
+        return f"Error sending to model: {str(e)}", []
+
 def send_to_hf_inference(prompt: str, model_name: str, api_key: str) -> str:
     """Send prompt to HuggingFace using Inference API"""
     try:
@@ -179,26 +217,27 @@ def send_to_groq(prompt: str, model_name: str, api_key: str) -> str:
         return f"Error with Groq API: {e}"
 
 def copy_to_clipboard(text: str) -> str:
-    """Copy text to clipboard"""
-    return "Text copied to clipboard!"
-
-def open_chatgpt() -> str:
-    """Open ChatGPT in browser"""
-    webbrowser.open('https://chat.openai.com/')
-    return "Opening ChatGPT in browser..."
-
-def process_pdf(pdf, fmt, ctx_size, snippet_num, prompt, model_selection, 
-                hf_model_choice, hf_custom_model, hf_api_key,
-                groq_model_choice, groq_api_key) -> Tuple[str, str, str, List[str]]:
-    """Process PDF and generate summary"""
+    """Copy text to clipboard using JavaScript"""
+    return """
+        navigator.clipboard.writeText(text)
+            .then(() => gradioApp().querySelector('#progress_status').value = 'Copied to clipboard!')
+            .catch(() => gradioApp().querySelector('#progress_status').value = 'Failed to copy');
+    """
+
+def open_chatgpt() -> None:
+    """Open ChatGPT in new browser tab"""
+    return """window.open('https://chat.openai.com/', '_blank');"""
+
+def process_pdf(pdf, fmt, ctx_size, snippet_num, prompt):
+    """Generate prompt from PDF without model processing"""
     try:
         if not pdf:
-            return "Please upload a PDF file.", "", "", []
+            return "Please upload a PDF file.", "", []
         
         # Extract text
         text = extract_text_from_pdf(pdf.name)
         if text.startswith("Error"):
-            return text, "", "", []
+            return text, "", []
         
         # Format content
         formatted_text = format_content(text, fmt)
@@ -211,42 +250,17 @@ def process_pdf(pdf, fmt, ctx_size, snippet_num, prompt, model_selection,
         full_prompt = build_prompts(snippets, default_prompt, prompt, snippet_num)
         
         if isinstance(full_prompt, str) and full_prompt.startswith("Error"):
-            return full_prompt, "", "", []
-        
-        # Process with selected model
-        if model_selection == "HuggingFace Inference":
-            if not hf_api_key:
-                return "HuggingFace API key required.", full_prompt, "", []
-            
-            model_id = hf_custom_model if hf_model_choice == "Custom Model" else model_registry.hf_models[hf_model_choice]
-            summary = send_to_hf_inference(full_prompt, model_id, hf_api_key)
-            
-        elif model_selection == "Groq API":
-            if not groq_api_key:
-                return "Groq API key required.", full_prompt, "", []
-                
-            summary = send_to_groq(full_prompt, groq_model_choice, groq_api_key)
-            
-        else:  # OpenAI ChatGPT
-            summary = "Please use the Copy Prompt button and paste into ChatGPT."
-        
-        # Save files for download
-        files_to_download = []
+            return full_prompt, "", []
         
+        # Save prompt for download
         with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as prompt_file:
             prompt_file.write(full_prompt)
-            files_to_download.append(prompt_file.name)
-            
-        if summary != "Please use the Copy Prompt button and paste into ChatGPT.":
-            with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as summary_file:
-                summary_file.write(summary)
-                files_to_download.append(summary_file.name)
         
-        return "Processing complete!", full_prompt, summary, files_to_download
+        return "Prompt generated!", full_prompt, [prompt_file.name]
         
     except Exception as e:
         logging.error(f"Error processing PDF: {e}")
-        return f"Error processing PDF: {str(e)}", "", "", []
+        return f"Error processing PDF: {str(e)}", "", []
 
 # Main Interface
 with gr.Blocks(theme=gr.themes.Default()) as demo:
@@ -273,12 +287,18 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
                     label="📝 Output Format"
                 )
             
-            gr.Markdown("### Context Window Size")
+            gr.Markdown("### Context Size")
             with gr.Row():
-                context_buttons = []
                 for size_name, size_value in CONTEXT_SIZES.items():
-                    btn = gr.Button(size_name)
-                    context_buttons.append((btn, size_value))
+                    gr.Button(
+                        size_name, 
+                        size="sm",  # Make buttons smaller
+                        scale=1     # Equal scaling
+                    ).click(
+                        lambda v=size_value: v,
+                        None,
+                        context_size
+                    )
                         
             context_size = gr.Slider(
                 minimum=1000,
@@ -334,6 +354,13 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
                     type="password"
                 )
 
+            # In the UI section, add OpenAI API key input:
+            with gr.Column(visible=False) as openai_options:
+                openai_api_key = gr.Textbox(
+                    label="🔑 OpenAI API Key",
+                    type="password"
+                )
+
         # Right Column - Output
         with gr.Column(scale=1):
             process_button = gr.Button("🚀 Process PDF", variant="primary")
@@ -370,7 +397,8 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
     def toggle_model_options(choice):
         return (
             gr.update(visible=choice == "HuggingFace Inference"),
-            gr.update(visible=choice == "Groq API")
+            gr.update(visible=choice == "Groq API"),
+            gr.update(visible=choice == "OpenAI ChatGPT")
         )
 
     def refresh_groq_models_list():
@@ -384,7 +412,7 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
     model_choice.change(
         toggle_model_options,
         inputs=[model_choice],
-        outputs=[hf_options, groq_options]
+        outputs=[hf_options, groq_options, openai_options]
     )
 
     for btn, size_value in context_buttons:
@@ -412,17 +440,30 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
             format_type,
             context_size,
             snippet_number,
-            custom_prompt,
+            custom_prompt
+        ],
+        outputs=[
+            progress_status,
+            generated_prompt,
+            download_files
+        ]
+    )
+
+    # Add a new button for sending to model
+    send_button = gr.Button("🚀 Send to Model", variant="primary")
+    send_button.click(
+        send_to_model,
+        inputs=[
+            generated_prompt,
             model_choice,
             hf_model,
             hf_custom_model,
             hf_api_key,
             groq_model,
-            groq_api_key
+            groq_api_key,
+            openai_api_key
         ],
         outputs=[
-            progress_status,
-            generated_prompt,
             summary_output,
             download_files
         ]
@@ -451,22 +492,13 @@ with gr.Blocks(theme=gr.themes.Default()) as demo:
     1. Upload a PDF document
     2. Choose output format and context window size
     3. Select snippet number (default: 1) or enter custom prompt
-    4. Select your preferred model:
+    4. Select your preferred model in case you want to proceed directly (or continue with 5):
        - OpenAI ChatGPT: Manual copy/paste workflow
        - HuggingFace Inference: Direct API integration
        - Groq API: High-performance inference
     5. Click 'Process PDF' to generate summary
-    6. Use 'Copy Prompt' and 'Open ChatGPT' for manual processing
+    6. Use 'Copy Prompt' and, optionally, 'Open ChatGPT' for manual processing
     7. Download generated files as needed
-
-    ### ⚙️ Features:
-    - Support for multiple PDF formats
-    - Flexible text formatting options
-    - Predefined context window sizes (4K to 200K)
-    - Multiple model integrations
-    - Copy to clipboard functionality
-    - Direct ChatGPT integration
-    - Downloadable outputs
     """)
 
 # Launch the interface