Implemented aliases

Author: eunwoo1104

dico_command/bot.py

@@ -6,7 +6,7 @@
 import dico
 from .command import Command
 from .context import Context
-from .exception import InvalidArgument, InvalidModule, MissingLoadFunction, MissingUnloadFunction, ModuleNotLoaded
+from .exception import *
 from .utils import smart_split, is_coro
 
 if typing.TYPE_CHECKING:
@@ -25,6 +25,7 @@ def __init__(self,
         super().__init__(token, intents=intents, default_allowed_mentions=default_allowed_mentions, loop=loop, cache=cache)
         self.prefixes = [prefix] if not isinstance(prefix, list) else prefix
         self.commands = {}
+        self.aliases = {}
         self.logger = logging.Logger("dico_command")
         self.on("MESSAGE_CREATE", self.execute_handler)
         self.addons: typing.List[Addon] = []
@@ -48,10 +49,10 @@ async def execute_handler(self, message: dico.Message):
         raw_ipt = cont[len(prefix_result):]
         ipt = raw_ipt.split(maxsplit=1)
         name = ipt[0]
-        cmd = self.commands.get(name)
+        cmd = self.commands.get(self.aliases.get(name, name))
         if not cmd:
             return
-        context = Context.from_message(message, prefix_result, cmd)
+        context = Context.from_message(message, prefix_result, cmd, name)
         try:
             try:
                 args, kwargs = smart_split(ipt[1] if len(ipt) > 1 else "", cmd.args_data)
@@ -64,18 +65,25 @@ async def execute_handler(self, message: dico.Message):
 
     def add_command(self, command: Command):
         if command.name in self.commands:
-            raise
+            raise CommandAlreadyExists(name=command.name)
         self.commands[command.name] = command
+        for x in command.aliases:
+            if x in self.aliases:
+                raise CommandAlreadyExists(name=x)
+            self.aliases[x] = command.name
         return command
 
     def remove_command(self, name: str):
         if name not in self.commands:
-            raise
-        del self.commands[name]
+            return
+        command = self.commands.pop(name)
+        for x in command.aliases:
+            if x in self.aliases:
+                del self.aliases[x]
 
-    def command(self, name: str = None):
+    def command(self, name: typing.Optional[str] = None, *, aliases: typing.Optional[typing.List[str]] = None):
         def wrap(func):
-            cmd = Command(func, name or func.__name__)
+            cmd = Command(func, name or func.__name__, aliases=aliases)
             self.add_command(cmd)
             return cmd
         return wrap
@@ -89,7 +97,7 @@ def handle_command_error(self, context, ex):
     def load_addons(self, *addons: typing.Type["Addon"]):
         for x in addons:
             if x.name in self.addon_names:
-                raise
+                raise AddonAlreadyLoaded(name=x.name)
             self.addon_names.append(x.name)
             loaded = x(self)
             self.addons.append(loaded)
@@ -130,13 +138,15 @@ def load_module(self, import_path: str):
         try:
             module = importlib.import_module(import_path)
             importlib.reload(module)
+            if module.__name__ in self.modules:
+                raise ModuleAlreadyLoaded(path=import_path)
             self.modules.append(module.__name__)
             if hasattr(module, "load"):
                 module.load(self)
             else:
-                raise MissingLoadFunction
+                raise MissingLoadFunction(path=import_path)
         except ImportError:
-            raise InvalidModule
+            raise InvalidModule(path=import_path)
 
     def unload_module(self, import_path: str):
         try:
@@ -146,11 +156,11 @@ def unload_module(self, import_path: str):
                     module.unload(self)
                     self.modules.remove(module.__name__)
                 else:
-                    raise MissingUnloadFunction
+                    raise MissingUnloadFunction(path=import_path)
             else:
-                raise ModuleNotLoaded
+                raise ModuleNotLoaded(path=import_path)
         except ImportError:
-            raise InvalidModule
+            raise InvalidModule(path=import_path)
 
     def reload_module(self, import_path: str):
         self.unload_module(import_path)

dico_command/command.py

@@ -8,10 +8,12 @@ class Command:
     def __init__(self,
                  func,
                  name: str,
-                 checks: typing.List[typing.Callable[[Context], bool]] = None):
+                 checks: typing.Optional[typing.List[typing.Callable[[Context], bool]]] = None,
+                 aliases: typing.Optional[typing.List[str]] = None):
         self.func = func
         self.name = name
         self.checks = checks or []
