Update app.py

app.py

@@ -1,287 +1,116 @@
-import discord
-import os
-import threading
-import gradio as gr
-import requests
-import json
-import random
-import time
-import re
-from discord import Embed, Color
-from discord.ext import commands
-
-from gradio_client import Client
-from PIL import Image
-from ratelimiter import RateLimiter
-
-from datetime import datetime # for times
-from pytz import timezone # for times
-
-import asyncio # check if used
-
-zurich_tz = timezone("Europe/Zurich")
-
-def convert_to_timezone(dt, tz):
-    return dt.astimezone(tz).strftime("%Y-%m-%d %H:%M:%S %Z")
-
-DISCORD_TOKEN = os.environ.get("LUNARBOT_TOKEN", None)
-intents = discord.Intents.default()
-intents.message_content = True
-
-bot = commands.Bot(command_prefix='!', intents=intents)
-
-#rate_limiter = RateLimiter(max_calls=10, period=60)  # needs testing
-
-# todo
-'''
-discord.gg / discord/invite (block completely, need to be cautious)
-attempted @everyone / @here pings, or trying to use those strings (ping @alerts)
-ping alerts for list of keywords 
-
-
+from typing import Optional
 
-'''
-
-
-
-
-# moderation stuff----------------------------------------------------------------------------------------------------------------------------------------------------------
-
-@bot.event
-async def on_message_edit(before, after):
-    if before.author == bot.user:
-        return
-
-    if before.content != after.content:
-        embed = Embed(color=Color.orange())
-        embed.set_author(name=f"{before.author}    ID: {before.author.id}", icon_url=before.author.avatar.url)
-        embed.title = "Message Edited"
-        embed.description = f"**Before:** {before.content or '*(empty message)*'}\n**After:** {after.content or '*(empty message)*'}"
-        embed.add_field(name="Author Username", value=before.author.name, inline=True)
-        embed.add_field(name="Channel", value=before.channel.mention, inline=True)
-        #embed.add_field(name="Message Created On", value=before.created_at.strftime("%Y-%m-%d %H:%M:%S UTC"), inline=True)
-        embed.add_field(name="Message Created On", value=convert_to_timezone(before.created_at, zurich_tz), inline=True)
-        embed.add_field(name="Message ID", value=before.id, inline=True)
-        embed.add_field(name="Message Jump URL", value=f"[Jump to message!](https://discord.com/channels/{before.guild.id}/{before.channel.id}/{before.id})", inline=True)
-
-        if before.attachments:
-            attachment_urls = "\n".join([attachment.url for attachment in before.attachments])
-            embed.add_field(name="Attachments", value=attachment_urls, inline=False)
-
-        #embed.set_footer(text=f"{datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')}")
-        embed.set_footer(text=f"{convert_to_timezone(datetime.utcnow(), zurich_tz)}")
-
-        await bot.log_channel.send(embed=embed)
+import discord
+from discord import app_commands
 
-@bot.event
-async def on_message_delete(message):
-    if message.author == bot.user:
-        return
 
-    embed = Embed(color=Color.red())
-    embed.set_author(name=f"{message.author}    ID: {message.author.id}", icon_url=message.author.avatar.url)
-    embed.title = "Message Deleted"
-    embed.description = message.content or "*(empty message)*"
-    embed.add_field(name="Author Username", value=message.author.name, inline=True)
-    embed.add_field(name="Channel", value=message.channel.mention, inline=True)
-    #embed.add_field(name="Message Created On", value=message.created_at.strftime("%Y-%m-%d %H:%M:%S UTC"), inline=True)
-    embed.add_field(name="Message Created On", value=convert_to_timezone(message.created_at, zurich_tz), inline=True)
-    embed.add_field(name="Message ID", value=message.id, inline=True)
-    embed.add_field(name="Message Jump URL", value=f"[Jump to message!](https://discord.com/channels/{message.guild.id}/{message.channel.id}/{message.id})", inline=True)
+MY_GUILD = discord.Object(id=1077674588122648679)  # replace with your guild id
 
-    if message.attachments:
-        attachment_urls = "\n".join([attachment.url for attachment in message.attachments])
-        embed.add_field(name="Attachments", value=attachment_urls, inline=False)
 
-    #embed.set_footer(text=f"{datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S UTC')}")
-    embed.set_footer(text=f"{convert_to_timezone(datetime.utcnow(), zurich_tz)}")
+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)
 
-    await bot.log_channel.send(embed=embed)
+    # 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)
 
-# nickname stuff
-@bot.event
-async def on_member_update(before, after):
-    if before.nick != after.nick:
-        embed = Embed(description=f'{before} changed their nickname to {after.nick}', color=Color.blue())
-        await bot.log_channel.send(embed=embed)
 
-@bot.event
-async def on_member_ban(guild, user):
-    # member banned from the guild
-    embed = Embed(description=f'Member {user.mention} was banned from the guild', color=Color.red())
-    await bot.log_channel.send(embed=embed)
+intents = discord.Intents.default()
+client = MyClient(intents=intents)
 
