Synced repo using 'sync_with_huggingface' Github Action

Makefile

@@ -0,0 +1,10 @@
+.PHONY: quality style
+
+check_dirs := app.py deepfloydif.py falcon.py
+
+quality:
+	black --check $(check_dirs)
+	ruff $(check_dirs)
+style:
+	black $(check_dirs)
+	ruff $(check_dirs) --fix

app.py

@@ -1,12 +1,13 @@
-import discord
-from discord import app_commands
-import gradio as gr
 import os
 import threading
-from falcon import try_falcon
-from falcon import continue_falcon
-from deepfloydif import deepfloydif_stage_1
-from deepfloydif import deepfloydif_stage_2_react_check
+
+import discord
+import gradio as gr
+from deepfloydif import deepfloydif_stage_1, deepfloydif_stage_2_react_check
+from discord import app_commands
+from discord.ext import commands
+from falcon import continue_falcon, try_falcon
+from musicgen import music_create
 
 # HF GUILD SETTINGS
 MY_GUILD_ID = 1077674588122648679 if os.getenv("TEST_ENV", False) else 879548962464493619
@@ -14,20 +15,18 @@ MY_GUILD = discord.Object(id=MY_GUILD_ID)
 DISCORD_TOKEN = os.environ.get("DISCORD_TOKEN", None)
 
 
-class MyClient(discord.Client):
+class Bot(commands.Bot):
     """This structure allows slash commands to work instantly."""
 
-    def __init__(self, *, intents: discord.Intents):
-        super().__init__(intents=intents)
-        self.tree = app_commands.CommandTree(self)
+    def __init__(self):
+        super().__init__(command_prefix="/", intents=discord.Intents.all())
 
     async def setup_hook(self):
-        # This copies the global commands over to our guild
-        self.tree.copy_global_to(guild=MY_GUILD)
-        await self.tree.sync(guild=MY_GUILD)
+        await self.tree.sync(guild=discord.Object(MY_GUILD_ID))
+        print(f"Synced slash commands for {self.user}.")
 
 
-client = MyClient(intents=discord.Intents.all())
+client = Bot()
 
 
 @client.event
@@ -36,12 +35,16 @@ async def on_ready():
     print("------")
 
 
-@client.tree.command()
-@app_commands.describe(prompt="Enter some text to chat with the bot! Like this: /falcon Hello, how are you?")
-async def falcon(interaction: discord.Interaction, prompt: str):
+@client.hybrid_command(
+    name="falcon",
+    with_app_command=True,
+    description="Enter some text to chat with the bot! Like this: /falcon Hello, how are you?",
+)
+@app_commands.guilds(MY_GUILD)
+async def falcon(ctx, prompt: str):
     """Command that begins a new conversation with Falcon"""
     try:
-        await try_falcon(interaction, prompt)
+        await try_falcon(ctx, prompt)
     except Exception as e:
         print(f"Error: {e}")
 
@@ -55,12 +58,26 @@ async def on_message(message):
         print(f"Error: {e}")
 
 
-@client.tree.command()
-@app_commands.describe(prompt="Enter a prompt to generate an image! Can generate realistic text, too!")
-async def deepfloydif(interaction: discord.Interaction, prompt: str):
+@client.hybrid_command(
+    name="deepfloydif",
+    with_app_command=True,
+    description="Enter a prompt to generate an image! Can generate realistic text, too!",
+)
+@app_commands.guilds(MY_GUILD)
+async def deepfloydif(ctx, prompt: str):
     """DeepfloydIF stage 1 generation"""
     try:
-        await deepfloydif_stage_1(interaction, prompt, client)
+        await deepfloydif_stage_1(ctx, prompt, client)
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+@client.hybrid_command(name="musicgen", with_app_command=True, description="Enter a prompt to generate music!")
+@app_commands.guilds(MY_GUILD)
+async def musicgen(ctx, prompt: str):
+    """Generates music based on a prompt"""
+    try:
+        await music_create(ctx, prompt)
     except Exception as e:
         print(f"Error: {e}")
 
