matrix-python 0.1.2a0__tar.gz → 1.0.3a0__tar.gz

matrix_python-1.0.3a0/.github/workflows/codeql.yml

@@ -0,0 +1,99 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL Advanced"
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    - cron: '24 17 * * 4'
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners (GitHub.com only)
+    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # required to fetch internal or private CodeQL packs
+      packages: read
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - language: python
+          build-mode: none
+        # CodeQL supports the following values keywords for 'language': 'actions', 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'rust', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Add any setup steps before running the `github/codeql-action/init` action.
+    # This includes steps like installing compilers or runtimes (`actions/setup-node`
+    # or others). This is typically only required for manual builds.
+    # - name: Setup runtime (example)
+    #   uses: actions/setup-example@v1
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v4
+      with:
+        languages: ${{ matrix.language }}
+        build-mode: ${{ matrix.build-mode }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+    # If the analyze step fails for one of the languages you are analyzing with
+    # "We were unable to automatically build your code", modify the matrix above
+    # to set the build mode to "manual" for that language. Then modify this step
+    # to build your code.
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+    - name: Run manual build steps
+      if: matrix.build-mode == 'manual'
+      shell: bash
+      run: |
+        echo 'If you are using a "manual" build mode for one or more of the' \
+          'languages you are analyzing, replace this with the commands to build' \
+          'your code, for example:'
+        echo '  make bootstrap'
+        echo '  make release'
+        exit 1
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v4
+      with:
+        category: "/language:${{matrix.language}}"

matrix_python-1.0.3a0/.github/workflows/scorecard.yml

@@ -0,0 +1,52 @@
+name: Scorecard supply-chain security
+on:
+  branch_protection_rule:
+  schedule:
+    - cron: '16 0 * * 4'
+  push:
+    branches: ["main"]
+  workflow_dispatch:
+
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      # Needed to publish results and get a badge (see publish_results below).
+      id-token: write
+      contents: read
+      actions: read
+
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@ec9f2d5744a09debf3a187a3f4f675c53b671911 # v2.13.0
+        with:
+          egress-policy: audit
+
+      - name: "Checkout code"
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@05b42c624433fc40578a4040d5cf5e36ddca8cde # v2.4.2
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          publish_results: true
+
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.29.5
+        with:
+          sarif_file: results.sarif

{matrix_python-0.1.2a0 → matrix_python-1.0.3a0}/.gitignore

@@ -165,7 +165,7 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+.idea/
 
 # Ruff stuff:
 .ruff_cache/

{matrix_python-0.1.2a0 → matrix_python-1.0.3a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: matrix-python
-Version: 0.1.2a0
+Version: 1.0.3a0
 Summary: An easy-to-use Matrix bot framework designed for quick development and minimal setup
 Author: Simon Roy,  Chris Dedman Rollet 
 Maintainer-email: Code Society Lab <admin@codesociety.xyz>
@@ -710,6 +710,8 @@ Requires-Dist: types-Markdown; extra == "dev"
 [![Static Badge](https://img.shields.io/badge/%F0%9F%93%9A-Documentation-%235c5c5c)](https://github.com/Code-Society-Lab/matrixpy/wiki)
 [![Join on Discord](https://discordapp.com/api/guilds/823178343943897088/widget.png?style=shield)](https://discord.gg/code-society-823178343943897088)
 [![Tests](https://github.com/Code-Society-Lab/matrixpy/actions/workflows/tests.yml/badge.svg)](https://github.com/Code-Society-Lab/matrixpy/actions/workflows/tests.yml)
+[![CodeQL Advanced](https://github.com/Code-Society-Lab/matrixpy/actions/workflows/codeql.yml/badge.svg)](https://github.com/Code-Society-Lab/matrixpy/actions/workflows/codeql.yml)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/Code-Society-Lab/matrixpy/badge)](https://securityscorecards.dev/viewer/?uri=github.com/Code-Society-Lab/matrixpy)
 
 Matrix.py is a lightweight and intuitive Python library to build bots on
 the [Matrix protocol]([Matrix](https://matrix.org)). It provides a clean,

{matrix_python-0.1.2a0 → matrix_python-1.0.3a0}/README.md

@@ -11,6 +11,8 @@
 [![Static Badge](https://img.shields.io/badge/%F0%9F%93%9A-Documentation-%235c5c5c)](https://github.com/Code-Society-Lab/matrixpy/wiki)
 [![Join on Discord](https://discordapp.com/api/guilds/823178343943897088/widget.png?style=shield)](https://discord.gg/code-society-823178343943897088)
 [![Tests](https://github.com/Code-Society-Lab/matrixpy/actions/workflows/tests.yml/badge.svg)](https://github.com/Code-Society-Lab/matrixpy/actions/workflows/tests.yml)
+[![CodeQL Advanced](https://github.com/Code-Society-Lab/matrixpy/actions/workflows/codeql.yml/badge.svg)](https://github.com/Code-Society-Lab/matrixpy/actions/workflows/codeql.yml)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/Code-Society-Lab/matrixpy/badge)](https://securityscorecards.dev/viewer/?uri=github.com/Code-Society-Lab/matrixpy)
 
 Matrix.py is a lightweight and intuitive Python library to build bots on
 the [Matrix protocol]([Matrix](https://matrix.org)). It provides a clean,

{matrix_python-0.1.2a0 → matrix_python-1.0.3a0}/examples/scheduler.py

@@ -1,7 +1,6 @@
 from matrix import Bot, Context
-from matrix.message import Message
 
-bot = Bot("config.yaml")
+bot = Bot("examples/config.yaml")
 
 room_id = "!your_room_id:matrix.org"  # Replace with your room ID
 

{matrix_python-0.1.2a0 → matrix_python-1.0.3a0}/matrix/__init__.py

@@ -1,8 +1,9 @@
 """A simple, developer-friendly library to create powerful Matrix bots."""
 
-__version__ = "0.1.2-alpha"
+__version__ = "1.0.3-alpha"
 
 from .bot import Bot
+from .group import Group
 from .config import Config
 from .context import Context
 from .command import Command
@@ -11,6 +12,7 @@ from .checks import cooldown
 
 __all__ = [
     "Bot",
+    "Group",
     "Config",
     "Command",
     "Context",

{matrix_python-0.1.2a0 → matrix_python-1.0.3a0}/matrix/bot.py

@@ -25,15 +25,22 @@ from nio import (
 )
 
 from .room import Room
+from .group import Group
 from .config import Config
 from .context import Context
 from .command import Command
-from .help import HelpCommand
-from .errors import AlreadyRegisteredError, CommandNotFoundError, CheckError
+from .help import HelpCommand, DefaultHelpCommand
 from .scheduler import Scheduler
 
+from .errors import (
+    AlreadyRegisteredError,
+    CommandNotFoundError,
+    CheckError,
+)
+
 
 Callback = Callable[..., Coroutine[Any, Any, Any]]
+GroupCallable = Callable[[Callable[..., Coroutine[Any, Any, Any]]], Group]
 ErrorCallback = Callable[[Exception], Coroutine]
 CommandErrorCallback = Callable[["Context", Exception], Coroutine[Any, Any, Any]]
 
@@ -66,13 +73,15 @@ class Bot:
         "on_member_change": RoomMemberEvent,
     }
 
-    def __init__(self, config: Optional[Union[Config, str]] = None, **kwargs) -> None:
+    def __init__(
+        self, *, config: Union[Config, str], help: Optional[HelpCommand] = None
+    ) -> None:
         if isinstance(config, Config):
             self.config = config
         elif isinstance(config, str):
             self.config = Config(config_path=config)
         else:
-            self.config = Config(**kwargs)
+            raise TypeError("config must be a Config instance or a config file path")
 
         self.client: AsyncClient = AsyncClient(self.config.homeserver)
         self.log: logging.Logger = logging.getLogger(__name__)
@@ -89,7 +98,7 @@ class Bot:
         self._error_handlers: dict[type[Exception], ErrorCallback] = {}
         self._command_error_handlers: dict[type[Exception], CommandErrorCallback] = {}
 
-        self.help: HelpCommand = kwargs.get("help", HelpCommand(prefix=self.prefix))
+        self.help: HelpCommand = help or DefaultHelpCommand(prefix=self.prefix)
         self.register_command(self.help)
 
         self.client.add_event_callback(self._on_event, Event)
@@ -179,7 +188,14 @@ class Bot:
         return wrapper(func)
 
     def command(
-        self, name: Optional[str] = None, cooldown: Optional[tuple[int, float]] = None
+        self,
+        name: Optional[str] = None,
+        *,
+        description: Optional[str] = None,
+        prefix: Optional[str] = None,
+        parent: Optional[str] = None,
+        usage: Optional[str] = None,
+        cooldown: Optional[tuple[int, float]] = None,
     ) -> Callable[[Callback], Command]:
         """
         Decorator to register a coroutine function as a command handler.
@@ -187,9 +203,12 @@ class Bot:
         The command name defaults to the function name unless
         explicitly provided.
 
-        :param name: The name of the command. If omitted, the function
-                     name is used.
-        :type name: str, optional
+        :param name: The name of the command. If omitted, the function name is used.
+        :param description: A brief description of the command.
+        :param prefix: The command prefix. If omitted, the bot's default prefix is used.
+        :param parent: The parent command name for subcommands.
+        :param usage: A usage string describing command arguments.
+        :param cooldown: A tuple defining (max_calls, per_seconds) for rate limiting.
         :raises TypeError: If the decorated function is not a coroutine.
         :raises ValueError: If a command with the same name is registered.
         :return: Decorator that registers the command handler.
@@ -197,12 +216,20 @@ class Bot:
         """
 
         def wrapper(func: Callback) -> Command:
-            cmd = Command(func, name=name, cooldown=cooldown, prefix=self.prefix)
+            cmd = Command(
+                func,
+                name=name,
+                description=description,
+                prefix=prefix,
+                parent=parent,
+                usage=usage,
+                cooldown=cooldown,
+            )
             return self.register_command(cmd)
 
         return wrapper
 
-    def schedule(self, cron: str):
+    def schedule(self, cron: str) -> Callable[..., Callback]:
         """
         Decorator to register a coroutine function as a scheduled task.
 
@@ -225,12 +252,12 @@ class Bot:
 
         return wrapper
 
-    def register_command(self, cmd: Command):
+    def register_command(self, cmd: Command) -> Command:
         if cmd in self.commands:
             raise AlreadyRegisteredError(cmd)
 
         self.commands[cmd.name] = cmd
-        self.log.debug("command %s registered", cmd)
+        self.log.debug("command '%s' registered", cmd)
 
         return cmd
 
@@ -312,7 +339,7 @@ class Bot:
 
             await ctx.command(ctx)
 
-    async def _build_context(self, room: MatrixRoom, event: Event):
+    async def _build_context(self, room: MatrixRoom, event: Event) -> Context:
         """Builds the base context and extracts the command from the event"""
         ctx = Context(bot=self, room=room, event=event)
 

{matrix_python-0.1.2a0 → matrix_python-1.0.3a0}/matrix/checks.py

@@ -1,4 +1,7 @@
-from typing import Callable
+from typing import TYPE_CHECKING, Callable
+
+if TYPE_CHECKING:
+    from .command import Command
 
 
 def cooldown(rate: int, period: float) -> Callable:
@@ -11,7 +14,7 @@ def cooldown(rate: int, period: float) -> Callable:
     :type period: float
     """
 
-    def wrapper(cmd):
+    def wrapper(cmd: Command) -> Command:
         cmd.set_cooldown(rate, period)
         return cmd
 

{matrix_python-0.1.2a0 → matrix_python-1.0.3a0}/matrix/command.py

@@ -31,32 +31,43 @@ class Command:
     :param func: The coroutine that is executed when the command is invoked.
     :type func: Callable[..., Coroutine[Any, Any, Any]]
 
-    :keyword str name: Optional name. Defaults to the function's name.
-    :keyword str help: Optional help text displayed to users.
-    :keyword str usage: Optional usage string for the command.
-    :keyword str description: Optional description of what the command does.
+    :param name: Optional name. Defaults to the function's name.
+    :param description: Optional description of what the command does.
+    :param prefix: Optional prefix for the command.
+    :param parent: Optional parent command name for subcommands.
+    :param usage: Optional usage string for the command.
+    :param cooldown: Optional cooldown settings as a tuple of (rate, period).
 
     :raises TypeError: If the provided name is not a string.
     :raises TypeError: If the provided callback is not a coroutine.
     """
 
-    def __init__(self, func: Callback, **kwargs: Any):
-        name: str = kwargs.get("name") or func.__name__
-
-        if not isinstance(name, str):
+    def __init__(
+        self,
+        func: Callback,
+        *,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        prefix: Optional[str] = None,
+        parent: Optional[str] = None,
+        usage: Optional[str] = None,
+        cooldown: Optional[tuple[int, float]] = None,
+    ):
+        if name is not None and not isinstance(name, str):
             raise TypeError("Name must be a string.")
 
-        self.name: str = name
+        self.name: str = name or func.__name__
         self.callback = func
         self.checks: List[Callback] = []
 
-        self.description: str = kwargs.get("description", "")
-        self.prefix: str = kwargs.get("prefix", "")
-        self.usage: str = kwargs.get("usage", self._build_usage())
+        self.description: str = description or ""
+        self.prefix: str = prefix or ""
+        self.parent: str = parent or ""
+        self.usage: str = usage or self._build_usage()
         self.help: str = self._build_help()
 
-        self._before_invoke: Optional[Callback] = None
-        self._after_invoke: Optional[Callback] = None
+        self._before_invoke_callback: Optional[Callback] = None
+        self._after_invoke_callback: Optional[Callback] = None
         self._on_error: Optional[ErrorCallback] = None
         self._error_handlers: dict[type[Exception], ErrorCallback] = {}
 
@@ -64,7 +75,7 @@ class Command:
         self.cooldown_period: Optional[float] = None
         self.cooldown_calls: DefaultDict[str, deque[float]] = defaultdict(deque)
 
-        if cooldown := kwargs.get("cooldown"):
+        if cooldown:
             self.set_cooldown(*cooldown)
 
     @property
@@ -115,7 +126,12 @@ class Command:
         :rtype: str
         """
         params = " ".join(f"[{p.name}]" for p in self.params)
-        return f"{self.prefix}{self.name} {params}"
+        command_name = self.name
+
+        if self.parent:
+            command_name = f"{self.parent} {self.name}"
+
+        return f"{self.prefix}{command_name} {params}"
 
     def _parse_arguments(self, ctx: "Context") -> list[Any]:
         parsed_args = []
@@ -153,10 +169,13 @@ class Command:
         self.cooldown_rate = rate
         self.cooldown_period = period
 
-        async def cooldown_function(ctx):
+        async def cooldown_function(ctx: "Context") -> bool:
             if ctx is None or not hasattr(ctx, "sender"):
                 return False
 
+            if self.cooldown_period is None or self.cooldown_rate is None:
+                return False
+
             now = monotonic()
             user_id = ctx.sender
             calls = self.cooldown_calls[user_id]
@@ -186,7 +205,7 @@ class Command:
         if not asyncio.iscoroutinefunction(func):
             raise TypeError("The hook must be a coroutine.")
 
-        self._before_invoke = func
+        self._before_invoke_callback = func
 
     def after_invoke(self, func: Callback) -> None:
         """
@@ -201,7 +220,7 @@ class Command:
         if not asyncio.iscoroutinefunction(func):
             raise TypeError("The hook must be a coroutine.")
 
-        self._after_invoke = func
+        self._after_invoke_callback = func
 
     def error(self, exception: Optional[type[Exception]] = None) -> Callable:
         """
@@ -250,17 +269,25 @@ class Command:
         ctx.logger.exception("error while executing command '%s'", self)
         raise error
 
-    async def __before_invoke(self, ctx: "Context") -> None:
-        for check in self.checks:
-            if not await check(ctx):
-                raise CheckError(self, check)
+    async def invoke(self, ctx: "Context") -> None:
+        parsed_args = self._parse_arguments(ctx)
+        await self.callback(ctx, *parsed_args)
+
+    async def _invoke(self, ctx: "Context") -> None:
+        try:
+            for check in self.checks:
+                if not await check(ctx):
+                    raise CheckError(self, check)
 
-        if self._before_invoke:
-            await self._before_invoke(ctx)
+            if self._before_invoke_callback:
+                await self._before_invoke_callback(ctx)
 
-    async def __after_invoke(self, ctx: "Context") -> None:
-        if self._after_invoke:
-            await self._after_invoke(ctx)
+            await self.invoke(ctx)
+
+            if self._after_invoke_callback:
+                await self._after_invoke_callback(ctx)
+        except Exception as error:
+            await self.on_error(ctx, error)
 
     async def __call__(self, ctx: "Context") -> None:
         """
@@ -269,17 +296,9 @@ class Command:
         :param ctx: The command execution context.
         :type ctx: Context
         """
-        try:
-            await self.__before_invoke(ctx)
-
-            parsed_args = self._parse_arguments(ctx)
-            await self.callback(ctx, *parsed_args)
-
-            await self.__after_invoke(ctx)
-        except Exception as error:
-            await self.on_error(ctx, error)
+        await self._invoke(ctx)
 
-    def __eq__(self, other) -> bool:
+    def __eq__(self, other: object) -> bool:
         return self.name == other
 
     def __hash__(self) -> int:

{matrix_python-0.1.2a0 → matrix_python-1.0.3a0}/matrix/config.py

@@ -13,30 +13,40 @@ class Config:
         token: (Optional) One of the password or token must be provided.
         prefix: Defaults to '!' if not specified in the config file.
 
-    :param config_path: (Optional) Path to the YAML configuration file.
-    :type config_path: str
-
-    :param **kwargs: (Optional) Varaiable to Matrix client configuration.
-    :type **kwargs: dict[str, Any]
+    :param config_path: Path to the YAML configuration file.
+    :param homeserver: The Matrix homeserver URL.
+    :param username: The Matrix user ID (username).
+    :param password: The password for the Matrix user.
+    :param token: The access token for the Matrix user.
+    :param prefix: The command prefix.
 
     :raises FileNotFoundError: If the configuration file does not exist.
     :raises yaml.YAMLError: If the configuration file cannot be parsed.
     :raises ConfigError: If neither password or token has been provided.
     """
 
-    def __init__(self, config_path: Optional[str] = None, **kwargs):
-        self.homeserver: str = kwargs.get("homeserver", "https://matrix.org")
-        self.user_id: Optional[str] = kwargs.get("username")
-        self.password: Optional[str] = kwargs.get("password", None)
-        self.token: Optional[str] = kwargs.get("token", None)
-        self.prefix: str = kwargs.get("prefix", "!")
+    def __init__(
+        self,
+        config_path: Optional[str] = None,
+        *,
+        homeserver: Optional[str] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        token: Optional[str] = None,
+        prefix: Optional[str] = None,
+    ) -> None:
+        self.homeserver: str = homeserver or "https://matrix.org"
+        self.user_id: Optional[str] = username
+        self.password: Optional[str] = password
+        self.token: Optional[str] = token
+        self.prefix: str = prefix or "!"
 
         if config_path:
             self.load_from_file(config_path)
         elif not (self.password or self.token):
             raise ConfigError("username and password or token")
 
-    def load_from_file(self, config_path: str):
+    def load_from_file(self, config_path: str) -> None:
         """Load Matrix client settings via YAML config file."""
         with open(config_path, "r") as f:
             config = yaml.safe_load(f)

{matrix_python-0.1.2a0 → matrix_python-1.0.3a0}/matrix/context.py

@@ -42,6 +42,7 @@ class Context:
         # Command metdata
         self.prefix: str = bot.prefix
         self.command: Optional[Command] = None
+        self.subcommand: Optional[Command] = None
         self._args: List[str] = shlex.split(self.body)
 
     @property
@@ -54,8 +55,12 @@ class Context:
         :return: The list of arguments.
         :rtype: List[str]
         """
+        if self.subcommand:
+            return self._args[2:]
+
         if self.command:
             return self._args[1:]
+
         return self._args
 
     @property
@@ -80,6 +85,12 @@ class Context:
             raise MatrixError(f"Failed to send message: {e}")
 
     async def send_help(self) -> None:
-        if not self.command:
-            return await self.bot.help.execute(self)
-        await self.reply(self.command.help)
+        if self.subcommand:
+            await self.reply(self.subcommand.help)
+            return
+
+        if self.command:
+            await self.reply(self.command.help)
+            return
+
+        await self.bot.help.execute(self)