app.py

import discord
import threading
import os
import gradio as gr
from discord.ext import commands
from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError

DISCORD_TOKEN = os.getenv('DISCORD_TOKEN')
SLACK_BOT_TOKEN = os.getenv('BOT_USER_OAUTH_TOKEN_HF')
SLACK_CHANNEL_ID = os.getenv('SLACK_CHANNEL_ID_HF')
SLACK_CHANNEL_ID_TEST = 'C07B4KNU5BQ'

TRIGGERS = {
    "discord bot": "<@U051DB2754M>", # Adam
    "text to speech": "<@U039C2GANMV>", # VB
    "tts": "<@U039C2GANMV>", # VB
    "asr": "<@U039C2GANMV>", # VB
    "musicgen": "<@U039C2GANMV>", # VB
    "whisper": "<@U039C2GANMV>", # VB
    "speech recognition": "<@U039C2GANMV>", # VB
    "bark": "<@U039C2GANMV>", # VB
    "autotrain": "<@U01E3LEC2N7>", # abhishek
    "auto train": "<@U01E3LEC2N7>", # abhishek
    "competition": "<@U01E3LEC2N7>", # abhishek
    "competitions": "<@U01E3LEC2N7>", # abhishek
    "sentence-transformers": "<@U04E4DNPWG7>", # tom aarsen
    "sentence_transformers": "<@U04E4DNPWG7>", # tom aarsen
    "setfit": "<@U04E4DNPWG7>", # tom aarsen
    "sentence transformers": "<@U04E4DNPWG7>", # tom aarsen
    "argilla": "<@U076B8C7G3E>", # david berenstein
    "distilabel": "<@U076B8C7G3E>", # david berenstein
    "argilla": "<@U0766H30T7F>", # natalia elvira
    "dataset": "<@U0766H30T7F>", # natalia elvira
    "docs": "<@U02DATT4C5B>", # steven liu
    "documentation": "<@U02DATT4C5B>", # steven liu
    
}

intents = discord.Intents.all()
intents.messages = True
bot = commands.Bot(command_prefix='!', intents=intents)

slack_client = WebClient(token=SLACK_BOT_TOKEN)

@bot.event
async def on_ready():
    print(f'Logged in as {bot.user}')

@bot.event
async def on_message(message):
    if message.author == bot.user:
        return

    # notification bot
    huggingfolks_role = discord.utils.get(message.guild.roles, id=897376942817419265)
    bots_role = discord.utils.get(message.guild.roles, id=1258328471609016341)
    if huggingfolks_role not in message.author.roles: # no need for ping if we're already discussing
        if bots_role not in message.author.roles: # bots shouldn't trigger pings for this
            content = message.content.lower()
            for trigger, slack_mention in TRIGGERS.items():
                if trigger in content:
                    await post_to_slack(message.author, message.content, message.channel.name, message.jump_url, slack_mention, trigger)
                    break

    # ask-for-help
    # discord.ForumChannel.last_message_id -> The last thread ID that was created on this forum.
    # when message is posted
    # fetch ask-for-help channel 
    # if ask-for-help.last_message_id == message.id of on_message -> success
    #--------------------------------------------------------------------------------------------------------------------
    ask_for_help = await bot.fetch_channel(1019883044724822016)
    if ask_for_help.last_message_id == message.channel.id:
        content = message.content
        try:
            # title
            response = slack_client.chat_postMessage(
                channel=SLACK_CHANNEL_ID,
                text=f"New post in #ask-for-help by {message.author}: *{message.channel.name}*\n{message.jump_url}"
            )
            # reply in thread
            thread_ts = response['ts']
            slack_client.chat_postMessage(
                channel=SLACK_CHANNEL_ID,
                text=content,
                thread_ts=thread_ts
            )
        except SlackApiError as e:
            print(f"Error posting to Slack: {e.response['error']}")
    #--------------------------------------------------------------------------------------------------------------------


    ask_for_help = await bot.fetch_channel(1019883044724822016)
    if ask_for_help.last_message_id == message.channel.id:
        content = message.content
        thread_id = message.channel.id

        try:
            thread_ts = find_slack_thread_ts(thread_id)

            if thread_ts:
                # if exists, post in existing thread (don't create new one)
                slack_client.chat_postMessage(
                    channel=SLACK_CHANNEL_ID_TEST,
                    text=content,
                    thread_ts=thread_ts
                )
            else:
                # if not, create new thread
                response = slack_client.chat_postMessage(
                    channel=SLACK_CHANNEL_ID_TEST,
                    text=f"New post in #ask-for-help by {message.author}: *{message.channel.name}*\n{message.jump_url}\n\nDiscord Thread ID: {thread_id}"
                )
                thread_ts = response['ts']
                # first reply
                slack_client.chat_postMessage(
                    channel=SLACK_CHANNEL_ID_TEST,
                    text=content,
                    thread_ts=thread_ts
                )
        except SlackApiError as e:
            print(f"Error posting to Slack: {e.response['error']}")

    def find_slack_thread_ts(thread_id):
        # search for a Slack thread based on Discord thread_id"""
        try:
            response = slack_client.conversations_history(
                channel=SLACK_CHANNEL_ID_TEST,
                limit=1000  # adjustable
            )
            messages = response['messages']
    
            for message in messages:
                if f"Discord Thread ID: {thread_id}" in message['text']:
                    return message['ts']
    
        except SlackApiError as e:
            print(f"Error fetching Slack messages: {e.response['error']}")
    
        return None    



    #----------------------------------------------------------------------------------------------




async def post_to_slack(author, content, channel, url, slack_mention, trigger):
    try:
        response = slack_client.chat_postMessage(
            channel=SLACK_CHANNEL_ID,
            text=f"{slack_mention} (for the keyword -> '{trigger}')\nFrom {author} in channel #{channel}: {content}\n{url}"
        )
    except SlackApiError as e:
        print(f"Error posting to Slack: {e.response['error']}")


# runs discord bot in thread = helps avoid blocking calls
def run_bot():
    bot.run(DISCORD_TOKEN)
threading.Thread(target=run_bot).start()
def greet(name):
    return "Hello " + name + "!"
demo = gr.Interface(fn=greet, inputs="text", outputs="text")
demo.launch()