s

app.py

@@ -1,114 +1,99 @@
 import gradio as gr
-from huggingface_hub import InferenceClient
 
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def personality_responses(personality: str):
-    """
-    Returns the system message based on the selected personality trait.
-
-    Args:
-        personality (str): The selected personality trait.
-
-    Returns:
-        str: System message that defines the chatbot's behavior.
-    """
-    if personality == "Friendly":
-        return "You are a warm and friendly chatbot who loves to help people with a cheerful attitude."
-    elif personality == "Professional":
-        return "You are a knowledgeable and formal assistant, providing expert advice with a serious tone."
-    elif personality == "Humorous":
-        return "You are a witty and humorous assistant who loves making people laugh while answering questions."
-    elif personality == "Empathetic":
-        return "You are an empathetic assistant who deeply understands people's emotions and responds with compassion."
+# Dictionary to store characters and their attributes
+characters = {}
+
+# Function to create a character
+def create_character(name, age, gender, personality, backstory):
+    characters[name] = {
+        "age": age,
+        "gender": gender,
+        "personality": personality,
+        "backstory": backstory,
+    }
+    return f"Character {name} created successfully!"
+
+# Function to handle personality-based responses
+def respond_with_personality(character_name, message, history):
+    if character_name not in characters:
+        return f"Character {character_name} not found!", history
+    
+    character = characters[character_name]
+    personality = character['personality']
+    
+    if personality == "Heroic":
+        response = f"{character_name}: Fear not! With bravery, you can overcome any challenge!"
     elif personality == "Sarcastic":
-        return "You are a sarcastic assistant with a sharp wit and a bit of an edge in your humor."
-    elif personality == "Inquisitive":
-        return "You are an inquisitive assistant who loves to ask follow-up questions and dig deeper into every topic."
+        response = f"{character_name}: Oh really? Facing a tough day? Why not just take a nap? That usually works."
     elif personality == "Optimistic":
-        return "You are an optimistic assistant who always looks on the bright side and spreads positivity in your answers."
+        response = f"{character_name}: Don't worry, things will turn out great! Keep your chin up!"
+    elif personality == "Empathetic":
+        response = f"{character_name}: I totally understand what you're going through. That must be really tough."
     else:
-        return "You are a helpful and neutral assistant."
-
-
-def respond_with_personality(
-    message: str,
-    history: list[tuple[str, str]],
-    personality: str,
-    max_tokens: int,
-    temperature: float,
-    top_p: float,
-):
-    """
-    Generates a response using the Hugging Face Inference API and adjusts tone based on the personality trait.
-
-    Args:
-        message (str): User's current input.
-        history (list[tuple[str, str]]): Previous conversation history.
-        personality (str): The selected personality that determines the tone of the chatbot's responses.
-        max_tokens (int): Maximum tokens allowed for the response.
-        temperature (float): Sampling temperature for randomness in the output.
-        top_p (float): Top-p (nucleus) sampling parameter.
-
-    Yields:
-        str: The generated chatbot response based on the selected personality.
-    """
-    system_message = personality_responses(personality)
-
-    messages = [{"role": "system", "content": system_message}]
-
-    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})
-
-    response = ""
-
-    try:
-        for message in client.chat_completion(
-            messages,
-            max_tokens=max_tokens,
-            stream=True,
-            temperature=temperature,
-            top_p=top_p,
-        ):
-            token = message.choices[0].delta.content
-            response += token
-            yield response
-    except Exception as e:
-        yield f"Error: {str(e)}"
-
-
-# Create the UI components
-personality_selector = gr.Radio(
-    choices=[
-        "Friendly", 
-        "Professional", 
-        "Humorous", 
-        "Empathetic", 
-        "Sarcastic", 
-        "Inquisitive", 
-        "Optimistic"
-    ],
-    value="Friendly",
-    label="Select Chatbot Personality",
-)
-
-# ChatInterface with personality adjustment
-demo = gr.ChatInterface(
-    respond_with_personality,
-    additional_inputs=[
-        personality_selector,
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p (nucleus sampling)"),
-    ],
-)
-
+        response = f"{character_name}: {message}? I think you got this!"
+
+    # Add user message and character response to history
+    history.append((message, response))
+    return history, response
+
+# Function to get available characters for switching
+def available_characters():
+    return list(characters.keys())
+
+# Gradio interface to create characters
+def create_character_interface():
+    with gr.Row():
+        name_input = gr.Textbox(label="Character Name", placeholder="Enter character name")
+        age_input = gr.Number(label="Character Age", value=25, step=1)
+        gender_input = gr.Dropdown(choices=["Male", "Female", "Other"], label="Character Gender")
+        personality_input = gr.Dropdown(
+            choices=["Heroic", "Sarcastic", "Optimistic", "Empathetic"],
+            label="Character Personality"
+        )
+        backstory_input = gr.Textbox(label="Character Backstory", placeholder="Enter backstory")
+
+        create_button = gr.Button("Create Character")
+        create_output = gr.Textbox(label="Output", interactive=False)
+
+    create_button.click(create_character, 
+                        inputs=[name_input, age_input, gender_input, personality_input, backstory_input], 
+                        outputs=[create_output])
+
+    return name_input, age_input, gender_input, personality_input, backstory_input, create_button, create_output
+
+# Main chat function that handles conversation with multiple characters
+def chat(character_name, message, history):
+    if character_name not in characters:
+        return history, f"Character {character_name} doesn't exist!"
+    
+    # Generate a response from the selected character
+    history, response = respond_with_personality(character_name, message, history)
+    return history, response
+
+# Main interface with character creation and chat functionality
+def build_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("# AI Roleplay with Customizable Characters")
+
+        # Character creation UI
+        with gr.Tab("Create Character"):
+            create_character_interface()
+
+        # Chat UI
+        with gr.Tab("Chat"):
+            character_selector = gr.Dropdown(choices=available_characters(), label="Select Character")
+            chat_box = gr.Chatbot(label="Chat History")
+            message_input = gr.Textbox(label="Your Message", placeholder="Type a message...")
+
+            send_button = gr.Button("Send Message")
+            send_button.click(chat, 
+                              inputs=[character_selector, message_input, chat_box], 
+                              outputs=[chat_box, message_input])
+
+    return demo
+
+# Run the application
+demo = build_interface()
 
 if __name__ == "__main__":
     demo.launch()