Merge branch 'main' of https://github.com/Serbirial/DisCommand

Author: Serbirial

discommand/entry/inject.py

@@ -1,5 +1,13 @@
 from ..ext.cog_manager import CogManager
 
+from discord import (
+    Client,
+    AutoShardedClient
+)
+
 def inject_into_bot(bot):
+    if not issubclass(bot.__class__, Client) or not issubclass(bot.__class__, AutoShardedClient):
+        raise TypeError("Bot is not of type discord.Client or discord.AutoShardedClient (ext.commands.Bot or ext.commands.AutoShardedBot are not supported as they implement commands themselves.)")
+    
     cog_manager = CogManager(bot)
     bot.cog_manager = cog_manager

discommand/ext/cog_manager.py

@@ -13,7 +13,8 @@ def __init__(self, bot) -> None:
         # FIXME: make internal only and have staticmethod to retrieve
         self._cogs: dict[str, cogs.Cog] = {}
 
-        self.all_commands: dict[str, Command] = {}
+        self.all_commands: dict[str, Command | CommandGroup] = {}
+        self.sub_commands: dict[str, Command] = {}
 
 
     def update_all_commands(self) -> None:
@@ -22,11 +23,12 @@ def update_all_commands(self) -> None:
                 print(f"Updating: {name}")
                 if type(command) == CommandGroup: # Add all the groups sub-commands so discord.py recognizes them too.
                     print("Found Group while updating...")
-                    print(command.commands)
                     for _name, _command in command.commands.items():
-                        self.all_commands[_name] = _command
+                        self.sub_commands[_name] = _command
                 self.all_commands[name] = command
+                
         self.client.all_commands = self.all_commands
+        self.client.sub_commands = self.sub_commands
 
     async def start_load_cogs(self, path: str) -> None:
         for file in listdir(path):

discommand/ext/cogs.py

@@ -2,8 +2,6 @@
 import importlib.util
 import importlib.machinery
 
