Deploy ChatInterface as a discord bot

.changeset/eleven-turkeys-talk.md

@@ -0,0 +1,6 @@
+---
+"gradio": minor
+"gradio_client": minor
+---
+
+feat:Deploy ChatInterface as a discord bot

client/python/gradio_client/cli/__init__.py

@@ -0,0 +1,3 @@
+from gradio_client.cli import deploy_discord
+
+__all__ = ["deploy_discord"]

client/python/gradio_client/cli/deploy_discord.py

@@ -0,0 +1,58 @@
+import argparse
+
+from gradio_client import Client
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Deploy Space as Discord Bot.")
+    parser.add_argument("deploy-discord")
+    parser.add_argument(
+        "--src",
+        type=str,
+        help="The space id or url or gradio app you want to deploy as a gradio bot.",
+    )
+    parser.add_argument(
+        "--discord-bot-token",
+        type=str,
+        help="Discord bot token. Get one on the discord website.",
+    )
+    parser.add_argument(
+        "--api-names",
+        nargs="*",
+        help="Api names to turn into discord bots",
+        default=[],
+    )
+    parser.add_argument(
+        "--to-id",
+        type=str,
+        help="Name of the space used to host the discord bot",
+        default=None,
+    )
+    parser.add_argument(
+        "--hf-token",
+        type=str,
+        help=(
+            "Hugging Face token. Can be ommitted if you are logged in via huggingface_hub cli. "
+            "Must be provided if upstream space is private."
+        ),
+        default=None,
+    )
+    parser.add_argument(
+        "--private",
+        type=bool,
+        nargs="?",
+        help="Whether the discord bot space is private.",
+        const=True,
+        default=False,
+    )
+    args = parser.parse_args()
+    for i, name in enumerate(args.api_names):
+        if "," in name:
+            args.api_names[i] = tuple(name.split(","))
+    Client(args.src).deploy_discord(
+        discord_bot_token=args.discord_bot_token,
+        api_names=args.api_names,
+        to_id=args.to_id,
+        hf_token=args.hf_token,
+        private=args.private,
+    )

client/python/gradio_client/client.py

@@ -5,6 +5,7 @@
 import json
 import os
 import re
+import secrets
 import tempfile
 import threading
 import time
@@ -20,7 +21,7 @@
 import huggingface_hub
 import requests
 import websockets
-from huggingface_hub import SpaceHardware, SpaceStage
+from huggingface_hub import CommitOperationAdd, SpaceHardware, SpaceStage
 from huggingface_hub.utils import (
     RepositoryNotFoundError,
     build_hf_headers,
@@ -603,6 +604,147 @@ def _get_config(self) -> dict:
                 )
             return config
 
