feat(help): simplify select options creation by iterating over cached categories

fix(logging): enhance message handling for exceptions and newlines in LoguruRichHandler

Author: electron271

tux/help.py

@@ -1,6 +1,5 @@
 import asyncio
 import os
-import re
 from collections.abc import Awaitable, Mapping
 from pathlib import Path
 from typing import Any, get_type_hints
@@ -103,17 +102,21 @@ def _add_command_field(embed: discord.Embed, command: commands.Command[Any, Any,
     async def _create_select_options(
         self,
         command_categories: dict[str, dict[str, str]],
-        cog_groups: list[str],
         menu: ViewMenu,
     ) -> dict[discord.SelectOption, list[Page]]:
+        """
+        Creates select options for the help menu by iterating over the keys in the
+        cached command categories. This approach ensures that even categories without
+        a corresponding folder (e.g. "extra") are included.
+        """
         select_options: dict[discord.SelectOption, list[Page]] = {}
-
         prefix: str = await self._get_prefix()
 
+        # Iterate over the keys in command_categories
         tasks: list[Awaitable[tuple[str, Page]]] = [
             self._create_page(cog_group, command_categories, menu, prefix)
-            for cog_group in cog_groups
-            if cog_group in command_categories and any(command_categories[cog_group].values())
+            for cog_group in command_categories
+            if any(command_categories[cog_group].values())
         ]
 
         select_options_data: list[tuple[str, Page]] = await asyncio.gather(*tasks)
@@ -132,6 +135,9 @@ async def _create_select_options(
             emoji = category_emoji_map.get(cog_group, "❓")
             select_options[discord.SelectOption(label=cog_group.capitalize(), emoji=emoji)] = [page]
 
+        logger.info(f"Select options: {select_options}")
+        logger.info(f"Cached categories: {self._category_cache}")
+
         return select_options
 
     async def _create_page(
@@ -148,7 +154,6 @@ async def _create_page(
 
         sorted_commands: list[tuple[str, str]] = sorted(command_categories[cog_group].items())
         description: str = "\n".join(f"**`{prefix}{cmd}`** | {command_list}" for cmd, command_list in sorted_commands)
-
         embed.description = description
         page: Page = Page(embed=embed)
         menu.add_page(embed)
@@ -169,8 +174,8 @@ async def _add_cog_pages(
     ) -> None:
         """Adds pages for each cog category to the help menu."""
         command_categories = await self._get_command_categories(mapping)
-        cog_groups = self._get_cog_groups()
-        select_options = await self._create_select_options(command_categories, cog_groups, menu)
+        # Instead of using filesystem folders, iterate over cached categories.
+        select_options = await self._create_select_options(command_categories, menu)
         self._add_navigation_and_selection(menu, select_options)
 
     async def _get_command_categories(
@@ -185,6 +190,7 @@ async def _get_command_categories(
 
         for cog, mapping_commands in mapping.items():
             if cog and len(mapping_commands) > 0:
+                # Attempt to extract the group using the cog's module name.
                 cog_group = self._extract_cog_group(cog) or "extra"
                 command_categories.setdefault(cog_group, {})
                 for command in mapping_commands:
@@ -204,9 +210,15 @@ def _get_cog_groups() -> list[str]:
 
     @staticmethod
     def _extract_cog_group(cog: commands.Cog) -> str | None:
-        """Extracts the cog group from a cog's string representation."""
-        if match := re.search(r"<cogs\.([^\.]+)\..*>", str(cog)):
-            return match[1]
+        """
+        Extracts the cog group using the cog's module attribute.
+        For example, if a cog's module is 'tux.cogs.admin.some_cog', this returns 'admin'.
+        """
+        module = getattr(cog, "__module__", "")
+        parts = module.split(".")
+        # Assuming the structure is: tux.cogs.<group>...
+        if len(parts) >= 3 and parts[1].lower() == "cogs":
+            return parts[2].lower()
         return None
 
     # Sending Help Messages

tux/utils/logging.py

@@ -17,8 +17,6 @@
 from rich.text import Text
 from rich.theme import Theme
 
-from tux.utils.config import Config
-
 T = TypeVar("T")
 
 
@@ -73,6 +71,11 @@ def emit(self, record: LogRecord) -> None:
             # Get the formatted message from loguru's formatter.
             message = self.format(record)
 
+            # If there is exception info (or the message contains newlines),
+            # delegate to the base class so that Rich can render tracebacks properly.
+            if record.exc_info or "\n" in message:
+                return super().emit(record)
+
             # --- Time formatting ---
             time_format: str | Callable[[datetime], Text] | None = (
                 None if self.formatter is None else self.formatter.datefmt
@@ -114,12 +117,6 @@ def emit(self, record: LogRecord) -> None:
 
             # --- Build the continued prefix ---
             # We want the continued prefix to have the same plain-text width as the normal one.
-            # The normal prefix width (plain) is:
-            #   len(symbol + " ") + (len(log_time_str) + 2) + (LEVEL_FIELD_WIDTH + 2)
-            # For the continued prefix we print "CONTINUED" (padded) in a single bracket:
-            #   Total width = len(symbol + " ") + (continued_field_width + 2)
-            # Setting these equal gives:
-            #   continued_field_width = len(log_time_str) + LEVEL_FIELD_WIDTH + 2
             continued_field_width = len(log_time_str) + level_field_width
             continued_prefix_markup = (
                 f"{symbol} "
@@ -138,34 +135,27 @@ def emit(self, record: LogRecord) -> None:
             source_info_plain = Text.from_markup(source_info).plain
 
             # --- Total width ---
-            # Use the console's actual width if available.
             total_width = (self.console.size.width or self.console.width) or 80
 
             # Convert the formatted message to plain text.
             plain_message = Text.from_markup(message).plain
 
             # --- One-line vs two-line decision ---
-            # For one-line messages, the available space is the total width
-            # minus the widths of the normal prefix and the source info.
             available_for_message = total_width - len(first_prefix_plain) - len(source_info_plain)
             if len(plain_message) <= available_for_message:
-                # The message fits on one line.
                 padded_msg = plain_message.ljust(available_for_message)
                 full_line = first_prefix_markup + padded_msg + source_info
                 self.console.print(full_line, markup=True, highlight=False)
             else:
-                # --- Two-line (continued) layout ---
-                # First line: Reserve all space after the normal prefix.
+                # Two-line (continued) layout
                 first_line_area = total_width - len(first_prefix_plain)
-                first_line_msg = plain_message[:first_line_area]  # Simply cut off without ellipsis
+                first_line_msg = plain_message[:first_line_area]  # Cut off without ellipsis
 
-                # Second line: use the continued prefix and reserve space for the source info.
                 second_line_area = total_width - len(continued_prefix_plain) - len(source_info_plain)
-                # The remainder of the message is everything after what was printed on the first line.
-                remainder_start = first_line_area  # Adjusted to not account for ellipsis
+                remainder_start = first_line_area
                 second_line_msg = plain_message[remainder_start:]
                 if len(second_line_msg) > second_line_area:
-                    second_line_msg = second_line_msg[:second_line_area]  # Simply cut off without ellipsis
+                    second_line_msg = second_line_msg[:second_line_area]  # Cut off without ellipsis
                 padded_second_line_msg = second_line_msg.ljust(second_line_area)
                 self.console.print(first_prefix_markup + first_line_msg, markup=True, highlight=False)
                 self.console.print(
@@ -211,7 +201,7 @@ def setup_logging() -> None:
                     highlighter=None,
                 ),
                 "format": "{message}",
-                "level": "DEBUG" if Config.DEV else "INFO",
+                "level": "DEBUG",
             },
         ],
     )