import os
import re
import tempfile
import requests
import gradio as gr
print(f"Gradio version: {gr.__version__}")
from PyPDF2 import PdfReader
import fitz # pymupdf
import logging
import webbrowser
from huggingface_hub import InferenceClient
from typing import Dict, List, Optional, Tuple
from functools import wraps
import threading
import time
from groq import Groq # Import the Groq client
# Set up logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
# Constants
CONTEXT_SIZES = {
"4K": 4096,
"8K": 8192,
"32K": 32768,
"64K": 65536,
"128K": 131072
}
MODEL_CONTEXT_SIZES = {
"Clipboard only": 4096,
"OpenAI ChatGPT": {
"gpt-3.5-turbo": 16385,
"gpt-3.5-turbo-0125": 16385,
"gpt-3.5-turbo-1106": 16385,
"gpt-3.5-turbo-instruct": 4096,
"gpt-4": 8192,
"gpt-4-0314": 8192,
"gpt-4-0613": 8192,
"gpt-4-turbo": 128000,
"gpt-4-turbo-2024-04-09": 128000,
"gpt-4-turbo-preview": 128000,
"gpt-4-0125-preview": 128000,
"gpt-4-1106-preview": 128000,
"gpt-4o": 128000,
"gpt-4o-2024-11-20": 128000,
"gpt-4o-2024-08-06": 128000,
"gpt-4o-2024-05-13": 128000,
"chatgpt-4o-latest": 128000,
"gpt-4o-mini": 128000,
"gpt-4o-mini-2024-07-18": 128000,
"gpt-4o-realtime-preview": 128000,
"gpt-4o-realtime-preview-2024-10-01": 128000,
"gpt-4o-audio-preview": 128000,
"gpt-4o-audio-preview-2024-10-01": 128000,
"o1-preview": 128000,
"o1-preview-2024-09-12": 128000,
"o1-mini": 128000,
"o1-mini-2024-09-12": 128000,
},
"HuggingFace Inference": {
"microsoft/phi-3-mini-4k-instruct": 4096,
"microsoft/Phi-3-mini-128k-instruct": 131072, # Added Phi-3 128k
"HuggingFaceH4/zephyr-7b-beta": 8192,
"deepseek-ai/DeepSeek-Coder-V2-Instruct": 8192,
"mistralai/Mistral-7B-Instruct-v0.3": 32768,
"NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO": 32768,
"microsoft/Phi-3.5-mini-instruct": 4096,
"HuggingFaceTB/SmolLM2-1.7B-Instruct": 2048,
"google/gemma-2-2b-it": 2048,
"openai-community/gpt2": 1024,
"microsoft/phi-2": 2048,
"TinyLlama/TinyLlama-1.1B-Chat-v1.0": 2048,
"VAGOsolutions/Llama-3-SauerkrautLM-8b-Instruct": 2048,
"VAGOsolutions/Llama-3.1-SauerkrautLM-8b-Instruct": 4096,
"VAGOsolutions/SauerkrautLM-Nemo-12b-Instruct": 4096,
"openGPT-X/Teuken-7B-instruct-research-v0.4": 4096,
"Qwen/Qwen2.5-7B-Instruct": 131072,
"tiiuae/falcon-7b-instruct": 8192,
"Qwen/QwQ-32B-preview": 32768, # Add QwQ model
},
"Groq API": {
"gemma2-9b-it": 8192,
"gemma-7b-it": 8192,
"llama-3.3-70b-versatile": 131072,
"llama-3.1-70b-versatile": 131072, # Deprecated
"llama-3.1-8b-instant": 131072,
"llama-guard-3-8b": 8192,
"llama3-70b-8192": 8192,
"llama3-8b-8192": 8192,
"mixtral-8x7b-32768": 32768,
"llama3-groq-70b-8192-tool-use-preview": 8192,
"llama3-groq-8b-8192-tool-use-preview": 8192,
"llama-3.3-70b-specdec": 131072,
"llama-3.1-70b-specdec": 131072,
"llama-3.2-1b-preview": 131072,
"llama-3.2-3b-preview": 131072,
},
"Cohere API": {
"command-r-plus-08-2024": 131072, # 128k
"command-r-plus-04-2024": 131072,
"command-r-plus": 131072,
"command-r-08-2024": 131072,
"command-r-03-2024": 131072,
"command-r": 131072,
"command": 4096,
"command-nightly": 131072,
"command-light": 4096,
"command-light-nightly": 4096,
"c4ai-aya-expanse-8b": 8192,
"c4ai-aya-expanse-32b": 131072,
},
"GLHF API": {
"mistralai/Mixtral-8x7B-Instruct-v0.1": 32768,
# "NousResearch/Nous-Hermes-2-Solar-10.7B": 32768,
"01-ai/Yi-34B-Chat": 32768,
"mistralai/Mistral-7B-Instruct-v0.3": 32768,
"microsoft/phi-3-mini-4k-instruct": 4096,
"microsoft/Phi-3.5-mini-instruct": 4096,
"microsoft/Phi-3-mini-128k-instruct": 131072,
"HuggingFaceH4/zephyr-7b-beta": 8192,
"NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO": 32768,
"google/gemma-2-2b-it": 2048,
"microsoft/phi-2": 2048,
}
}
class RateLimit:
def __init__(self, calls_per_min):
self.calls_per_min = calls_per_min
self.calls = []
self.lock = threading.Lock()
def __call__(self, func):
@wraps(func)
def wrapped(*args, **kwargs):
with self.lock:
now = time.time()
# Remove old calls
self.calls = [call for call in self.calls if call > now - 60]
if len(self.calls) >= self.calls_per_min:
sleep_time = self.calls[0] - (now - 60)
if sleep_time > 0:
time.sleep(sleep_time)
self.calls.append(now)
return func(*args, **kwargs)
return wrapped
class ModelRegistry:
def __init__(self):
# HuggingFace Models
self.hf_models = {
"Mistral 7B": "mistralai/Mistral-7B-Instruct-v0.3", # works well
"Nous-Hermes": "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO", # works well
"Zephyr 7B": "HuggingFaceH4/zephyr-7b-beta", # works
"Phi-3.5 Mini": "microsoft/Phi-3.5-mini-instruct", # works but poor results
"Phi-3 Mini 4K": "microsoft/phi-3-mini-4k-instruct", # good for small context
"Phi-3 Mini 128K": "microsoft/Phi-3-mini-128k-instruct", # good for large context
"Gemma 2 2B": "google/gemma-2-2b-it", # works but often busy
"GPT2": "openai-community/gpt2", # works with token limits
"Phi-2": "microsoft/phi-2", # works with token limits
"TinyLlama 1.1B": "TinyLlama/TinyLlama-1.1B-Chat-v1.0", # works with token limits
"DeepSeek Coder V2": "deepseek-ai/DeepSeek-Coder-V2-Instruct", # good for code
"Falcon-7B": "tiiuae/falcon-7b-instruct", # reliable
"Qwen 2.5 7B": "Qwen/Qwen2.5-7B-Instruct", # good performance
"QwQ 32B Preview": "Qwen/QwQ-32B-preview", # special handling
# Models requiring API key
"DeepSeek Coder V2 (Pro)": "deepseek-ai/DeepSeek-Coder-V2-Instruct", # needs API key
"Meta Llama 3.1 70B (Pro)": "meta-llama/Meta-Llama-3.1-70B-Instruct", # needs API key
"Aya 23-35B (Pro)": "CohereForAI/aya-23-35B", # needs API key
"Custom Model": ""
}
# Default Groq Models
self.default_groq_models = { # Keep defaults in case fetching fails
"gemma2-9b-it": "gemma2-9b-it",
"gemma-7b-it": "gemma-7b-it",
"llama-3.3-70b-versatile": "llama-3.3-70b-versatile",
"llama-3.1-70b-versatile": "llama-3.1-70b-versatile", # Deprecated
"llama-3.1-8b-instant": "llama-3.1-8b-instant",
"llama-guard-3-8b": "llama-guard-3-8b",
"llama3-70b-8192": "llama3-70b-8192",
"llama3-8b-8192": "llama3-8b-8192",
"mixtral-8x7b-32768": "mixtral-8x7b-32768",
"llama3-groq-70b-8192-tool-use-preview": "llama3-groq-70b-8192-tool-use-preview",
"llama3-groq-8b-8192-tool-use-preview": "llama3-groq-8b-8192-tool-use-preview",
"llama-3.3-70b-specdec": "llama-3.3-70b-specdec",
"llama-3.1-70b-specdec": "llama-3.1-70b-specdec",
"llama-3.2-1b-preview": "llama-3.2-1b-preview",
"llama-3.2-3b-preview": "llama-3.2-3b-preview",
}
self.groq_models = self._fetch_groq_models()
def _fetch_groq_models(self) -> Dict[str, str]:
"""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.default_groq_models
headers = {
"Authorization": f"Bearer {groq_api_key}",
"Content-Type": "application/json"
}
response = requests.get(
"https://api.groq.com/openai/v1/models",
headers=headers,
timeout=10
)
if response.status_code == 200:
models = response.json().get("data", [])
model_dict = {model["id"]: model["id"] for model in models}
# Merge with defaults to ensure all models are available
return {**self.default_groq_models, **model_dict}
else:
logging.error(f"Failed to fetch Groq models: {response.status_code}")
return self.default_groq_models
except requests.exceptions.Timeout:
logging.error("Timeout while fetching Groq models")
return self.default_groq_models
except Exception as e:
logging.error(f"Error fetching Groq models: {e}")
return self.default_groq_models
def _get_default_groq_models(self) -> Dict[str, str]:
"""Return default Groq models"""
return self.default_groq_models
def refresh_groq_models(self) -> Dict[str, str]:
"""Refresh the list of available Groq models"""
self.groq_models = self._fetch_groq_models()
return self.groq_models
def apply_rate_limit(func, calls_per_min, *args, **kwargs):
"""Apply rate limiting only when needed."""
rate_decorator = RateLimit(calls_per_min)
wrapped_func = rate_decorator(func)
return wrapped_func(*args, **kwargs)
class PDFProcessor:
"""Handles PDF conversion to text and markdown using different methods"""
@staticmethod
def txt_convert(pdf_path: str) -> str:
"""Basic text extraction using PyPDF2"""
try:
reader = PdfReader(pdf_path)
text = ""
for page_num, page in enumerate(reader.pages, start=1):
page_text = page.extract_text()
if page_text:
text += page_text + "\n"
else:
logging.warning(f"No text found on page {page_num}.")
return text
except Exception as e:
logging.error(f"Error in txt conversion: {e}")
return f"Error: {str(e)}"
@staticmethod
def md_convert_with_pymupdf(pdf_path: str) -> str:
"""Convert PDF to Markdown using pymupdf"""
try:
doc = fitz.open(pdf_path)
markdown_text = []
for page in doc:
blocks = page.get_text("dict")["blocks"]
for block in blocks:
if "lines" in block:
for line in block["lines"]:
for span in line["spans"]:
font_size = span["size"]
content = span["text"]
font_flags = span["flags"] # Contains bold, italic info
# Handle headers based on font size
if font_size > 20:
markdown_text.append(f"# {content}\n")
elif font_size > 16:
markdown_text.append(f"## {content}\n")
elif font_size > 14:
markdown_text.append(f"### {content}\n")
else:
# Handle bold and italic
if font_flags & 2**4: # Bold
content = f"**{content}**"
if font_flags & 2**1: # Italic
content = f"*{content}*"
markdown_text.append(content)
markdown_text.append(" ") # Space between spans
markdown_text.append("\n") # Newline between lines
# Add extra newline between blocks for paragraphs
markdown_text.append("\n")
doc.close()
return "".join(markdown_text)
except Exception as e:
logging.error(f"Error in pymupdf conversion: {e}")
return f"Error: {str(e)}"
# Initialize model registry
model_registry = ModelRegistry()
def extract_text_from_pdf(pdf_path: str, format_type: str = "txt") -> str:
"""
Extract and format text from PDF using different processors based on format.
Args:
pdf_path: Path to PDF file
format_type: Either 'txt' or 'md'
Returns:
Formatted text content
"""
processor = PDFProcessor()
try:
if format_type == "txt":
return processor.txt_convert(pdf_path)
elif format_type == "md":
return processor.md_convert_with_pymupdf(pdf_path)
else:
return f"Error: Unsupported format type: {format_type}"
except Exception as e:
logging.error(f"Error in PDF conversion: {e}")
return f"Error: {str(e)}"
def format_content(text: str, format_type: str) -> str:
"""Format extracted text according to specified format."""
if format_type == 'txt':
return text
elif format_type == 'md':
paragraphs = text.split('\n\n')
return '\n\n'.join(paragraphs)
elif format_type == 'html':
paragraphs = text.split('\n\n')
return ''.join([f'<p>{para.strip()}</p>' for para in paragraphs if para.strip()])
else:
logging.error(f"Unsupported format: {format_type}")
return f"Unsupported format: {format_type}"
def split_into_snippets(text: str, context_size: int) -> List[str]:
"""Split text into manageable snippets based on context size."""
sentences = re.split(r'(?<=[.!?]) +', text)
snippets = []
current_snippet = ""
for sentence in sentences:
if len(current_snippet) + len(sentence) + 1 > context_size:
if current_snippet:
snippets.append(current_snippet.strip())
current_snippet = sentence + " "
else:
snippets.append(sentence.strip())
current_snippet = ""
else:
current_snippet += sentence + " "
if current_snippet.strip():
snippets.append(current_snippet.strip())
return snippets
def build_prompts(snippets: List[str], prompt_instruction: str, custom_prompt: Optional[str], snippet_num: Optional[int] = None) -> str:
"""Build formatted prompts from text snippets."""
if snippet_num is not None:
if 1 <= snippet_num <= len(snippets):
selected_snippets = [snippets[snippet_num - 1]]
else:
return f"Error: Invalid snippet number. Please choose between 1 and {len(snippets)}."
else:
selected_snippets = snippets
prompts = []
base_prompt = custom_prompt if custom_prompt else prompt_instruction
for idx, snippet in enumerate(selected_snippets, start=1):
if len(selected_snippets) > 1:
prompt_header = f"{base_prompt} Part {idx} of {len(selected_snippets)}: ---\n"
else:
prompt_header = f"{base_prompt} ---\n"
framed_prompt = f"{prompt_header}{snippet}\n---"
prompts.append(framed_prompt)
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, openai_model_choice,
cohere_api_key=None, cohere_model=None, glhf_api_key=None, glhf_model=None,
glhf_custom_model=None):
"""Primary wrapper for model interactions with error handling."""
logging.info("send to model starting...")
if not prompt or not prompt.strip():
return gr.HTML(""), "Error: No prompt provided", None
try:
logging.info("sending to model preparation.")
# Basic input validation
valid_selections = ["Clipboard only", "HuggingFace Inference", "Groq API",
"OpenAI ChatGPT", "Cohere API", "GLHF API"]
if model_selection not in valid_selections:
return gr.HTML(""), "Error: Invalid model selection", None
# Check environment API keys
env_api_keys = {
"GROQ_API_KEY": os.getenv('GROQ_API_KEY'),
"OPENAI_API_KEY": os.getenv('OPENAI_API_KEY'),
"COHERE_API_KEY": os.getenv('COHERE_API_KEY'),
"GLHF_API_KEY": os.getenv('GLHF_API_KEY')
}
for key_name, key_value in env_api_keys.items():
if not key_value:
logging.warning(f"No {key_name} found in environment")
# Model-specific validation - check only required keys
if model_selection == "Groq API" and not groq_api_key:
groq_api_key = env_api_keys.get("GROQ_API_KEY")
if not groq_api_key:
return gr.HTML(""), "Error: Groq API key required", None
elif model_selection == "OpenAI ChatGPT" and not openai_api_key:
openai_api_key = env_api_keys.get("OPENAI_API_KEY")
if not openai_api_key:
return gr.HTML(""), "Error: OpenAI API key required", None
elif model_selection == "GLHF API" and not glhf_api_key:
glhf_api_key = env_api_keys.get("GLHF_API_KEY")
if not glhf_api_key:
return gr.HTML(""), "Error: GLHF API key required", None
# Call the implementation function
clipboard_status, summary, download_file = send_to_model_impl(
prompt=prompt.strip(),
model_selection=model_selection,
hf_model_choice=hf_model_choice,
hf_custom_model=hf_custom_model,
hf_api_key=hf_api_key,
groq_model_choice=groq_model_choice,
groq_api_key=groq_api_key,
openai_api_key=openai_api_key,
openai_model_choice=openai_model_choice,
cohere_api_key=cohere_api_key or env_api_keys.get("COHERE_API_KEY"),
cohere_model=cohere_model,
glhf_api_key=glhf_api_key,
glhf_model=glhf_model,
glhf_custom_model=glhf_custom_model,
use_rate_limits=False # Adjust based on your needs
)
return clipboard_status, summary, download_file
except Exception as e:
error_msg = str(e) or "Unknown error occurred"
logging.error(f"Error in send_to_model: {error_msg}")
return gr.HTML(f"Error: {error_msg}"), f"Error: {error_msg}", None
finally:
logging.info("send to model completed.")
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, openai_model_choice,
cohere_api_key=None, cohere_model=None, glhf_api_key=None, glhf_model=None,
glhf_custom_model=None, use_rate_limits=False):
"""Implementation of model sending with all providers."""
logging.info("send to model impl commencing...")
try:
if model_selection == "Clipboard only":
# Escape the prompt for JavaScript
escaped_prompt = prompt.replace('"', '\\"').replace("'", "\\'").replace('\n', '\\n')
# Create temporary file for download
with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as f:
f.write(prompt)
download_file = f.name
# Create HTML with JavaScript using fallback methods
html_template = f'''
<button
onclick="
try {{
const textToCopy = `{escaped_prompt}`;
navigator.clipboard.writeText(textToCopy)
.then(() => {{
this.textContent = '✅ Copied to clipboard!';
setTimeout(() => {{
this.textContent = '📋 Copy Text to Clipboard';
}}, 2000);
}})
.catch(err => {{
console.error('Modern copy failed:', err);
// Fallback to textarea method
const textarea = document.createElement('textarea');
textarea.value = textToCopy;
document.body.appendChild(textarea);
textarea.select();
document.execCommand('copy');
document.body.removeChild(textarea);
this.textContent = '✅ Copied using fallback!';
setTimeout(() => {{
this.textContent = '📋 Copy Text to Clipboard';
}}, 2000);
}});
}} catch(err) {{
console.error('Copy error:', err);
this.textContent = '❌ Copy failed. Try again.';
setTimeout(() => {{
this.textContent = '📋 Copy Text to Clipboard';
}}, 2000);
}}
"
style="
padding: 10px 20px;
background-color: #2C3E50;
color: white;
border: none;
border-radius: 5px;
font-weight: bold;
cursor: pointer;
transition: background-color 0.3s ease;
"
onmouseover="this.style.backgroundColor='#34495E'"
onmouseout="this.style.backgroundColor='#2C3E50'"
>
📋 Copy Text to Clipboard
</button>
'''
# Return all three expected outputs:
# 1. HTML component for clipboard action
# 2. A success message for summary output
# 3. The download file
return gr.HTML(html_template), "Use Copy Text to Clipboard button below, then paste where you like.", download_file
# Get the summary based on model selection
if model_selection == "HuggingFace Inference":
# Use the selected model ID directly
model_id = hf_custom_model if hf_model_choice == "Custom Model" else hf_model_choice
# Always try without API key first
summary = send_to_hf_inference(prompt, model_id)
if summary.startswith("Error: This model requires authentication") and hf_api_key:
# Only try with API key if the model specifically requires it
summary = send_to_hf_inference(prompt, model_id, hf_api_key, use_rate_limits)
elif model_selection == "Groq API":
if not groq_api_key:
return gr.HTML(""), "Error: Groq API key required", None
summary = send_to_groq(prompt, groq_model_choice, groq_api_key, use_rate_limits)
elif model_selection == "OpenAI ChatGPT":
if not openai_api_key:
return "Error: OpenAI API key required", None
summary = send_to_openai(prompt, openai_api_key, model=openai_model_choice,
use_rate_limit=use_rate_limits)
elif model_selection == "Cohere API":
summary = send_to_cohere(prompt, cohere_api_key, cohere_model, use_rate_limits)
elif model_selection == "GLHF API":
if not glhf_api_key:
return "Error: GLHF API key required", None
# Handle model selection
if glhf_model == "Custom Model":
model_id = f"hf:{glhf_custom_model}"
else:
model_id = f"hf:{glhf_model}"
summary = send_to_glhf(prompt, glhf_api_key, model_id, use_rate_limits)
else:
return "Error: Invalid model selection", None
# Validate response
if not summary:
return gr.HTML(""), "Error: No response from model", None
if not isinstance(summary, str):
return gr.HTML(""), "Error: Invalid response type from model", None
# Create download file for valid responses
if not summary.startswith("Error"):
with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as f:
f.write(summary)
return gr.HTML(""), summary, f.name
return gr.HTML(""), summary, None
except Exception as e:
error_msg = str(e)
if not error_msg:
error_msg = "Unknown error occurred"
logging.error(f"Error in send_to_model_impl: {error_msg}")
# FIX: Return all three values even in error case
return gr.HTML(""), f"Error: {error_msg}", None
def send_to_qwq(prompt: str):
"""Send prompt to QwQ API."""
try:
from gradio_client import Client
client = Client("Qwen/QwQ-32B-preview")
# Call the add_text endpoint
result = client.predict(
_input={"files":[], "text": prompt},
_chatbot=[],
api_name="/add_text"
)
# Call the agent_run endpoint
response = client.predict(
_chatbot=result[1], # This is correct
api_name="/agent_run"
)
if isinstance(response, list) and len(response) > 0:
# Extract text from first message in chat history
if isinstance(response[0], list) and len(response[0]) > 0:
if isinstance(response[0][1], dict):
return response[0][1].get('text', 'No response text from QwQ')
elif isinstance(response[0][1], str):
return response[0][1]
return 'No valid response from QwQ'
return 'No response from QwQ'
except Exception as e:
logging.error(f"QwQ API error: {e}")
return f"Error with QwQ API: {str(e)}"
def send_to_hf_inference(prompt: str, model_name: str, api_key: str = None, use_rate_limit: bool = False) -> str:
"""Send prompt to HuggingFace Inference API."""
# Special handling for QwQ
if model_name == "Qwen/QwQ-32B-preview":
return send_to_qwq(prompt)
def _send():
# Check token limits first
is_within_limits, error_msg = check_token_limits(prompt, model_name)
if not is_within_limits:
return error_msg
try:
client = InferenceClient(token=api_key) if api_key else InferenceClient()
response = client.text_generation(
prompt,
model=model_name,
max_new_tokens=500,
temperature=0.7,
top_p=0.95,
repetition_penalty=1.1
)
return str(response)
except Exception as e:
logging.error(f"HuggingFace inference error: {e}")
return f"Error with HuggingFace inference: {str(e)}"
return apply_rate_limit(_send, 16) if use_rate_limit else _send()
def send_to_glhf(prompt: str, api_key: str, model_id: str, use_rate_limit: bool = False) -> str:
"""Send prompt to GLHF API."""
def _send():
try:
import openai
client = openai.OpenAI(
api_key=api_key,
base_url="https://glhf.chat/api/openai/v1",
)
# For GLHF, always use streaming for reliability
completion = client.chat.completions.create(
stream=True,
model=model_id,
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": prompt}
],
)
response_text = []
for chunk in completion:
if chunk.choices[0].delta.content is not None:
response_text.append(chunk.choices[0].delta.content)
return "".join(response_text)
except Exception as e:
logging.error(f"GLHF API error: {e}")
return f"Error with GLHF API: {str(e)}"
return apply_rate_limit(_send, 384) if use_rate_limit else _send()
def send_to_openai(prompt: str, api_key: str, model: str = "gpt-3.5-turbo", use_rate_limit: bool = False) -> str:
"""Send prompt to OpenAI API."""
def _send():
try:
from openai import OpenAI
client = OpenAI(api_key=api_key)
response = client.chat.completions.create(
model=model,
messages=[
{"role": "system", "content": "You are a helpful assistant that provides detailed responses."},
{"role": "user", "content": prompt}
],
temperature=0.7,
max_tokens=500,
top_p=0.95
)
if response.choices and len(response.choices) > 0:
return response.choices[0].message.content
return "Error: No response generated"
except ImportError:
return "Error: Please install the latest version of openai package"
except Exception as e:
logging.error(f"OpenAI API error: {e}")
return f"Error with OpenAI API: {str(e)}"
return apply_rate_limit(_send, 3000/60) if use_rate_limit else _send()
def send_to_cohere(prompt: str, api_key: str = None, model: str = None, use_rate_limit: bool = False) -> str:
"""Send prompt to Cohere API with V2 and V1 fallback."""
def _send():
try:
import cohere
# Try V2 first
try:
client = cohere.ClientV2(api_key) if api_key else cohere.ClientV2()
response = client.chat(
model=model or "command-r-plus-08-2024",
messages=[{
"role": "user",
"content": prompt
}],
temperature=0.7,
)
return response.message.content[0].text
except Exception as v2_error:
logging.warning(f"Cohere V2 failed, trying V1: {v2_error}")
# Fallback to V1
client = cohere.Client(api_key) if api_key else cohere.Client()
response = client.chat(
message=prompt,
model=model or "command-r-plus-08-2024",
temperature=0.7,
max_tokens=500,
)
return response.text
except Exception as e:
logging.error(f"Cohere API error: {e}")
return f"Error with Cohere API: {str(e)}"
return apply_rate_limit(_send, 16) if use_rate_limit else _send()
def send_to_groq(prompt: str, model_name: str, api_key: str, use_rate_limit: bool = False) -> str:
"""Send prompt to Groq API."""
def _send():
try:
client = Groq(api_key=api_key)
response = client.chat.completions.create(
model=model_name,
messages=[{
"role": "user",
"content": prompt
}],
temperature=0.7,
max_tokens=500,
top_p=0.95
)
return response.choices[0].message.content
except Exception as e:
logging.error(f"Groq API error: {e}")
return f"Error with Groq API: {str(e)}"
return apply_rate_limit(_send, 4) if use_rate_limit else _send()
def estimate_tokens(text: str) -> int:
"""Rough token estimation: ~4 characters per token on average"""
return len(text) // 4
def check_token_limits(prompt: str, model_name: str) -> tuple[bool, str]:
"""Check if prompt might exceed model's token limits."""
token_limited_models = {
"openai-community/gpt2": 1500, # 2048 - buffer
"microsoft/phi-2": 1500,
"TinyLlama/TinyLlama-1.1B-Chat-v1.0": 1500
}
if model_name in token_limited_models:
estimated_tokens = estimate_tokens(prompt)
max_tokens = token_limited_models[model_name]
if estimated_tokens > max_tokens:
return False, f"Prompt too long (estimated {estimated_tokens} tokens). This model supports max {max_tokens} tokens."
return True, ""
def copy_to_clipboard(text):
return gr.HTML(f"""
<script>
navigator.clipboard.writeText(`{text}`).then(
function() {{
const btn = document.querySelector('button:contains("Copy to Clipboard")');
btn.textContent = '✅ Copied!';
setTimeout(() => btn.textContent = '📋 Copy to Clipboard', 2000);
}},
function(err) {{
console.error('Failed to copy:', err);
const btn = document.querySelector('button:contains("Copy to Clipboard")');
btn.textContent = '❌ Failed to copy';
setTimeout(() => btn.textContent = '📋 Copy to Clipboard', 2000);
}}
);
</script>
""")
def handle_model_selection(choice):
"""Handle model selection and update UI"""
ctx_size = MODEL_CONTEXT_SIZES.get(choice, {})
if isinstance(ctx_size, dict):
first_model = list(ctx_size.keys())[0]
ctx_size = ctx_size[first_model]
if choice == "OpenAI ChatGPT":
model_choices = list(MODEL_CONTEXT_SIZES["OpenAI ChatGPT"].keys())
return [
gr.update(visible=False), # hf_options
gr.update(visible=False), # groq_options
gr.update(visible=True), # openai_options
gr.update(visible=False), # cohere_options
gr.update(visible=False), # glhf_options
gr.update(value=ctx_size), # context_size
gr.update(interactive=True), # send_model_btn
gr.Dropdown(choices=model_choices, value=first_model), # openai_model
gr.update(visible=False) # hf_custom_model visibility
]
elif choice == "HuggingFace Inference":
model_choices = list(MODEL_CONTEXT_SIZES["HuggingFace Inference"].keys())
return [
gr.update(visible=True), # hf_options
gr.update(visible=False), # groq_options
gr.update(visible=False), # openai_options
gr.update(visible=False), # cohere_options
gr.update(visible=False), # glhf_options
gr.update(value=ctx_size), # context_size
gr.update(interactive=True), # send_model_btn
gr.Dropdown(choices=model_choices, value="mistralai/Mistral-7B-Instruct-v0.3"),
gr.update(visible=False) # hf_custom_model initially hidden
]
elif choice == "Groq API":
model_choices = list(model_registry.groq_models.keys())
return [
gr.update(visible=False), # hf_options
gr.update(visible=True), # groq_options
gr.update(visible=False), # openai_options
gr.update(visible=False), # cohere_options
gr.update(visible=False), # glhf_options
gr.update(value=ctx_size), # context_size
gr.update(interactive=True), # send_model_btn
gr.Dropdown(choices=model_choices, value=model_choices[0] if model_choices else None),
gr.update(visible=False) # hf_custom_model visibility
]
elif choice == "Cohere API":
return [
gr.update(visible=False), # hf_options
gr.update(visible=False), # groq_options
gr.update(visible=False), # openai_options
gr.update(visible=True), # cohere_options
gr.update(visible=False), # glhf_options
gr.update(value=ctx_size), # context_size
gr.update(interactive=True), # send_model_btn
gr.Dropdown(choices=[]), # not used
gr.update(visible=False) # hf_custom_model visibility
]
elif choice == "GLHF API":
model_choices = list(MODEL_CONTEXT_SIZES["GLHF API"].keys())
return [
gr.update(visible=False), # hf_options
gr.update(visible=False), # groq_options
gr.update(visible=False), # openai_options
gr.update(visible=False), # cohere_options
gr.update(visible=True), # glhf_options
gr.update(value=ctx_size), # context_size
gr.update(interactive=True), # send_model_btn
gr.Dropdown(choices=[]), # not used
gr.update(visible=False) # hf_custom_model visibility
]
# Default return for "Clipboard only" or other options
return [
gr.update(visible=False), # hf_options
gr.update(visible=False), # groq_options
gr.update(visible=False), # openai_options
gr.update(visible=False), # cohere_options
gr.update(visible=False), # glhf_options
gr.update(value=4096), # context_size
gr.update(interactive=False), # send_model_btn
gr.Dropdown(choices=[]), # not used
gr.update(visible=False) # hf_custom_model visibility
]
def copy_text_js(element_id: str) -> str:
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 process_pdf(pdf, fmt, ctx_size):
"""Process PDF and return text and snippets"""
try:
if not pdf:
return "Please upload a PDF file.", "", [], None
# Extract text
text = extract_text_from_pdf(pdf.name)
if text.startswith("Error"):
return text, "", [], None
# Format content
formatted_text = format_content(text, fmt)
# Split into snippets
snippets = split_into_snippets(formatted_text, ctx_size)
# Save full text for download
with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as text_file:
text_file.write(formatted_text)
snippet_choices = [f"Snippet {i+1} of {len(snippets)}" for i in range(len(snippets))]
return (
"PDF processed successfully!",
formatted_text,
snippets,
snippet_choices,
[text_file.name]
)
except Exception as e:
logging.error(f"Error processing PDF: {e}")
return f"Error processing PDF: {str(e)}", "", [], None
def generate_prompt(text, template, snippet_idx=None):
"""Generate prompt from text or selected snippet"""
try:
if not text:
return "No text available.", "", None
default_prompt = "Summarize the following text:"
prompt_template = template if template else default_prompt
if isinstance(text, list):
# If text is list of snippets
if snippet_idx is not None:
if 0 <= snippet_idx < len(text):
content = text[snippet_idx]
else:
return "Invalid snippet index.", "", None
else:
content = "\n\n".join(text)
else:
content = text
prompt = f"{prompt_template}\n---\n{content}\n---"
# Save prompt for download
with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as prompt_file:
prompt_file.write(prompt)
return "Prompt generated!", prompt, [prompt_file.name]
except Exception as e:
logging.error(f"Error generating prompt: {e}")
return f"Error generating prompt: {str(e)}", "", None
# Main Interface
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:
# State variables
pdf_content = gr.State("")
snippets = gr.State([])
# Header
gr.Markdown("# 📄 Smart PDF Summarizer")
gr.Markdown("Upload a PDF document and get AI-powered summaries using various AI models.")
with gr.Tabs() as tabs:
# Tab 1: PDF Processing
with gr.Tab("1️⃣ PDF Processing"):
with gr.Row():
with gr.Column(scale=1):
pdf_input = gr.File(
label="📁 Upload PDF",
file_types=[".pdf"]
)
format_type = gr.Radio(
choices=["txt", "md"],
value="txt",
label="📝 Output Format"
)
context_size = gr.Slider(
minimum=1000,
maximum=200000,
step=1000,
value=4096,
label="Context Size"
)
gr.Markdown("### Context Size")
with gr.Row():
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
)
process_button = gr.Button("🔍 Process PDF", variant="primary")
with gr.Column(scale=1):
progress_status = gr.Textbox(
label="Status",
interactive=False,
show_label=True,
visible=True # Ensure error messages are always visible
)
processed_text = gr.Textbox(
label="Processed Text",
lines=10,
max_lines=50,
show_copy_button=True
)
download_full_text = gr.File(label="📥 Download Full Text")
# Tab 2: Snippet Selection
with gr.Tab("2️⃣ Snippet Selection"):
with gr.Row():
with gr.Column(scale=1):
snippet_selector = gr.Dropdown(
label="Select Snippet",
choices=[],
interactive=True
)
custom_prompt = gr.Textbox(
label="✍️ Custom Prompt Template",
placeholder="Enter your custom prompt here...",
lines=2
)
generate_prompt_btn = gr.Button("Generate Prompt", variant="primary")
with gr.Column(scale=1):
generated_prompt = gr.Textbox(
label="📋 Generated Prompt",
lines=10,
max_lines=50,
show_copy_button=True,
elem_id="generated_prompt",
elem_classes="generated_prompt"
)
with gr.Row():
download_prompt = gr.File(label="📥 Download Prompt")
download_snippet = gr.File(label="📥 Download Selected Snippet")
# Tab 3: Model Processing
with gr.Tab("3️⃣ Model Processing"):
with gr.Row():
with gr.Column(scale=1):
model_choice = gr.Radio(
choices=list(MODEL_CONTEXT_SIZES.keys()),
value="Clipboard only",
label="🤖 Provider Selection"
)
# Model-specific option containers
with gr.Column(visible=False) as openai_options:
openai_model = gr.Dropdown(
choices=list(MODEL_CONTEXT_SIZES["OpenAI ChatGPT"].keys()),
value="gpt-3.5-turbo",
label="OpenAI Model"
)
openai_api_key = gr.Textbox(
label="🔑 OpenAI API Key",
type="password"
)
with gr.Column(visible=False) as hf_options:
hf_model = gr.Dropdown(
choices=list(MODEL_CONTEXT_SIZES["HuggingFace Inference"].keys()),
label="🔧 HuggingFace Model",
value="mistralai/Mistral-7B-Instruct-v0.3",
allow_custom_value=True
)
hf_custom_model = gr.Textbox(
label="Custom Model ID",
placeholder="Enter custom model ID...",
visible=False
)
hf_api_key = gr.Textbox(
label="🔑 HuggingFace API Key",
type="password"
)
with gr.Column(visible=False) as groq_options:
groq_model = gr.Dropdown(
choices=list(model_registry.groq_models.keys()),
value=list(model_registry.groq_models.keys())[0] if model_registry.groq_models else None,
label="Groq Model"
)
groq_api_key = gr.Textbox(
label="🔑 Groq API Key",
type="password"
)
groq_refresh_btn = gr.Button("🔄 Refresh Groq Models")
with gr.Column(visible=False) as glhf_options:
glhf_api_key = gr.Textbox(
label="🔑 GLHF API Key",
type="password"
)
glhf_model = gr.Dropdown(
choices=list(MODEL_CONTEXT_SIZES["GLHF API"].keys()),
value="mistralai/Mistral-7B-Instruct-v0.3",
label="Model Selection"
)
glhf_custom_model = gr.Textbox(
label="Custom Model ID",
placeholder="Enter custom model ID...",
visible=False
)
with gr.Column(visible=False) as cohere_options:
cohere_api_key = gr.Textbox(
label="🔑 Cohere API Key",
type="password"
)
cohere_model = gr.Dropdown(
choices=list(MODEL_CONTEXT_SIZES["Cohere API"].keys()),
value="command-r-plus-08-2024",
label="Cohere Model"
)
# Action Buttons Row
with gr.Row():
# Copy to Clipboard button with robust fallbacks
copy_button = gr.HTML("""
<div style="text-align: center; margin: 10px;">
<button
onclick="
try {
const promptArea =
document.querySelector('#generated_prompt textarea') ||
document.querySelector('textarea#generated_prompt') ||
document.querySelector('.generated_prompt textarea') ||
Array.from(document.querySelectorAll('textarea')).find(el => el.value.includes('Summarize'));
if (promptArea && promptArea.value) {
navigator.clipboard.writeText(promptArea.value)
.then(() => {
this.textContent = '✅ Copied!';
setTimeout(() => {
this.textContent = '📋 Copy to Clipboard';
}, 2000);
})
.catch(err => {
console.error('Modern copy failed:', err);
promptArea.select();
document.execCommand('copy');
this.textContent = '✅ Copied using fallback!';
setTimeout(() => {
this.textContent = '📋 Copy to Clipboard';
}, 2000);
});
} else {
this.textContent = '❌ No text found';
setTimeout(() => {
this.textContent = '📋 Copy to Clipboard';
}, 2000);
}
} catch (err) {
console.error('Copy error:', err);
this.textContent = '❌ Copy failed';
setTimeout(() => {
this.textContent = '📋 Copy to Clipboard';
}, 2000);
}
"
style="
padding: 10px 20px;
background-color: #2C3E50;
color: white;
border: none;
border-radius: 5px;
font-weight: bold;
cursor: pointer;
transition: background-color 0.3s ease;
"
onmouseover="this.style.backgroundColor='#34495E'"
onmouseout="this.style.backgroundColor='#2C3E50'"
>
📋 Copy to Clipboard
</button>
</div>
""")
send_to_model_btn = gr.Button("🚀 Send to Model", variant="primary", interactive=False)
# Restore the robust ChatGPT button implementation
chatgpt_button = gr.HTML("""
<div style="text-align: center; margin: 10px;">
<button
onclick="
try {
const promptArea =
document.querySelector('#generated_prompt textarea') ||
document.querySelector('textarea#generated_prompt') ||
document.querySelector('.generated_prompt textarea') ||
Array.from(document.querySelectorAll('textarea')).find(el => el.value.includes('Summarize'));
if (promptArea && promptArea.value) {
navigator.clipboard.writeText(promptArea.value)
.then(() => {
this.textContent = '✅ Copied! Opening ChatGPT...';
setTimeout(() => {
window.open('https://chat.openai.com/', '_blank');
setTimeout(() => {
this.textContent = '📋 Copy & Open ChatGPT';
}, 2000);
}, 500);
})
.catch(err => {
console.error('Modern copy failed:', err);
promptArea.select();
document.execCommand('copy');
this.textContent = '✅ Copied! Opening ChatGPT...';
setTimeout(() => {
window.open('https://chat.openai.com/', '_blank');
setTimeout(() => {
this.textContent = '📋 Copy & Open ChatGPT';
}, 2000);
}, 500);
});
} else {
this.textContent = '❌ No prompt found. Generate one first.';
setTimeout(() => {
this.textContent = '📋 Copy & Open ChatGPT';
}, 2000);
}
} catch (err) {
console.error('Copy error:', err);
this.textContent = '❌ Copy failed. Try again.';
setTimeout(() => {
this.textContent = '📋 Copy & Open ChatGPT';
}, 2000);
}
"
style="
padding: 10px 20px;
background-color: #2C3E50;
color: white;
border: none;
border-radius: 5px;
font-weight: bold;
cursor: pointer;
transition: background-color 0.3s ease;
"
onmouseover="this.style.backgroundColor='#34495E'"
onmouseout="this.style.backgroundColor='#2C3E50'"
>
📋 Copy & Open ChatGPT
</button>
</div>
""")
# JavaScript for model choice handling
gr.HTML("""
<script>
// Enable/disable send button based on selection
document.querySelector('input[name="model_choice"]').addEventListener('change', function(e) {
const sendButton = document.querySelector('button:contains("Send to Model")');
if (sendButton) {
sendButton.disabled = (e.target.value === 'Clipboard only');
}
});
</script>
""")
# Summary section
with gr.Column(scale=1):
summary_output = gr.Textbox(
label="📝 Summary",
lines=15,
max_lines=50,
show_copy_button=True,
elem_id="summary_output"
)
# Summary actions row
with gr.Row():
copy_summary_btn = gr.Button("📋 Copy Summary", size="sm")
download_summary = gr.File(label="📥 Download Summary")
# Status display
clipboard_status = gr.HTML(elem_id="clipboard_status")
# Hidden components for file handling
download_files = gr.Files(label="📥 Downloads", visible=False)
# Event Handlers
def update_context_size(size: int) -> None:
"""Update context size slider with validation"""
if not isinstance(size, (int, float)):
size = 4096 # Default size
return gr.update(value=int(size))
def get_model_context_size(choice: str, groq_model: str = None) -> int:
"""Get context size for model with better defaults"""
if choice == "Groq API" and groq_model:
return MODEL_CONTEXT_SIZES["Groq API"].get(groq_model, 4096)
elif choice == "OpenAI ChatGPT":
return 4096
elif choice == "HuggingFace Inference":
return 4096
return 32000 # Safe default
def update_snippet_choices(snippets_list: List[str]) -> List[str]:
"""Create formatted snippet choices"""
return [f"Snippet {i+1} of {len(snippets_list)}" for i in range(len(snippets_list))]
def get_snippet_index(choice: str) -> int:
"""Extract snippet index from choice string"""
if not choice:
return 0
try:
return int(choice.split()[1]) - 1
except:
return 0
def toggle_model_options(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(visible=choice == "Cohere API"), # cohere_options
gr.update(visible=choice == "GLHF API") # glhf_options
)
def refresh_groq_models_list():
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")
def handle_groq_model_change(model_name):
"""Handle Groq model selection change"""
return update_context_size("Groq API", model_name)
# PDF Processing Handlers
def handle_pdf_process(pdf, fmt, ctx_size): # Remove md_eng parameter
if not pdf:
return "Please upload a PDF file.", "", "", [], gr.update(choices=[], value=None), None
try:
text = extract_text_from_pdf(pdf.name, format_type=fmt) # Just use format_type
if text.startswith("Error"):
return text, "", "", [], gr.update(choices=[], value=None), None
# The important part: still do snippets processing
snippets_list = split_into_snippets(text, ctx_size)
snippet_choices = update_snippet_choices(snippets_list)
with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix=f'.{fmt}') as f:
f.write(text)
download_file = f.name
return (
f"PDF processed successfully! Generated {len(snippets_list)} snippets.",
text,
text,
snippets_list,
gr.update(choices=snippet_choices, value=snippet_choices[0] if snippet_choices else None),
download_file
)
except Exception as e:
error_msg = f"Error processing PDF: {str(e)}"
logging.error(error_msg)
return error_msg, "", "", [], gr.update(choices=[], value=None), None
def handle_snippet_selection(choice, snippets_list): # Add download_snippet output
"""Handle snippet selection, update prompt, and provide snippet download."""
if not snippets_list:
return "No snippets available.", "", None # Return None for download
try:
idx = get_snippet_index(choice)
selected_snippet = snippets_list[idx]
with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt') as f:
f.write(selected_snippet)
snippet_download_file = f.name # Store the file path
return (
f"Selected snippet {idx + 1}",
selected_snippet,
snippet_download_file # Return file for download
)
except Exception as e:
error_msg = f"Error selecting snippet: {str(e)}"
logging.error(error_msg)
return (
error_msg,
"",
None
)
# Copy button handlers
def handle_prompt_generation(snippet_text, template, snippet_choice, snippets_list):
try:
if not snippets_list:
return "No text available.", "", None
idx = get_snippet_index(snippet_choice)
base_prompt = template if template else "Summarize the following text:"
content = snippets_list[idx]
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)
download_file = f.name
return "Prompt generated!", prompt, download_file # Return the file for download_prompt
except Exception as e:
logging.error(f"Error generating prompt: {e}")
return f"Error: {str(e)}", "", None
def handle_copy_action(text):
"""Handle copy to clipboard action"""
return {
progress_status: gr.update(value="Text copied to clipboard!", visible=True)
}
# Connect all event handlers
# Core event handlers
process_button.click(
handle_pdf_process,
inputs=[pdf_input, format_type, context_size],
outputs=[progress_status, processed_text, pdf_content, snippets, snippet_selector, download_full_text]
)
generate_prompt_btn.click(
handle_prompt_generation,
inputs=[generated_prompt, custom_prompt, snippet_selector, snippets],
outputs=[progress_status, generated_prompt, download_prompt]
)
# copy_button.click(
# fn=copy_to_clipboard,
# inputs=[generated_prompt],
# outputs=[clipboard_status]
# )
# copy_summary_btn.click(
# fn=None,
# inputs=[],
# outputs=[],
# _js=copy_summary_js
# )
# Snippet handling
snippet_selector.change(
handle_snippet_selection,
inputs=[snippet_selector, snippets],
outputs=[progress_status, generated_prompt, download_snippet] # Connect download_snippet
)
# Model selection
model_choice.change(
handle_model_selection,
inputs=[model_choice],
outputs=[
hf_options,
groq_options,
openai_options,
cohere_options,
glhf_options,
context_size,
send_to_model_btn,
hf_model, # For updating model choices
hf_custom_model # Add this to update custom model visibility
]
)
hf_model.change(
toggle_custom_model,
inputs=[hf_model],
outputs=[hf_custom_model]
)
groq_model.change(
handle_groq_model_change,
inputs=[groq_model],
outputs=[context_size]
)
def download_file(content: str, prefix: str) -> List[str]:
if not content:
return []
try:
filename = f"{prefix}_{int(time.time())}.txt" # Add timestamp
with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt', prefix=filename) as f:
f.write(content)
return [f.name]
except Exception as e:
logging.error(f"Error creating download file: {e}")
return []
# Model processing
send_to_model_btn.click(
fn=send_to_model,
inputs=[
generated_prompt,
model_choice,
hf_model,
hf_custom_model,
hf_api_key,
groq_model,
groq_api_key,
openai_api_key,
openai_model,
cohere_api_key,
cohere_model,
glhf_api_key,
glhf_model,
glhf_custom_model
],
outputs=[
clipboard_status, # HTML component for clipboard status
summary_output, # Textbox for summary
download_summary # File component for download
]
)
groq_refresh_btn.click(
refresh_groq_models_list,
outputs=[groq_model]
)
# Instructions
gr.Markdown("""
### 📌 Instructions:
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 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, optionally, 'Open ChatGPT' for manual processing
7. Download generated files as needed
""")
# Launch the interface
if __name__ == "__main__":
demo.launch(share=False, debug=True)