+        self.aliases = aliases or []
 
         self.args_data = read_function(self.func)
         if hasattr(func, "_checks"):
@@ -32,7 +34,7 @@ async def invoke(self, ctx: Context, *args, **kwargs):
         return await self.func(*init_args, *args, **kwargs)
 
 
-def command(name: str = None):
+def command(name: typing.Optional[str] = None, *, aliases: typing.Optional[typing.List[str]] = None):
     def wrap(func):
-        return Command(func, name)
+        return Command(func, name, aliases=aliases)
     return wrap

dico_command/context.py

@@ -1,18 +1,18 @@
-import io
 import typing
-import pathlib
-from dico import Message, Embed, AllowedMentions, MessageReference
+from dico import Message, Embed, AllowedMentions, MessageReference, Component
+from dico.model.extras import FILE_TYPE
 
 
 class Context(Message):
-    def __init__(self, client, resp, prefix, command, **kwargs):
+    def __init__(self, client, resp, prefix, command, name_used, **kwargs):
         super().__init__(client, resp, **kwargs)
         self.prefix = prefix
         self.command = command
+        self.name_used = name_used
 
     @classmethod
-    def from_message(cls, message: Message, prefix, command):
-        return cls(message.client, message.raw, prefix, command)
+    def from_message(cls, message: Message, prefix, command, name_used):
+        return cls(message.client, message.raw, prefix, command, name_used)
 
     @property
     def bot(self):
@@ -22,9 +22,22 @@ def send(self,
              content: str = None,
              *,
              embed: typing.Union[Embed, dict] = None,
-             file: typing.Union[io.FileIO, pathlib.Path, str] = None,
-             files: typing.List[typing.Union[io.FileIO, pathlib.Path, str]] = None,
+             embeds: typing.List[typing.Union[Embed, dict]] = None,
+             file: FILE_TYPE = None,
+             files: typing.List[FILE_TYPE] = None,
              tts: bool = False,
              allowed_mentions: typing.Union[AllowedMentions, dict] = None,
-             message_reference: typing.Union[Message, MessageReference, dict] = None):
-        return self.client.create_message(self.channel, content, embed=embed, file=file, files=files, tts=tts, allowed_mentions=allowed_mentions, message_reference=message_reference)
+             message_reference: typing.Union[Message, MessageReference, dict] = None,
+             component: typing.Union[dict, Component] = None,
+             components: typing.List[typing.Union[dict, Component]] = None):
+        return self.client.create_message(self.channel,
+                                          content,
+                                          embed=embed,
+                                          embeds=embeds,
+                                          file=file,
+                                          files=files,
+                                          tts=tts,
+                                          allowed_mentions=allowed_mentions,
+                                          message_reference=message_reference,
+                                          component=component,
+                                          components=components)

dico_command/exception.py

@@ -3,8 +3,16 @@
 
 class CommandException(DicoException):
     """Base exception for dico-command."""
-    def __init__(self, *args):
-        super().__init__(*args or [self.__doc__])
+    def __init__(self, *args, **fmt):
+        super().__init__(*args or [self.__doc__.format(**fmt)])
+
+
+class CommandAlreadyExists(CommandException):
+    """Command {name} already exists."""
+
+
+class CommandNotExists(CommandException):
+    """Command {name} doesn't exist."""
 
 
 class InvalidArgument(CommandException):
@@ -16,16 +24,24 @@ class CheckFailed(CommandException):
 
 
 class InvalidModule(CommandException):
-    """Unable to find module. Check if path is correct."""
+    """Unable to find module {path}. Check if path is correct."""
+
+
+class ModuleAlreadyLoaded(CommandException):
+    """Module {path} is already loaded."""
 
 
 class ModuleNotLoaded(CommandException):
-    """This module is never loaded."""
+    """Module {path} is never loaded."""
 
 
 class MissingLoadFunction(CommandException):
-    """This module is missing "load" function."""
+    """Module {path} is missing "load" function."""
 
 
 class MissingUnloadFunction(CommandException):
-    """This module is missing "unload" function."""
+    """Module {path} is missing "unload" function."""
+
+
+class AddonAlreadyLoaded(CommandException):
+    """Addon {name} is already loaded."""