Update app.py

app.py

@@ -1,137 +1,124 @@
 import gradio as gr
-import os
-import sys
-import json 
-import requests
+import random
+from gpti import bing, gpt
 
-MODEL = "gpt-3.5-turbo"
-API_URL = os.getenv("API_URL")
-DISABLED = os.getenv("DISABLED") == 'True'
-OPENAI_API_KEY = os.getenv("OPEN_API_KEY")
-print (API_URL)
-print (OPENAI_API_KEY)
+def error_alert(message):
+    gr.Warning(message)
 
-def exception_handler(exception_type, exception, traceback):
-    print("%s: %s" % (exception_type.__name__, exception))
-sys.excepthook = exception_handler
-sys.tracebacklimit = 0
+with gr.Blocks() as demo:
+    gr.Markdown("""
+    # ChatGPT
+    Interact with GPT-3.5-turbo, GPT-3.5, or Bing to explore a world of intelligent answers and informative discoveries. You can also visit my [website](https://aryahcr.cc/) where you can generate multiple images and more.
+    """)
+    chatbot = gr.Chatbot()
+    radio = gr.Radio(["ChatGPT", "Bing"], value="ChatGPT", label="Select the AI model you want to chat with", info="AI")
+    drp = gr.Dropdown(
+        interactive=True, choices=["gpt-4", "gpt-3.5-turbo"], value="gpt-4", label="Select Model", info="ChatGPT", visible=True
+    )
+    msg = gr.Textbox(placeholder="Message", show_label=False)
+    clear = gr.ClearButton([msg, chatbot])
 
-def parse_codeblock(text):
-    lines = text.split("\n")
-    for i, line in enumerate(lines):
-        if "```" in line:
-            if line != "```":
-                lines[i] = f'<pre><code class="{lines[i][3:]}">'
-            else:
-                lines[i] = '</code></pre>'
-        else:
-            if i > 0:
-                lines[i] = "<br/>" + line.replace("<", "&lt;").replace(">", "&gt;")
-    return "".join(lines)
-    
-def predict(inputs, top_p, temperature, chat_counter, chatbot, history, request:gr.Request):
-    payload = {
-        "model": MODEL,
-        "messages": [{"role": "user", "content": f"{inputs}"}],
-        "temperature" : 1.0,
-        "top_p":1.0,
-        "n" : 1,
-        "stream": True,
-        "presence_penalty":0,
-        "frequency_penalty":0,
-    }
+    def change_model(req):
+        match req.lower():
+            case "bing":
+                return gr.Dropdown(
+                    interactive=True, choices=["Balanced", "Creative", "Precise"], value="Balanced", label="Select Model", info="Bing", visible=True
+                )
+            case "chatgpt":
+                return gr.Dropdown(
+                    interactive=True, choices=["gpt-3.5-turbo", "gpt-3.5-turbo"], value="gpt-4", label="Select Model", info="ChatGPT", visible=True
+                )
+            case _:
+                return gr.Dropdown(
+                    visible=False
+                )
 
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {OPENAI_API_KEY}",
-        "Headers": f"{request.kwargs['headers']}"
-    }
-
-    # print(f"chat_counter - {chat_counter}")
-    if chat_counter != 0 :
-        messages = []
-        for i, data in enumerate(history):
-            if i % 2 == 0:
-                role = 'user'
-            else:
-                role = 'assistant'
-            message = {}
-            message["role"] = role
-            message["content"] = data
-            messages.append(message)
+    def user_msg(message, history):
+        return "", history + [[message, None]]
+    
+    def strm_message(history, option, model):
+        model_ai = None
+        if option.lower() if option is not None else "" and option.lower() in ["chatgpt", "bing"]:
+            model_ai = model
+        ai_option = option if option is not None else "chatgpt"
         
-        message = {}
-        message["role"] = "user" 
-        message["content"] = inputs
-        messages.append(message)
-        payload = {
-            "model": MODEL,
-            "messages": messages,
-            "temperature" : temperature,
-            "top_p": top_p,
-            "n" : 1,
-            "stream": True,
-            "presence_penalty":0,
-            "frequency_penalty":0,
-        }
+        messages_history = []
+        cnt = 0
+        for x in range(len(history)):
+            cnt = x
+        for user, assistant in list(history):
+            if assistant != None:
+                messages_history.append({
+                    "role": "assistant",
+                    "content": assistant
+                })
+            if user != None:
+                messages_history.append({
+                    "role": "user",
+                    "content": user
+                })
 
