From ba710816872b4ce298c03cd4ffd3383d5753d9f9 Mon Sep 17 00:00:00 2001 From: pacnpal <183241239+pacnpal@users.noreply.github.com> Date: Fri, 15 Nov 2024 00:45:13 +0000 Subject: [PATCH] fix: Properly implement slash commands - Use app_commands for slash command support - Add proper command group structure - Handle command registration and syncing --- videoarchiver/__init__.py | 19 ++- videoarchiver/commands.py | 269 ++++++++++++++++---------------- videoarchiver/video_archiver.py | 27 ++-- 3 files changed, 162 insertions(+), 153 deletions(-) diff --git a/videoarchiver/__init__.py b/videoarchiver/__init__.py index 77fd8c0..b40517f 100644 --- a/videoarchiver/__init__.py +++ b/videoarchiver/__init__.py @@ -1,13 +1,12 @@ """VideoArchiver cog for Red-DiscordBot""" - from redbot.core.bot import Red -from redbot.core.utils import get_end_user_data_statement +from .video_archiver import VideoArchiver -from videoarchiver.video_archiver import VideoArchiver -from videoarchiver.ffmpeg.ffmpeg_manager import FFmpegManager -from videoarchiver.ffmpeg.exceptions import FFmpegError, GPUError, DownloadError - -__red_end_user_data_statement__ = get_end_user_data_statement(__file__) - -async def setup(bot: Red): - await bot.add_cog(VideoArchiver(bot)) +async def setup(bot: Red) -> None: + """Load VideoArchiver.""" + cog = VideoArchiver(bot) + await bot.add_cog(cog) + # Sync commands with Discord + if not hasattr(bot, "tree"): + return + await bot.tree.sync() diff --git a/videoarchiver/commands.py b/videoarchiver/commands.py index e25119d..bd5ab21 100644 --- a/videoarchiver/commands.py +++ b/videoarchiver/commands.py @@ -1,7 +1,7 @@ """Discord commands for VideoArchiver""" import discord -from redbot.core import commands, checks -from typing import Optional +from redbot.core import commands, app_commands +from typing import Optional, Literal import yt_dlp from datetime import datetime @@ -15,185 +15,188 @@ class VideoArchiverCommands(commands.Cog): self.processor = processor super().__init__() - @commands.hybrid_group(name="videoarchiver", aliases=["va"], fallback="settings") - @commands.guild_only() + videoarchiver = app_commands.Group( + name="videoarchiver", + description="Video Archiver configuration commands", + guild_only=True + ) + + @videoarchiver.command(name="settings") + @app_commands.guild_only() @commands.admin_or_permissions(administrator=True) - async def videoarchiver(self, ctx: commands.Context): - """Video Archiver configuration commands""" - if ctx.invoked_subcommand is None: - embed = await self.config.format_settings_embed(ctx.guild) - await ctx.send(embed=embed) + async def settings(self, interaction: discord.Interaction): + """Show current settings""" + embed = await self.config.format_settings_embed(interaction.guild) + await interaction.response.send_message(embed=embed) @videoarchiver.command(name="updateytdlp") - @commands.guild_only() - @checks.is_owner() - async def update_ytdlp(self, ctx: commands.Context): + @app_commands.guild_only() + @commands.is_owner() + async def update_ytdlp(self, interaction: discord.Interaction): """Update yt-dlp to the latest version""" success, message = await self.update_checker.update_yt_dlp() - await ctx.send("✅ " + message if success else "❌ " + message) + await interaction.response.send_message("✅ " + message if success else "❌ " + message) @videoarchiver.command(name="toggleupdates") - @commands.guild_only() + @app_commands.guild_only() @commands.admin_or_permissions(administrator=True) - async def toggle_update_check(self, ctx: commands.Context): + async def toggle_update_check(self, interaction: discord.Interaction): """Toggle yt-dlp update notifications""" - state = await self.config.toggle_setting(ctx.guild.id, "disable_update_check") + state = await self.config.toggle_setting(interaction.guild.id, "disable_update_check") status = "disabled" if state else "enabled" - await ctx.send(f"Update notifications {status}") + await interaction.response.send_message(f"Update notifications {status}") @videoarchiver.command(name="addrole") - @commands.guild_only() - async def add_allowed_role(self, ctx: commands.Context, role: Optional[discord.Role] = None): - """Add a role that's allowed to trigger archiving (leave empty for @everyone)""" - role_id = role.id if role else ctx.guild.default_role.id - role_name = role.name if role else "@everyone" - - # If no role is specified, clear the list to allow everyone + @app_commands.guild_only() + @app_commands.describe(role="The role to allow (leave empty for @everyone)") + async def add_allowed_role(self, interaction: discord.Interaction, role: Optional[discord.Role] = None): + """Add a role that's allowed to trigger archiving""" if not role: - await self.config.update_setting(ctx.guild.id, "allowed_roles", []) - await ctx.send("Allowed role set to @everyone (all users can trigger archiving)") + # If no role is specified, clear the list to allow everyone + await self.config.update_setting(interaction.guild.id, "allowed_roles", []) + await interaction.response.send_message("Allowed role set to @everyone (all users can trigger archiving)") return - await self.config.add_to_list(ctx.guild.id, "allowed_roles", role_id) - await ctx.send(f"Added {role_name} to allowed roles") + await self.config.add_to_list(interaction.guild.id, "allowed_roles", role.id) + await interaction.response.send_message(f"Added {role.name} to allowed roles") @videoarchiver.command(name="removerole") - @commands.guild_only() - async def remove_allowed_role(self, ctx: commands.Context, role: discord.Role): + @app_commands.guild_only() + @app_commands.describe(role="The role to remove") + async def remove_allowed_role(self, interaction: discord.Interaction, role: discord.Role): """Remove a role from allowed roles""" - await self.config.remove_from_list(ctx.guild.id, "allowed_roles", role.id) - await ctx.send(f"Removed {role.name} from allowed roles") + await self.config.remove_from_list(interaction.guild.id, "allowed_roles", role.id) + await interaction.response.send_message(f"Removed {role.name} from allowed roles") @videoarchiver.command(name="listroles") - @commands.guild_only() - async def list_allowed_roles(self, ctx: commands.Context): + @app_commands.guild_only() + async def list_allowed_roles(self, interaction: discord.Interaction): """List all roles allowed to trigger archiving""" - roles = await self.config.get_setting(ctx.guild.id, "allowed_roles") + roles = await self.config.get_setting(interaction.guild.id, "allowed_roles") if not roles: - await ctx.send( + await interaction.response.send_message( "No roles are currently set (all users can trigger archiving)" ) return role_names = [ r.name if r else "@everyone" - for r in [ctx.guild.get_role(role_id) for role_id in roles] + for r in [interaction.guild.get_role(role_id) for role_id in roles] ] - await ctx.send(f"Allowed roles: {', '.join(role_names)}") + await interaction.response.send_message(f"Allowed roles: {', '.join(role_names)}") @videoarchiver.command(name="setconcurrent") - @commands.guild_only() - async def set_concurrent_downloads(self, ctx: commands.Context, count: int): - """Set the number of concurrent downloads (1-5)""" - if not 1 <= count <= 5: - await ctx.send("Concurrent downloads must be between 1 and 5") - return - await self.config.update_setting(ctx.guild.id, "concurrent_downloads", count) - await ctx.send(f"Concurrent downloads set to {count}") + @app_commands.guild_only() + @app_commands.describe(count="Number of concurrent downloads (1-5)") + async def set_concurrent_downloads(self, interaction: discord.Interaction, count: app_commands.Range[int, 1, 5]): + """Set the number of concurrent downloads""" + await self.config.update_setting(interaction.guild.id, "concurrent_downloads", count) + await interaction.response.send_message(f"Concurrent downloads set to {count}") @videoarchiver.command(name="setchannel") - @commands.guild_only() - async def set_archive_channel( - self, ctx: commands.Context, channel: discord.TextChannel - ): + @app_commands.guild_only() + @app_commands.describe(channel="The archive channel") + async def set_archive_channel(self, interaction: discord.Interaction, channel: discord.TextChannel): """Set the archive channel""" - await self.config.update_setting(ctx.guild.id, "archive_channel", channel.id) - await ctx.send(f"Archive channel set to {channel.mention}") + await self.config.update_setting(interaction.guild.id, "archive_channel", channel.id) + await interaction.response.send_message(f"Archive channel set to {channel.mention}") @videoarchiver.command(name="setnotification") - @commands.guild_only() - async def set_notification_channel( - self, ctx: commands.Context, channel: discord.TextChannel - ): + @app_commands.guild_only() + @app_commands.describe(channel="The notification channel") + async def set_notification_channel(self, interaction: discord.Interaction, channel: discord.TextChannel): """Set the notification channel (where archive messages appear)""" await self.config.update_setting( - ctx.guild.id, "notification_channel", channel.id + interaction.guild.id, "notification_channel", channel.id ) - await ctx.send(f"Notification channel set to {channel.mention}") + await interaction.response.send_message(f"Notification channel set to {channel.mention}") @videoarchiver.command(name="setlogchannel") - @commands.guild_only() - async def set_log_channel( - self, ctx: commands.Context, channel: discord.TextChannel - ): + @app_commands.guild_only() + @app_commands.describe(channel="The log channel") + async def set_log_channel(self, interaction: discord.Interaction, channel: discord.TextChannel): """Set the log channel for error messages and notifications""" - await self.config.update_setting(ctx.guild.id, "log_channel", channel.id) - await ctx.send(f"Log channel set to {channel.mention}") + await self.config.update_setting(interaction.guild.id, "log_channel", channel.id) + await interaction.response.send_message(f"Log channel set to {channel.mention}") @videoarchiver.command(name="addmonitor") - @commands.guild_only() - async def add_monitored_channel( - self, ctx: commands.Context, channel: Optional[discord.TextChannel] = None - ): - """Add a channel to monitor for videos (leave empty to monitor all channels)""" + @app_commands.guild_only() + @app_commands.describe(channel="The channel to monitor (leave empty to monitor all channels)") + async def add_monitored_channel(self, interaction: discord.Interaction, channel: Optional[discord.TextChannel] = None): + """Add a channel to monitor for videos""" if not channel: # If no channel is specified, clear the list to monitor all channels - await self.config.update_setting(ctx.guild.id, "monitored_channels", []) - await ctx.send("Now monitoring all channels for videos") + await self.config.update_setting(interaction.guild.id, "monitored_channels", []) + await interaction.response.send_message("Now monitoring all channels for videos") return - await self.config.add_to_list(ctx.guild.id, "monitored_channels", channel.id) - await ctx.send(f"Now monitoring {channel.mention} for videos") + await self.config.add_to_list(interaction.guild.id, "monitored_channels", channel.id) + await interaction.response.send_message(f"Now monitoring {channel.mention} for videos") @videoarchiver.command(name="removemonitor") - @commands.guild_only() - async def remove_monitored_channel( - self, ctx: commands.Context, channel: discord.TextChannel - ): + @app_commands.guild_only() + @app_commands.describe(channel="The channel to stop monitoring") + async def remove_monitored_channel(self, interaction: discord.Interaction, channel: discord.TextChannel): """Remove a channel from monitoring""" await self.config.remove_from_list( - ctx.guild.id, "monitored_channels", channel.id + interaction.guild.id, "monitored_channels", channel.id ) - await ctx.send(f"Stopped monitoring {channel.mention}") + await interaction.response.send_message(f"Stopped monitoring {channel.mention}") @videoarchiver.command(name="setformat") - @commands.guild_only() - async def set_video_format(self, ctx: commands.Context, format: str): - """Set the video format (e.g., mp4, webm)""" - await self.config.update_setting(ctx.guild.id, "video_format", format.lower()) - await ctx.send(f"Video format set to {format.lower()}") + @app_commands.guild_only() + @app_commands.describe(format="The video format (e.g., mp4, webm)") + async def set_video_format(self, interaction: discord.Interaction, format: Literal["mp4", "webm"]): + """Set the video format""" + await self.config.update_setting(interaction.guild.id, "video_format", format.lower()) + await interaction.response.send_message(f"Video format set to {format.lower()}") @videoarchiver.command(name="setquality") - @commands.guild_only() - async def set_video_quality(self, ctx: commands.Context, quality: int): - """Set the maximum video quality in pixels (e.g., 1080)""" - await self.config.update_setting(ctx.guild.id, "video_quality", quality) - await ctx.send(f"Maximum video quality set to {quality}p") + @app_commands.guild_only() + @app_commands.describe(quality="Maximum video quality in pixels (e.g., 1080)") + async def set_video_quality(self, interaction: discord.Interaction, quality: app_commands.Range[int, 144, 4320]): + """Set the maximum video quality""" + await self.config.update_setting(interaction.guild.id, "video_quality", quality) + await interaction.response.send_message(f"Maximum video quality set to {quality}p") @videoarchiver.command(name="setmaxsize") - @commands.guild_only() - async def set_max_file_size(self, ctx: commands.Context, size: int): - """Set the maximum file size in MB""" - await self.config.update_setting(ctx.guild.id, "max_file_size", size) - await ctx.send(f"Maximum file size set to {size}MB") + @app_commands.guild_only() + @app_commands.describe(size="Maximum file size in MB") + async def set_max_file_size(self, interaction: discord.Interaction, size: app_commands.Range[int, 1, 100]): + """Set the maximum file size""" + await self.config.update_setting(interaction.guild.id, "max_file_size", size) + await interaction.response.send_message(f"Maximum file size set to {size}MB") @videoarchiver.command(name="toggledelete") - @commands.guild_only() - async def toggle_delete_after_repost(self, ctx: commands.Context): + @app_commands.guild_only() + async def toggle_delete_after_repost(self, interaction: discord.Interaction): """Toggle whether to delete local files after reposting""" - state = await self.config.toggle_setting(ctx.guild.id, "delete_after_repost") - await ctx.send(f"Delete after repost: {state}") + state = await self.config.toggle_setting(interaction.guild.id, "delete_after_repost") + await interaction.response.send_message(f"Delete after repost: {state}") @videoarchiver.command(name="setduration") - @commands.guild_only() - async def set_message_duration(self, ctx: commands.Context, hours: int): - """Set how long to keep archive messages (0 for permanent)""" - await self.config.update_setting(ctx.guild.id, "message_duration", hours) - await ctx.send(f"Archive message duration set to {hours} hours") + @app_commands.guild_only() + @app_commands.describe(hours="Duration in hours (0 for permanent)") + async def set_message_duration(self, interaction: discord.Interaction, hours: app_commands.Range[int, 0, 720]): + """Set how long to keep archive messages""" + await self.config.update_setting(interaction.guild.id, "message_duration", hours) + await interaction.response.send_message(f"Archive message duration set to {hours} hours") @videoarchiver.command(name="settemplate") - @commands.guild_only() - async def set_message_template(self, ctx: commands.Context, *, template: str): - """Set the archive message template. Use {author}, {url}, and {original_message} as placeholders""" - await self.config.update_setting(ctx.guild.id, "message_template", template) - await ctx.send(f"Archive message template set to:\n{template}") + @app_commands.guild_only() + @app_commands.describe(template="Message template using {author}, {url}, and {original_message}") + async def set_message_template(self, interaction: discord.Interaction, template: str): + """Set the archive message template""" + await self.config.update_setting(interaction.guild.id, "message_template", template) + await interaction.response.send_message(f"Archive message template set to:\n{template}") @videoarchiver.command(name="enablesites") - @commands.guild_only() - async def enable_sites(self, ctx: commands.Context, *, sites: Optional[str] = None): - """Enable specific sites (leave empty for all sites). Separate multiple sites with spaces.""" + @app_commands.guild_only() + @app_commands.describe(sites="Sites to enable (leave empty for all sites)") + async def enable_sites(self, interaction: discord.Interaction, sites: Optional[str] = None): + """Enable specific sites""" if sites is None: - await self.config.update_setting(ctx.guild.id, "enabled_sites", []) - await ctx.send("All sites enabled") + await self.config.update_setting(interaction.guild.id, "enabled_sites", []) + await interaction.response.send_message("All sites enabled") return site_list = [s.strip().lower() for s in sites.split()] @@ -203,19 +206,19 @@ class VideoArchiverCommands(commands.Cog): valid_sites = set(ie.IE_NAME.lower() for ie in ydl._ies) invalid_sites = [s for s in site_list if s not in valid_sites] if invalid_sites: - await ctx.send( + await interaction.response.send_message( f"Invalid sites: {', '.join(invalid_sites)}\nValid sites: {', '.join(valid_sites)}" ) return - await self.config.update_setting(ctx.guild.id, "enabled_sites", site_list) - await ctx.send(f"Enabled sites: {', '.join(site_list)}") + await self.config.update_setting(interaction.guild.id, "enabled_sites", site_list) + await interaction.response.send_message(f"Enabled sites: {', '.join(site_list)}") @videoarchiver.command(name="listsites") - @commands.guild_only() - async def list_sites(self, ctx: commands.Context): + @app_commands.guild_only() + async def list_sites(self, interaction: discord.Interaction): """List all available sites and currently enabled sites""" - enabled_sites = await self.config.get_setting(ctx.guild.id, "enabled_sites") + enabled_sites = await self.config.get_setting(interaction.guild.id, "enabled_sites") embed = discord.Embed( title="Video Sites Configuration", color=discord.Color.blue() @@ -243,14 +246,14 @@ class VideoArchiverCommands(commands.Cog): inline=False, ) - await ctx.send(embed=embed) + await interaction.response.send_message(embed=embed) @videoarchiver.command(name="queue") - @commands.guild_only() + @app_commands.guild_only() @commands.admin_or_permissions(administrator=True) - async def show_queue(self, ctx: commands.Context): + async def show_queue(self, interaction: discord.Interaction): """Show current queue status with basic metrics""" - status = self.processor.queue_manager.get_queue_status(ctx.guild.id) + status = self.processor.queue_manager.get_queue_status(interaction.guild.id) embed = discord.Embed( title="Video Processing Queue Status", @@ -281,15 +284,15 @@ class VideoArchiverCommands(commands.Cog): inline=False ) - embed.set_footer(text="Use [p]va queuemetrics for detailed performance metrics") - await ctx.send(embed=embed) + embed.set_footer(text="Use /videoarchiver queuemetrics for detailed performance metrics") + await interaction.response.send_message(embed=embed) @videoarchiver.command(name="queuemetrics") - @commands.guild_only() + @app_commands.guild_only() @commands.admin_or_permissions(administrator=True) - async def show_queue_metrics(self, ctx: commands.Context): + async def show_queue_metrics(self, interaction: discord.Interaction): """Show detailed queue performance metrics""" - status = self.processor.queue_manager.get_queue_status(ctx.guild.id) + status = self.processor.queue_manager.get_queue_status(interaction.guild.id) metrics = status['metrics'] embed = discord.Embed( @@ -333,12 +336,12 @@ class VideoArchiverCommands(commands.Cog): ) embed.set_footer(text="Metrics are updated in real-time as videos are processed") - await ctx.send(embed=embed) + await interaction.response.send_message(embed=embed) @videoarchiver.command(name="clearqueue") - @commands.guild_only() + @app_commands.guild_only() @commands.admin_or_permissions(administrator=True) - async def clear_queue(self, ctx: commands.Context): + async def clear_queue(self, interaction: discord.Interaction): """Clear the video processing queue for this guild""" - cleared = await self.processor.queue_manager.clear_guild_queue(ctx.guild.id) - await ctx.send(f"Cleared {cleared} items from the queue") + cleared = await self.processor.queue_manager.clear_guild_queue(interaction.guild.id) + await interaction.response.send_message(f"Cleared {cleared} items from the queue") diff --git a/videoarchiver/video_archiver.py b/videoarchiver/video_archiver.py index af589ef..f003a34 100644 --- a/videoarchiver/video_archiver.py +++ b/videoarchiver/video_archiver.py @@ -2,7 +2,7 @@ from __future__ import annotations import discord -from redbot.core import commands, Config, data_manager +from redbot.core import commands, Config, data_manager, app_commands from pathlib import Path import logging import asyncio @@ -29,13 +29,7 @@ from videoarchiver.exceptions import ( logger = logging.getLogger('VideoArchiver') -def setup(bot): - """Load the VideoArchiver cog.""" - cog = VideoArchiver(bot) - asyncio.create_task(bot.add_cog(cog)) - return cog - -class VideoArchiver(VideoArchiverCommands): +class VideoArchiver(commands.Cog): """Archive videos from Discord channels""" def __init__(self, bot: commands.Bot) -> None: @@ -82,8 +76,13 @@ class VideoArchiver(VideoArchiverCommands): self.update_checker = UpdateChecker(self.bot, self.config_manager) self.processor = VideoProcessor(self.bot, self.config_manager, self.components) - # Initialize base class last - super().__init__(self.bot, self.config_manager, self.update_checker, self.processor) + # Initialize commands handler + self.commands_handler = VideoArchiverCommands( + self.bot, + self.config_manager, + self.update_checker, + self.processor + ) # Initialize components for existing guilds for guild in self.bot.guilds: @@ -124,6 +123,10 @@ class VideoArchiver(VideoArchiverCommands): # Wait for initialization to complete await asyncio.wait_for(self.ready.wait(), timeout=30) + # Add commands to the bot + for command in self.commands_handler.videoarchiver.commands: + self.bot.tree.add_command(command) + except asyncio.TimeoutError: await self._cleanup() raise ProcessingError("Cog initialization timed out") @@ -133,6 +136,10 @@ class VideoArchiver(VideoArchiverCommands): async def cog_unload(self) -> None: """Clean up when cog is unloaded""" + # Remove commands from the bot + for command in self.commands_handler.videoarchiver.commands: + self.bot.tree.remove_command(command.name) + await self._cleanup() async def _cleanup(self) -> None: