Add enum shortcut to option with choices

discord/ext/slash/__init__.py:
+ ChoiceEnum is the base class for the enum
* Options constructed from enums reference the enum in a private attr
  * This required modifying Option.clone()
* Context converts values to enum values if the _enum is present
* Option(description) can now take a ChoiceEnum as the description
  * This sets the description to the docstring, the type to STRING,
    and the choices to the enum names and value
* Parameters annotated with ChoiceEnum subclasses are treated as if
  annotated with Option(ChoiceEnum)

demo_bot.py:
* /math -> /numbers
+ /numbers now supports choosing the operator, using a ChoiceEnum

docs/discord-ext-slash.rst:
+ ChoiceEnum docs

Author: Kenny2github

demo_bot.py

@@ -115,16 +115,35 @@ async def names(
     emb.add_field(name='Text Channel Name', value=text_channel.name)
     await ctx.respond(embed=emb, ephemeral=True)
 
-@client.slash_cmd(name='math')
+class ArithmeticOperator(slash.ChoiceEnum):
+    # The docstring is used as the description of the
+    # option - it is required
+    """The operation to perform on the numbers."""
+    # Only string options are supported by ChoiceEnum
+    ADDITION = '+'
+    SUBTRACTION = '-'
+    MULTIPLICATION = '\N{MULTIPLICATION SIGN}'
+    DIVISION = '\N{DIVISION SIGN}'
+
+@client.slash_cmd()
 async def numbers(
     ctx: slash.Context,
     num1: slash.Option(description='The first number',
                        min_value=0),
+    operator: ArithmeticOperator, # see above
     num2: slash.Option(description='The second number',
                        min_value=-4.20, max_value=6.9),
 ):
     """Do some math! (With limitations)"""
-    await ctx.respond(num1 + num2, ephemeral=True)
+    if operator == ArithmeticOperator.ADDITION:
+        value = num1 + num2
+    elif operator == ArithmeticOperator.SUBTRACTION:
+        value = num1 - num2
+    elif operator == ArithmeticOperator.MULTIPLICATION:
+        value = num1 * num2
+    elif operator == ArithmeticOperator.DIVISION:
+        value = num1 / num2
+    await ctx.respond(value, ephemeral=True)
 
 @client.slash_cmd(default_permission=False)
 async def stop(ctx: slash.Context):

discord/ext/slash/__init__.py

@@ -54,8 +54,10 @@ async def repeat( # command name
 from __future__ import annotations
 import sys
 from warnings import warn
-from enum import IntEnum, IntFlag
-from typing import Coroutine, Dict, Iterable, Set, Tuple, Union, Optional, Mapping, Any, List
+from enum import Enum, IntEnum, IntFlag
+from typing import (
+    Coroutine, Dict, Iterable, Set, Tuple,
+    Type, Union, Optional, Mapping, Any, List)
 from functools import partial
 from inspect import signature
 import logging
@@ -69,6 +71,7 @@ async def repeat( # command name
     'ApplicationCommandPermissionType',
     'InteractionResponseType',
     'CallbackFlags',
+    'ChoiceEnum',
     'Context',
     'Interaction',
     'Option',
@@ -186,6 +189,13 @@ class CallbackFlags(IntFlag):
 
 MessageFlags = CallbackFlags
 
+class ChoiceEnum(Enum):
+    """Callback parameters annotated with subclasses of this class
+    will use the enums as choices. See the ``/numbers`` command in the
+    demo bot for an example.
+    """
+    pass
+
 class _Route(discord.http.Route):
     BASE = 'https://discord.com/api/v8'
 
@@ -347,6 +357,9 @@ async def _kwargs_from_options(self, options, resolved):
                 else:
                     raise commands.CommandInvokeError(
                         f'No such option: {opt["name"]!r}')
+                _enum = self.command.options[opt['name']]._enum
+                if _enum is not None:
+                    value = _enum.__members__[value]
                 opttype = self.command.options[opt['name']].type
                 try:
                     opttype = ApplicationCommandOptionType(opttype)
@@ -628,6 +641,10 @@ class Option:
     Constructor arguments map directly to attributes, besides the ones below
     which have different type signatures:
 
+    :param description:
+        Annotating a parameter with ``EnumClass`` has the same effect as
+        with ``Option(description=EnumClass)``.
+    :type description: Union[str, Type[ChoiceEnum]]
     :param choices:
         Strings are converted into :class:`Choice` objects with the same
         ``name`` and ``value``. :class:`dict` objects are passed as kwargs to
@@ -692,14 +709,16 @@ class Option:
     min_value: Union[int, float, None] = None
     max_value: Union[int, float, None] = None
 
+    _enum: Optional[Type[ChoiceEnum]] = None
+
     @staticmethod
     def value_to_enum(value: Union[int, discord.ChannelType]):
         if isinstance(value, discord.ChannelType):
             return value
         return discord.ChannelType(value)
 
     def __init__(
-        self, description: str,
+        self, description: Union[str, Type[ChoiceEnum]],
         type: ApplicationCommandOptionType = ApplicationCommandOptionType.STRING,
         **kwargs
     ):
@@ -732,7 +751,15 @@ def __init__(
                 self.type = ApplicationCommandOptionType.INTEGER
             elif isinstance(self.min_value, float):
                 self.type = ApplicationCommandOptionType.NUMBER
-        self.description = description
+        if isinstance(description, str):
+            self.description = description
+        elif issubclass(description, ChoiceEnum):
+            kwargs['choices'] = [
+                Choice(desc.value, attr)
+                for attr, desc in description.__members__.items()]
+            self._enum = description
+            self.description = description.__doc__
+            self.type = ApplicationCommandOptionType.STRING
         self.required = kwargs.pop('required', False)
         choices = kwargs.pop('choices', None)
         if choices is not None:
@@ -764,7 +791,10 @@ def to_dict(self):
         return data
 
     def clone(self):
-        return type(self)(**self.to_dict())
+        value = type(self)(**self.to_dict())
+        if self._enum is not None:
+            value._enum = self._enum
+        return value
 
 class Choice:
     """Represents one choice for an option value.
@@ -920,9 +950,8 @@ def __init__(self, coro: Coroutine, **kwargs):
                 except:
                     typ = param.empty
             if (
-                not (isinstance(typ, Option) or (
-                    isinstance(typ, type) and issubclass(typ, Context)
-                ))
+                not (isinstance(typ, Option) or (isinstance(typ, type) and (
+                    issubclass(typ, ChoiceEnum) or issubclass(typ, Context))))
                 and param.default is param.empty
             ):
                 if not found_self_arg:
@@ -937,6 +966,8 @@ def __init__(self, coro: Coroutine, **kwargs):
             try:
                 if issubclass(typ, Context):
                     self._ctx_arg = param.name
+                elif issubclass(typ, ChoiceEnum):
+                    typ = Option(description=typ)
             except TypeError: # not even a class
                 pass
             if isinstance(typ, Option):

docs/discord-ext-slash.rst

@@ -69,6 +69,7 @@ Enums
 .. autoclass:: InteractionResponseType
 .. autoclass:: CallbackFlags
 .. autoclass:: MessageFlags
+.. autoclass:: ChoiceEnum
 
 Events
 ------