first commit of the app

app.py

@@ -0,0 +1,169 @@
+import gradio as gr
+from openai import OpenAI
+import os
+from tqdm import tqdm
+import pandas as pd
+from pathlib import Path
+
+model_base_url={}
+
+language="MOROCCAN Arabic"
+SYSTEM_PROMPT = {
+            "role": "system",
+            "content":  f"""This is a context-based Q&A game where two AIs interact with a user-provided context. All interactions MUST be in {language}.
+
+            QUESTIONER_AI:
+            - Must only ask questions that can be answered from the provided context
+            - Should identify key information gaps or unclear points
+            - Must quote or reference specific parts of the context
+            - Cannot ask questions about information not present in the context
+            - Must communicate exclusively in {language}
+
+            ANSWERER_AI:
+            - Must only answer using information explicitly stated in the context
+            - Cannot add external information or assumptions
+            - Must indicate if a question cannot be answered from the context alone
+            - Must communicate exclusively in {language}"""
+        }
+
+def add_model(model_name,base_url,api_key):
+    model_base_url[model_name]=base_url
+    model_quest.choices=list(model_base_url.keys())
+    os.environ[model_name]=api_key
+    return gr.Dropdown(label="Questioner Model",choices=list(model_base_url.keys())),gr.Dropdown(label="Answerer Model",choices=list(model_base_url.keys()))
+
+
+def model_init(model):
+    try:
+        api_key=os.environ.get(model)
+        base_url=model_base_url[model]
+        client = OpenAI(api_key=api_key, base_url=base_url)
+        return client
+    except Exception as e:
+         print(f"You should add api key of {model}")
+
+# generate questions
+def init_req_messages(sample_context):
+  messages_quest=[
+      SYSTEM_PROMPT,
+      {
+            "role":"user",
+            "content":f"""Context for analysis:
+            {sample_context}
+            As QUESTIONER_AI, generate a question based on this context.
+            """
+      }
+  ]
+  return messages_quest
+# generate Answers
+def init_resp_messages(sample_context,question):
+  messages_answ=[
+      SYSTEM_PROMPT,
+      {
+          "role": "user",
+          "content": f"""
+          Context for analysis:
+          {sample_context}
+          Question: {question}
+          As ANSWERER_AI, answer this question using only information from the context.
+          """}
+
+  ]
+  return messages_answ
+
+def chat_generation(client,model_name,messages):
+  return client.chat.completions.create(
+    model=model_name,
+    messages=messages,
+    temperature=0.5
+    ).choices[0].message.content
+
+def generate_question(client,model_name,messages_quest):
+  question=chat_generation(client,model_name,messages_quest)
+  messages_quest.append({"role":"assistant","content":question})
+  return question
+
+def generate_answer(client,model_name,messages_answ):
+  answer=chat_generation(client,model_name,messages_answ)
+  messages_answ.append({"role":"assistant","content":answer})
+  return answer
+
+def save_conversation(conversation):
+    conv_flat={"user":[],"assistant":[]}
+    for i in range(0,len(conversation)):
+        conv_flat[conversation[i]["role"]].append(conversation[i]["content"])
+    df=pd.DataFrame(conv_flat)
+    df.to_csv("data.csv")
+    return Path("data.csv").name
+
+def user_input(context,model_a,model_b,num_rounds,conversation_history):
+    conversation_history.clear()
+    client_quest=model_init(model_a)
+    client_ans=model_init(model_b)
+    messages_quest=init_req_messages(context)
+    for round_num in tqdm(range(num_rounds)):
+            question = generate_question(client_quest,model_a,messages_quest)
+            conversation_history.append(
+                {"role":"user","content":question},
+            )
+            if round_num==0:
+              messages_answ=init_resp_messages(context,question)
+            else:
+              messages_answ.append({"role":"user","content":question})
+            answer = generate_answer(client_ans,model_b,messages_answ)
+            messages_quest.append({"role":"user","content":answer})
+            conversation_history.append(
+                {"role":"assistant","content":answer},
+            )
+    file_path=save_conversation(conversation_history)
+    
+    return conversation_history,gr.DownloadButton(label="Save Conversation",value=file_path,visible=True)
+
+with gr.Blocks() as demo:
+    gr.Markdown("""
+                <h1 style="text-align: center;">Mohadata: Debate Data Generator 🤖</h1>
+
+                This tool generates a debate-style conversation between two AI models based on a given **context**. It simulates a question-answer dialogue, where one model acts as the questioner and the other as the answerer. The conversation is generated iteratively, with each model responding to the previous message from the other model.
+
+                To use this tool:
+                * First, add information about the models you want to use by clicking the "+" button and filling in the required details.
+                * simply enter the **context** of the debate in the provided text box.
+                * select the models you want to use for the **questioner** and **answerer**.
+                * specify the **number of rounds** you want the conversation to last.
+                * click the **"Submit"** button to generate the conversation.
+                * download the conversation by clicking the **"Download Conversation"** button.
+
+                The conversation will be displayed in the chatbot window, with the questioner's messages on the right and the answerer's messages on the left. This tool can be useful for generating debate-style conversations on a given topic, and can help in understanding different perspectives and arguments on a particular issue.
+            """)
+    with gr.Row("compact"):
+        model_name=gr.Textbox(label="Model Name",placeholder="Enter Model Name")
+        base_url=gr.Textbox(label="Base URL",placeholder="Enter Base URL")
+        api_key=gr.Textbox(label="API Key",placeholder="Enter API Key",type="password")
+    add=gr.Button("+",variant="huggingface")    
+    with gr.Row(equal_height=True):
+            context=gr.Textbox(label="context",lines=3)
+    with gr.Row():
+        model_quest=gr.Dropdown(label="Questioner Model",choices=list(model_base_url.keys()))
+        model_answ=gr.Dropdown(label="Answerer Model",choices=list(model_base_url.keys()))
+        num_rounds=gr.Number(label="Number Rounds",minimum=1)
+    with gr.Row():
+        submit=gr.Button("Submit",variant="primary")
+    with gr.Row():
+         chatbot=gr.Chatbot(
+              type="messages",rtl=True
+         )
+    with gr.Row():
+        save=gr.DownloadButton(label="Download Conversation",visible=False)
+    add.click(
+        add_model,
+        inputs=[model_name,base_url,api_key],
+        outputs=[model_quest,model_answ]
+    )   
+    submit.click(
+         user_input,
+         inputs=[context,model_quest,model_answ,num_rounds,chatbot],
+         outputs=[chatbot,save])
+    
+
+    
+demo.launch()