-@bot.event
-async def on_member_unban(guild, user):
-    # member unbanned from the guild
-    embed = Embed(description=f'Member {user.mention} was unbanned from the guild', color=Color.green())
-    await bot.log_channel.send(embed=embed)       
 
-# admin stuff---------------------------------------------------------------------------------------------------------------------------------------------------------------
+@client.event
+async def on_ready():
+    print(f'Logged in as {client.user} (ID: {client.user.id})')
+    print('------')
 
-@bot.event
-async def on_guild_channel_create(channel):
-    # creating channels
-    embed = Embed(description=f'Channel {channel.mention} was created', color=Color.green())
-    await bot.log_channel.send(embed=embed)
 
-@bot.event
-async def on_guild_channel_delete(channel):
-    # deleting channels, should ping @alerts for this
-    embed = Embed(description=f'Channel {channel.name} ({channel.mention}) was deleted', color=Color.red())
-    await bot.log_channel.send(embed=embed)
+@client.tree.command()
+async def hello(interaction: discord.Interaction):
+    """Says hello!"""
+    await interaction.response.send_message(f'Hi, {interaction.user.mention}')
 
-@bot.event
-async def on_guild_role_create(role):
-    # creating roles
-    embed = Embed(description=f'Role {role.mention} was created', color=Color.green())
-    await bot.log_channel.send(embed=embed)
 
-@bot.event
-async def on_guild_role_delete(role):
-    # deleting roles, should ping @alerts for this
-    embed = Embed(description=f'Role {role.name} ({role.mention}) was deleted', color=Color.red())
-    await bot.log_channel.send(embed=embed)
+@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}')
 
-@bot.event
-async def on_guild_role_update(before, after):
-    # editing roles, could expand this 
-    if before.name != after.name:
-        embed = Embed(description=f'Role {before.mention} was renamed to {after.name}', color=Color.orange())
-        await bot.log_channel.send(embed=embed)
 
-    if before.permissions.administrator != after.permissions.administrator:
-        # changes involving the administrator permission / sensitive permissions (can help to prevent mistakes)
-        certain_role_id = 1106995261487710411  # role to ping (@alerts)
-        certain_role = after.guild.get_role(certain_role_id)
-        embed = Embed(description=f'Role {after.mention} had its administrator permission {"enabled" if after.permissions.administrator else "disabled"}', color=Color.red())
-        await bot.log_channel.send(content=certain_role.mention, embed=embed)  
+# 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)
 
-@bot.event
-async def on_voice_state_update(member, before, after):
-    if before.mute != after.mute:
-        # muting members
-        embed = Embed(description=f'{member} was {"muted" if after.mute else "unmuted"} in voice chat', color=Color.orange())
-        await bot.log_channel.send(embed=embed)
 
-    if before.deaf != after.deaf:
-        # deafening members
-        embed = Embed(description=f'{member} was {"deafened" if after.deaf else "undeafened"} in voice chat', color=Color.orange())
-        await bot.log_channel.send(embed=embed)
+# 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
 
-# bot stuff ---------------------------------------------------------------------------------------------------------------------------------------------------------------
-#---------------------------------------------------------------------------------------------------------------------------- 
-chathistory = None
-falcon_users = []
-#falcon_threads = []
-falcon_dictionary = {}
-falcon_userid_threadid_dictionary = {}
+    # 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)}')
 
-@bot.command()
-async def falcon(ctx, *, prompt: str):
-    # todo: need to be careful with these, rework into something simpler
-    try:
-        global falcon_users
-        #global falcon_threads # deprecated
-        global falcon_dictionary
-        global falcon_userid_threadid_dictionary
 
-        # dict[generation, authorid]
-        # dict[threadid, authorid]
+# 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.
 
-        if not ctx.author.bot:
-            if ctx.channel.id != 1119313248056004729: # initial thread creation inside #falcon
-                #if ctx.author.id not in falcon_users: # deprecated
-                if ctx.author.id not in falcon_userid_threadid_dictionary:
-                    #await ctx.message.add_reaction('<a:loading:1114111677990981692>')
-                    thread = await ctx.message.create_thread(name=f'{ctx.author}')
-                    #falcon_users = [ctx.author.id] + falcon_users # deprecated
-                    #falcon_threads = [thread.id] + falcon_threads # deprecated
-                    await thread.send(f"[DISCLAIMER: HuggingBot is a **highly experimental** beta feature; The Falcon model and system prompt can be found here: https://huggingface.co/spaces/HuggingFaceH4/falcon-chat]")
-                    
-                    # initial generation here
-                    chathistory = falconclient.predict( 
-                            fn_index=5
-                    ) # []
-                    instructions = "The following is a conversation between a highly knowledgeable and intelligent AI assistant, called Falcon, and a human user, called User. In the following interactions, User and Falcon will converse in natural language, and Falcon will answer User's questions. Falcon was built to be respectful, polite and inclusive. Falcon was built by the Technology Innovation Institute in Abu Dhabi. Falcon will never decline to answer a question, and always attempts to give an answer that User would be satisfied with. It knows a lot, and always tells the truth. The conversation begins."
-                    job = falconclient.submit(prompt, chathistory, instructions, 0.8, 0.9, fn_index=1)  # This is not blocking, similar to run_in_executor (but better)
-                    while job.done() == False: 
-                        status = job.status() # could be spammy, let's test anyways
-                        #print(status)
-                    else:
-                        file_paths = job.outputs()
-                        full_generation = file_paths[-1] # tmp12345678.json
-                    with open(full_generation, 'r') as file:
-                        data = json.load(file)
-                        output_text = data[-1][-1] # we output this as the bot
+# 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)}')
 
