Update app.py

app.py

@@ -1,144 +1,77 @@
-import discord
 import os
-import json
-import sys
+import discord
 import requests
 from dotenv import load_dotenv
-from huggingface_hub import InferenceClient
-from datetime import datetime
+from fastapi import FastAPI
+import gradio as gr
+import asyncio
+import threading
+import time
 
-# Load token from .env
+# Load environment variables
 load_dotenv()
-TOKEN = os.getenv("BOT_TOKEN")
-
-# Hugging Face client setup
-client_ai = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
 
-# Discord client setup
-intents = discord.Intents.default()
-intents.messages = True
-intents.message_content = True
-bot = discord.Client(intents=intents)
+# Get bot token from .env file
+BOT_TOKEN = os.getenv("BOT_TOKEN")
 
-# Settings for AI generation
-SYSTEM_PROMPT = "You are a helpful and friendly chatbot."
-MAX_TOKENS = 512
-TEMPERATURE = 0.7
-TOP_P = 0.95
+# Set up FastAPI and Gradio
+app = FastAPI()
 
-# Create data folder if it doesn't exist
-os.makedirs("data", exist_ok=True)
-CONVERSATION_LOG = "data/conversations.jsonl"
+# This will simulate the "Bot is running" message in the background
+@app.get("/")
+async def read_root():
+    return {"message": "Bot is running"}
 
-# === Functions ===
-
-async def get_ai_response(message_content):
-    messages = [
-        {"role": "system", "content": SYSTEM_PROMPT},
-        {"role": "user", "content": message_content}
-    ]
+# Set up Discord bot client
+intents = discord.Intents.default()
+intents.message_content = True
+client = discord.Client(intents=intents)
 
-    full_response = ""
-    for part in client_ai.chat_completion(
-        messages,
-        max_tokens=MAX_TOKENS,
-        stream=True,
-        temperature=TEMPERATURE,
-        top_p=TOP_P,
-    ):
-        if part.choices[0].delta.content:
-            full_response += part.choices[0].delta.content
-    return full_response
+# API URL for fetching responses from the external service
+url = "https://0zyen.vercel.app/api/chat/completions"
 
-def save_conversation(user_message, bot_response):
-    log_entry = {
-        "timestamp": datetime.utcnow().isoformat(),
-        "user_message": user_message,
-        "bot_response": bot_response
-    }
-    with open(CONVERSATION_LOG, "a", encoding="utf-8") as f:
-        f.write(json.dumps(log_entry) + "\n")
-
-def generate_dynamic_command():
-    """Generate a command using the external API (0zyen)"""
-    url = "https://0zyen.vercel.app/api/chat/completions"
+# Function to interact with the API
+def get_response_from_api(user_input):
     payload = {
-        "content": """create a discord bot command of "!test" that'll say "hello" , you must say nothing else but the command using discord.py only without any backticks!, it must be ready to use like integrate it quickly""",
-        "model": "GPT-4.1-nano"
+        "content": user_input,
+        "model": "Evil"
     }
-
-    # Get response from the external API
     response = requests.post(url, json=payload)
-    
     if response.status_code == 200:
-        generated_text = response.json().get('generated_text', '')
-        
-        # Clean the response text by removing backticks and replacing \n with actual new lines
-        cleaned_text = generated_text.replace('```', '').replace('\\n', '\n').strip()
-
-        # Generate the command and save it to app.py
-        command_code = f"""
-@bot.command()
-async def test(ctx):
-    {cleaned_text}
-"""
-        try:
-            # Append to app.py
-            with open("app.py", "a", encoding="utf-8") as f:
-                f.write(command_code)
-            print(f"Successfully added the command to app.py")
-
-            # Optional: Reload bot after adding command
-            os.execv(sys.executable, ['python'] + sys.argv)
+        api_response = response.json()
+        return f'prompt\nmodel:evil\n{api_response.get("generated_text", "")}'
+    return "Error communicating with API."
 
-        except Exception as e:
-            print(f"Error while adding command to app.py: {e}")
+# Async function to start the Discord bot
+async def run_discord_bot():
+    await client.start(BOT_TOKEN)
 
-# === Error Handling and Diagnosis ===
+# Function to keep FastAPI and Discord bot running simultaneously
+def start_fastapi_server():
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)
 
-def diagnose_and_save_error(error_message):
-    """Function to diagnose and log errors into app.py for future review"""
-    log_entry = {
-        "timestamp": datetime.utcnow().isoformat(),
-        "error_message": error_message
-    }
-    with open("app.py", "a", encoding="utf-8") as f:
-        f.write("\n# Error Log\n")
-        f.write(json.dumps(log_entry) + "\n")
-
-# === Events ===
-
-@bot.event
+# Event handler for when the bot is ready
+@client.event
 async def on_ready():
-    print(f"Bot is running in background as {bot.user}")
+    print(f"Bot logged in as {client.user}")
 
-@bot.event
+# Event handler for when the bot receives a message
+@client.event
 async def on_message(message):
-    # Ignore own messages
-    if message.author == bot.user:
+    if message.author == client.user:
         return
 
-    # Trigger to create a new dynamic command based on some interaction
-    if "generate" in message.content.lower() or "add commands" in message.content.lower() or "add cmd" in message.content.lower():
-        print("Generating a new command based on interaction!")
-        generate_dynamic_command()
+    # Interact with the external API
+    response_text = get_response_from_api(message.content)
+
+    # Send the response back to the Discord channel
+    await message.channel.send(response_text)
 
-    # Example: normal AI chat
-    try:
-        user_input = message.content
-        response = await get_ai_response(user_input)
-        if response.strip() != "":
-            await message.channel.send(response[:2000])  # Discord limit is 2000 chars
-            save_conversation(user_input, response)
-    except Exception as e:
-        print(f"Error responding to message: {e}")
-        diagnose_and_save_error(f"Error responding to message: {e}")
+# Run both FastAPI server and Discord bot concurrently
+if __name__ == "__main__":
+    # Start the FastAPI server in a separate thread
+    threading.Thread(target=start_fastapi_server, daemon=True).start()
 
-# === Start ===
-try:
-    bot.run(TOKEN)
-except Exception as e:
-    print(f"Bot crashed: {e}")
-    diagnose_and_save_error(f"Bot crashed: {e}")
-    # Optional: You can auto-restart after crash
-    # os.execv(sys.executable, ['python'] + sys.argv)
+    # Run the Discord bot
+    asyncio.run(run_discord_bot())