Update app.py

app.py

@@ -1,222 +1,109 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
-import json
-import uuid
-from PIL import Image
-from bs4 import BeautifulSoup
 import requests
-import random
-from transformers import LlavaProcessor, LlavaForConditionalGeneration, TextIteratorStreamer
-from threading import Thread
-import re
-import time 
-import torch
+from bs4 import BeautifulSoup
 import cv2
-from gradio_client import Client, file
-
-def image_gen(prompt):
-    client = Client("KingNish/Image-Gen-Pro")
-    return client.predict("Image Generation",None, prompt, api_name="/image_gen_pro")
-
-model_id = "llava-hf/llava-interleave-qwen-0.5b-hf"
-
-processor = LlavaProcessor.from_pretrained(model_id)
+from PIL import Image
+from transformers import pipeline
+from huggingface_hub import InferenceApi
+import sqlite3
+from sqlalchemy import create_engine, Column, Integer, String, MetaData, Table
+from sqlalchemy.orm import sessionmaker
+import json
+import random
+import io
 
-model = LlavaForConditionalGeneration.from_pretrained(model_id)
-model.to("cpu")
+# Setting up the SQLAlchemy engine and session
+DATABASE_URL = "sqlite:///chatbot.db"
+engine = create_engine(DATABASE_URL)
+Session = sessionmaker(bind=engine)
+session = Session()
+metadata = MetaData()
 
+# Load the image generation model (for example, using a Hugging Face model)
+image_generator = pipeline("image-generation", model="CompVis/stable-diffusion-v1-4")
 
-def llava(message, history):
-    if message["files"]:
-        image = message["files"][0]    
-    else:
-        for hist in history:
-            if type(hist[0])==tuple:
-                image = hist[0][0]
-        
-    txt = message["text"]
-        
-    gr.Info("Analyzing image")
-    image = Image.open(image).convert("RGB")
-    prompt = f"<|im_start|>user <image>\n{txt}<|im_end|><|im_start|>assistant"
+def create_table(table_name, columns):
+    if table_name in engine.table_names():
+        return f"Table '{table_name}' already exists."
     
-    inputs = processor(prompt, image, return_tensors="pt")
-    return inputs
-
-def extract_text_from_webpage(html_content):
-    soup = BeautifulSoup(html_content, 'html.parser')
-    for tag in soup(["script", "style", "header", "footer"]):
-        tag.extract()
-    return soup.get_text(strip=True)
-
-def search(query):
-    term = query
-    start = 0
-    all_results = []
-    max_chars_per_page = 8000
-    with requests.Session() as session:
-        resp = session.get(
-            url="https://www.google.com/search",
-            headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0"},
-            params={"q": term, "num": 3, "udm": 14},
-            timeout=5,
-            verify=None,
-        )
-        resp.raise_for_status()
-        soup = BeautifulSoup(resp.text, "html.parser")
-        result_block = soup.find_all("div", attrs={"class": "g"})
-        for result in result_block:
-            link = result.find("a", href=True)
-            link = link["href"]
-            try:
-                webpage = session.get(link, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/111.0"}, timeout=5, verify=False)
-                webpage.raise_for_status()
-                visible_text = extract_text_from_webpage(webpage.text)
-                if len(visible_text) > max_chars_per_page:
-                    visible_text = visible_text[:max_chars_per_page]
-                all_results.append({"link": link, "text": visible_text})
-            except requests.exceptions.RequestException:
-                all_results.append({"link": link, "text": None})
-    return all_results
-
-# Initialize inference clients for different models
-client_gemma = InferenceClient("mistralai/Mistral-7B-Instruct-v0.3")
-client_mixtral = InferenceClient("NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO")
-client_llama = InferenceClient("meta-llama/Meta-Llama-3-8B-Instruct")
-
-
-func_caller = []
-
-# Define the main chat function
-def respond(message, history):
-    func_caller = []
-
-    user_prompt = message
-    # Handle image processing
-    if message["files"]:
-        inputs = llava(message, history)
-        streamer = TextIteratorStreamer(processor, skip_prompt=True, **{"skip_special_tokens": True})
-        generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=1024)
+    columns_list = [Column('id', Integer, primary_key=True)]
+    for col_name, col_type in columns.items():
+        if col_type.lower() == 'string':
+            columns_list.append(Column(col_name, String))
+        elif col_type.lower() == 'integer':
+            columns_list.append(Column(col_name, Integer))
+        else:
+            return "Unsupported column type. Use 'String' or 'Integer'."
+    
+    new_table = Table(table_name, metadata, *columns_list)
+    metadata.create_all(engine)
+    return f"Table '{table_name}' created successfully."
 
