Update app.py

app.py

@@ -1,142 +1,116 @@
-from discord import app_commands
-import requests
-import discord
-import asyncio
-from discord.ext.commands import is_owner, Context, has_permissions
-import os
 from typing import Optional
 
-intents = discord.Intents.all()
-client = discord.Client(intents=intents)
-tree = app_commands.CommandTree(client)
-
-url = "https://huggingface.co/chat/conversation"
-
-# load system prompt
-try:
-    with open("sysp.txt", "r") as f:
-        sysp = f.read()
-except:
-    sysp = ""
-
-# models
-mixtral = "mistralai/Mixtral-8x7B-Instruct-v0.1"
-llama = "meta-llama/Llama-2-70b-chat-hf"
-openchat = "openchat/openchat-3.5-0106"
-mistral = "mistralai/Mistral-7B-Instruct-v0.2"
-hermes = "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO"
-codellama = "codellama/CodeLlama-70b-Instruct-hf"
-
-async def chat(conversationId, ip, cookie):
-    s = requests.Session()
-    url = f"https://huggingface.co/chat/conversation/{conversationId}"
-    
-    payload = {
-        "inputs": ip,
-        "id": cookie,
-        "is_retry": False,
-        "is_continue": False,
-        "web_search": False,
-        "files": []
-    }
-    
-    headers = {
-        "authority": "huggingface.co",
-        "accept": "*/*",
-        "accept-language": "en-US,en;q=0.9",
-        "content-type": "application/json",
-    }
-
-    response = s.post(url, json=payload, headers=headers)
-    return response
-    s.close()
-
-@client.tree.command(
-    description="Starts the conversation with Lyre.",
-    guild=discord.Object(id=1079318749116641320)
-)
-@app_commands.describe(
-    channel='The channel to start the conversation in. Defaults to the channel it was called in.',
-)
-@has_permissions(manage_channels=True, manage_messages=True)
-async def start(ctx: discord.Interaction, channel: Optional[discord.AppCommandOptionType.channel]=None):
-    s = requests.Session()
-    payload = {
-        "model": mixtral,
-        "preprompt": sysp
-    }
-    headers = {
-        "authority": "huggingface.co",
-        "accept": "*/*",
-        "accept-language": "en-US,en;q=0.9",
-        "content-type": "application/json"
-    }
-    if channel == None:
-        chping = f"<#{ctx.channel_id}>"
-        with open(str(ctx.channel_id), "w") as f:
-            f.write(s.cookies.get("hf-chat") + "\n" + response.json.loads(response.text)['conversationId'])
-    else:
-        chping = f"<#{channel.id}>"
-        with open(str(ctx.channel_id), "w") as f:
-            f.write(s.cookies.get("hf-chat") + "\n" + response.json.loads(response.text)['conversationId'])
-    ctx.response.send_message(f"Started a conversation in {chping}")
-
-@start.error
-async def start_error(error, ctx):
-    if isinstance(error, commands.MissingPermissions):
-        ctx.response.send_message(f"Missing permissions in {chping}")
-        
-@client.tree.command(
-    description="Ends the conversation with Lyre.",
-    guild=discord.Object(id=1079318749116641320)
-)
-@app_commands.describe(
-    channel='The channel to end the conversation in. Defaults to the channel it was called in.',
-)
-@has_permissions(manage_channels=True, manage_messages=True)
-async def start(ctx: discord.Interaction, channel: Optional[discord.AppCommandOptionType.channel]=None):
-    s = requests.Session()
-    payload = {
-        "model": mixtral,
-        "preprompt": sysp
-    }
-    headers = {
-        "authority": "huggingface.co",
-        "accept": "*/*",
-        "accept-language": "en-US,en;q=0.9",
-        "content-type": "application/json"
-    }
-    if channel == None:
-        chping = f"<#{ctx.channel_id}>"
-        os.remove(str(ctx.channel_id))
-    else:
-        chping = f"<#{channel.id}>"
-        os.remove(str(ctx.channel_id))
-    ctx.response.send_message(f"Ended the conversation in {chping}")
-    s.close()
-
-@end.error
-async def end_error(error, ctx):
-    if isinstance(error, commands.MissingPermissions):
-        ctx.response.send_message(f"Missing permissions in {chping}")
-
-@client.command()
-@is_owner()
-async def sync(ctx: Context) -> None:
-    synced = await client.tree.sync()
-    await ctx.reply("{} commands synced".format(len(synced)))
+import discord
+from discord import app_commands
+
+
+MY_GUILD = discord.Object(id=0)  # replace with your guild id
+
+
+class MyClient(discord.Client):
+    def __init__(self, *, intents: discord.Intents):
+        super().__init__(intents=intents)
+        # A CommandTree is a special type that holds all the application command
+        # state required to make it work. This is a separate class because it
+        # allows all the extra state to be opt-in.
+        # Whenever you want to work with application commands, your tree is used
+        # to store and work with them.
+        # Note: When using commands.Bot instead of discord.Client, the bot will
+        # maintain its own tree instead.
+        self.tree = app_commands.CommandTree(self)
+
+    # In this basic example, we just synchronize the app commands to one guild.
+    # Instead of specifying a guild to every command, we copy over our global commands instead.
+    # By doing so, we don't have to wait up to an hour until they are shown to the end-user.
+    async def setup_hook(self):
+        # This copies the global commands over to your guild.
+        self.tree.copy_global_to(guild=MY_GUILD)
+        await self.tree.sync(guild=MY_GUILD)
+
+
+intents = discord.Intents.default()
+client = MyClient(intents=intents)
+
 
 @client.event
 async def on_ready():
