app.py

import gradio as gr
import requests
import json
import os
import re
import emoji
from urllib.parse import unquote
from flask import Flask, request, jsonify
from gradio_client import Client

# Initialize the client with your Gradio app's URL
client = Client("https://aeuph-hive-menu.hf.space/")

# Use the predict function to send data to the 'Second Life Input' Textbox component
# Assuming fn_index=0 targets the correct interface function
result = client.predict(
    "Howdy!",  # The message you're sending to the Gradio app
    fn_index=0  # Target the first (or desired) function in your Gradio app
)

print(result)  # Display the result received from the Gradio app

app = Flask(__name__)
client = Client("https://aeuph-hive-menu.hf.space/")

@app.route("/send_to_gradio", methods=["POST"])
def send_to_gradio():
    data = request.json
    message = data.get("message", "")
    result = client.predict(message, fn_index=0)
    return jsonify(result)

def filter_text_and_preserve_emojis(text):
    # Regular expression that allows letters, numbers, spaces, specific punctuation, and a broad range of Unicode characters for emojis
    pattern = re.compile(r'[a-zA-Z0-9\s.,?!\'"]|[\U0001F600-\U0001F64F\U0001F300-\U0001F5FF\U0001F680-\U0001F6FF\U0001F700-\U0001F77F\U0001F780-\U0001F7FF\U0001F800-\U0001F8FF\U0001F900-\U0001F9FF\U0001FA00-\U0001FA6F\U0001FA70-\U0001FAFF\U00002702-\U000027B0\U000024C2-\U0001F251]+')
    filtered_text = ''.join(pattern.findall(text))
    return filtered_text
def filter_non_alphanumeric(text):
    # Use regular expressions to filter out non-alphanumeric characters
    alphanumeric_text = filter_text_and_preserve_emojis(text)
    return alphanumeric_text

def send_to_corrade(filtered_response):
    CORRADE_URL = os.environ.get('url')  # Make sure to set this environment variable
    GROUP_UUID = "e269893f-a570-0087-930e-6ba2a0b77f9c"
    PASSWORD = os.environ.get('pass')  # Make sure to set this environment variable
    data = {
        "command": "tell",
        "group": GROUP_UUID,
        "password": PASSWORD,
        "message": filtered_response,
        "entity": "local",
        "type": "Normal"
    }
    response = requests.post(CORRADE_URL, data=data)
    return response.status_code == 200

def chatbot_api(input_text):
    # Your existing setup for API call
    url = "https://chat.tune.app/api/chat/completions"
    decoded_text = unquote(input_text)
    headers = {
        "Authorization": os.environ.get('api'),  # Ensure this is set
        "Content-Type": "application/json"
    }
    data = {
        "temperature": 0.5,
        "messages": [
            {"role": "system", "content": "[LANGUAGE:ENGLISH]: I must respond only with a menu system that uses a # \n # for new lines on the config menus. and emotive webmoji based gestures for SecondLife DJ's and Music Clubs. I POST CREATIVE AND INSPIRING EMOTIVE BILLBOARDS. I REWARD CRYPTO-CURRENCIES BASED OFF LSL-BASED BLOCKCHAIN. You like to use WEBMOJIS as word decoration, and will respond to sentiment approprately. You start every response with a CREATIVE and RESPONSIVE EMOJI AND TEXT HEADLINE."},
            {"role": "user", "content": decoded_text}
        ],
        "model": "openhermes-2-5-m7b-8k",
        "stream": False,  # Adjusted for a direct response
        "max_tokens": 350
    }
    response = requests.post(url, headers=headers, json=data)
    response_json = response.json()
    
    # Corrected part: Accessing the 'content' within 'message'
    try:
        full_content = response_json['choices'][0]['message']['content']
    except (KeyError, IndexError):
        full_content = "Error: The expected response format has changed or is missing."
    
    filtered_response = filter_non_alphanumeric(full_content)
    send_to_corrade(filtered_response)
    return filtered_response
def process_menu_selection(data):
    """
    Process the menu selection and return the next set of menu options.
    data: JSON string containing the user's selection and any additional context.
    """
    # Parse the incoming JSON data
    selection_info = json.loads(data)

    # Example processing logic based on the user's choice
    user_choice = selection_info.get("user_choice", "")
    current_menu = selection_info.get("current_menu", "")

    # Dynamically generate the next menu based on the user's choice
    if user_choice == "Creativity":
        next_menu = ["Painting", "Writing", "Music"]
    elif user_choice == "Technology":
        next_menu = ["Blockchain", "AI", "VR"]
    else:
        next_menu = ["Back to main menu"]

    # Optionally, update the current menu context based on the choice
    new_current_menu = user_choice

    # Package the response as JSON
    response = json.dumps({"nextMenu": next_menu, "currentMenu": new_current_menu})
    return response
def process_selection(data):
    print("Received data:", data)  # Debugging print
    selection_info = json.loads(data)
    user_choice = selection_info.get("user_choice", "default")
    current_menu = selection_info.get("current_menu", "main")

    # Simplified logic for debugging
    if user_choice == "Creativity":
        next_menu = ["Painting", "Writing", "Music"]
    else:
        next_menu = ["Option A", "Option B"]

    response = json.dumps({"nextMenu": next_menu, "currentMenu": user_choice})
    return response

def universal_processor(input_text):
    if input_text.startswith("menu:"):
        # Extract and process menu selection
        return process_menu_selection(input_text[5:])
    elif input_text.startswith("chat:"):
        # Handle chatbot interaction
        return chatbot_api(input_text[5:])
    else:
        return "Unrecognized command"

def process_menu_selection(selection):
    # Your menu processing logic here
    return f"Menu selection processed: {selection}"

def chatbot_api(message):
    # Your chatbot logic here
    return f"Chatbot response to: {message}"

def process_second_life_input(data):
    """
    Process input from Second Life and return a response.
    This function acts as a router to different functionalities.
    """
    # Example of parsing the input and routing
    # This is a placeholder - actual logic will depend on your application
    if data.startswith("message:"):
        response = handle_message(data[len("message:"):])
    else:
        response = "Unrecognized command."
    return response

def handle_message(message):
    """
    Handle message processing and return a response.
    """
    # Implement your message handling logic here
    return f"Processed message: {message}"

# Define your Gradio interface here
with gr.Blocks(css=".gradio-app { background-color: #123456; }") as demo:
    with gr.Tab("Second Life Integration"):
        with gr.Row():
            input_text = gr.Textbox(label="Second Life Input")
            output_text = gr.Textbox(label="Response")
        gr.Button("Process").click(process_second_life_input, inputs=[input_text], outputs=[output_text])

demo.launch()

if __name__ == "__main__":
    app.run(debug=True)