Update app.py

app.py

@@ -1,24 +1,17 @@
-import random
+import fitz  # PyMuPDF
+import gradio as gr
 import requests
 from bs4 import BeautifulSoup
-from transformers import AutoTokenizer, AutoModelForCausalLM
-from huggingface_hub import login
-import torch
+import urllib.parse
+import random
 import os
+from dotenv import load_dotenv
 
-# Ensure sentencepiece is installed
-try:
-    import sentencepiece
-except ImportError:
-    raise ImportError("Please install the sentencepiece library using `pip install sentencepiece`.")
-
-# Retrieve the Hugging Face token from secrets (replace 'HUGGINGFACE_TOKEN' with your secret key)
-hf_token = os.getenv('HUGGINGFACE_TOKEN')
+load_dotenv()  # Load environment variables from .env file
 
-# Log in to Hugging Face
-login(token=hf_token)
+# Now replace the hard-coded token with the environment variable
+HUGGINGFACE_API_TOKEN = os.getenv("HUGGINGFACE_TOKEN")
 
-# List of user agents
 _useragent_list = [
     "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
     "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
@@ -45,7 +38,7 @@ def extract_text_from_webpage(html):
 def google_search(term, num_results=5, lang="en", timeout=5, safe="active", ssl_verify=None):
     """Performs a Google search and returns the results."""
     print(f"Searching for term: {term}")
-    escaped_term = requests.utils.quote(term)
+    escaped_term = urllib.parse.quote_plus(term)
     start = 0
     all_results = []
     max_chars_per_page = 8000  # Limit the number of characters from each webpage to stay under the token limit
@@ -106,30 +99,191 @@ def google_search(term, num_results=5, lang="en", timeout=5, safe="active", ssl_
     print(f"Total results fetched: {len(all_results)}")
     return all_results
 
-# Load the Mixtral-8x7B-Instruct model and tokenizer
-model_name = 'mistralai/Mistral-7B-Instruct-v0.3'
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-model = AutoModelForCausalLM.from_pretrained(model_name)
+# Function to format the prompt for the Hugging Face API
+def format_prompt(query, search_results, instructions):
+    formatted_results = ""
+    for result in search_results:
+        link = result["link"]
+        text = result["text"]
+        if link:
+            formatted_results += f"URL: {link}\nContent: {text}\n{'-'*80}\n"
+        else:
+            formatted_results += "No link found.\n" + '-'*80 + '\n'
+
+    prompt = f"{instructions}User Query: {query}\n\nWeb Search Results:\n{formatted_results}\n\nAssistant:"
+    return prompt
+
+# Function to generate text using Hugging Face API
+def generate_text(input_text, temperature=0.7, repetition_penalty=1.0, top_p=0.9):
+    print("Generating text using Hugging Face API...")
+    endpoint = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.3"
+    headers = {
+        "Authorization": f"Bearer {HUGGINGFACE_API_TOKEN}",  # Use the environment variable
+        "Content-Type": "application/json"
+    }
+    data = {
+        "inputs": input_text,
+        "parameters": {
+            "max_new_tokens": 4000,  # Adjust as needed
+            "temperature": temperature,
+            "repetition_penalty": repetition_penalty,
+            "top_p": top_p
+        }
+    }
+
+    try:
+        response = requests.post(endpoint, headers=headers, json=data)
+        response.raise_for_status()
+
+        # Check if response is JSON
+        try:
+            json_data = response.json()
+        except ValueError:
+            print("Response is not JSON.")
+            return None
+
+        # Extract generated text from response JSON
+        if isinstance(json_data, list):
+            # Handle list response (if applicable for your use case)
+            generated_text = json_data[0].get("generated_text") if json_data else None
+        elif isinstance(json_data, dict):
+            # Handle dictionary response
+            generated_text = json_data.get("generated_text")
+        else:
+            print("Unexpected response format.")
+            return None
+
+        if generated_text is not None:
+            print("Text generation complete using Hugging Face API.")
+            print(f"Generated text: {generated_text}")  # Debugging line
+            return generated_text
+        else:
+            print("Generated text not found in response.")
+            return None
+
+    except requests.exceptions.RequestException as e:
+        print(f"Error generating text using Hugging Face API: {e}")
+        return None
+
+# Function to read and extract text from a PDF
+def read_pdf(file_obj):
+    with fitz.open(file_obj.name) as document:
+        text = ""
+        for page_num in range(document.page_count):
+            page = document.load_page(page_num)
+            text += page.get_text()
+        return text
 
-# Check if a GPU is available and if not, fall back to CPU
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")  # Check for GPU
-model.to(device)  # Move model to the device
+# Function to format the prompt with instructions for text generation
+def format_prompt_with_instructions(text, instructions):
+    prompt = f"{instructions}{text}\n\nAssistant:"
+    return prompt
 
-# Example usage
-search_term = "How did Tesla perform in Q1 2024"
-search_results = google_search(search_term, num_results=3)
+# Function to save text to a PDF
+def save_text_to_pdf(text, output_path):
+    print(f"Saving text to PDF at {output_path}...")
+    doc = fitz.open()  # Create a new PDF document
+    page = doc.new_page()  # Create a new page
 
-# Combine text from search results to create a prompt
-combined_text = "\n\n".join(result['text'] for result in search_results if result['text'])
+    # Set the page margins
+    margin = 50  # 50 points margin
+    page_width = page.rect.width
+    page_height = page.rect.height
+    text_width = page_width - 2 * margin
+    text_height = page_height - 2 * margin
 
-# Tokenize the input text
-inputs = tokenizer(combined_text, return_tensors="pt").to(device)  # Move inputs to the device
+    # Define font size and line spacing
+    font_size = 9
+    line_spacing = 1 * font_size
+    fontname = "times-roman"  # Use a supported font name
 
-# Generate a response
-outputs = model.generate(**inputs, max_length=150, temperature=0.7, top_p=0.9, top_k=50)
+    # Process the text to handle line breaks and paragraphs
+    paragraphs = text.split("\n")  # Split text into paragraphs
+    y_position = margin
 
-# Decode the generated tokens to a readable string
-response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    for paragraph in paragraphs:
+        words = paragraph.split()
+        current_line = ""
+
+        for word in words:
+            word = str(word)  # Ensure word is treated as string
+            # Calculate the length of the current line plus the new word
+            current_line_length = fitz.get_text_length(current_line + " " + word, fontsize=font_size, fontname=fontname)
+            if current_line_length <= text_width:
+                current_line += " " + word
+            else:
+                page.insert_text(fitz.Point(margin, y_position), current_line.strip(), fontsize=font_size, fontname=fontname)
+                y_position += line_spacing
+                if y_position + line_spacing > page_height - margin:
+                    page = doc.new_page()  # Add a new page if text exceeds page height
+                    y_position = margin
+                current_line = word
+
+        # Add the last line of the paragraph
+        page.insert_text(fitz.Point(margin, y_position), current_line.strip(), fontsize=font_size, fontname=fontname)
+        y_position += line_spacing
+
+        # Add extra space for new paragraph
+        y_position += line_spacing
+        if y_position + line_spacing > page_height - margin:
+            page = doc.new_page()  # Add a new page if text exceeds page height
+            y_position = margin
+
+    doc.save(output_path)  # Save the PDF to the specified path
+    print("PDF saved successfully.")
+
+
+
+
+# Integrated function to perform web scraping, formatting, and text generation
+def scrape_and_display(query, num_results, instructions, web_search=True, temperature=0.7, repetition_penalty=1.0, top_p=0.9):
+    print(f"Scraping and displaying results for query: {query} with num_results: {num_results}")
+    if web_search:
+        search_results = google_search(query, num_results)
+        formatted_prompt = format_prompt(query, search_results, instructions)
+        generated_summary = generate_text(formatted_prompt, temperature=temperature, repetition_penalty=repetition_penalty, top_p=top_p)
+    else:
+        formatted_prompt = format_prompt_with_instructions(query, instructions)
+        generated_summary = generate_text(formatted_prompt, temperature=temperature, repetition_penalty=repetition_penalty, top_p=top_p)
+    print("Scraping and display complete.")
+    if generated_summary:
+        # Extract and return text starting from "Assistant:"
+        assistant_index = generated_summary.find("Assistant:")
+        if assistant_index != -1:
+            generated_summary = generated_summary[assistant_index:]
+        else:
+            generated_summary = "Assistant: No response generated."
+    print(f"Generated summary: {generated_summary}")  # Debugging line
+    return generated_summary
+
+# Main Gradio interface function
+def gradio_interface(query, use_pdf, pdf, num_results, instructions, temperature, repetition_penalty, top_p):
+    if use_pdf and pdf is not None:
+        pdf_text = read_pdf(pdf)
+        generated_summary = scrape_and_display(pdf_text, num_results=0, instructions=instructions, web_search=False, temperature=temperature, repetition_penalty=repetition_penalty, top_p=top_p)
+    else:
+        generated_summary = scrape_and_display(query, num_results=num_results, instructions=instructions, web_search=True, temperature=temperature, repetition_penalty=repetition_penalty, top_p=top_p)
+    
+    # Save the generated summary to a PDF
+    output_pdf_path = "output_summary.pdf"
+    save_text_to_pdf(generated_summary, output_pdf_path)
+    
+    return generated_summary, output_pdf_path
 
-# Print the response
-print(response)
+# Deploy Gradio Interface
+gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Textbox(label="Query"),
+        gr.Checkbox(label="Use PDF"),
+        gr.File(label="Upload PDF"),
+        gr.Slider(minimum=1, maximum=20, label="Number of Results"),  # Added Slider for num_results
+        gr.Textbox(label="Instructions"),
+        gr.Slider(minimum=0.1, maximum=1.0, step=1, label="Temperature"),
+        gr.Slider(minimum=0.1, maximum=1.0, label="Repetition Penalty"),
+        gr.Slider(minimum=0.1, maximum=1.0, label="Top p")
+    ],
+    outputs=["text", "file"],  # Updated to return text and a file
+    title="Financial Analyst AI Assistant",
+    description="Enter your query about a company's financials to get valuable insights. Optionally, upload a PDF for analysis.Please instruct me for curating your output template, also for web search you can modify my search results but its advisable to restrict the same at 10. You can also adjust my parameters like Temperature, Repetition Penalty and Top_P, its adivsable to set repetition penalty at 1 and other two parameters at 0.1.",
+).launch(share=True)