-        thread = Thread(target=model.generate, kwargs=generation_kwargs)
-        thread.start()
+def edit_table(table_name, columns):
+    if table_name not in engine.table_names():
+        return f"Table '{table_name}' does not exist."
+    
+    table = Table(table_name, metadata, autoload_with=engine)
+    for col_name, col_type in columns.items():
+        if col_name not in table.c:
+            if col_type.lower() == 'string':
+                new_column = Column(col_name, String)
+            elif col_type.lower() == 'integer':
+                new_column = Column(col_name, Integer)
+            else:
+                return "Unsupported column type. Use 'String' or 'Integer'."
+            new_column.create(table, populate_default=True)
     
-        buffer = ""
-        for new_text in streamer:
-            buffer += new_text
-            yield buffer
+    return f"Table '{table_name}' updated successfully."
+
+def chatbot_response(task, table_name=None, columns=None):
+    if task == "create_table":
+        if table_name and columns:
+            result = create_table(table_name, columns)
+        else:
+            result = "Please provide a table name and columns."
+    elif task == "edit_table":
+        if table_name and columns:
+            result = edit_table(table_name, columns)
+        else:
+            result = "Please provide a table name and columns."
     else:
-        functions_metadata = [
-            {"type": "function", "function": {"name": "web_search", "description": "Search query on google", "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "web search query"}}, "required": ["query"]}}},
-            {"type": "function", "function": {"name": "general_query", "description": "Reply general query of USER", "parameters": {"type": "object", "properties": {"prompt": {"type": "string", "description": "A detailed prompt"}}, "required": ["prompt"]}}},
-            {"type": "function", "function": {"name": "image_generation", "description": "Generate image for user", "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "image generation prompt"}}, "required": ["query"]}}},
-            {"type": "function", "function": {"name": "image_qna", "description": "Answer question asked by user related to image", "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "Question by user"}}, "required": ["query"]}}},
-        ]
-
-        for msg in history:
-            func_caller.append({"role": "user", "content": f"{str(msg[0])}"})
-            func_caller.append({"role": "assistant", "content": f"{str(msg[1])}"})
-
-        message_text = message["text"]
-        func_caller.append({"role": "user", "content": f'[SYSTEM]You are a helpful assistant. You have access to the following functions: \n {str(functions_metadata)}\n\nTo use these functions respond with:\n<functioncall> {{ "name": "function_name", "arguments": {{ "arg_1": "value_1", "arg_1": "value_1", ... }} }}  </functioncall>  [USER] {message_text}'})
+        result = "Unsupported task. Use 'create_table' or 'edit_table'."
     
-        response = client_gemma.chat_completion(func_caller, max_tokens=200)
-        response = str(response)
-        try:
-            response = response[int(response.find("{")):int(response.rindex("</"))]
-        except:
-            response = response[int(response.find("{")):(int(response.rfind("}"))+1)]
-        response = response.replace("\\n", "")
-        response = response.replace("\\'", "'")
-        response = response.replace('\\"', '"')
-        response = response.replace('\\', '')
-        print(f"\n{response}")
+    # Generate a descriptive image based on the response
+    description = f"Task: {task}, Table Name: {table_name}, Columns: {columns}"
+    image = generate_image(description)
     
-        try:
-            json_data = json.loads(str(response))
-            if json_data["name"] == "web_search":
-                query = json_data["arguments"]["query"]
-                gr.Info("Searching Web")
-                web_results = search(query)
-                gr.Info("Extracting relevant Info")
-                web2 = ' '.join([f"Link: {res['link']}\nText: {res['text']}\n\n" for res in web_results])
-                messages = f"<|im_start|>system\nYou are OpenCHAT mini a helpful assistant made by KingNish. You are provided with WEB results from which you can find informations to answer users query in Structured and More better way. You do not say Unnecesarry things Only say thing which is important and relevant. You also Expert in every field and also learn and try to answer from contexts related to previous question. Try your best to give best response possible to user. You also try to show emotions using Emojis and reply like human, use short forms, friendly tone and emotions.<|im_end|>"
-                for msg in history:
-                    messages += f"\n<|im_start|>user\n{str(msg[0])}<|im_end|>"
-                    messages += f"\n<|im_start|>assistant\n{str(msg[1])}<|im_end|>"
-                messages+=f"\n<|im_start|>user\n{message_text}<|im_end|>\n<|im_start|>web_result\n{web2}<|im_end|>\n<|im_start|>assistant\n"
-                stream = client_mixtral.text_generation(messages, max_new_tokens=2000, do_sample=True, stream=True, details=True, return_full_text=False)
-                output = ""
-                for response in stream:
-                    if not response.token.text == "<|im_end|>":
-                        output += response.token.text
-                        yield output
-            elif json_data["name"] == "image_generation":
-                query = json_data["arguments"]["query"]
-                gr.Info("Generating Image, Please wait 10 sec...")
-                yield "Generating Image, Please wait 10 sec..."
-                try:
-                    image = image_gen(f"{str(query)}")
-                    yield gr.Image(image[1])
-                except:
-                    client_sd3 = InferenceClient("stabilityai/stable-diffusion-3-medium-diffusers")
-                    seed = random.randint(0,999999)
-                    image = client_sd3.text_to_image(query, negative_prompt=f"{seed}")
-                    yield gr.Image(image)
-            elif json_data["name"] == "image_qna":
-                inputs = llava(message, history)
-                streamer = TextIteratorStreamer(processor, skip_prompt=True, **{"skip_special_tokens": True})
-                generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=1024)
+    return result, image
 
-                thread = Thread(target=model.generate, kwargs=generation_kwargs)
-                thread.start()
+def handle_chatbot(task, table_name, columns):
+    if task not in ['create_table', 'edit_table']:
+        return "Unsupported task. Use 'create_table' or 'edit_table'.", None
     
-                buffer = ""
-                for new_text in streamer:
-                    buffer += new_text
-                    yield buffer
-            else:
-                messages = f"<|start_header_id|>system\nYou are OpenCHAT mini a helpful assistant made by KingNish. You answers users query like human friend. You are also Expert in every field and also learn and try to answer from contexts related to previous question. Try your best to give best response possible to user. You also try to show emotions using Emojis and reply like human, use short forms, friendly tone and emotions.<|end_header_id|>"
-                for msg in history:
-                    messages += f"\n<|start_header_id|>user\n{str(msg[0])}<|end_header_id|>"
-                    messages += f"\n<|start_header_id|>assistant\n{str(msg[1])}<|end_header_id|>"
-                messages+=f"\n<|start_header_id|>user\n{message_text}<|end_header_id|>\n<|start_header_id|>assistant\n"
-                stream = client_llama.text_generation(messages, max_new_tokens=2000, do_sample=True, stream=True, details=True, return_full_text=False)
-                output = ""
-                for response in stream:
-                    if not response.token.text == "<|eot_id|>":
-                        output += response.token.text
-                        yield output
-        except:
-            messages = f"<|start_header_id|>system\nYou are OpenCHAT mini a helpful assistant made by KingNish. You answers users query like human friend. You are also Expert in every field and also learn and try to answer from contexts related to previous question. Try your best to give best response possible to user. You also try to show emotions using Emojis and reply like human, use short forms, friendly tone and emotions.<|end_header_id|>"
-            for msg in history:
-                messages += f"\n<|start_header_id|>user\n{str(msg[0])}<|end_header_id|>"
-                messages += f"\n<|start_header_id|>assistant\n{str(msg[1])}<|end_header_id|>"
-            messages+=f"\n<|start_header_id|>user\n{message_text}<|end_header_id|>\n<|start_header_id|>assistant\n"
-            stream = client_llama.text_generation(messages, max_new_tokens=2000, do_sample=True, stream=True, details=True, return_full_text=False)
-            output = ""
-            for response in stream:
-                if not response.token.text == "<|eot_id|>":
-                    output += response.token.text
-                    yield output
-
-# Create the Gradio interface
-demo = gr.ChatInterface(
-    fn=respond,
-    chatbot=gr.Chatbot(show_copy_button=True, likeable=True, layout="panel"),
-    description ="# OpenGPT 4o mini\n ### You can engage in chat, generate images, perform web searches, and Q&A with images.",
-    textbox=gr.MultimodalTextbox(),
-    multimodal=True,
-    concurrency_limit=200,
-    examples=[
-        {"text": "Hy, who are you?",},
-        {"text": "What's the current price of Bitcoin",},
-        {"text": "Search and Tell me what's the release date of llama 3 400b",},
-        {"text": "Create A Beautiful image of Effiel Tower at Night",},
-        {"text": "Write me a Python function to calculate the first 10 digits of the fibonacci sequence.",},
-        {"text": "What's the colour of car in given image", "files": ["./car1.png"]},
-        {"text": "Read what's written on paper", "files": ["./paper_with_text.png"]},
-    ],
-    cache_examples=False,
+    try:
+        columns_dict = json.loads(columns)
+    except json.JSONDecodeError:
+        return "Invalid columns format. Please use JSON format.", None
+    
+    return chatbot_response(task, table_name, columns_dict)
+
+def generate_image(description):
+    images = image_generator(description, num_return_sequences=1)
+    image = images[0]['image']
+    return image
+
+# Gradio interface setup
+task_input = gr.inputs.Textbox(lines=1, placeholder="Task (create_table or edit_table)")
+table_name_input = gr.inputs.Textbox(lines=1, placeholder="Table Name")
+columns_input = gr.inputs.Textbox(lines=2, placeholder="Columns (JSON format: {'column1': 'type', 'column2': 'type'})")
+
+interface = gr.Interface(
+    fn=handle_chatbot,
+    inputs=[task_input, table_name_input, columns_input],
+    outputs=[gr.outputs.Textbox(), gr.outputs.Image(type="pil")],
+    title="SQL Database Chatbot with Image Generation",
+    description="A chatbot interface to create and edit SQL tables with image generation."
 )
-demo.launch()
+
+if __name__ == "__main__":
+    interface.launch()