Minichan

from googlesearch import search
import openai
import requests
from bs4 import BeautifulSoup

# Authenticate to the OpenAI API
openai.api_key = "YOUR_API_KEY"

# Define the OpenAI language model
model_engine = "davinci"

# Prompt the user for a search query
query = input("Enter a search query: ")
summary = ""

while True:
    # Define the number of search results to retrieve
    num_results = 5

    # Search Google and retrieve the first 5 results
    search_results = list(search(query, num_results=num_results))

    # Define a list to store the relevance scores for each message
    relevance_scores = []

    # Iterate over the search results and prompt the user to enter a message
    for i, result in enumerate(search_results):
        print(f"Result {i+1}: {result}")
        message = input("Enter a message to compare with this result: ")

        # Compare the relevance of the message to the search query using OpenAI
        prompt = f"Compare the relevance of the message '{message}' to the search query '{query}'"
        response = openai.Completion.create(
            engine=model_engine,
            prompt=prompt,
            max_tokens=1024,
            n=1,
            stop=None,
            temperature=0.7,
        )

        # Store the relevance score for this message
        relevance_score = response.choices[0].text.strip()
        relevance_scores.append(float(relevance_score))
        print(f"Relevance score: {relevance_score}\n")

    # Find the index of the message with the highest relevance score
    max_index = relevance_scores.index(max(relevance_scores))

    # Get the HTML content of the suggested search result page
    response = requests.get(search_results[max_index])
    soup = BeautifulSoup(response.content, "html.parser")

    # Extract the text content of the page
    text_content = ""
    for paragraph in soup.find_all("p"):
        text_content += paragraph.get_text() + "\n"

    # Define a prompt for OpenAI to summarize the text using the original search query
    prompt = f"Summarize the text content of '{search_results[max_index]}' that is most relevant to the search query '{query}'"

    # Generate a summary using OpenAI's language model
    response = openai.Completion.create(
        engine=model_engine,
        prompt=prompt,
        max_tokens=1024,
        n=1,
        stop=None,
        temperature=0.7,
    )

    # Output the summary
    summary = response.choices[0].text.strip()
    print(f"\nHere's a summary of the text content that is most relevant to the search query '{query}':\n{summary}\n")

    # Prompt the user to rate the summary
    rating = input("Did the summary satisfy your search? (y/n): ")

    if rating.lower() == "y":
        print("Great! I'm glad I could help you find what you were looking for.")
        break
    else:
        print("I'm sorry the summary wasn't satisfactory. Please try refining your search query.")
        query = input("Enter a new search query: ")

import openai
import requests
from bs4 import BeautifulSoup
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize, sent_tokenize
import re
from flask import Flask, request, render_template

# Set up OpenAI API credentials
openai.api_key = "YOUR_API_KEY"

# Define function to search Google and scrape text content from top results
def search_google(query):
    # Search Google and get top 5 results
    url = f"https://www.google.com/search?q={query}&num=5"
    res = requests.get(url)
    soup = BeautifulSoup(res.text, "html.parser")
    search_results = soup.select(".kCrYT a")
    urls = [result.get("href") for result in search_results]

    # Scrape text content from top results
    text = ""
    for url in urls:
        res = requests.get(url)
        soup = BeautifulSoup(res.text, "html.parser")
        content = soup.find_all("p")
        text += " ".join([c.get_text() for c in content])

    return text

# Define function to generate questions from text content using ChatGPT
def generate_questions(text):
    # Use ChatGPT to generate questions from text content
    prompt = f"Generate questions from the following text: {text}"
    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        temperature=0.7,
        max_tokens=50,
        n=1,
        stop=None,
        timeout=15,
    )

    # Extract questions from OpenAI API response
    questions = []
    for choice in response.choices:
        question = choice.text.strip()
        if question.endswith("?"):
            questions.append(question)

    return questions

