refactor: rename command attributes for clarity and consistency

Author: HitaloM

src/korone/filters/command.py

@@ -153,15 +153,22 @@ class Command(Filter):
     prefixes, case sensitivity, and mention requirements.
 
     Attributes:
-        commands: Compiled patterns of allowed commands
-        prefixes: Command prefixes to recognize
+        command_patterns: Compiled patterns of allowed commands
+        command_prefixes: Command prefixes to recognize
         ignore_case: Whether to ignore case when matching commands
         ignore_mention: Whether to ignore bot mentions after commands
         magic: Optional magic filter to further restrict command matches
         disableable: Whether this command can be disabled in specific chats
     """
 
-    __slots__ = ("commands", "disableable", "ignore_case", "ignore_mention", "magic", "prefixes")
+    __slots__ = (
+        "command_patterns",
+        "command_prefixes",
+        "disableable",
+        "ignore_case",
+        "ignore_mention",
+        "magic",
+    )
 
     def __init__(
         self,
@@ -187,14 +194,14 @@ def __init__(
         Raises:
             ValueError: If no command patterns are provided
         """
-        self.prefixes = prefixes
+        self.command_prefixes = prefixes
         self.ignore_case = ignore_case
         self.ignore_mention = ignore_mention
         self.magic = magic
         self.disableable = disableable
-        self.commands = tuple(self._prepare_commands(values, commands))
+        self.command_patterns = tuple(self._prepare_commands(values, commands))
 
-        if not self.commands:
+        if not self.command_patterns:
             msg = "Command filter requires at least one command."
             raise ValueError(msg)
 
@@ -272,7 +279,11 @@ def validate_prefix(self, command: CommandObject) -> None:
             CommandError: If the prefix is not among the allowed prefixes
         """
         prefix = command.prefix.lower() if self.ignore_case and command.prefix else command.prefix
-        valid_prefixes = [p.lower() for p in self.prefixes] if self.ignore_case else self.prefixes
+        valid_prefixes = (
+            [p.lower() for p in self.command_prefixes]
+            if self.ignore_case
+            else self.command_prefixes
+        )
         if prefix not in valid_prefixes:
             msg = f"Invalid prefix: {command.prefix!r}."
             raise CommandError(msg)
@@ -306,7 +317,7 @@ def validate_command(self, command: CommandObject) -> CommandObject:
             CommandError: If the command doesn't match any allowed pattern
         """
         cmd_name = command.command.lower() if self.ignore_case else command.command
-        for allowed_cmd in self.commands:
+        for allowed_cmd in self.command_patterns:
             match = allowed_cmd.match(cmd_name)
             if match:
                 return replace(command, regexp_match=match)

src/korone/modules/core.py

@@ -82,7 +82,7 @@ async def fetch_command_state(command: str) -> Documents | None:
         return result
 
 
-def extract_commands(filters: Filter) -> list[str] | None:
+def extract_commands(filters: Filter) -> list[str | None] | None:
     """
     Extracts command patterns from filter objects.
 
@@ -92,17 +92,20 @@ def extract_commands(filters: Filter) -> list[str] | None:
     Returns:
         A list of command patterns or None if no commands found.
     """
+    # Import here to avoid circular import
+    from korone.filters import Command, Regex  # noqa: PLC0415
+
     try:
-        if hasattr(filters, "commands"):
-            return [cmd.pattern for cmd in filters.commands if filters.disableable]  # type: ignore
-        if hasattr(filters, "friendly_name"):
-            return [filters.friendly_name]  # type: ignore
+        if isinstance(filters, Command) and filters.disableable:
+            return [cmd.pattern for cmd in filters.command_patterns]
+        if isinstance(filters, Regex):
+            return [filters.friendly_name]
     except AttributeError:
         pass
     return None
 
 
-async def update_command_structure(commands: list[str]) -> None:
+async def update_command_structure(commands: list[str | None]) -> None:
     """
     Updates the command structure with parent-child relationships and chat states.
 

src/korone/modules/errors/utils.py

@@ -25,7 +25,7 @@
 )
 
 ERROR_NOTIFICATION_TTL: Final[float] = 300.0
-_error_notification_state: dict[str, float] = {}
+_ERROR_NOTIFICATION_STATE: dict[str, float] = {}
 
 
 def compute_error_signature(exc: BaseException) -> str:
@@ -37,18 +37,18 @@ def compute_error_signature(exc: BaseException) -> str:
 def should_notify(signature: str, *, ttl: float = ERROR_NOTIFICATION_TTL) -> bool:
     now = time.monotonic()
 
-    expiry = _error_notification_state.get(signature)
+    expiry = _ERROR_NOTIFICATION_STATE.get(signature)
     if expiry and expiry > now:
         return False
 
-    _error_notification_state[signature] = now + ttl
+    _ERROR_NOTIFICATION_STATE[signature] = now + ttl
     _purge_expired_notifications(now)
     return True
 
 
 def _purge_expired_notifications(now: float) -> None:
     expired_signatures = [
-        key for key, expiry in _error_notification_state.items() if expiry <= now
+        key for key, expiry in _ERROR_NOTIFICATION_STATE.items() if expiry <= now
     ]
     for signature in expired_signatures:
-        _error_notification_state.pop(signature, None)
+        _ERROR_NOTIFICATION_STATE.pop(signature, None)

src/korone/utils/concurrency.py

@@ -3,24 +3,27 @@
 
 from __future__ import annotations
 
-import typing as t
 from functools import partial
 from os import cpu_count
+from typing import TYPE_CHECKING, Any, Final
 
 from anyio import CapacityLimiter, to_thread
 
-_DEFAULT_THREAD_TOKENS: t.Final[int] = max(16, min(64, (cpu_count() or 1) * 5))
-BLOCKING_CALLS_LIMITER: t.Final[CapacityLimiter] = CapacityLimiter(_DEFAULT_THREAD_TOKENS)
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+_DEFAULT_THREAD_TOKENS: Final[int] = max(16, min(64, (cpu_count() or 1) * 5))
+BLOCKING_CALLS_LIMITER: Final[CapacityLimiter] = CapacityLimiter(_DEFAULT_THREAD_TOKENS)
 
 
 async def run_blocking[R](
-    func: t.Callable[..., R],
+    func: Callable[..., R],
     /,
-    *args: t.Any,
+    *args: Any,
     limiter: CapacityLimiter | None = None,
     cancellable: bool = False,
     abandon_on_cancel: bool = False,
-    **kwargs: t.Any,
+    **kwargs: Any,
 ) -> R:
     """Run a blocking callable in a worker thread.