disagreement 0.1.0rc2__py3-none-any.whl → 0.2.0rc1__py3-none-any.whl

disagreement/ext/app_commands/handler.py

@@ -1,6 +1,9 @@
 # disagreement/ext/app_commands/handler.py
 
 import inspect
+import json
+import logging
+import os
 from typing import (
     TYPE_CHECKING,
     Dict,
@@ -64,6 +67,11 @@ if not TYPE_CHECKING:
     Message = Any
 
 
+logger = logging.getLogger(__name__)
+
+COMMANDS_CACHE_FILE = ".disagreement_commands.json"
+
+
 class AppCommandHandler:
     """
     Manages application command registration, parsing, and dispatching.
@@ -80,6 +88,33 @@ class AppCommandHandler:
         self._app_command_groups: Dict[str, AppCommandGroup] = {}
         self._converter_registry: Dict[type, type] = {}
 
+    def _load_cached_ids(self) -> Dict[str, Dict[str, str]]:
+        try:
+            with open(COMMANDS_CACHE_FILE, "r", encoding="utf-8") as fp:
+                return json.load(fp)
+        except FileNotFoundError:
+            return {}
+        except json.JSONDecodeError:
+            logger.warning("Invalid command cache file. Ignoring.")
+            return {}
+
+    def _save_cached_ids(self, data: Dict[str, Dict[str, str]]) -> None:
+        try:
+            with open(COMMANDS_CACHE_FILE, "w", encoding="utf-8") as fp:
+                json.dump(data, fp, indent=2)
+        except Exception as e:  # pragma: no cover - logging only
+            logger.error("Failed to write command cache: %s", e)
+
+    def clear_stored_registrations(self) -> None:
+        """Remove persisted command registration data."""
+        if os.path.exists(COMMANDS_CACHE_FILE):
+            os.remove(COMMANDS_CACHE_FILE)
+
+    def migrate_stored_registrations(self, new_path: str) -> None:
+        """Move stored registrations to ``new_path``."""
+        if os.path.exists(COMMANDS_CACHE_FILE):
+            os.replace(COMMANDS_CACHE_FILE, new_path)
+
     def add_command(self, command: Union["AppCommand", "AppCommandGroup"]) -> None:
         """Adds an application command or a command group to the handler."""
         if isinstance(command, AppCommandGroup):
@@ -544,7 +579,7 @@ class AppCommandHandler:
                 await command.invoke(ctx, *parsed_args, **parsed_kwargs)
 
         except Exception as e:
-            print(f"Error invoking app command '{command.name}': {e}")
+            logger.error("Error invoking app command '%s': %s", command.name, e)
             await self.dispatch_app_command_error(ctx, e)
             # else:
             #     # Default error reply if no handler on client
@@ -560,11 +595,13 @@ class AppCommandHandler:
         Synchronizes (registers/updates) all application commands with Discord.
         If guild_id is provided, syncs commands for that guild. Otherwise, syncs global commands.
         """
-        commands_to_sync: List[Dict[str, Any]] = []
+        cache = self._load_cached_ids()
+        scope_key = str(guild_id) if guild_id else "global"
+        stored = cache.get(scope_key, {})
 
-        # Collect commands based on scope (global or specific guild)
-        # This needs to be more sophisticated to handle guild_ids on commands/groups
+        current_payloads: Dict[str, Dict[str, Any]] = {}
 
+        # Collect commands based on scope (global or specific guild)
         source_commands = (
             list(self._slash_commands.values())
             + list(self._user_commands.values())
@@ -573,55 +610,102 @@ class AppCommandHandler:
         )
 
         for cmd_or_group in source_commands:
-            # Determine if this command/group should be synced for the current scope
             is_guild_specific_command = (
                 cmd_or_group.guild_ids is not None and len(cmd_or_group.guild_ids) > 0
             )
 
-            if guild_id:  # Syncing for a specific guild
-                # Skip if not a guild-specific command OR if it's for a different guild
+            if guild_id:
                 if not is_guild_specific_command or (
                     cmd_or_group.guild_ids is not None
                     and guild_id not in cmd_or_group.guild_ids
                 ):
                     continue
-            else:  # Syncing global commands
+            else:
                 if is_guild_specific_command:
-                    continue  # Skip guild-specific commands when syncing global
+                    continue
 
-            # Use the to_dict() method from AppCommand or AppCommandGroup
             try:
-                payload = cmd_or_group.to_dict()
-                commands_to_sync.append(payload)
+                current_payloads[cmd_or_group.name] = cmd_or_group.to_dict()
             except AttributeError:
-                print(
-                    f"Warning: Command or group '{cmd_or_group.name}' does not have a to_dict() method. Skipping."
+                logger.warning(
+                    "Command or group '%s' does not have a to_dict() method. Skipping.",
+                    cmd_or_group.name,
                 )
             except Exception as e:
-                print(
-                    f"Error converting command/group '{cmd_or_group.name}' to dict: {e}. Skipping."
+                logger.error(
+                    "Error converting command/group '%s' to dict: %s. Skipping.",
+                    cmd_or_group.name,
+                    e,
                 )
 
-        if not commands_to_sync:
-            print(
-                f"No commands to sync for {'guild ' + str(guild_id) if guild_id else 'global'} scope."
+        if not current_payloads:
+            logger.info(
+                "No commands to sync for %s scope.",
+                f"guild {guild_id}" if guild_id else "global",
+            )
+            return
+
+        names_current = set(current_payloads)
+        names_stored = set(stored)
+
+        to_delete = names_stored - names_current
+        to_create = names_current - names_stored
+        to_update = names_current & names_stored
+
+        if not to_delete and not to_create and not to_update:
+            logger.info(
+                "Application commands already up to date for %s scope.", scope_key
             )
             return
 
         try:
-            if guild_id:
-                print(
-                    f"Syncing {len(commands_to_sync)} commands for guild {guild_id}..."
-                )
-                await self.client._http.bulk_overwrite_guild_application_commands(
-                    application_id, guild_id, commands_to_sync
-                )
-            else:
-                print(f"Syncing {len(commands_to_sync)} global commands...")
-                await self.client._http.bulk_overwrite_global_application_commands(
-                    application_id, commands_to_sync
-                )
-            print("Command sync successful.")
+            for name in to_delete:
+                cmd_id = stored[name]
+                if guild_id:
+                    await self.client._http.delete_guild_application_command(
+                        application_id, guild_id, cmd_id
+                    )
+                else:
+                    await self.client._http.delete_global_application_command(
+                        application_id, cmd_id
+                    )
+
+            new_ids: Dict[str, str] = {}
+            for name in to_create:
+                payload = current_payloads[name]
+                if guild_id:
+                    result = await self.client._http.create_guild_application_command(
+                        application_id, guild_id, payload
+                    )
+                else:
+                    result = await self.client._http.create_global_application_command(
+                        application_id, payload
+                    )
+                if result.id:
+                    new_ids[name] = str(result.id)
+
+            for name in to_update:
+                payload = current_payloads[name]
+                cmd_id = stored[name]
+                if guild_id:
+                    await self.client._http.edit_guild_application_command(
+                        application_id, guild_id, cmd_id, payload
+                    )
+                else:
+                    await self.client._http.edit_global_application_command(
+                        application_id, cmd_id, payload
+                    )
+                new_ids[name] = cmd_id
+
+            final_ids: Dict[str, str] = {}
+            for name in names_current:
+                if name in new_ids:
+                    final_ids[name] = new_ids[name]
+                else:
+                    final_ids[name] = stored[name]
+
+            cache[scope_key] = final_ids
+            self._save_cached_ids(cache)
+            logger.info("Command sync successful.")
         except Exception as e:
-            print(f"Error syncing application commands: {e}")
-            # Consider re-raising or specific error handling
+            logger.error("Error syncing application commands: %s", e)

disagreement/ext/app_commands/hybrid.py

@@ -58,4 +58,4 @@ class HybridCommand(SlashCommand, PrefixCommand):  # Inherit from both
     # The correct one will be called depending on how the command is dispatched.
     # The AppCommandHandler will use AppCommand.invoke (via SlashCommand).
     # The prefix CommandHandler will use PrefixCommand.invoke.
-    # This seems acceptable.
+    # This seems acceptable.

disagreement/ext/commands/__init__.py

@@ -16,6 +16,7 @@ from .decorators import (
     check,
     check_any,
     cooldown,
+    max_concurrency,
     requires_permissions,
 )
 from .errors import (
@@ -28,6 +29,7 @@ from .errors import (
     CheckAnyFailure,
     CommandOnCooldown,
     CommandInvokeError,
+    MaxConcurrencyReached,
 )
 
 __all__ = [
@@ -43,6 +45,7 @@ __all__ = [
     "check",
     "check_any",
     "cooldown",
+    "max_concurrency",
     "requires_permissions",
     # Errors
     "CommandError",
@@ -54,4 +57,5 @@ __all__ = [
     "CheckAnyFailure",
     "CommandOnCooldown",
     "CommandInvokeError",
+    "MaxConcurrencyReached",
 ]

disagreement/ext/commands/cog.py

@@ -1,6 +1,7 @@
 # disagreement/ext/commands/cog.py
 
 import inspect
+import logging
 from typing import TYPE_CHECKING, List, Tuple, Callable, Awaitable, Any, Dict, Union
 
 if TYPE_CHECKING:
@@ -16,6 +17,8 @@ else:  # pragma: no cover - runtime imports for isinstance checks
     # EventDispatcher might be needed if cogs register listeners directly
     # from disagreement.event_dispatcher import EventDispatcher
 
+logger = logging.getLogger(__name__)
+
 
 class Cog:
     """
@@ -59,8 +62,10 @@ class Cog:
                 cmd.cog = self  # Assign the cog instance to the command
                 if cmd.name in self._commands:
                     # This should ideally be caught earlier or handled by CommandHandler
-                    print(
-                        f"Warning: Duplicate command name '{cmd.name}' in cog '{self.cog_name}'. Overwriting."
+                    logger.warning(
+                        "Duplicate command name '%s' in cog '%s'. Overwriting.",
+                        cmd.name,
+                        self.cog_name,
                     )
                 self._commands[cmd.name.lower()] = cmd
                 # Also register aliases
@@ -79,8 +84,10 @@ class Cog:
                     # For AppCommandGroup, its commands will have cog set individually if they are AppCommands
                     self._app_commands_and_groups.append(app_cmd_obj)
                 else:
-                    print(
-                        f"Warning: Member '{member_name}' in cog '{self.cog_name}' has '__app_command_object__' but it's not an AppCommand or AppCommandGroup."
+                    logger.warning(
+                        "Member '%s' in cog '%s' has '__app_command_object__' but it's not an AppCommand or AppCommandGroup.",
+                        member_name,
+                        self.cog_name,
                     )
 
             elif isinstance(member, (AppCommand, AppCommandGroup)):
@@ -92,8 +99,10 @@ class Cog:
                 # This is a method decorated with @commands.Cog.listener or @commands.listener
                 if not inspect.iscoroutinefunction(member):
                     # Decorator should have caught this, but double check
-                    print(
-                        f"Warning: Listener '{member_name}' in cog '{self.cog_name}' is not a coroutine. Skipping."
+                    logger.warning(
+                        "Listener '%s' in cog '%s' is not a coroutine. Skipping.",
+                        member_name,
+                        self.cog_name,
                     )
                     continue
 

disagreement/ext/commands/core.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 import inspect
 from typing import (
     TYPE_CHECKING,
@@ -31,6 +32,8 @@ from .errors import (
 from .converters import run_converters, DEFAULT_CONVERTERS, Converter
 from disagreement.typing import Typing
 
+logger = logging.getLogger(__name__)
+
 if TYPE_CHECKING:
     from .cog import Cog
     from disagreement.client import Client
@@ -67,6 +70,10 @@ class Command:
         if hasattr(callback, "__command_checks__"):
             self.checks.extend(getattr(callback, "__command_checks__"))
 
+        self.max_concurrency: Optional[Tuple[int, str]] = None
+        if hasattr(callback, "__max_concurrency__"):
+            self.max_concurrency = getattr(callback, "__max_concurrency__")
+
     def add_check(
         self, predicate: Callable[["CommandContext"], Awaitable[bool] | bool]
     ) -> None:
@@ -212,6 +219,7 @@ class CommandHandler:
         ] = prefix
         self.commands: Dict[str, Command] = {}
         self.cogs: Dict[str, "Cog"] = {}
+        self._concurrency: Dict[str, Dict[str, int]] = {}
 
         from .help import HelpCommand
 
@@ -224,8 +232,10 @@ class CommandHandler:
         self.commands[command.name.lower()] = command
         for alias in command.aliases:
             if alias in self.commands:
-                print(
-                    f"Warning: Alias '{alias}' for command '{command.name}' conflicts with an existing command or alias."
+                logger.warning(
+                    "Alias '%s' for command '%s' conflicts with an existing command or alias.",
+                    alias,
+                    command.name,
                 )
             self.commands[alias.lower()] = command
 
@@ -241,6 +251,7 @@ class CommandHandler:
 
     def add_cog(self, cog_to_add: "Cog") -> None:
         from .cog import Cog
+
         if not isinstance(cog_to_add, Cog):
             raise TypeError("Argument must be a subclass of Cog.")
 
@@ -258,8 +269,9 @@ class CommandHandler:
             for event_name, callback in cog_to_add.get_listeners():
                 self.client._event_dispatcher.register(event_name.upper(), callback)
         else:
-            print(
-                f"Warning: Client does not have '_event_dispatcher'. Listeners for cog '{cog_to_add.cog_name}' not registered."
+            logger.warning(
+                "Client does not have '_event_dispatcher'. Listeners for cog '%s' not registered.",
+                cog_to_add.cog_name,
             )
 
         if hasattr(cog_to_add, "cog_load") and inspect.iscoroutinefunction(
@@ -267,7 +279,7 @@ class CommandHandler:
         ):
             asyncio.create_task(cog_to_add.cog_load())
 
-        print(f"Cog '{cog_to_add.cog_name}' added.")
+        logger.info("Cog '%s' added.", cog_to_add.cog_name)
 
     def remove_cog(self, cog_name: str) -> Optional["Cog"]:
         cog_to_remove = self.cogs.pop(cog_name, None)
@@ -277,8 +289,11 @@ class CommandHandler:
 
             if hasattr(self.client, "_event_dispatcher"):
                 for event_name, callback in cog_to_remove.get_listeners():
-                    print(
-                        f"Note: Listener '{callback.__name__}' for event '{event_name}' from cog '{cog_name}' needs manual unregistration logic in EventDispatcher."
+                    logger.debug(
+                        "Listener '%s' for event '%s' from cog '%s' needs manual unregistration logic in EventDispatcher.",
+                        callback.__name__,
+                        event_name,
+                        cog_name,
                     )
 
             if hasattr(cog_to_remove, "cog_unload") and inspect.iscoroutinefunction(
@@ -287,9 +302,50 @@ class CommandHandler:
                 asyncio.create_task(cog_to_remove.cog_unload())
 
             cog_to_remove._eject()
-            print(f"Cog '{cog_name}' removed.")
+            logger.info("Cog '%s' removed.", cog_name)
         return cog_to_remove
 
+    def _acquire_concurrency(self, ctx: CommandContext) -> None:
+        mc = getattr(ctx.command, "max_concurrency", None)
+        if not mc:
+            return
+        limit, scope = mc
+        if scope == "user":
+            key = ctx.author.id
+        elif scope == "guild":
+            key = ctx.message.guild_id or ctx.author.id
+        else:
+            key = "global"
+        buckets = self._concurrency.setdefault(ctx.command.name, {})
+        current = buckets.get(key, 0)
+        if current >= limit:
+            from .errors import MaxConcurrencyReached
+
+            raise MaxConcurrencyReached(limit)
+        buckets[key] = current + 1
+
+    def _release_concurrency(self, ctx: CommandContext) -> None:
+        mc = getattr(ctx.command, "max_concurrency", None)
+        if not mc:
+            return
+        _, scope = mc
+        if scope == "user":
+            key = ctx.author.id
+        elif scope == "guild":
+            key = ctx.message.guild_id or ctx.author.id
+        else:
+            key = "global"
+        buckets = self._concurrency.get(ctx.command.name)
+        if not buckets:
+            return
+        current = buckets.get(key, 0)
+        if current <= 1:
+            buckets.pop(key, None)
+        else:
+            buckets[key] = current - 1
+        if not buckets:
+            self._concurrency.pop(ctx.command.name, None)
+
     async def get_prefix(self, message: "Message") -> Union[str, List[str], None]:
         if callable(self.prefix):
             if inspect.iscoroutinefunction(self.prefix):
@@ -491,13 +547,17 @@ class CommandHandler:
             parsed_args, parsed_kwargs = await self._parse_arguments(command, ctx, view)
             ctx.args = parsed_args
             ctx.kwargs = parsed_kwargs
-            await command.invoke(ctx, *parsed_args, **parsed_kwargs)
+            self._acquire_concurrency(ctx)
+            try:
+                await command.invoke(ctx, *parsed_args, **parsed_kwargs)
+            finally:
+                self._release_concurrency(ctx)
         except CommandError as e:
-            print(f"Command error for '{command.name}': {e}")
+            logger.error("Command error for '%s': %s", command.name, e)
             if hasattr(self.client, "on_command_error"):
                 await self.client.on_command_error(ctx, e)
         except Exception as e:
-            print(f"Unexpected error invoking command '{command.name}': {e}")
+            logger.error("Unexpected error invoking command '%s': %s", command.name, e)
             exc = CommandInvokeError(e)
             if hasattr(self.client, "on_command_error"):
                 await self.client.on_command_error(ctx, exc)

disagreement/ext/commands/decorators.py

@@ -107,6 +107,33 @@ def check_any(
     return check(predicate)
 
 
+def max_concurrency(
+    number: int, per: str = "user"
+) -> Callable[[Callable[..., Awaitable[None]]], Callable[..., Awaitable[None]]]:
+    """Limit how many concurrent invocations of a command are allowed.
+
+    Parameters
+    ----------
+    number:
+        The maximum number of concurrent invocations.
+    per:
+        The scope of the limiter. Can be ``"user"``, ``"guild"`` or ``"global"``.
+    """
+
+    if number < 1:
+        raise ValueError("Concurrency number must be at least 1.")
+    if per not in {"user", "guild", "global"}:
+        raise ValueError("per must be 'user', 'guild', or 'global'.")
+
+    def decorator(
+        func: Callable[..., Awaitable[None]],
+    ) -> Callable[..., Awaitable[None]]:
+        setattr(func, "__max_concurrency__", (number, per))
+        return func
+
+    return decorator
+
+
 def cooldown(
     rate: int, per: float
 ) -> Callable[[Callable[..., Awaitable[None]]], Callable[..., Awaitable[None]]]:

disagreement/ext/commands/errors.py

@@ -72,5 +72,13 @@ class CommandInvokeError(CommandError):
         super().__init__(f"Error during command invocation: {original}")
 
 
+class MaxConcurrencyReached(CommandError):
+    """Raised when a command exceeds its concurrency limit."""
+
+    def __init__(self, limit: int):
+        self.limit = limit
+        super().__init__(f"Max concurrency of {limit} reached")
+
+
 # Add more specific errors as needed, e.g., UserNotFound, ChannelNotFound, etc.
 # These might inherit from BadArgument.