# Define function to summarize text content using ChatGPT
def summarize_text(text, keywords):
    # Use ChatGPT to summarize text content based on keywords
    prompt = f"Summarize the following text: {text} based on the keywords: {keywords}"
    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        temperature=0.7,
        max_tokens=100,
        n=1,
        stop=None,
        timeout=15,
    )

    # Extract summary from OpenAI API response
    summary = response.choices[0].text.strip()

    return summary

# Set up Flask app
app = Flask(__name__)

# Define home page
@app.route("/", methods=["GET", "POST"])
def home():
    if request.method == "POST":
        # Get search query from user input
        query = request.form["query"]

        # Search Google and scrape text content from top results
        text = search_google(query)

        # Generate questions from text content using ChatGPT
        questions = generate_questions(text)

        # Prompt user to refine search based on generated questions
        while True:
            # Check if there are any questions left to ask
            if len(questions) == 0:
                return render_template("no_results.html")

            # Ask next question
            question = questions.pop(0)

            # Render question page and get user's answer
            if question.startswith("What") or question.startswith("Who") or question.startswith("Where"):
                return render_template("question.html", question=question, query=query, yesno=False)
            else:
                return render_template("question.html", question=question, query=query, yesno=True)

            answer = request.form["answer"]

            # If answer is yes, summarize text content using ChatGPT and return result
                    if answer.lower() == "y":
            keywords = re.findall(r"\w+", query)
            summary = summarize_text(text, keywords)
            return render_template("result.html", summary=summary, query=query)

# Render home page if method is GET
else:
    return render_template("home.html")
Run Flask app
if name == "main":
app.run(debug=True)# Define home page (continued)
            if answer.lower() == "y":
                keywords = re.findall(r"\w+", query)
                summary = summarize_text(text, keywords)
                return render_template("result.html", summary=summary, query=query)

    # Render home page if method is GET
    else:
        return render_template("home.html")

# Run Flask app
if __name__ == "__main__":
    app.run(debug=True)

import requests
from bs4 import BeautifulSoup
from nltk.tokenize import sent_tokenize

# Define function to search Google and scrape text content from top results
def search_google(query):
    # Search Google and get top 5 results
    url = f"https://www.google.com/search?q={query}&num=5"
    res = requests.get(url)
    soup = BeautifulSoup(res.text, "html.parser")
    search_results = soup.select(".kCrYT a")
    urls = [result.get("href") for result in search_results]

    # Scrape text content from top results
    text = ""
    for url in urls:
        res = requests.get(url)
        soup = BeautifulSoup(res.text, "html.parser")
        content = soup.find_all("p")
        text += " ".join([c.get_text() for c in content])

    return text

# Define function to generate questions from text content
def generate_questions(text):
    # Split text into sentences and generate questions from each sentence
    sentences = sent_tokenize(text)
    questions = []
    for sentence in sentences:
        # Skip short or incomplete sentences
        if len(sentence) < 10 or sentence.endswith(("?", ".", "!", ":", ";"))):
            continue
        # Generate question from sentence
        question = sentence.capitalize() + "?"
        # Add question to list
        questions.append(question)
    return questions

# Prompt user to refine search based on generated questions
def refine_search(query, text):
    # Generate questions from text content
    questions = generate_questions(text)

    # Loop through questions and prompt user to refine search based on each question
    for question in questions:
        print(question)
        answer = input("Do you want to refine your search based on this question? (y/n) ")

        # If answer is yes, add question to search query and search again
        if answer.lower() == "y":
            query += " " + question

            # Search Google and scrape text content from top results again
            text = search_google(query)

            # Recursively refine search based on new questions generated from updated text
            refine_search(query, text)

            # Stop looping through questions
            break

    # Return final search query and text content
    return query, text

# Get search query from user input
query = input("Enter search query: ")

# Search Google and scrape text content from top results
text = search_google(query)

# Refine search based on generated questions
refined_query, refined_text = refine_search(query, text)

# Print final search query and text content
print("Final search query: ", refined_query)
print("Text content: ", refined_text)

