The admin tool relies on a third-party library called simple_term_menu. There are many menus available that allow you to dive deep into options. For example, the admin tool starts asking if you are running the command in the Raspberry PI (prod) or in your local machine (dev). Then, the options are different. In production, when updating the code, the admin tool stops the service, fetches the latest code, installs the dependencies, and starts the service again. In development, options for visualization, tests, or fetching the latest production data are all available.

def main():
    """First menu"""
 options = ["[1] Raspberry PI", "[2] Local", "[q] Exit"]
 terminal_menu = TerminalMenu(options, title="Environment", show_shortcut_hints=True)
 menu_entry_index = terminal_menu.show()
    if menu_entry_index == 0:
        raspberry_pi_menu()
    elif menu_entry_index == 1:
        local_menu()
    elif menu_entry_index == 2:
 sys.exit(0)
    main()

Voice Message Channel

On my journey of adding features, I wanted to let people know they are not alone when joining a voice channel. There is always a first one to join. I added a feature that the bot would join the voice channel and play a dynamically generated message using the user name and then the schedule. The bot was mentioning out loud who was playing in the current hours, and if no one was, it would say the upcoming hour's schedule. This feature is temporarily disabled as it was making the false impression that a human had joined the channel.

The feature relies on the gtts library that converts text to speech. The library is easy to use, and the code looks like this:

# Convert text to speech using gTTS
tts = gTTS(text_message, lang="en")
tts.save("welcome.mp3")

# Connect to the voice channel
if member.guild.voice_client is None:  # Bot isn't already in a channel
 voice_client = await voice_channel.connect()
else:
 voice_client = member.guild.voice_client

# Play the audio
audio_source = Discord.FFmpegPCMAudio("welcome.mp3")
voice_client.play(audio_source)

# Wait for the audio to finish playing
while voice_client.is_playing():
    await discord.utils.sleep_until(datetime.now() + timedelta(seconds=1))

# Disconnect after playing the audio
await voice_client.disconnect()

# Clean up the saved audio file
os.remove("welcome.mp3")

The FFmpegPCMAudio plays the audio like if the bot was talking into a microphone.

Organizing Voice Channel

The more people joined, the more organization was required. The game is Siege, and it is a 5v5 game. I added a feature that user, with a command, could set up their account by saying their in-game user name and, using an API on a third-party service, could figure out some statistics about the user, like their maximum rank. Then, the bot can assign a role that opens access to the different voice channels.

The feature relies on a UI, called "View" for Discord. It has a text box for the user to enter their in-game user name and a dropdown to select a time zone.

Getting Player Statistics

By touching the API, I found out that it could also give information about the matches. However, the API was not free and required special permission, which was denied (I suspect my bot is too little). I had to rely on the website and scrap the data. I could re-use the session by connecting once and directly accessing the data via a REST API. Then, by hooking the voice channel event, I can see if a user is leaving. In that case, I wait a few minutes to ensure the latest data is available and query the website. I get the last 12 hours' match data and create an aggregation.

The feature is one of the more popular ones, as it gives a quick overview of everyone's performance without having to leave the server.

Technically, it was challenging because of the many security steps in place to avoid having people scrape. I have contacted the API owner, but the communication was very broken, and I received a denial without any explanation. So, upon disconnect, I accumulate people's names. That is a good way to get a list instead of going one by one since we need to actually open a browser. And the website detects a headless browser. Thus, we need a real browser! So, on the disconnect event, the user id is persisted in the memory cache. Then, a Discord task that runs every 5 minutes check if there is any user to query. The task opens a browser and does its job. Using Python context manager, the code is clean:

try:
    with BrowserContextManager() as context:
        for user in users:
            try:
 matches: List[UserMatchInfo] = context.download_matches(user.user_info.ubisoft_username_active) # <------ HERE it downloads the data
 all_users_matches.append(UserWithUserMatchInfo(user, matches))
                if len(users) > 1:
                    await asyncio.sleep(random.uniform(0.5, 2))  # Sleep 0.5 to 2 seconds between each request
            except Exception as e:
                print_error_log(
                    f"post_queued_user_stats: Error getting the user ({user.user_info.display_name}) stats from R6 tracker: {e}"
                )
                continue  # Skip to the next user
except Exception as e:
    print_error_log(f"post_queued_user_stats: Error opening the browser context: {e}")

The BrowserContextManager uses selenium and with xvfb open Chrome. The code works locally (WSL on Windows) and on the Raspberry PI.

def _config_browser(self) -> None:
    """Configure the browser for headers and to receive a cookie to call future API endpoints"""
 options = uc.ChromeOptions()
 options.add_argument("--no-sandbox")
 options.add_argument("--disable-dev-shm-usage")
 options.add_argument("--disable-blink-features=AutomationControlled")
 options.add_argument("--disable-gpu")
 options.add_argument("--start-maximized")
 options.add_argument("--disable-extensions")
 options.add_argument("--disable-background-networking")
 options.add_argument("--disable-sync")
 options.add_argument(
        "user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.93 Safari/537.36"
    )

 environment_var = os.getenv("ENV")

    if environment_var == "prod":
 options.binary_location = "/usr/bin/chromium-browser"
 driver_path = "/usr/bin/chromedriver"
        self.driver = uc.Chrome(options=options, driver_executable_path=driver_path)
    else:
 service = Service()
 options.binary_location = "/usr/bin/google-chrome"
 options = webdriver.ChromeOptions()
        self.driver = webdriver.Chrome(service=service, options=options)
    print_log(f"_config_browser: Using binary location: {options.binary_location}")

The download_match uses BeautifulSoup to parse the data using the REST API endpoint while the configuration method uses selenium to open the browser and connect to the login page to get a proper session.

Asking for Teammate and Information

The usage of @here is not recommended as the community grows as it spams everyone. I added a command where it looks at who is in the voice channel and calculates the number of people needed (e.g., if two people are in the voice, the command will ask for three). Another command was introduced, which gives the timezone of the users in the voice channel, which helps determine the best host.

Auto-Requesting Teammate

I noticed that Discord shows the game you are playing but also provides some additional details, like if you are in a game or in the main menu. So, the bot can capture the change of event and, with a state machine, figure out if the group is missing a teammate and ready for a new match. The bot will then ask for a teammate only if needed, allowing the user to not have to ask for a teammate.

Tournament

One member wanted to create a 1-1 tournament. I added a tournament command to create, join, and report a loss. The bot randomly assigns people in a single elimination bracket. Upon reporting a loss, the bot figures out the tournament and match of the user and adjusts the bracket.