Merge branch 'master' into viewless-components

Author: Paillat-dev

discord/abc.py

@@ -99,9 +99,9 @@
     from .types.channel import PermissionOverwrite as PermissionOverwritePayload
     from .user import ClientUser
 
-    PartialMessageableChannel = Union[TextChannel, VoiceChannel, StageChannel, Thread, DMChannel, PartialMessageable]
-    MessageableChannel = Union[PartialMessageableChannel, GroupChannel]
-    SnowflakeTime = Union["Snowflake", datetime]
+    PartialMessageableChannel = TextChannel | VoiceChannel | StageChannel | Thread | DMChannel | PartialMessageable
+    MessageableChannel = PartialMessageableChannel | GroupChannel
+    SnowflakeTime = "Snowflake" | datetime
 
 MISSING = utils.MISSING
 
@@ -912,8 +912,8 @@ async def set_permissions(self, target, *, overwrite=MISSING, reason=None, **per
                 raise InvalidArgument("No overwrite provided.")
             try:
                 overwrite = PermissionOverwrite(**permissions)
-            except (ValueError, TypeError):
-                raise InvalidArgument("Invalid permissions given to keyword arguments.")
+            except (ValueError, TypeError) as e:
+                raise InvalidArgument("Invalid permissions given to keyword arguments.") from e
         elif len(permissions) > 0:
             raise InvalidArgument("Cannot mix overwrite and keyword arguments.")
 
@@ -1748,8 +1748,8 @@ def can_send(self, *objects) -> bool:
                     if obj.guild_id == channel.guild.id:
                         continue
 
-            except (KeyError, AttributeError):
-                raise TypeError(f"The object {obj} is of an invalid type.")
+            except (KeyError, AttributeError) as e:
+                raise TypeError(f"The object {obj} is of an invalid type.") from e
 
             if not getattr(channel.permissions_for(channel.guild.me), permission):
                 return False

discord/activity.py

@@ -805,7 +805,7 @@ def __repr__(self) -> str:
         return f"<CustomActivity name={self.name!r} emoji={self.emoji!r}>"
 
 
-ActivityTypes = Union[Activity, Game, CustomActivity, Streaming, Spotify]
+ActivityTypes = Activity | Game | CustomActivity | Streaming | Spotify
 
 
 @overload

discord/audit_logs.py

@@ -383,7 +383,7 @@ def _handle_role(
         elem: list[RolePayload],
     ) -> None:
         if not hasattr(first, "roles"):
-            setattr(first, "roles", [])
+            first.roles = []
 
         data = []
         g: Guild = entry.guild  # type: ignore
@@ -398,7 +398,7 @@ def _handle_role(
 
             data.append(role)
 
-        setattr(second, "roles", data)
+        second.roles = data
 
     def _handle_trigger_metadata(
         self,
@@ -409,13 +409,13 @@ def _handle_trigger_metadata(
         attr: str,
     ) -> None:
         if not hasattr(first, "trigger_metadata"):
-            setattr(first, "trigger_metadata", None)
+            first.trigger_metadata = None
 
         key = attr.split("_", 1)[-1]
         data = {key: elem}
         tm = AutoModTriggerMetadata.from_dict(data)
 
-        setattr(second, "trigger_metadata", tm)
+        second.trigger_metadata = tm
 
 
 class _AuditLogProxyMemberPrune:

discord/bot.py

@@ -113,7 +113,7 @@ def pending_application_commands(self):
     def commands(self) -> list[ApplicationCommand | Any]:
         commands = self.application_commands
         if self._bot._supports_prefixed_commands and hasattr(self._bot, "prefixed_commands"):
-            commands += getattr(self._bot, "prefixed_commands")
+            commands += self._bot.prefixed_commands
         return commands
 
     @property
@@ -267,7 +267,7 @@ def _check_command(cmd: ApplicationCommand, match: Mapping[str, Any]) -> bool:
             if isinstance(cmd, SlashCommandGroup):
                 if len(cmd.subcommands) != len(match.get("options", [])):
                     return True
-                for i, subcommand in enumerate(cmd.subcommands):
+                for subcommand in cmd.subcommands:
                     match_ = next(
                         (data for data in match["options"] if data["name"] == subcommand.name),
                         MISSING,
@@ -359,8 +359,9 @@ def _check_command(cmd: ApplicationCommand, match: Mapping[str, Any]) -> bool:
                 return_value.append({"command": cmd, "action": None, "id": int(match["id"])})
 
         # Now let's see if there are any commands on discord that we need to delete
-        for cmd, value_ in registered_commands_dict.items():
-            match = find(lambda c: c.name == value_["name"], pending)
+        for _, value_ in registered_commands_dict.items():
+            # name default arg is used because loop variables leak in surrounding scope
+            match = find(lambda c, name=value_["name"]: c.name == name, pending)
             if match is None:
                 # We have this command registered but not in our list
                 return_value.append(
@@ -519,7 +520,11 @@ def register(
                     )
                     continue
                 # We can assume the command item is a command, since it's only a string if action is delete
-                match = find(lambda c: c.name == cmd["command"].name and c.type == cmd["command"].type, pending)
+                wanted = cmd["command"]
+                name = wanted.name
+                type_ = wanted.type
+
+                match = next((c for c in pending if c.name == name and c.type == type_), None)
                 if match is None:
                     continue
                 if cmd["action"] == "edit":
@@ -608,8 +613,10 @@ def register(
             registered = await register("bulk", data, guild_id=guild_id)
 
         for i in registered:
+            type_ = i.get("type")
+            # name, type_ default args are used because loop variables leak in surrounding scope
             cmd = find(
-                lambda c: c.name == i["name"] and c.type == i.get("type"),
+                lambda c, name=i["name"], type_=type_: c.name == name and c.type == type_,
                 self.pending_application_commands,
             )
             if not cmd:
@@ -626,7 +633,7 @@ async def sync_commands(
         force: bool = False,
         guild_ids: list[int] | None = None,
         register_guild_commands: bool = True,
-        check_guilds: list[int] | None = [],
+        check_guilds: list[int] | None = None,
         delete_existing: bool = True,
     ) -> None:
         """|coro|
@@ -713,25 +720,37 @@ async def on_connect():
                 )
                 registered_guild_commands[guild_id] = app_cmds
 
-        for i in registered_commands:
+        for item in registered_commands:
+            type_ = item.get("type")
+            # name, type_ default args are used because loop variables leak in surrounding scope
             cmd = find(
-                lambda c: c.name == i["name"] and c.guild_ids is None and c.type == i.get("type"),
+                lambda c, name=item["name"], type_=type_: (c.name == name and c.guild_ids is None and c.type == type_),
                 self.pending_application_commands,
             )
             if cmd:
-                cmd.id = i["id"]
+                cmd.id = item["id"]
                 self._application_commands[cmd.id] = cmd
 
         if register_guild_commands and registered_guild_commands:
             for guild_id, guild_cmds in registered_guild_commands.items():
                 for i in guild_cmds:
-                    cmd = find(
-                        lambda cmd: cmd.name == i["name"]
-                        and cmd.type == i.get("type")
-                        and cmd.guild_ids is not None
-                        and (guild_id := i.get("guild_id"))
-                        and guild_id in cmd.guild_ids,
-                        self.pending_application_commands,
+                    name = i["name"]
+                    type_ = i.get("type")
+                    target_gid = i.get("guild_id")
+                    if target_gid is None:
+                        continue
+
+                    cmd = next(
+                        (
+                            c
+                            for c in self.pending_application_commands
+                            if c.name == name
+                            and c.type == type_
+                            and c.guild_ids is not None
+                            and target_gid == guild_id
+                            and target_gid in c.guild_ids
+                        ),
+                        None,
                     )
                     if not cmd:
                         # command has not been added yet

discord/cog.py

@@ -186,14 +186,12 @@ def __new__(cls: type[CogMeta], *args: Any, **kwargs: Any) -> CogMeta:
                         commands[f"ext_{cmd.ext_variant.qualified_name}"] = cmd.ext_variant
 
                 if inspect.iscoroutinefunction(value):
-                    try:
-                        getattr(value, "__cog_listener__")
-                    except AttributeError:
-                        continue
-                    else:
+                    if hasattr(value, "__cog_listener__"):
                         if elem.startswith(("cog_", "bot_")):
                             raise TypeError(no_bot_cog.format(base, elem))
                         listeners[elem] = value
+                    else:
+                        continue
 
         new_cls.__cog_commands__ = list(commands.values())
 
@@ -711,7 +709,7 @@ def _remove_module_references(self, name: str) -> None:
 
     def _call_module_finalizers(self, lib: types.ModuleType, key: str) -> None:
         try:
-            func = getattr(lib, "teardown")
+            func = lib.teardown
         except AttributeError:
             pass
         else:
@@ -738,10 +736,10 @@ def _load_from_module_spec(self, spec: importlib.machinery.ModuleSpec, key: str)
             raise errors.ExtensionFailed(key, e) from e
 
         try:
-            setup = getattr(lib, "setup")
-        except AttributeError:
+            setup = lib.setup
+        except AttributeError as e:
             del sys.modules[key]
-            raise errors.NoEntryPointError(key)
+            raise errors.NoEntryPointError(key) from e
 
         try:
             setup(self)
@@ -756,8 +754,8 @@ def _load_from_module_spec(self, spec: importlib.machinery.ModuleSpec, key: str)
     def _resolve_name(self, name: str, package: str | None) -> str:
         try:
             return importlib.util.resolve_name(name, package)
-        except ImportError:
-            raise errors.ExtensionNotFound(name)
+        except ImportError as e:
+            raise errors.ExtensionNotFound(name) from e
 
     @overload
     def load_extension(

discord/commands/core.py

@@ -763,8 +763,8 @@ def _check_required_params(self, params):
         for p in required_params:
             try:
                 next(params)
-            except StopIteration:
-                raise ClientException(f'Callback for {self.name} command is missing "{p}" parameter.')
+            except StopIteration as e:
+                raise ClientException(f'Callback for {self.name} command is missing "{p}" parameter.') from e
 
         return params
 
@@ -849,7 +849,7 @@ def _match_option_param_names(self, params, options):
             lambda o, a: o.input_type == SlashCommandOptionType.string
             and o.converter is not None,  # pass on converters
             lambda o, a: isinstance(o.input_type, SlashCommandOptionType),  # pass on slash cmd option type enums
-            lambda o, a: isinstance(o._raw_type, tuple) and a == Union[o._raw_type],  # type: ignore # union types
+            lambda o, a: isinstance(o._raw_type, tuple) and a == Union[o._raw_type],  # type: ignore # union types  # noqa: UP007
             lambda o, a: self._is_typing_optional(a) and not o.required and o._raw_type in a.__args__,  # optional
             lambda o, a: isinstance(a, type) and issubclass(a, o._raw_type),  # 'normal' types
         ]
@@ -858,8 +858,8 @@ def _match_option_param_names(self, params, options):
             _validate_descriptions(o)
             try:
                 p_name, p_obj = next(params)
-            except StopIteration:  # not enough params for all the options
-                raise ClientException("Too many arguments passed to the options kwarg.")
+            except StopIteration as e:  # not enough params for all the options
+                raise ClientException("Too many arguments passed to the options kwarg.") from e
             p_obj = p_obj.annotation
 
             if not any(check(o, p_obj) for check in check_annotations):
@@ -936,7 +936,8 @@ async def _invoke(self, ctx: ApplicationContext) -> None:
         # TODO: Parse the args better
         kwargs = {}
         for arg in ctx.interaction.data.get("options", []):
-            op = find(lambda x: x.name == arg["name"], self.options)
+            # name is used because loop variables leak in surrounding scope
+            op = find(lambda x, name=arg["name"]: x.name == name, self.options)
             if op is None:
                 continue
             arg = arg["value"]
@@ -1021,7 +1022,8 @@ async def _invoke(self, ctx: ApplicationContext) -> None:
                         arg = op._raw_type(int(arg))
                     except ValueError:
                         arg = op._raw_type(arg)
-                elif choice := find(lambda c: c.value == arg, op.choices):
+                # _arg is used because loop variables leak in surrounding scope
+                elif choice := find(lambda c, _arg=arg: c.value == _arg, op.choices):
                     arg = getattr(op._raw_type, choice.name)
 
             kwargs[op._parameter_name] = arg
@@ -1042,7 +1044,8 @@ async def invoke_autocomplete_callback(self, ctx: AutocompleteContext):
 
         for op in ctx.interaction.data.get("options", []):
             if op.get("focused", False):
-                option = find(lambda o: o.name == op["name"], self.options)
+                # op_name is used because loop variables leak in surrounding scope
+                option = find(lambda o, op_name=op["name"]: o.name == op_name, self.options)
                 values.update({i["name"]: i["value"] for i in ctx.interaction.data["options"]})
                 ctx.command = self
                 ctx.focused = option
@@ -1155,7 +1158,7 @@ def __new__(cls, *args, **kwargs) -> SlashCommandGroup:
         self.__original_kwargs__ = kwargs.copy()
 
         self.__initial_commands__ = []
-        for i, c in cls.__dict__.items():
+        for _, c in cls.__dict__.items():
             if isinstance(c, type) and SlashCommandGroup in c.__bases__:
                 c = c(
                     c.__name__,
@@ -1587,15 +1590,15 @@ def validate_parameters(self):
         # next we have the 'ctx' as the next parameter
         try:
             next(params)
-        except StopIteration:
-            raise ClientException(f'Callback for {self.name} command is missing "ctx" parameter.')
+        except StopIteration as e:
+            raise ClientException(f'Callback for {self.name} command is missing "ctx" parameter.') from e
 
         # next we have the 'user/message' as the next parameter
         try:
             next(params)
-        except StopIteration:
+        except StopIteration as e:
             cmd = "user" if type(self) == UserCommand else "message"
-            raise ClientException(f'Callback for {self.name} command is missing "{cmd}" parameter.')
+            raise ClientException(f'Callback for {self.name} command is missing "{cmd}" parameter.') from e
 
         # next there should be no more parameters
         try:

discord/commands/options.py

@@ -52,24 +52,24 @@
     from ..role import Role
     from ..user import User
 
-    InputType = Union[
-        Type[str],
-        Type[bool],
-        Type[int],
-        Type[float],
-        Type[GuildChannel],
-        Type[Thread],
-        Type[Member],
-        Type[User],
-        Type[Attachment],
-        Type[Role],
-        Type[Mentionable],
-        SlashCommandOptionType,
-        Converter,
-        Type[Converter],
-        Type[Enum],
-        Type[DiscordEnum],
-    ]
+    InputType = (
+        Type[str]
+        | Type[bool]
+        | Type[int]
+        | Type[float]
+        | Type[GuildChannel]
+        | Type[Thread]
+        | Type[Member]
+        | Type[User]
+        | Type[Attachment]
+        | Type[Role]
+        | Type[Mentionable]
+        | SlashCommandOptionType
+        | Converter
+        | Type[Converter]
+        | Type[Enum]
+        | Type[DiscordEnum]
+    )
 
 __all__ = (
     "ThreadOption",
@@ -271,17 +271,17 @@ def __init__(self, input_type: InputType = str, /, description: str | None = Non
 
         if self.input_type == SlashCommandOptionType.integer:
             minmax_types = (int, type(None))
-            minmax_typehint = Optional[int]
+            minmax_typehint = Optional[int]  # noqa: UP045
         elif self.input_type == SlashCommandOptionType.number:
             minmax_types = (int, float, type(None))
-            minmax_typehint = Optional[Union[int, float]]
+            minmax_typehint = Optional[int | float]  # noqa: UP045
         else:
             minmax_types = (type(None),)
             minmax_typehint = type(None)
 
         if self.input_type == SlashCommandOptionType.string:
             minmax_length_types = (int, type(None))
-            minmax_length_typehint = Optional[int]
+            minmax_length_typehint = Optional[int]  # noqa: UP045
         else:
             minmax_length_types = (type(None),)
             minmax_length_typehint = type(None)