import requests
import sys
from bs4 import BeautifulSoup
from nltk.tokenize import sent_tokenize

def search_google(query):
    query = query.replace(' ', '+')
    url = f"https://www.google.com/search?q={query}"
    res = requests.get(url)
    soup = BeautifulSoup(res.text, 'html.parser')
    search_results = soup.select('a')
    text_content = ''
    for link in search_results:
        href = link.get('href')
        if href and href.startswith("/url?q="):
            url = href.replace("/url?q=", '').split('&')[0]
            res = requests.get(url)
            soup = BeautifulSoup(res.text, 'html.parser')
            for script in soup(["script", "style"]):
                script.decompose()
            text_content += soup.get_text()
    return text_content

def get_answer(prompt):
    while True:
        answer = input(prompt).strip().lower()
        if answer in ['yes', 'no']:
            return answer
        elif answer in ['stop', 'end']:
            print("Exiting program.")
            sys.exit(0)
        else:
            print("Please enter 'yes' or 'no'.")

def main():
    query = input("Enter search query: ")
    print(f"Final search query:  {query}")
    text = search_google(query)
    print(f"Text content:\n{text}")
    answer = get_answer("Do you want to summarize the text content? (yes/no) ")
    if answer.lower() == "yes":
        sentences = sent_tokenize(text)
        summary = []
        for sentence in sentences:
            if len(summary) < 3 and len(sentence) > 10 and sentence.endswith(("?", ".", "!", ":", ";")):
                summary.append(sentence)
        print("Summary:")
        print("\n".join(summary))
        print("End of summary.")
    else:
        print("No summary generated.")
        print("Exiting program.")
        sys.exit(0)

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        print("\nExiting program.")
        sys.exit(0)

import requests
import sys
from bs4 import BeautifulSoup
from nltk.tokenize import sent_tokenize


def search_google(query):
    query = query.replace(' ', '+')
    url = f"https://www.google.com/search?q={query}"
    res = requests.get(url)
    soup = BeautifulSoup(res.text, 'html.parser')
    search_results = soup.select('a')
    text_content = ''
    for link in search_results:
        href = link.get('href')
        if href and href.startswith("/url?q="):
            url = href.replace("/url?q=", '').split('&')[0]
            res = requests.get(url)
            soup = BeautifulSoup(res.text, 'html.parser')
            for script in soup(["script", "style"]):
                script.decompose()
            text_content += soup.get_text()
    return text_content


def get_answer(prompt):
    while True:
        answer = input(prompt).strip().lower()
        if answer in ['yes', 'no']:
            return answer
        elif answer in ['stop', 'end']:
            print("Exiting program.")
            sys.exit(0)
        else:
            print("Please enter 'yes' or 'no'.")


def main():
    query = input("Enter search query: ")
    print(f"Final search query:  {query}")
    text = search_google(query)
    print(f"Text content:\n{text}")
    with open("sploogecatcher.txt", "w", encoding='utf-8') as f:
        f.write(f"Text content:\n{text}\n")  # Write the text content to the file
    answer = get_answer("Do you want to summarize the text content? (yes/no) ")
    if answer.lower() == "yes":
        sentences = sent_tokenize(text)
        summary = []
        for sentence in sentences:
            if len(summary) < 3 and len(sentence) > 10 and sentence.endswith(("?", ".", "!", ":", ";")):
                summary.append(sentence)
        print("Summary:")
        print("\n".join(summary))
        print("End of summary.")
        with open("sploogecatcher.txt", "a", encoding='utf-8') as f:
            f.write("\n\nSummary:\n")
            f.write("\n".join(summary))  # Write the summary to the file
            f.write("\nEnd of summary.")
    else:
        print("No summary generated.")
        print("Exiting program.")
        sys.exit(0)


if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        print("\nExiting program.")
        sys.exit(0)

        pip install requests beautifulsoup4 nltk

        import nltk
        nltk.download("punkt")