feat: ensure all resolvable types are attempted to be resolved

Author: LordOfPolls

interactions/models/internal/application_commands.py

@@ -134,6 +134,21 @@ class OptionType(IntEnum):
     NUMBER = 10
     ATTACHMENT = 11
 
+    @classmethod
+    def resolvable_types(cls) -> tuple["OptionType", ...]:
+        """A tuple of all resolvable types."""
+        return cls.USER, cls.CHANNEL, cls.ROLE, cls.MENTIONABLE, cls.ATTACHMENT
+
+    @classmethod
+    def static_types(cls) -> tuple["OptionType", ...]:
+        """A tuple of all static types."""
+        return cls.STRING, cls.INTEGER, cls.BOOLEAN, cls.NUMBER
+
+    @classmethod
+    def command_types(cls) -> tuple["OptionType", ...]:
+        """A tuple of all command types."""
+        return cls.SUB_COMMAND, cls.SUB_COMMAND_GROUP
+
     @classmethod
     def from_type(cls, t: type) -> "OptionType | None":
         """

interactions/models/internal/context.py

@@ -89,7 +89,8 @@ def __bool__(self) -> bool:
             or bool(self.attachments)
         )
 
-    def get(self, snowflake: Snowflake, default: typing.Any = None) -> typing.Any:
+    def get(self, snowflake: Snowflake | str, default: typing.Any = None) -> typing.Any:
+        snowflake = Snowflake(snowflake)
         """Returns the value of the given snowflake."""
         if channel := self.channels.get(snowflake):
             return channel
@@ -353,31 +354,8 @@ def gather_options(_options: list[dict[str, typing.Any]]) -> dict[str, typing.An
 
                 value = option.get("value")
 
-                # resolve data using the cache
-                match option["type"]:
-                    case OptionType.USER:
-                        if self.guild_id:
-                            value = (
-                                self.client.cache.get_member(self.guild_id, value)
-                                or self.client.cache.get_user(value)
-                                or value
-                            )
-                        else:
-                            value = self.client.cache.get_user(value) or value
-                    case OptionType.CHANNEL:
-                        value = self.client.cache.get_channel(value)
-                    case OptionType.ROLE:
-                        value = self.client.cache.get_role(value) or value
-                    case OptionType.MENTIONABLE:
-                        snow = Snowflake(value)
-                        if user := (
-                            self.client.cache.get_member(self.guild_id, snow) or self.client.cache.get_user(snow)
-                        ):
-                            value = user
-                        elif channel := self.client.cache.get_channel(snow):
-                            value = channel
-                        elif role := self.client.cache.get_role(snow):
-                            value = role
+                if option["type"] in OptionType.resolvable_types():
+                    value = self.resolved.get(value, value)
 
                 kwargs[option["name"]] = value
             return kwargs