-from functools import wraps
-
 from typing_extensions import (
     Self,
     Any

discommand/ext/commands.py

@@ -125,7 +125,7 @@ async def invoke(self, bot, context): # FIXME: type check context
             raise CommandCheckError("One of the commands checks failed.")
 
         injected = hooked_wrapped_callback(self, bot, context, self.callback)
-        await injected(*context.args, **context.kwargs)
+        await injected(**context.args)
 
     def add_check(self, check: Callable) -> None:
         """Adds a check to the checks list.
@@ -137,12 +137,13 @@ def add_check(self, check: Callable) -> None:
 
 def hooked_wrapped_callback(command: Command, bot, context, coro: Callable) -> Callable:
     @wraps(coro)
-    async def wrapped(*args, **kwargs):
+    async def wrapped(**args):
         try:
-            ret = await coro(command, bot, context, *args, **kwargs)
+            ret = await coro(command, bot, context, **args)
         except asyncio.CancelledError:
             return
         except Exception as exc:
+            print(exc)
             raise CommandInvokeError(exc) from exc
         return ret
 
@@ -212,7 +213,7 @@ async def invoke(self, bot, context):
         if _do_checks(self.checks, context) != True:
             raise CommandCheckError("One of the commands checks failed.")
         injected = hooked_wrapped_callback(self, bot, context, self.callback)
-        await injected(*context.args, **context.kwargs)
+        await injected(**context.args)
 
 
     def add_command(self, command: Command) -> None:

discommand/ext/context.py

@@ -0,0 +1,110 @@
+from discord import (
+    Message,
+    Client,
+    AutoShardedClient
+)
+from discord.channel import DMChannel, GroupChannel, PartialMessageable, StageChannel, TextChannel, VoiceChannel
+from discord.threads import Thread 
+from .commands import (
+    Command,
+    CommandGroup
+)
+from typing import (
+    Any,
+    Callable,
+    Coroutine
+)
+from discord import (
+    TextChannel,
+    VoiceChannel,
+    StageChannel
+)
+
+from discord.embeds import Embed
+from discord.abc import Messageable
+
+class Context(Messageable):
+    def __init__(
+            self,
+            *,
+            message: Message,
+            bot: Client | AutoShardedClient,
+            args: list[Any] | str,
+            kwargs: dict[str, Any],
+            prefix: str | Callable | Coroutine,
+            command: Command | CommandGroup,
+            invoked_with: Command | CommandGroup,
+            invoked_parent: CommandGroup,
+            invoked_subcommand: Command
+        ) -> None:
+        self._message = message
+        self.bot = bot
+        self.args =  args if args else {}
+        self.prefix = prefix
+        self.command = command
+        self.invoked_with = invoked_with
+        self.invoked_parent = invoked_parent
+        self.invoked_subcommand = invoked_subcommand
+
+
+    async def invoke(self, command: Command | CommandGroup):
+        return await command.invoke(self.bot, self)
+
+    @property
+    def message(self):
+        return self._message
+    
+    @property
+    def guild(self):
+        return self.message.guild
+    
+    @property
+    def channel(self):
+        return self.message.channel
+    
+    @property
+    def author(self):
+        return self.message.author
+    
+    @property
+    def me(self):
+        return self.guild.me if self.guild else self.bot.user
+    
+
+    @property
+    def permissions(self):
+        _type = type(self.channel)
+        #if _type == DMChannel:
+        #    return None # FIXME: return DM permissions.
+        return self.channel.permissions_for(self.author)
+        # FIXME: interactions not implemented
+
+    @property
+    def bot_permissions(self):
+        return self.channel.permissions_for(self.bot)
+
+    @property
+    def valid(self) -> bool:
+        return self.prefix is not None and self.command is not None
+    
+
+
+    async def send(self, content: str, tts: bool = False, embed: Embed = None, mention_author: bool = False, delete_after: int = None):
+        return await self.channel.send(
+            content=content,
+            tts=tts,
+            embed=embed,
+            embeds=None, #FIXME: support multiple embeds, files, stickers
+            file=None,
+            files=None,
+            stickers=None,
+            delete_after=delete_after,
+            nonce=None,             # FIXME: Support none, mentions, reference
+            allowed_mentions=None,
+            reference=None,
+            mention_author=mention_author,
+            view=None, # FIXME: support view, embed supression, and silent flag
+            suppress_embeds=None,
+            silent=False,
+        ) 
+    

discommand/ext/events.py

@@ -0,0 +1,101 @@
+import inspect
+
+from discord import (
+    Message,
+    Client,
+    AutoShardedClient
+) 
+from typing import (
+    Any,
+    Callable,
+    Coroutine
+)
+from .commands import (
+    Command,
+    CommandGroup
+)
+
+from .context import Context
+
+def _create_context(
+        message: Message,
+        bot: Client | AutoShardedClient,
+        args: list[Any],
+        prefix: str | Callable | Coroutine,
+        command: Command | CommandGroup,
+        invoked_with: Command | CommandGroup,
+        kwargs: dict[str, Any] = {},
+        invoked_parent: CommandGroup = None,
+        invoked_subcommand: Command = None,
+        cls: Context = None): # FIXME: typing
+    _cls = cls or Context
+
+    return _cls(
+        message=message,
+        bot=bot,
+        args=args,
+        kwargs=kwargs,
+        prefix=prefix,
+        command=command,
+        invoked_with=invoked_with,
+        invoked_parent=invoked_parent,
+        invoked_subcommand=invoked_subcommand
+    )
+
+def _has_prefix(prefixes: list, message: Message) -> str:
+    for prefix in prefixes:
+        if len(message.content.split(prefix))==2:
+            return prefix
+
+def _find_command(bot: Client | AutoShardedClient, prefix: str, content: str) -> Command | None: 
+    name = content.split(prefix, 1)[1].split(" ")
+    if len(name)>=2:
+        if bot.all_commands[name[0]] == bot.sub_commands[name[1]].parent:
+            return bot.sub_commands[name[1]]
+        elif name[0] in bot.all_commands:
+            return bot.all_commands[name[0]]
+    else:
+        return bot.all_commands[name[0]] if name[0] in bot.all_commands else None
+    
+def _process_arguments(content: str):
+    pass
+    
+def _find_args(command: Command, message: Message) -> dict[str, str]:
+    try:
+        args = inspect.getfullargspec(command.callback)[0]
+    except ValueError:
+        args = inspect.signature(command.callback)
+    
+    given_args = {}
+    if not len(args)>3:
+        return None
+    del args[:3]
+    iteration = 0
+    _temp = " "
+    for arg in message.content.split(command.name, 1)[1].strip().split(" "):
+        if iteration>=len(args):
+            _temp += arg
+        else: 
+            given_args[args[iteration]] = arg
+            iteration += 1
+    given_args[args[-1]] += _temp
+
+    return given_args
+    
+def process_message(bot: Client | AutoShardedClient, prefixes: str | list, message: Message, context = None) -> Command:
+    """Processes a message, for retrieving a command if the message contains the prefix+command combination.
+
+    Args:
+        bot (Client | AutoShardedClient): Initialized discord.py bot.
+        prefixes (str | list): either a string or a list of prefixes.
+        message (Message): The message processed for a command.
+
+    Returns:
+        Command: The command found
+        Args (dict): All found args
+    """
+    if (prefix := _has_prefix(prefixes, message)):
+        if (command := _find_command(bot, prefix, message.content)):
+            args = _find_args(command, message)
+            context = _create_context(message, bot, args=args, kwargs={}, prefix=prefixes, command=command, invoked_with=command, cls=context)
+            return command, context