@@ -87,4 +104,4 @@ with gr.Blocks() as demo:
     Currently supported models are Falcon and DeepfloydIF
     """)
 demo.queue(concurrency_count=20)
-demo.launch()
+demo.launch()

deepfloydif.py

@@ -1,11 +1,12 @@
-import discord
-from gradio_client import Client
-import os
-import random
-from PIL import Image
 import asyncio
 import glob
+import os
 import pathlib
+import random
+
+import discord
+from gradio_client import Client
+from PIL import Image
 
 HF_TOKEN = os.getenv("HF_TOKEN")
 deepfloydif_client = Client("huggingface-projects/IF", HF_TOKEN)
@@ -87,23 +88,21 @@ def combine_images(png_files, stage_1_images, partial_path):
     return combined_image_path
 
 
-async def deepfloydif_stage_1(interaction, prompt, client):
+async def deepfloydif_stage_1(ctx, prompt, client):
     """DeepfloydIF command (generate images with realistic text using slash commands)"""
     try:
-        if interaction.user.id != BOT_USER_ID:
-            if interaction.channel.id == DEEPFLOYDIF_CHANNEL_ID:
+        if ctx.author.id != BOT_USER_ID:
+            if ctx.channel.id == DEEPFLOYDIF_CHANNEL_ID:
                 if os.environ.get("TEST_ENV") == "True":
                     print("Safety checks passed for deepfloydif_stage_1")
-                await interaction.response.send_message("Working on it!")
-                channel = interaction.channel
                 # interaction.response message can't be used to create a thread, so we create another message
-                message = await channel.send("DeepfloydIF Thread")
+                message = await ctx.send(f"**{prompt}** - {ctx.author.mention}")
                 thread = await message.create_thread(name=f"{prompt}", auto_archive_duration=60)
                 await thread.send(
                     "[DISCLAIMER: HuggingBot is a **highly experimental** beta feature; Additional information on the"
                     " DeepfloydIF model can be found here: https://huggingface.co/spaces/DeepFloyd/IF"
                 )
-                await thread.send(f"{interaction.user.mention} Generating images in thread, can take ~1 minute...")
+                await thread.send(f"{ctx.author.mention} Generating images in thread, can take ~1 minute...")
 
                 loop = asyncio.get_running_loop()
                 result = await loop.run_in_executor(None, deepfloydif_stage_1_inference, prompt)
@@ -119,13 +118,14 @@ async def deepfloydif_stage_1(interaction, prompt, client):
                         print("Images combined for deepfloydif_stage_1")
                     with open(combined_image_path, "rb") as f:
                         combined_image_dfif = await thread.send(
-                            f"{interaction.user.mention} React with the image number you want to upscale!",
+                            f"{ctx.author.mention} React with the image number you want to upscale!",
                             file=discord.File(f, f"{partial_path}.png"),
                         )
                     emoji_list = ["↖️", "↗️", "↙️", "↘️"]
                     await react_1234(emoji_list, combined_image_dfif)
                 else:
-                    await thread.send(f"{interaction.user.mention} No PNG files were found, cannot post them!")
+                    await thread.send(f"{ctx.author.mention} No PNG files were found, cannot post them!")
+
     except Exception as e:
         print(f"Error: {e}")
 
@@ -192,4 +192,4 @@ async def deepfloydif_stage_2(index: int, path_for_stage_2_upscaling, thread):
             await thread.send("Here is the upscaled image!", file=discord.File(f, "result.png"))
         await thread.edit(archived=True)
     except Exception as e:
-        print(f"Error: {e}")
+        print(f"Error: {e}")

falcon.py

@@ -1,7 +1,8 @@
-from gradio_client import Client
-import os
 import asyncio
 import json
+import os
+
+from gradio_client import Client
 
 HF_TOKEN = os.getenv("HF_TOKEN")
 falcon_userid_threadid_dictionary = {}
@@ -56,19 +57,17 @@ def falcon_initial_generation(prompt, instructions, thread):
         return output_text
 
 
-async def try_falcon(interaction, prompt):
+async def try_falcon(ctx, prompt):
     """Generates text based on a given prompt"""
     try:
         global falcon_userid_threadid_dictionary  # tracks userid-thread existence
         global threadid_conversation
 
-        if interaction.user.id != BOT_USER_ID:
-            if interaction.channel.id == FALCON_CHANNEL_ID:
+        if ctx.author.id != BOT_USER_ID:
+            if ctx.channel.id == FALCON_CHANNEL_ID:
                 if os.environ.get("TEST_ENV") == "True":
                     print("Safetychecks passed for try_falcon")
-                await interaction.response.send_message("Working on it!")
-                channel = interaction.channel
-                message = await channel.send("Creating thread...")
+                message = await ctx.send(f"**{prompt}** - {ctx.author.mention}")
                 thread = await message.create_thread(name=prompt, auto_archive_duration=60)  # interaction.user
                 await thread.send(
                     "[DISCLAIMER: HuggingBot is a **highly experimental** beta feature; The Falcon model and system"
@@ -79,7 +78,7 @@ async def try_falcon(interaction, prompt):
                     print("Running falcon_initial_generation...")
                 loop = asyncio.get_running_loop()
                 output_text = await loop.run_in_executor(None, falcon_initial_generation, prompt, instructions, thread)
-                falcon_userid_threadid_dictionary[thread.id] = interaction.user.id
+                falcon_userid_threadid_dictionary[thread.id] = ctx.author.id
 
                 await thread.send(output_text)
     except Exception as e:
@@ -92,11 +91,8 @@ async def continue_falcon(message):
         if not message.author.bot:
             global falcon_userid_threadid_dictionary  # tracks userid-thread existence
             if message.channel.id in falcon_userid_threadid_dictionary:  # is this a valid thread?
-                if (
-                    falcon_userid_threadid_dictionary[message.channel.id] == message.author.id
-                ):  # more than that - is this specifically the right user for this thread?
-                    if os.environ.get("TEST_ENV") == "True":
-                        print("Safetychecks passed for continue_falcon")
+                if falcon_userid_threadid_dictionary[message.channel.id] == message.author.id:
+                    print("Safetychecks passed for continue_falcon")
                     global instructions
                     global threadid_conversation
                     await message.add_reaction("🔁")
@@ -133,4 +129,4 @@ async def continue_falcon(message):
                     await message.reply(output_text)
     except Exception as e:
         print(f"continue_falcon Error: {e}")
-        await message.reply(f"Error: {e} <@811235357663297546> (continue_falcon error)")
+        await message.reply(f"Error: {e} <@811235357663297546> (continue_falcon error)")

musicgen.py

@@ -0,0 +1,76 @@
+import asyncio
+import os
+
+import discord
+from gradio_client import Client
+
+BOT_USER_ID = 1102236653545861151  # real
+MUSIC_CHANNEL_ID = 1140990231730987058  # real
+
+musicgen = Client("huggingface-projects/transformers-musicgen", hf_token=os.getenv("HF_TOKEN"))
+
+
+def music_create_job(prompt):
+    """Generates music based on a given prompt"""
+    try:
+        job = musicgen.submit(prompt, api_name="/predict")
+        while not job.done():
+            pass
+        files = job.outputs()
+        files = files[0]
+
+        return files
+
+    except Exception as e:
+        print(f"music_create_job Error: {e}")
+
+
+async def music_create(ctx, prompt):
+    """Runs music_create_job in executor"""
+    try:
+        if ctx.author.id != BOT_USER_ID:
+            if ctx.channel.id == MUSIC_CHANNEL_ID:
+                if os.environ.get("TEST_ENV") == "True":
+                    print("Safetychecks passed for music_create")
+
+                message = await ctx.send(f"**{prompt}** - {ctx.author.mention}")
+                thread = await message.create_thread(name=prompt, auto_archive_duration=60)
+
+                await thread.send(
+                    "[DISCLAIMER: HuggingBot is a beta feature; The MusicGen"
+                    " model can be found here: https://huggingface.co/spaces/facebook/MusicGen]"
+                )
+                if os.environ.get("TEST_ENV") == "True":
+                    print("Running music_create_job...")
+
+                loop = asyncio.get_running_loop()
+                files = await loop.run_in_executor(None, music_create_job, prompt)
+
+                audio, video = files[0], files[1]
+
+                with open(audio, "rb") as file:
+                    discord_file = discord.File(file)
+                await thread.send(file=discord_file)
+
+                with open(video, "rb") as file:
+                    discord_file = discord.File(file)
+                await thread.send(file=discord_file)
+
+                embed = discord.Embed()
+                embed.set_thumbnail(url="https://abs.twimg.com/icons/apple-touch-icon-192x192.png")
+                tweet1 = "https://twitter.com/intent/tweet?text="
+                tweet2 = "I%20generated%20this%20audio%20using%20MusicGen"
+                tweet3 = "%20in%20the%20%F0%9F%A4%97%20@huggingface%20Discord!"
+                tweet4 = "%0Ahf.co/join/discord%0A%0APrompt:%20"
+                prompt = prompt.replace(" ", "%20")
+                intent_link = f"{tweet1}{tweet2}{tweet3}{tweet4}{prompt}"
+                embed.add_field(
+                    name="Twitter",
+                    value=f"[Share it!]({intent_link})",
+                    inline=True,
+                )
+
+                await thread.send(embed=embed)
+
+    except Exception as e:
+        print(f"music_create Error: {e}")

pyproject.toml

@@ -0,0 +1,7 @@
+[tool.black]
+line-length = 119
+target_version = ['py37', 'py38', 'py39', 'py310']
+preview = true
+
+[tool.ruff]
+line-length = 119

requirements.txt

@@ -1,2 +1,2 @@
 discord.py
-gradio
+gradio