-    print("Ready!")
-    synced = await client.tree.sync()
+    print(f'Logged in as {client.user} (ID: {client.user.id})')
+    print('------')
+
+
+@client.tree.command()
+async def hello(interaction: discord.Interaction):
+    """Says hello!"""
+    await interaction.response.send_message(f'Hi, {interaction.user.mention}')
+
+
+@client.tree.command()
+@app_commands.describe(
+    first_value='The first value you want to add something to',
+    second_value='The value you want to add to the first value',
+)
+async def add(interaction: discord.Interaction, first_value: int, second_value: int):
+    """Adds two numbers together."""
+    await interaction.response.send_message(f'{first_value} + {second_value} = {first_value + second_value}')
+
+
+# The rename decorator allows us to change the display of the parameter on Discord.
+# In this example, even though we use `text_to_send` in the code, the client will use `text` instead.
+# Note that other decorators will still refer to it as `text_to_send` in the code.
+@client.tree.command()
+@app_commands.rename(text_to_send='text')
+@app_commands.describe(text_to_send='Text to send in the current channel')
+async def send(interaction: discord.Interaction, text_to_send: str):
+    """Sends the text into the current channel."""
+    await interaction.response.send_message(text_to_send)
+
+
+# To make an argument optional, you can either give it a supported default argument
+# or you can mark it as Optional from the typing standard library. This example does both.
+@client.tree.command()
+@app_commands.describe(member='The member you want to get the joined date from; defaults to the user who uses the command')
+async def joined(interaction: discord.Interaction, member: Optional[discord.Member] = None):
+    """Says when a member joined."""
+    # If no member is explicitly provided then we use the command user here
+    member = member or interaction.user
+
+    # The format_dt function formats the date time into a human readable representation in the official client
+    await interaction.response.send_message(f'{member} joined {discord.utils.format_dt(member.joined_at)}')
+
+
+# A Context Menu command is an app command that can be run on a member or on a message by
+# accessing a menu within the client, usually via right clicking.
+# It always takes an interaction as its first parameter and a Member or Message as its second parameter.
+
+# This context menu command only works on members
+@client.tree.context_menu(name='Show Join Date')
+async def show_join_date(interaction: discord.Interaction, member: discord.Member):
+    # The format_dt function formats the date time into a human readable representation in the official client
+    await interaction.response.send_message(f'{member} joined at {discord.utils.format_dt(member.joined_at)}')
+
+
+# This context menu command only works on messages
+@client.tree.context_menu(name='Report to Moderators')
+async def report_message(interaction: discord.Interaction, message: discord.Message):
+    # We're sending this response message with ephemeral=True, so only the command executor can see it
+    await interaction.response.send_message(
+        f'Thanks for reporting this message by {message.author.mention} to our moderators.', ephemeral=True
+    )
+
+    # Handle report by sending it into a log channel
+    log_channel = interaction.guild.get_channel(0)  # replace with your channel id
+
+    embed = discord.Embed(title='Reported Message')
+    if message.content:
+        embed.description = message.content
+
+    embed.set_author(name=message.author.display_name, icon_url=message.author.display_avatar.url)
+    embed.timestamp = message.created_at
+
+    url_view = discord.ui.View()
+    url_view.add_item(discord.ui.Button(label='Go to Message', style=discord.ButtonStyle.url, url=message.jump_url))
+
+    await log_channel.send(embed=embed, view=url_view)
 
-@client.event
-async def on_message_create(msg):
-    if os.path.exists(str(msg.channel.id)) or isinstance(msg.channel, discord.DMChannel):
-        with open(str(msg.channel.id), "r") as f:
-            cookie, id = f.read().split("\n")
-        r = await chat(id, "{" + str(msg.author) + "}\n" + msg.content, id)
-        await msg.reply(json.loads("{" + r.text.split("finalAnswer")[-1][2:].strip())["text"].strip())
 
 client.run(os.environ["TOKEN"])