-                    falcon_dictionary[ctx.author.id] = full_generation # 1234567890: tmp12345678.json
-                    falcon_userid_threadid_dictionary[ctx.author.id] = thread.id
 
-                    print(output_text)
-                    await thread.send(f"{output_text}")     
-                    #await ctx.message.remove_reaction('<a:loading:1114111677990981692>', bot.user)
-                #elif ctx.author.id in falcon_users: # deprecated
-                elif ctx.author.id in falcon_userid_threadid_dictionary:
-                    # get the threadid, grab the last message in that thread, link to that message
-                    thread_id = falcon_userid_threadid_dictionary[ctx.author.id]
-                    thread_link = f"https://discord.com/channels/879548962464493619/1119313248056004729/{thread_id}"
-                    await ctx.reply(f"{ctx.author.mention}, you already have an existing conversation here {thread_link}! Use !falconclear in the #falcon channel to start a new one.")
-            #------------------------------------
-            # post all other generations here
-            #if ctx.channel.id in falcon_threads: # deprecated
-            if ctx.channel.id in falcon_userid_threadid_dictionary.values():
-                if ctx.channel.id == falcon_userid_threadid_dictionary[ctx.author.id]:
-                    await ctx.message.add_reaction('<a:loading:1114111677990981692>')
-                    chathistory = falcon_dictionary[ctx.author.id]
+# 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
+    )
 
-                    instructions = "The following is a conversation between a highly knowledgeable and intelligent AI assistant, called Falcon, and a human user, called User. In the following interactions, User and Falcon will converse in natural language, and Falcon will answer User's questions. Falcon was built to be respectful, polite and inclusive. Falcon was built by the Technology Innovation Institute in Abu Dhabi. Falcon will never decline to answer a question, and always attempts to give an answer that User would be satisfied with. It knows a lot, and always tells the truth. The conversation begins."
-                    job = falconclient.submit(prompt, chathistory, instructions, 0.8, 0.9, fn_index=1)  # This is not blocking, similar to run_in_executor (but better)
-                    while job.done() == False: 
-                        status = job.status() # could be spammy, let's test anyways
-                        #print(status)
-                    else:
-                        file_paths = job.outputs()
-                        full_generation = file_paths[-1] # tmp12345678.json
-                    with open(full_generation, 'r') as file:
-                        data = json.load(file)
-                        output_text = data[-1][-1] # we output this as the bot
-                    falcon_dictionary[ctx.author.id] = full_generation 
-                    print(output_text)
-                    await ctx.reply(f"{output_text}")                
-                    await ctx.message.remove_reaction('<a:loading:1114111677990981692>', bot.user)
-            
-    except Exception as e:
-        print(f"Error: {e}")
-        await ctx.reply(f"{e} cc <@811235357663297546> (falconprivate error)")           
-        await ctx.message.remove_reaction('<a:loading:1114111677990981692>', bot.user)        
-        await ctx.message.add_reaction('<:disagree:1098628957521313892>')
-#----------------------------------------------------------------------------------------------------------------------------
-@bot.command()
-async def falconclear(ctx):
-    if not ctx.author.bot:
-        if ctx.channel.id == 1119313248056004729:
-            if ctx.author.id in falcon_userid_threadid_dictionary:
-                if ctx.author.id in falcon_dictionary:
-                    del falcon_userid_threadid_dictionary[ctx.author.id]
-                    del falcon_dictionary[ctx.author.id]
-                    await ctx.reply(f"{ctx.author.mention}'s conversation has been cleared. Feel free to start a new one!")
-#---------------------------------------------------------------------------------------------------------------------------- 
+    # Handle report by sending it into a log channel
+    log_channel = interaction.guild.get_channel(0)  # replace with your channel id
 
-@bot.event
-async def on_ready():
-    print('Logged on as', bot.user)
-    bot.log_channel = bot.get_channel(1107006391547342910)
+    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
 
-def run_bot():
-    bot.run(DISCORD_TOKEN)
+    url_view = discord.ui.View()
+    url_view.add_item(discord.ui.Button(label='Go to Message', style=discord.ButtonStyle.url, url=message.jump_url))
 
-threading.Thread(target=run_bot).start()
+    await log_channel.send(embed=embed, view=url_view)
 
-def greet(name):
-    return "Hello " + name + "!"
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+client.run('token')