Update app.py

app.py

@@ -16,25 +16,29 @@ 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")
+    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)
+
 model = LlavaForConditionalGeneration.from_pretrained(model_id)
 model.to("cpu")
 
+
 def llava(message, history):
     if message["files"]:
         image = message["files"][0]    
     else:
         for hist in history:
-            if type(hist[0]) == tuple:
+            if type(hist[0])==tuple:
                 image = hist[0][0]
         
     txt = message["text"]
         
+    gr.Info("Analyzing image")
     image = Image.open(image).convert("RGB")
-    prompt = f"user <image>\n{txt}assistant"
+    prompt = f"<|im_start|>user <image>\n{txt}<|im_start|>assistant"
     
     inputs = processor(prompt, image, return_tensors="pt")
     return inputs
@@ -85,132 +89,123 @@ client_yi = InferenceClient("01-ai/Yi-1.5-34B-Chat")
 def respond(message, history):
     func_caller = []
 
-    if isinstance(message, dict):
-        user_prompt = message
-        if "files" in message and message["files"]:
-            inputs = llava(message, history)
-            streamer = TextIteratorStreamer(None, skip_prompt=True, **{"skip_special_tokens": True})
-            generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=1024)
-
-            thread = Thread(target=None.generate, kwargs=generation_kwargs)  # Replace None with actual model
-            thread.start()
-        
-            buffer = ""
-            for new_text in streamer:
-                buffer += new_text
-                yield buffer
-        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])}"})
+    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)
 
-            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}'})
-        
-            response = None.chat_completion(func_caller, max_tokens=200)  # Replace None with actual model
-            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}")
-        
-            try:
-                json_data = json.loads(str(response))
-                if json_data["name"] == "web_search":
-                    query = json_data["arguments"]["query"]
-                    yield "Searching Web"
-                    web_results = search(query)
-                    yield "Extracting relevant Info"
-                    web2 = ' '.join([f"Link: {res['link']}\nText: {res['text']}\n\n" for res in web_results])
-                    messages = f"system\nYou are OpenCHAT mini a helpful assistant made by Nithish. 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."
-                    for msg in history:
-                        messages += f"\nuser\n{str(msg[0])}"
-                        messages += f"\nassistant\n{str(msg[1])}"
-                    messages+=f"\nuser\n{message_text}\nweb_result\n{web2}\nassistant\n"
-                    stream = None.text_generation(messages, max_new_tokens=2000, do_sample=True, stream=True, details=True, return_full_text=False)  # Replace None with actual model
-                    output = ""
-                    for response in stream:
-                        if not response.token.text == "":
-                            output += response.token.text
-                            yield output
-                elif json_data["name"] == "image_generation":
-                    query = json_data["arguments"]["query"]
-                    yield "Generating Image, Please wait 10 sec..."
-                    try:
-                        image = image_gen(f"{str(query)}")
-                        yield gr.Image(image[1])
-                    except:
-                        client_sd3 = None.InferenceClient("stabilityai/stable-diffusion-3-medium-diffusers")  # Replace None with actual model
-                        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":
-                    if "files" in message:
-                        image = message["files"][0]    
-                    else:
-                        for hist in history:
-                            if type(hist[0]) == tuple:
-                                image = hist[0][0]
-                    
-                    txt = json_data["arguments"]["query"]
-
-                    image = Image.open(image).convert("RGB")
-                    prompt = f"user <image>\n{txt}assistant"
-                    
-                    inputs = None(prompt, image, return_tensors="pt")  # Replace None with actual model
-                    streamer = TextIteratorStreamer(None, skip_prompt=True, **{"skip_special_tokens": True})
-                    generation_kwargs = dict(inputs, streamer=streamer, max_new_tokens=1024)
-
-                    thread = Thread(target=None.generate, kwargs=generation_kwargs)  # Replace None with actual model
-                    thread.start()
-                
-                    buffer = ""
-                    for new_text in streamer:
-                        buffer += new_text
-                        yield buffer
-            except:
-                messages = ""
+        thread = Thread(target=model.generate, kwargs=generation_kwargs)
+        thread.start()
+    
+        buffer = ""
+        for new_text in streamer:
+            buffer += new_text
+            yield buffer
+    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}'})
+    
+        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}")
+    
+        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 Nithish. 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"\nuser\n{str(msg[0])}"
-                    messages += f"\nassistant\n{str(msg[1])}"
-                messages += f"\nuser\n{str(message)}"
-                stream = None.text_generation(messages, max_new_tokens=2000, do_sample=True, stream=True, details=True, return_full_text=False)  # Replace None with actual model
+                    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 == "":
+                    if not response.token.text == "<|im_end|>":
                         output += response.token.text
                         yield output
-    else:
-        yield "Error: Message format is incorrect."
-
-# Interface Layout
-with gr.Blocks() as demo:
-    chatbot = gr.Chatbot(label="ChatGPT Style Chatbot", height=500)
-
-    with gr.Row():
-        upload_button = gr.File(label="Upload File", elem_id="upload-button")
-        with gr.Column(scale=8):
-            text_input = gr.Textbox(label="", placeholder="Type your message here...", lines=1)
-        submit_button = gr.Button("Send")
-
-    def update_chat(message, history):
-        return chatbot.update(respond(message, history))
-
-    text_input.submit(update_chat, inputs=[text_input, chatbot], outputs=chatbot)
-    submit_button.click(update_chat, inputs=[text_input, chatbot], outputs=chatbot)
-    upload_button.change(lambda file: {"text": "", "files": [file]}, inputs=upload_button, outputs=text_input)
-
-# Run the demo
+            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)
+
+                thread = Thread(target=model.generate, kwargs=generation_kwargs)
+                thread.start()
+    
+                buffer = ""
+                for new_text in streamer:
+                    buffer += new_text
+                    yield buffer
+            else:
+                messages = f"<|im_start|>system\nYou are OpenCHAT mini a helpful assistant made by Nithish. 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 only in required case 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|>assistant\n"
+                stream = client_yi.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 == "<|endoftext|>":
+                        output += response.token.text
+                        yield output
+        except:
+            messages = f"<|start_header_id|>system\nYou are OpenCHAT mini a helpful assistant made by Nithish. 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 only in required case 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 \n ### chat, generate images, perform web searches, and Q&A with images.",
+    textbox=gr.MultimodalTextbox(),
+    multimodal=True,
+    concurrency_limit=200,
+    cache_examples=False,
+)
 demo.launch()