app.py

import os
import torch
from transformers import AutoModelForCausalLM as m, AutoTokenizer as t
mod=m.from_pretrained("peterpeter8585/sungyoonaimodel2")
tok=t.from_pretrained("peterpeter8585/sungyoonaimodel2", trust_remote_code=True)
mod.eval()
import requests
from bs4 import BeautifulSoup
import urllib
import random
import gradio as gr
chatbot = gr.Chatbot(
    label="OpenGPT-4o-Chatty",
    avatar_images=["user.png", "OpenAI_logo.png"],
    show_copy_button=True,
    likeable=True,
    layout="panel"
)

# List of user agents to choose from for requests
_useragent_list = [
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:66.0) Gecko/20100101 Firefox/66.0',
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36',
    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36',
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36 Edg/111.0.1661.62',
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0'
]

def get_useragent():
    """Returns a random user agent from the list."""
    return random.choice(_useragent_list)

def extract_text_from_webpage(html_content):
    """Extracts visible text from HTML content using BeautifulSoup."""
    soup = BeautifulSoup(html_content, "html.parser")
    # Remove unwanted tags
    for tag in soup(["script", "style", "header", "footer", "nav"]):
        tag.extract()
    # Get the remaining visible text
    visible_text = soup.get_text(strip=True)
    return visible_text

def search(term, num_results=1, lang="ko", advanced=True, sleep_interval=0, timeout=5, safe="active", ssl_verify=None):
    """Performs a Google search and returns the results."""
    escaped_term = urllib.parse.quote_plus(term)
    start = 0
    all_results = []

    # Fetch results in batches
    while start < num_results:
        resp = requests.get(
            url="https://www.google.com/search",
            headers={"User-Agent": get_useragent()}, # Set random user agent
            params={
                "q": term,
                "num": num_results - start, # Number of results to fetch in this batch
                "hl": lang,
                "start": start,
                "safe": safe,
            },
            timeout=timeout,
            verify=ssl_verify,
        )
        resp.raise_for_status() # Raise an exception if request fails

        soup = BeautifulSoup(resp.text, "html.parser")
        result_block = soup.find_all("div", attrs={"class": "g"})

        # If no results, continue to the next batch
        if not result_block:
            start += 1
            continue

        # Extract link and text from each result
        for result in result_block:
            link = result.find("a", href=True)
            if link:
                link = link["href"]
                try:
                    # Fetch webpage content
                    webpage = requests.get(link, headers={"User-Agent": get_useragent()})
                    webpage.raise_for_status()
                    # Extract visible text from webpage
                    visible_text = extract_text_from_webpage(webpage.text)
                    all_results.append({"link": link, "text": visible_text})
                except requests.exceptions.RequestException as e:
                    # Handle errors fetching or processing webpage
                    print(f"Error fetching or processing {link}: {e}")
                    all_results.append({"link": link, "text": None})
            else:
                all_results.append({"link": None, "text": None})

        start += len(result_block) # Update starting index for next batch

    return all_results

def chat(message,
    history: list[tuple[str, str]],
    system_message,
    max_tokens,
    temperature,
    top_p):
    s=search(term="괴도키드", num_results=5)
    messages=[{"role":"system","content":f"You are Kaito KID of the animation conan.this is the information of Kaito KID:{s}"+f"And, your name is also Kaito KID."}]
    for val in history:
        if val[0]:
            messages.append({"role": "user", "content": val[0]})
        if val[1]:
            messages.append({"role": "assistant", "content": val[1]})

    messages.append({"role": "user", "content": message})
    input_ids=tok.apply_chat_template(messages, add_generation_prompt=True,return_tensors="pt")
    with torch.no_grad():
      o=mod.generate(input_ids, max_new_tokens=max_tokens,do_sample=True,temperature=temperature,top_p=top_p)[0][input_ids.shape[-1]:]
    ans=tok.decode(o, skip_special_tokens=True)
    yield ans
ai1=gr.ChatInterface(
    chat,
    chatbot=chatbot,
    additional_inputs=[
        gr.Textbox(value="You are Kaito KID", label="System message",  interactive=False),
        gr.Slider(minimum=1, maximum=2048, value=400, step=1, label="Max new tokens"),
        gr.Slider(minimum=0.1, maximum=4.0, value=0.1, step=0.1, label="Temperature"),
        gr.Slider(
            minimum=0.1,
            maximum=1.0,
            value=0.1,
            step=0.05,
            label="Top-p (nucleus sampling)",
        )      
    ],
)
with gr.Blocks(theme="prithivMLmods/Minecraft-Theme") as ai:
    gr.TabbedInterface([ai1],["Chatchat"])
    ai.launch()