Move mutes to new cog, add role-based and temporary mutes (#3634)

* revert the revert the revert git is hard...

* and remove old mutes

* make voicemutes less yelly

* fix error when no args present in mute commands

* update docstrings

* address review

* black

* oops

* fix voicemutes

* remove mutes.py file

* Remove _voice_perm_check from mod since it's now in mutes cog

* remove naive datetimes
prevent muting the bot
prevent muting yourself
fix error message when lots of channels are present

* change alias for channelunmute
Be more verbose for creating default mute role

* add `[p]activemutes` to show current mutes in the server and time remaining on the mutes

* improve resolution of unmute time

* black

* Show indefinite mutes in activemutes and only show the current servers mutes in activemutes

* replace message.created_at with timezone aware timezone

* remove "server" from activemutes to clean up look since channelmutes will show channel

* better cache management, add tracking for manual muted role removal in the cache and modlog cases

* Fix keyerror in mutes command when unsuccessful mutes

* add typing indicator and improve config settings

* flake8 issue

* add one time message when attempting to mute without a role set, consume rate limits across channels for overwrite mutes

* Don't clear the whole guilds settings when a mute is finished. Optimize server mutes to better handle migration to API method later. Fix typehints.

* Utilize usage to make converter make more sense

* remove decorator permission checks and fix doc strings

* handle role changes better

* More sanely handle channel mutes return and improve failed mutes dialogue. Re-enable task cleaner. Reduce wait time to improve resolution of mute time.

* Handle re-mute on leave properly

* fix unbound error in overwrites mute

* revert the revert the revert git is hard...

* and remove old mutes

* make voicemutes less yelly

* fix error when no args present in mute commands

* update docstrings

* address review

* black

* oops

* fix voicemutes

* Remove _voice_perm_check from mod since it's now in mutes cog

* remove naive datetimes
prevent muting the bot
prevent muting yourself
fix error message when lots of channels are present

* change alias for channelunmute
Be more verbose for creating default mute role

* add `[p]activemutes` to show current mutes in the server and time remaining on the mutes

* improve resolution of unmute time

* black

* Show indefinite mutes in activemutes and only show the current servers mutes in activemutes

* replace message.created_at with timezone aware timezone

* remove "server" from activemutes to clean up look since channelmutes will show channel

* better cache management, add tracking for manual muted role removal in the cache and modlog cases

* Fix keyerror in mutes command when unsuccessful mutes

* add typing indicator and improve config settings

* flake8 issue

* add one time message when attempting to mute without a role set, consume rate limits across channels for overwrite mutes

* Don't clear the whole guilds settings when a mute is finished. Optimize server mutes to better handle migration to API method later. Fix typehints.

* Utilize usage to make converter make more sense

* remove decorator permission checks and fix doc strings

* handle role changes better

* More sanely handle channel mutes return and improve failed mutes dialogue. Re-enable task cleaner. Reduce wait time to improve resolution of mute time.

* Handle re-mute on leave properly

* fix unbound error in overwrites mute

* remove mutes.pt

* remove reliance on mods is_allowed_by_hierarchy since we don't have a setting to control that anyways inside this.

* black

* fix hierarchy check

* wtf

* Cache mute roles for large bots

* fix lint

* fix this error

* Address review 1

* lint

* fix string i18n issue

* remove unused typing.Coroutine import and fix i18n again

* missed this docstring

* Put voiceban and voiceunban back in mod where it's more appropriate

* Address review 2 electric boogaloo

* Make voicemutes use same methods as channel mute

* black

* handle humanize_list doesn't accept generators

* update voicemutes docstrings

* make voiceperm check consistent with rest of error handling

* bleh

* fix modlog case spam when overrides are in place

* <a:pandaexplode:639975629793787922>

* bleck

* use total_seconds() instead of a dict, sorry everyone already using this lmao

* <:excited:474074780887285776> This should be everything

* black

* fix the things

* bleh

* more cleanup

* lmao hang on

* fix voice mutes thingy

* Title Case Permissions

* oh I see

* I'm running out of funny one-liners for commit messages

* oof

* ugh

* let's try this

* voicemutes manage_permissions

* Cleanup mutes if they expire when member is not present

* black

* linters go brr

Co-authored-by: Drapersniper <27962761+drapersniper@users.noreply.github.com>

.github/CODEOWNERS

@@ -2,6 +2,7 @@
 /redbot/cogs/audio/** @aikaterna @Drapersniper
 /redbot/cogs/downloader/* @jack1142
 /redbot/cogs/streams/* @palmtree5
+/redbot/cogs/mutes/* @TrustyJAID
 
 # Trivia Lists
 /redbot/cogs/trivia/data/lists/whosthatpokemon*.yaml @aikaterna

redbot/cogs/mod/kickban.py

@@ -8,7 +8,13 @@ import discord
 from redbot.core import commands, i18n, checks, modlog
 from redbot.core.commands import UserInputOptional
 from redbot.core.utils import AsyncIter
-from redbot.core.utils.chat_formatting import pagify, humanize_number, bold, humanize_list
+from redbot.core.utils.chat_formatting import (
+    pagify,
+    humanize_number,
+    bold,
+    humanize_list,
+    format_perms_list,
+)
 from redbot.core.utils.mod import get_audit_reason
 from .abc import MixinMeta
 from .converters import RawUserIds
@@ -60,6 +66,48 @@ class KickBanMixin(MixinMeta):
             except discord.HTTPException:
                 return
 
+    @staticmethod
+    async def _voice_perm_check(
+        ctx: commands.Context, user_voice_state: Optional[discord.VoiceState], **perms: bool
+    ) -> bool:
+        """Check if the bot and user have sufficient permissions for voicebans.
+
+        This also verifies that the user's voice state and connected
+        channel are not ``None``.
+
+        Returns
+        -------
+        bool
+            ``True`` if the permissions are sufficient and the user has
+            a valid voice state.
+
+        """
+        if user_voice_state is None or user_voice_state.channel is None:
+            await ctx.send(_("That user is not in a voice channel."))
+            return False
+        voice_channel: discord.VoiceChannel = user_voice_state.channel
+        required_perms = discord.Permissions()
+        required_perms.update(**perms)
+        if not voice_channel.permissions_for(ctx.me) >= required_perms:
+            await ctx.send(
+                _("I require the {perms} permission(s) in that user's channel to do that.").format(
+                    perms=format_perms_list(required_perms)
+                )
+            )
+            return False
+        if (
+            ctx.permission_state is commands.PermState.NORMAL
+            and not voice_channel.permissions_for(ctx.author) >= required_perms
+        ):
+            await ctx.send(
+                _(
+                    "You must have the {perms} permission(s) in that user's channel to use this "
+                    "command."
+                ).format(perms=format_perms_list(required_perms))
+            )
+            return False
+        return True
+
     async def ban_user(
         self,
         user: Union[discord.Member, discord.User, discord.Object],
@@ -678,6 +726,88 @@ class KickBanMixin(MixinMeta):
                 channel=case_channel,
             )
 
+    @commands.command()
+    @commands.guild_only()
+    @checks.admin_or_permissions(mute_members=True, deafen_members=True)
+    async def voiceunban(self, ctx: commands.Context, user: discord.Member, *, reason: str = None):
+        """Unban a user from speaking and listening in the server's voice channels."""
+        user_voice_state = user.voice
+        if (
+            await self._voice_perm_check(
+                ctx, user_voice_state, deafen_members=True, mute_members=True
+            )
+            is False
+        ):
+            return
+        needs_unmute = True if user_voice_state.mute else False
+        needs_undeafen = True if user_voice_state.deaf else False
+        audit_reason = get_audit_reason(ctx.author, reason)
+        if needs_unmute and needs_undeafen:
+            await user.edit(mute=False, deafen=False, reason=audit_reason)
+        elif needs_unmute:
+            await user.edit(mute=False, reason=audit_reason)
+        elif needs_undeafen:
+            await user.edit(deafen=False, reason=audit_reason)
+        else:
+            await ctx.send(_("That user isn't muted or deafened by the server."))
+            return
+
+        guild = ctx.guild
+        author = ctx.author
+        await modlog.create_case(
+            self.bot,
+            guild,
+            ctx.message.created_at.replace(tzinfo=timezone.utc),
+            "voiceunban",
+            user,
+            author,
+            reason,
+            until=None,
+            channel=None,
+        )
+        await ctx.send(_("User is now allowed to speak and listen in voice channels."))
+
+    @commands.command()
+    @commands.guild_only()
+    @checks.admin_or_permissions(mute_members=True, deafen_members=True)
+    async def voiceban(self, ctx: commands.Context, user: discord.Member, *, reason: str = None):
+        """Ban a user from speaking and listening in the server's voice channels."""
+        user_voice_state: discord.VoiceState = user.voice
+        if (
+            await self._voice_perm_check(
+                ctx, user_voice_state, deafen_members=True, mute_members=True
+            )
+            is False
+        ):
+            return
+        needs_mute = True if user_voice_state.mute is False else False
+        needs_deafen = True if user_voice_state.deaf is False else False
+        audit_reason = get_audit_reason(ctx.author, reason)
+        author = ctx.author
+        guild = ctx.guild
+        if needs_mute and needs_deafen:
+            await user.edit(mute=True, deafen=True, reason=audit_reason)
+        elif needs_mute:
+            await user.edit(mute=True, reason=audit_reason)
+        elif needs_deafen:
+            await user.edit(deafen=True, reason=audit_reason)
+        else:
+            await ctx.send(_("That user is already muted and deafened server-wide."))
+            return
+
+        await modlog.create_case(
+            self.bot,
+            guild,
+            ctx.message.created_at.replace(tzinfo=timezone.utc),
+            "voiceban",
+            user,
+            author,
+            reason,
+            until=None,
+            channel=None,
+        )
+        await ctx.send(_("User has been banned from speaking or listening in voice channels."))
+
     @commands.command()
     @commands.guild_only()
     @commands.bot_has_permissions(ban_members=True)

redbot/cogs/mod/mod.py

@@ -14,7 +14,6 @@ from redbot.core.i18n import Translator, cog_i18n
 from redbot.core.utils._internal_utils import send_to_owners_with_prefix_replaced
 from .events import Events
 from .kickban import KickBanMixin
-from .mutes import MuteMixin
 from .names import ModInfo
 from .slowmode import Slowmode
 from .settings import ModSettings
@@ -38,7 +37,6 @@ class Mod(
     ModSettings,
     Events,
     KickBanMixin,
-    MuteMixin,
     ModInfo,
     Slowmode,
     commands.Cog,

redbot/cogs/mod/mutes.py

@@ -1,478 +0,0 @@
-import asyncio
-from datetime import timezone
-from typing import cast, Optional
-
-import discord
-from redbot.core import commands, checks, i18n, modlog
-from redbot.core.utils import AsyncIter
-from redbot.core.utils.chat_formatting import format_perms_list
-from redbot.core.utils.mod import get_audit_reason
-from .abc import MixinMeta
-from .utils import is_allowed_by_hierarchy
-
-T_ = i18n.Translator("Mod", __file__)
-
-_ = lambda s: s
-mute_unmute_issues = {
-    "already_muted": _("That user can't send messages in this channel."),
-    "already_unmuted": _("That user isn't muted in this channel."),
-    "hierarchy_problem": _(
-        "I cannot let you do that. You are not higher than the user in the role hierarchy."
-    ),
-    "is_admin": _("That user cannot be muted, as they have the Administrator permission."),
-    "permissions_issue": _(
-        "Failed to mute user. I need the manage roles "
-        "permission and the user I'm muting must be "
-        "lower than myself in the role hierarchy."
-    ),
-    "left_guild": _("The user has left the server while applying an overwrite."),
-    "unknown_channel": _("The channel I tried to mute the user in isn't found."),
-}
-_ = T_
-
-
-class MuteMixin(MixinMeta):
-    """
-    Stuff for mutes goes here
-    """
-
-    @staticmethod
-    async def _voice_perm_check(
-        ctx: commands.Context, user_voice_state: Optional[discord.VoiceState], **perms: bool
-    ) -> bool:
-        """Check if the bot and user have sufficient permissions for voicebans.
-
-        This also verifies that the user's voice state and connected
-        channel are not ``None``.
-
-        Returns
-        -------
-        bool
-            ``True`` if the permissions are sufficient and the user has
-            a valid voice state.
-
-        """
-        if user_voice_state is None or user_voice_state.channel is None:
-            await ctx.send(_("That user is not in a voice channel."))
-            return False
-        voice_channel: discord.VoiceChannel = user_voice_state.channel
-        required_perms = discord.Permissions()
-        required_perms.update(**perms)
-        if not voice_channel.permissions_for(ctx.me) >= required_perms:
-            await ctx.send(
-                _("I require the {perms} permission(s) in that user's channel to do that.").format(
-                    perms=format_perms_list(required_perms)
-                )
-            )
-            return False
-        if (
-            ctx.permission_state is commands.PermState.NORMAL
-            and not voice_channel.permissions_for(ctx.author) >= required_perms
-        ):
-            await ctx.send(
-                _(
-                    "You must have the {perms} permission(s) in that user's channel to use this "
-                    "command."
-                ).format(perms=format_perms_list(required_perms))
-            )
-            return False
-        return True
-
-    @commands.command()
-    @commands.guild_only()
-    @checks.admin_or_permissions(mute_members=True, deafen_members=True)
-    async def voiceunban(self, ctx: commands.Context, user: discord.Member, *, reason: str = None):
-        """Unban a user from speaking and listening in the server's voice channels."""
-        user_voice_state = user.voice
-        if (
-            await self._voice_perm_check(
-                ctx, user_voice_state, deafen_members=True, mute_members=True
-            )
-            is False
-        ):
-            return
-        needs_unmute = True if user_voice_state.mute else False
-        needs_undeafen = True if user_voice_state.deaf else False
-        audit_reason = get_audit_reason(ctx.author, reason)
-        if needs_unmute and needs_undeafen:
-            await user.edit(mute=False, deafen=False, reason=audit_reason)
-        elif needs_unmute:
-            await user.edit(mute=False, reason=audit_reason)
-        elif needs_undeafen:
-            await user.edit(deafen=False, reason=audit_reason)
-        else:
-            await ctx.send(_("That user isn't muted or deafened by the server!"))
-            return
-
-        guild = ctx.guild
-        author = ctx.author
-        await modlog.create_case(
-            self.bot,
-            guild,
-            ctx.message.created_at.replace(tzinfo=timezone.utc),
-            "voiceunban",
-            user,
-            author,
-            reason,
-            until=None,
-            channel=None,
-        )
-        await ctx.send(_("User is now allowed to speak and listen in voice channels"))
-
-    @commands.command()
-    @commands.guild_only()
-    @checks.admin_or_permissions(mute_members=True, deafen_members=True)
-    async def voiceban(self, ctx: commands.Context, user: discord.Member, *, reason: str = None):
-        """Ban a user from speaking and listening in the server's voice channels."""
-        user_voice_state: discord.VoiceState = user.voice
-        if (
-            await self._voice_perm_check(
-                ctx, user_voice_state, deafen_members=True, mute_members=True
-            )
-            is False
-        ):
-            return
-        needs_mute = True if user_voice_state.mute is False else False
-        needs_deafen = True if user_voice_state.deaf is False else False
-        audit_reason = get_audit_reason(ctx.author, reason)
-        author = ctx.author
-        guild = ctx.guild
-        if needs_mute and needs_deafen:
-            await user.edit(mute=True, deafen=True, reason=audit_reason)
-        elif needs_mute:
-            await user.edit(mute=True, reason=audit_reason)
-        elif needs_deafen:
-            await user.edit(deafen=True, reason=audit_reason)
-        else:
-            await ctx.send(_("That user is already muted and deafened server-wide!"))
-            return
-
-        await modlog.create_case(
-            self.bot,
-            guild,
-            ctx.message.created_at.replace(tzinfo=timezone.utc),
-            "voiceban",
-            user,
-            author,
-            reason,
-            until=None,
-            channel=None,
-        )
-        await ctx.send(_("User has been banned from speaking or listening in voice channels"))
-
-    @commands.group()
-    @commands.guild_only()
-    @checks.mod_or_permissions(manage_channels=True)
-    async def mute(self, ctx: commands.Context):
-        """Mute users."""
-        pass
-
-    @mute.command(name="voice")
-    @commands.guild_only()
-    async def voice_mute(self, ctx: commands.Context, user: discord.Member, *, reason: str = None):
-        """Mute a user in their current voice channel."""
-        user_voice_state = user.voice
-        if (
-            await self._voice_perm_check(
-                ctx, user_voice_state, mute_members=True, manage_channels=True
-            )
-            is False
-        ):
-            return
-        guild = ctx.guild
-        author = ctx.author
-        channel = user_voice_state.channel
-        audit_reason = get_audit_reason(author, reason)
-
-        success, issue = await self.mute_user(guild, channel, author, user, audit_reason)
-
-        if success:
-            await modlog.create_case(
-                self.bot,
-                guild,
-                ctx.message.created_at.replace(tzinfo=timezone.utc),
-                "vmute",
-                user,
-                author,
-                reason,
-                until=None,
-                channel=channel,
-            )
-            await ctx.send(
-                _("Muted {user} in channel {channel.name}").format(user=user, channel=channel)
-            )
-            try:
-                if channel.permissions_for(ctx.me).move_members:
-                    await user.move_to(channel)
-                else:
-                    raise RuntimeError
-            except (discord.Forbidden, RuntimeError):
-                await ctx.send(
-                    _(
-                        "Because I don't have the Move Members permission, this will take into effect when the user rejoins."
-                    )
-                )
-        else:
-            await ctx.send(issue)
-
-    @mute.command(name="channel")
-    @commands.guild_only()
-    @commands.bot_has_permissions(manage_roles=True)
-    @checks.mod_or_permissions(administrator=True)
-    async def channel_mute(
-        self, ctx: commands.Context, user: discord.Member, *, reason: str = None
-    ):
-        """Mute a user in the current text channel."""
-        author = ctx.message.author
-        channel = ctx.message.channel
-        guild = ctx.guild
-        audit_reason = get_audit_reason(author, reason)
-
-        success, issue = await self.mute_user(guild, channel, author, user, audit_reason)
-
-        if success:
-            await modlog.create_case(
-                self.bot,
-                guild,
-                ctx.message.created_at.replace(tzinfo=timezone.utc),
-                "cmute",
-                user,
-                author,
-                reason,
-                until=None,
-                channel=channel,
-            )
-            await channel.send(_("User has been muted in this channel."))
-        else:
-            await channel.send(issue)
-
-    @mute.command(name="server", aliases=["guild"])
-    @commands.guild_only()
-    @commands.bot_has_permissions(manage_roles=True)
-    @checks.mod_or_permissions(administrator=True)
-    async def guild_mute(self, ctx: commands.Context, user: discord.Member, *, reason: str = None):
-        """Mutes user in the server."""
-        author = ctx.message.author
-        guild = ctx.guild
-        audit_reason = get_audit_reason(author, reason)
-
-        mute_success = []
-        async with ctx.typing():
-            for channel in guild.channels:
-                success, issue = await self.mute_user(guild, channel, author, user, audit_reason)
-                mute_success.append((success, issue))
-            await modlog.create_case(
-                self.bot,
-                guild,
-                ctx.message.created_at.replace(tzinfo=timezone.utc),
-                "smute",
-                user,
-                author,
-                reason,
-                until=None,
-                channel=None,
-            )
-            await ctx.send(_("User has been muted in this server."))
-
-    @commands.group()
-    @commands.guild_only()
-    @commands.bot_has_permissions(manage_roles=True)
-    @checks.mod_or_permissions(manage_channels=True)
-    async def unmute(self, ctx: commands.Context):
-        """Unmute users."""
-        pass
-
-    @unmute.command(name="voice")
-    @commands.guild_only()
-    async def unmute_voice(
-        self, ctx: commands.Context, user: discord.Member, *, reason: str = None
-    ):
-        """Unmute a user in their current voice channel."""
-        user_voice_state = user.voice
-        if (
-            await self._voice_perm_check(
-                ctx, user_voice_state, mute_members=True, manage_channels=True
-            )
-            is False
-        ):
-            return
-        guild = ctx.guild
-        author = ctx.author
-        channel = user_voice_state.channel
-        audit_reason = get_audit_reason(author, reason)
-
-        success, message = await self.unmute_user(guild, channel, author, user, audit_reason)
-
-        if success:
-            await modlog.create_case(
-                self.bot,
-                guild,
-                ctx.message.created_at.replace(tzinfo=timezone.utc),
-                "vunmute",
-                user,
-                author,
-                reason,
-                until=None,
-                channel=channel,
-            )
-            await ctx.send(
-                _("Unmuted {user} in channel {channel.name}").format(user=user, channel=channel)
-            )
-            try:
-                if channel.permissions_for(ctx.me).move_members:
-                    await user.move_to(channel)
-                else:
-                    raise RuntimeError
-            except (discord.Forbidden, RuntimeError):
-                await ctx.send(
-                    _(
-                        "Because I don't have the Move Members permission, this will take into effect when the user rejoins."
-                    )
-                )
-        else:
-            await ctx.send(_("Unmute failed. Reason: {}").format(message))
-
-    @checks.mod_or_permissions(administrator=True)
-    @unmute.command(name="channel")
-    @commands.bot_has_permissions(manage_roles=True)
-    @commands.guild_only()
-    async def unmute_channel(
-        self, ctx: commands.Context, user: discord.Member, *, reason: str = None
-    ):
-        """Unmute a user in this channel."""
-        channel = ctx.channel
-        author = ctx.author
-        guild = ctx.guild
-        audit_reason = get_audit_reason(author, reason)
-
-        success, message = await self.unmute_user(guild, channel, author, user, audit_reason)
-
-        if success:
-            await modlog.create_case(
-                self.bot,
-                guild,
-                ctx.message.created_at.replace(tzinfo=timezone.utc),
-                "cunmute",
-                user,
-                author,
-                reason,
-                until=None,
-                channel=channel,
-            )
-            await ctx.send(_("User unmuted in this channel."))
-        else:
-            await ctx.send(_("Unmute failed. Reason: {}").format(message))
-
-    @checks.mod_or_permissions(administrator=True)
-    @unmute.command(name="server", aliases=["guild"])
-    @commands.bot_has_permissions(manage_roles=True)
-    @commands.guild_only()
-    async def unmute_guild(
-        self, ctx: commands.Context, user: discord.Member, *, reason: str = None
-    ):
-        """Unmute a user in this server."""
-        guild = ctx.guild
-        author = ctx.author
-        audit_reason = get_audit_reason(author, reason)
-
-        unmute_success = []
-        async with ctx.typing():
-            for channel in guild.channels:
-                success, message = await self.unmute_user(
-                    guild, channel, author, user, audit_reason
-                )
-                unmute_success.append((success, message))
-            await modlog.create_case(
-                self.bot,
-                guild,
-                ctx.message.created_at.replace(tzinfo=timezone.utc),
-                "sunmute",
-                user,
-                author,
-                reason,
-                until=None,
-            )
-            await ctx.send(_("User has been unmuted in this server."))
-
-    async def mute_user(
-        self,
-        guild: discord.Guild,
-        channel: discord.abc.GuildChannel,
-        author: discord.Member,
-        user: discord.Member,
-        reason: str,
-    ) -> (bool, str):
-        """Mutes the specified user in the specified channel"""
-        overwrites = channel.overwrites_for(user)
-        permissions = channel.permissions_for(user)
-
-        if permissions.administrator:
-            return False, _(mute_unmute_issues["is_admin"])
-
-        new_overs = {}
-        if not isinstance(channel, discord.TextChannel):
-            new_overs.update(speak=False)
-        if not isinstance(channel, discord.VoiceChannel):
-            new_overs.update(send_messages=False, add_reactions=False)
-
-        if all(getattr(permissions, p) is False for p in new_overs.keys()):
-            return False, _(mute_unmute_issues["already_muted"])
-
-        elif not await is_allowed_by_hierarchy(self.bot, self.config, guild, author, user):
-            return False, _(mute_unmute_issues["hierarchy_problem"])
-
-        old_overs = {k: getattr(overwrites, k) for k in new_overs}
-        overwrites.update(**new_overs)
-        try:
-            await channel.set_permissions(user, overwrite=overwrites, reason=reason)
-        except discord.Forbidden:
-            return False, _(mute_unmute_issues["permissions_issue"])
-        except discord.NotFound as e:
-            if e.code == 10003:
-                return False, _(mute_unmute_issues["unknown_channel"])
-            elif e.code == 10009:
-                return False, _(mute_unmute_issues["left_guild"])
-        else:
-            await self.config.member(user).set_raw("perms_cache", str(channel.id), value=old_overs)
-            return True, None
-
-    async def unmute_user(
-        self,
-        guild: discord.Guild,
-        channel: discord.abc.GuildChannel,
-        author: discord.Member,
-        user: discord.Member,
-        reason: str,
-    ) -> (bool, str):
-        overwrites = channel.overwrites_for(user)
-        perms_cache = await self.config.member(user).perms_cache()
-
-        if channel.id in perms_cache:
-            old_values = perms_cache[channel.id]
-        else:
-            old_values = {"send_messages": None, "add_reactions": None, "speak": None}
-
-        if all(getattr(overwrites, k) == v for k, v in old_values.items()):
-            return False, _(mute_unmute_issues["already_unmuted"])
-
-        elif not await is_allowed_by_hierarchy(self.bot, self.config, guild, author, user):
-            return False, _(mute_unmute_issues["hierarchy_problem"])
-
-        overwrites.update(**old_values)
-        try:
-            if overwrites.is_empty():
-                await channel.set_permissions(
-                    user, overwrite=cast(discord.PermissionOverwrite, None), reason=reason
-                )
-            else:
-                await channel.set_permissions(user, overwrite=overwrites, reason=reason)
-        except discord.Forbidden:
-            return False, _(mute_unmute_issues["permissions_issue"])
-        except discord.NotFound as e:
-            if e.code == 10003:
-                return False, _(mute_unmute_issues["unknown_channel"])
-            elif e.code == 10009:
-                return False, _(mute_unmute_issues["left_guild"])
-        else:
-            await self.config.member(user).clear_raw("perms_cache", str(channel.id))
-            return True, None

redbot/cogs/mutes/__init__.py

@@ -0,0 +1,8 @@
+from redbot.core.bot import Red
+from .mutes import Mutes
+
+
+async def setup(bot: Red):
+    cog = Mutes(bot)
+    bot.add_cog(cog)
+    await cog.initialize()

redbot/cogs/mutes/abc.py

@@ -0,0 +1,27 @@
+from abc import ABC, abstractmethod
+from typing import List, Tuple, Optional, Dict
+from datetime import datetime
+
+import discord
+from redbot.core import Config, commands
+from redbot.core.bot import Red
+
+
+class MixinMeta(ABC):
+    """
+    Base class for well behaved type hint detection with composite class.
+
+    Basically, to keep developers sane when not all attributes are defined in each mixin.
+    """
+
+    def __init__(self, *_args):
+        self.config: Config
+        self.bot: Red
+        self._mutes_cache: Dict[int, Dict[int, Optional[datetime]]]
+
+    @staticmethod
+    @abstractmethod
+    async def _voice_perm_check(
+        ctx: commands.Context, user_voice_state: Optional[discord.VoiceState], **perms: bool
+    ) -> bool:
+        raise NotImplementedError()

redbot/cogs/mutes/converters.py

@@ -0,0 +1,55 @@
+import logging
+import re
+from typing import Union, Dict
+from datetime import timedelta
+
+from discord.ext.commands.converter import Converter
+from redbot.core import commands
+
+log = logging.getLogger("red.cogs.mutes")
+
+# the following regex is slightly modified from Red
+# it's changed to be slightly more strict on matching with finditer
+# this is to prevent "empty" matches when parsing the full reason
+# This is also designed more to allow time interval at the beginning or the end of the mute
+# to account for those times when you think of adding time *after* already typing out the reason
+# https://github.com/Cog-Creators/Red-DiscordBot/blob/V3/develop/redbot/core/commands/converter.py#L55
+TIME_RE_STRING = r"|".join(
+    [
+        r"((?P<weeks>\d+?)\s?(weeks?|w))",
+        r"((?P<days>\d+?)\s?(days?|d))",
+        r"((?P<hours>\d+?)\s?(hours?|hrs|hr?))",
+        r"((?P<minutes>\d+?)\s?(minutes?|mins?|m(?!o)))",  # prevent matching "months"
+        r"((?P<seconds>\d+?)\s?(seconds?|secs?|s))",
+    ]
+)
+TIME_RE = re.compile(TIME_RE_STRING, re.I)
+TIME_SPLIT = re.compile(r"t(?:ime)?=")
+
+
+class MuteTime(Converter):
+    """
+    This will parse my defined multi response pattern and provide usable formats
+    to be used in multiple reponses
+    """
+
+    async def convert(
+        self, ctx: commands.Context, argument: str
+    ) -> Dict[str, Union[timedelta, str, None]]:
+        time_split = TIME_SPLIT.split(argument)
+        result: Dict[str, Union[timedelta, str, None]] = {}
+        if time_split:
+            maybe_time = time_split[-1]
+        else:
+            maybe_time = argument
+
+        time_data = {}
+        for time in TIME_RE.finditer(maybe_time):
+            argument = argument.replace(time[0], "")
+            for k, v in time.groupdict().items():
+                if v:
+                    time_data[k] = int(v)
+        if time_data:
+            result["duration"] = timedelta(**time_data)
+        result["reason"] = argument
+        return result

redbot/cogs/mutes/voicemutes.py

@@ -0,0 +1,235 @@
+from typing import Optional, Tuple
+from datetime import timezone, timedelta, datetime
+from .abc import MixinMeta
+
+import discord
+from redbot.core import commands, checks, i18n, modlog
+from redbot.core.utils.chat_formatting import (
+    humanize_timedelta,
+    humanize_list,
+    pagify,
+    format_perms_list,
+)
+from redbot.core.utils.mod import get_audit_reason
+
+from .converters import MuteTime
+
+_ = i18n.Translator("Mutes", __file__)
+
+
+class VoiceMutes(MixinMeta):
+    """
+    This handles all voice channel related muting
+    """
+
+    @staticmethod
+    async def _voice_perm_check(
+        ctx: commands.Context, user_voice_state: Optional[discord.VoiceState], **perms: bool
+    ) -> Tuple[bool, Optional[str]]:
+        """Check if the bot and user have sufficient permissions for voicebans.
+
+        This also verifies that the user's voice state and connected
+        channel are not ``None``.
+
+        Returns
+        -------
+        bool
+            ``True`` if the permissions are sufficient and the user has
+            a valid voice state.
+
+        """
+        if user_voice_state is None or user_voice_state.channel is None:
+            return False, _("That user is not in a voice channel.")
+        voice_channel: discord.VoiceChannel = user_voice_state.channel
+        required_perms = discord.Permissions()
+        required_perms.update(**perms)
+        if not voice_channel.permissions_for(ctx.me) >= required_perms:
+            return (
+                False,
+                _("I require the {perms} permission(s) in that user's channel to do that.").format(
+                    perms=format_perms_list(required_perms)
+                ),
+            )
+        if (
+            ctx.permission_state is commands.PermState.NORMAL
+            and not voice_channel.permissions_for(ctx.author) >= required_perms
+        ):
+
+            return (
+                False,
+                _(
+                    "You must have the {perms} permission(s) in that user's channel to use this "
+                    "command."
+                ).format(perms=format_perms_list(required_perms)),
+            )
+        return True, None
+
+    @commands.command(name="voicemute", usage="<users...> [reason]")
+    @commands.guild_only()
+    async def voice_mute(
+        self,
+        ctx: commands.Context,
+        users: commands.Greedy[discord.Member],
+        *,
+        time_and_reason: MuteTime = {},
+    ):
+        """Mute a user in their current voice channel.
+
+        `<users...>` is a space separated list of usernames, ID's, or mentions.
+        `[time_and_reason]` is the time to mute for and reason. Time is
+        any valid time length such as `30 minutes` or `2 days`. If nothing
+        is provided the mute will use the set default time or indefinite if not set.
+
+        Examples:
+        `[p]voicemute @member1 @member2 spam 5 hours`
+        `[p]voicemute @member1 3 days`"""
+        if not users:
+            return await ctx.send_help()
+        if ctx.me in users:
+            return await ctx.send(_("You cannot mute me."))
+        if ctx.author in users:
+            return await ctx.send(_("You cannot mute yourself."))
+        async with ctx.typing():
+            success_list = []
+            issue_list = []
+            for user in users:
+                user_voice_state = user.voice
+                can_move, perm_reason = await self._voice_perm_check(
+                    ctx, user_voice_state, mute_members=True, manage_permissions=True
+                )
+                if not can_move:
+                    issue_list.append((user, perm_reason))
+                    continue
+                duration = time_and_reason.get("duration", None)
+                reason = time_and_reason.get("reason", None)
+                time = ""
+                until = None
+                if duration:
+                    until = datetime.now(timezone.utc) + duration
+                    time = _(" for {duration}").format(
+                        duration=humanize_timedelta(timedelta=duration)
+                    )
+                else:
+                    default_duration = await self.config.guild(ctx.guild).default_time()
+                    if default_duration:
+                        until = datetime.now(timezone.utc) + timedelta(seconds=default_duration)
+                        time = _(" for {duration}").format(
+                            duration=humanize_timedelta(
+                                timedelta=timedelta(seconds=default_duration)
+                            )
+                        )
+                guild = ctx.guild
+                author = ctx.author
+                channel = user_voice_state.channel
+                audit_reason = get_audit_reason(author, reason)
+
+                success = await self.channel_mute_user(
+                    guild, channel, author, user, until, audit_reason
+                )
+
+                if success["success"]:
+                    if "reason" in success and success["reason"]:
+                        issue_list.append((user, success["reason"]))
+                    else:
+                        success_list.append(user)
+                    await modlog.create_case(
+                        self.bot,
+                        guild,
+                        ctx.message.created_at.replace(tzinfo=timezone.utc),
+                        "vmute",
+                        user,
+                        author,
+                        reason,
+                        until=until,
+                        channel=channel,
+                    )
+                    async with self.config.member(user).perms_cache() as cache:
+                        cache[channel.id] = success["old_overs"]
+                else:
+                    issue_list.append((user, success["reason"]))
+
+        if success_list:
+            msg = _("{users} has been muted in this channel{time}.")
+            if len(success_list) > 1:
+                msg = _("{users} have been muted in this channel{time}.")
+            await ctx.send(
+                msg.format(users=humanize_list([f"{u}" for u in success_list]), time=time)
+            )
+        if issue_list:
+            msg = _("The following users could not be muted\n")
+            for user, issue in issue_list:
+                msg += f"{user}: {issue}\n"
+            await ctx.send_interactive(pagify(msg))
+
+    @commands.command(name="voiceunmute", usage="<users...> [reason]")
+    @commands.guild_only()
+    async def unmute_voice(
+        self,
+        ctx: commands.Context,
+        users: commands.Greedy[discord.Member],
+        *,
+        reason: Optional[str] = None,
+    ):
+        """Unmute a user in their current voice channel.
+
+        `<users...>` is a space separated list of usernames, ID's, or mentions.
+        `[reason]` is the reason for the unmute."""
+        if not users:
+            return await ctx.send_help()
+        if ctx.me in users:
+            return await ctx.send(_("You cannot unmute me."))
+        if ctx.author in users:
+            return await ctx.send(_("You cannot unmute yourself."))
+        async with ctx.typing():
+            issue_list = []
+            success_list = []
+            for user in users:
+                user_voice_state = user.voice
+                can_move, perm_reason = await self._voice_perm_check(
+                    ctx, user_voice_state, mute_members=True, manage_permissions=True
+                )
+                if not can_move:
+                    issue_list.append((user, perm_reason))
+                    continue
+                guild = ctx.guild
+                author = ctx.author
+                channel = user_voice_state.channel
+                audit_reason = get_audit_reason(author, reason)
+
+                success = await self.channel_unmute_user(
+                    guild, channel, author, user, audit_reason
+                )
+
+                if success["success"]:
+                    if "reason" in success and success["reason"]:
+                        issue_list.append((user, success["reason"]))
+                    else:
+                        success_list.append(user)
+                    await modlog.create_case(
+                        self.bot,
+                        guild,
+                        ctx.message.created_at.replace(tzinfo=timezone.utc),
+                        "vunmute",
+                        user,
+                        author,
+                        reason,
+                        until=None,
+                        channel=channel,
+                    )
+                else:
+                    issue_list.append((user, success["reason"]))
+        if success_list:
+            if channel.id in self._channel_mutes and self._channel_mutes[channel.id]:
+                await self.config.channel(channel).muted_users.set(self._channel_mutes[channel.id])
+            else:
+                await self.config.channel(channel).muted_users.clear()
+            await ctx.send(
+                _("{users} unmuted in this channel.").format(
+                    users=humanize_list([f"{u}" for u in success_list])
+                )
+            )
+        if issue_list:
+            msg = _("The following users could not be unmuted\n")
+            for user, issue in issue_list:
+                msg += f"{user}: {issue}\n"
+            await ctx.send_interactive(pagify(msg))