+    def deploy_discord(
+        self,
+        discord_bot_token: str | None = None,
+        api_names: list[str | tuple[str, str]] | None = None,
+        to_id: str | None = None,
+        hf_token: str | None = None,
+        private: bool = False,
+    ):
+        """
+        Deploy the upstream app as a discord bot. Currently only supports gr.ChatInterface.
+        Parameters:
+            discord_bot_token: This is the "password" needed to be able to launch the bot. Users can get a token by creating a bot app on the discord website. If run the method without specifying a token, the space will explain how to get one. See here: https://huggingface.co/spaces/freddyaboulton/test-discord-bot-v1.
+            api_names: The api_names of the app to turn into bot commands. This parameter currently has no effect as ChatInterface only has one api_name ('/chat').
+            to_id: The name of the space hosting the discord bot. If None, the name will be gradio-discord-bot-{random-substring}
+            hf_token: HF api token with write priviledges in order to upload the files to HF space. Can be ommitted if logged in via the HuggingFace CLI, unless the upstream space is private. Obtain from: https://huggingface.co/settings/token
+            private: Whether the space hosting the discord bot is private. The visibility of the discord bot itself is set via the discord website. See https://huggingface.co/spaces/freddyaboulton/test-discord-bot-v1
+        """
+
+        if self.config["mode"] == "chat_interface" and not api_names:
+            api_names = [("chat", "chat")]
+
+        valid_list = isinstance(api_names, list) and (
+            isinstance(n, str)
+            or (
+                isinstance(n, tuple) and isinstance(n[0], str) and isinstance(n[1], str)
+            )
+            for n in api_names
+        )
+        if api_names is None or not valid_list:
+            raise ValueError(
+                f"Each entry in api_names must be either a string or a tuple of strings. Received {api_names}"
+            )
+        assert (
+            len(api_names) == 1
+        ), "Currently only one api_name can be deployed to discord."
+
+        for i, name in enumerate(api_names):
+            if isinstance(name, str):
+                api_names[i] = (name, name)
+
+        fn = next(
+            (ep for ep in self.endpoints if ep.api_name == f"/{api_names[0][0]}"), None
+        )
+        if not fn:
+            raise ValueError(
+                f"api_name {api_names[0][0]} not present in {self.space_id or self.src}"
+            )
+        inputs = [
+            inp for inp in fn.input_component_types if fn not in utils.SKIP_COMPONENTS
+        ]
+        outputs = [
+            inp for inp in fn.input_component_types if fn not in utils.SKIP_COMPONENTS
+        ]
+        if not inputs == ["textbox"] and outputs == ["textbox"]:
+            raise ValueError(
+                "Currently only api_names with a single textbox as input and output are supported. "
+                f"Received {inputs} and {outputs}"
+            )
+
+        is_private = False
+        if self.space_id:
+            is_private = huggingface_hub.space_info(self.space_id).private
+            if is_private:
+                assert hf_token, (
+                    f"Since {self.space_id} is private, you must explicitly pass in hf_token "
+                    "so that it can be added as a secret in the discord bot space."
+                )
+
+        if to_id:
+            if "/" in to_id:
+                to_id = to_id.split("/")[1]
+            space_id = huggingface_hub.get_full_repo_name(to_id, token=hf_token)
+        else:
+            if self.space_id:
+                space_id = f'{self.space_id.split("/")[1]}-gradio-discord-bot'
+            else:
+                space_id = f"gradio-discord-bot-{secrets.token_hex(4)}"
+            space_id = huggingface_hub.get_full_repo_name(space_id, token=hf_token)
+
+        api = huggingface_hub.HfApi()
+
+        try:
+            huggingface_hub.space_info(space_id)
+            first_upload = False
+        except huggingface_hub.utils.RepositoryNotFoundError:
+            first_upload = True
+
+        huggingface_hub.create_repo(
+            space_id,
+            repo_type="space",
+            space_sdk="gradio",
+            token=hf_token,
+            exist_ok=True,
+            private=private,
+        )
+        if first_upload:
+            huggingface_hub.metadata_update(
+                repo_id=space_id,
+                repo_type="space",
+                metadata={"tags": ["gradio-discord-bot"]},
+            )
+
+        with open(str(Path(__file__).parent / "templates" / "discord_chat.py")) as f:
+            app = f.read()
+        app = app.replace("<<app-src>>", self.src)
+        app = app.replace("<<api-name>>", api_names[0][0])
+        app = app.replace("<<command-name>>", api_names[0][1])
+
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as app_file:
+            with tempfile.NamedTemporaryFile(mode="w", delete=False) as requirements:
+                app_file.write(app)
+                requirements.write("\n".join(["discord.py==2.3.1"]))
+
+        operations = [
+            CommitOperationAdd(path_in_repo="app.py", path_or_fileobj=app_file.name),
+            CommitOperationAdd(
+                path_in_repo="requirements.txt", path_or_fileobj=requirements.name
+            ),
+        ]
+
+        api.create_commit(
+            repo_id=space_id,
+            commit_message="Deploy Discord Bot",
+            repo_type="space",
+            operations=operations,
+            token=hf_token,
+        )
+
+        if discord_bot_token:
+            huggingface_hub.add_space_secret(
+                space_id, "DISCORD_TOKEN", discord_bot_token, token=hf_token
+            )
+        if is_private:
+            huggingface_hub.add_space_secret(
+                space_id, "HF_TOKEN", hf_token, token=hf_token
+            )
+
+        url = f"https://huggingface.co/spaces/{space_id}"
+        print(f"See your discord bot here! {url}")
+        return url
+
 
 class Endpoint:
     """Helper class for storing all the information about a single API endpoint."""