-    chat_counter += 1
-
-    history.append(inputs)
-    token_counter = 0 
-    partial_words = "" 
-    counter = 0
-
-    try:
-        # make a POST request to the API endpoint using the requests.post method, passing in stream=True
-        response = requests.post(API_URL, headers=headers, json=payload, stream=True)
-        response_code = f"{response}"
-
-        for chunk in response.iter_lines():
-            #Skipping first chunk
-            if counter == 0:
-                counter += 1
-                continue
-                #counter+=1
-            # check whether each line is non-empty
-            if chunk.decode() :
-                chunk = chunk.decode()
-                # decode each line as response data is in bytes
-                if len(chunk) > 12 and "content" in json.loads(chunk[6:])['choices'][0]['delta']:
-                    partial_words = partial_words + json.loads(chunk[6:])['choices'][0]["delta"]["content"]
-                    if token_counter == 0:
-                        history.append(" " + partial_words)
+        res = None
+        if ai_option.lower() == "chatgpt":
+            try:
+                res = gpt.v1(messages=messages_history, model=model_ai, markdown=False)
+    
+                if res.error != None:
+                    error_alert("The error has occurred. Please try again.")
+                    history[cnt][1] = None
+                    yield history
+                else:
+                    res_bot = res.result
+                    if res_bot.get("gpt") != None:
+                        history[cnt][1] = res_bot.get("gpt")
+                        yield history
                     else:
-                        history[-1] = partial_words
-                    token_counter += 1
-                    yield [(parse_codeblock(history[i]), parse_codeblock(history[i + 1])) for i in range(0, len(history) - 1, 2) ], history, chat_counter, response, gr.update(interactive=False), gr.update(interactive=False)  # resembles {chatbot: chat, state: history}  
-    except Exception as e:
-        print (f'error found: {e}')
-    yield [(parse_codeblock(history[i]), parse_codeblock(history[i + 1])) for i in range(0, len(history) - 1, 2) ], history, chat_counter, response, gr.update(interactive=True), gr.update(interactive=True)
-    print(json.dumps({"chat_counter": chat_counter, "payload": payload, "partial_words": partial_words, "token_counter": token_counter, "counter": counter}))
-                   
-
-def reset_textbox():
-    return gr.update(value='', interactive=False), gr.update(interactive=False)
-
-title = """<h1 align="center">GPT-3.5 Turbo Free (4K token limit, Long-Term Availability)</h1>"""
-if DISABLED:
-    title = """<h1 align="center" style="color:red">This app has reached OpenAI's usage limit. Please check back tomorrow.</h1>"""
-description = """
-In this app, you can explore the outputs of a gpt-4 turbo LLM.
-"""
-
-theme = gr.themes.Default(primary_hue="green")                
-
-with gr.Blocks(theme=theme) as app:
-    gr.HTML(title)
-    with gr.Column(elem_id = "col_container", visible=False) as main_block:
-        chatbot = gr.Chatbot(elem_id='chatbot') #c
-        inputs = gr.Textbox(placeholder= "Hi there!", label= "Type some and press Enter") #t
+                        error_alert("The error has occurred. Please try again.")
+                        history[cnt][1] = None
+                        yield history
+            except Exception as e:
+                error_alert("The error has occurred. Please try again.")
+                history[cnt][1] = None
+                yield history
+        elif ai_option.lower() == "bing":
+            try:
+                res = bing(messages=messages_history, conversation_style=model_ai, markdown=False, stream=True)
+            
+                if res.error != None:
+                    error_alert("The error has occurred. Please try again.")
+                    history[cnt][1] = None
+                    yield history
+                else:
+                    msg_x = None
+                    for chunk in res.stream():
+                        if chunk.get("error") != None and chunk.get("error") != True and chunk.get("message") != None:
+                            msg_x = chunk.get("message")
+                            history[cnt][1] = msg_x
+                            yield history
+                    if msg_x != None:
+                        history[cnt][1] = msg_x
+                        yield history
+                    else:
+                        error_alert("The error has occurred. Please try again.")
+                        msg_x = None
+                        history[cnt][1] = None
+                        yield history
+            except Exception as e:
+                error_alert("The error has occurred. Please try again.")
+                history[cnt][1] = None
+                yield history
+        else:
+            error_alert("You haven't selected an AI model to start")
+            history[cnt][1] = None
+            yield history
+        
+    radio.change(fn=change_model, inputs=radio, outputs=drp)
+    
+    msg.submit(user_msg, inputs=[msg, chatbot], outputs=[msg, chatbot], queue=True).then(
+        strm_message, [chatbot, radio, drp], chatbot
+    )
     
-        with gr.Accordion("Parameters", open=False):
-            top_p = gr.Slider( minimum=-0, maximum=1.0, value=1.0, step=0.05, interactive=True, label="Top-p (nucleus sampling)",)
-            temperature = gr.Slider( minimum=-0, maximum=5.0, value=1.0, step=0.1, interactive=True, label="Temperature",)
-            chat_counter = gr.Number(value=0, visible=False, precision=0)
 
-    app.launch(share=False)
+demo.queue()
+if __name__ == "__main__":
+    demo.launch()