disagreement 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

disagreement/ext/commands/cog.py

@@ -0,0 +1,155 @@
+# disagreement/ext/commands/cog.py
+
+import inspect
+from typing import TYPE_CHECKING, List, Tuple, Callable, Awaitable, Any, Dict, Union
+
+if TYPE_CHECKING:
+    from disagreement.client import Client
+    from .core import Command
+    from disagreement.ext.app_commands.commands import (
+        AppCommand,
+        AppCommandGroup,
+    )  # Added
+else:  # pragma: no cover - runtime imports for isinstance checks
+    from disagreement.ext.app_commands.commands import AppCommand, AppCommandGroup
+
+    # EventDispatcher might be needed if cogs register listeners directly
+    # from disagreement.event_dispatcher import EventDispatcher
+
+
+class Cog:
+    """
+    The base class for cogs, which are collections of commands and listeners.
+    """
+
+    def __init__(self, client: "Client"):
+        self._client: "Client" = client
+        self._cog_name: str = self.__class__.__name__
+        self._commands: Dict[str, "Command"] = {}
+        self._listeners: List[Tuple[str, Callable[..., Awaitable[None]]]] = []
+        self._app_commands_and_groups: List[Union["AppCommand", "AppCommandGroup"]] = (
+            []
+        )  # Added
+
+        # Discover commands and listeners defined in this cog instance
+        self._inject()
+
+    @property
+    def client(self) -> "Client":
+        return self._client
+
+    @property
+    def cog_name(self) -> str:
+        return self._cog_name
+
+    def _inject(self) -> None:
+        """
+        Called to discover and prepare commands and listeners within this cog.
+        This is typically called by the CommandHandler when adding the cog.
+        """
+        # Clear any previously injected state (e.g., if re-injecting)
+        self._commands.clear()
+        self._listeners.clear()
+        self._app_commands_and_groups.clear()  # Added
+
+        for member_name, member in inspect.getmembers(self):
+            if hasattr(member, "__command_object__"):
+                # This is a prefix or hybrid command object
+                cmd: "Command" = getattr(member, "__command_object__")
+                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."
+                    )
+                self._commands[cmd.name.lower()] = cmd
+                # Also register aliases
+                for alias in cmd.aliases:
+                    self._commands[alias.lower()] = cmd
+
+                # If this command is also an application command (HybridCommand)
+                if isinstance(cmd, (AppCommand, AppCommandGroup)):
+                    self._app_commands_and_groups.append(cmd)
+
+            elif hasattr(member, "__app_command_object__"):  # Added for app commands
+                app_cmd_obj = getattr(member, "__app_command_object__")
+                if isinstance(app_cmd_obj, (AppCommand, AppCommandGroup)):
+                    if isinstance(app_cmd_obj, AppCommand):
+                        app_cmd_obj.cog = self  # Associate 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."
+                    )
+
+            elif isinstance(member, (AppCommand, AppCommandGroup)):
+                if isinstance(member, AppCommand):
+                    member.cog = self
+                self._app_commands_and_groups.append(member)
+
+            elif hasattr(member, "__listener_name__"):
+                # 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."
+                    )
+                    continue
+
+                event_name: str = getattr(member, "__listener_name__")
+                # The callback needs to be the bound method from this cog instance
+                self._listeners.append((event_name, member))
+
+    def _eject(self) -> None:
+        """
+        Called when the cog is being removed.
+        The CommandHandler will handle unregistering commands/listeners.
+        This method is for any cog-specific cleanup before that.
+        """
+        # For now, just clear local collections. Actual unregistration is external.
+        self._commands.clear()
+        self._listeners.clear()
+        self._app_commands_and_groups.clear()  # Added
+
+    def get_commands(self) -> List["Command"]:
+        """Returns a list of commands in this cog."""
+        # Avoid duplicates if aliases point to the same command object
+        return list(dict.fromkeys(self._commands.values()))
+
+    def get_listeners(self) -> List[Tuple[str, Callable[..., Awaitable[None]]]]:
+        """Returns a list of (event_name, callback) tuples for listeners in this cog."""
+        return self._listeners
+
+    def get_app_commands_and_groups(
+        self,
+    ) -> List[Union["AppCommand", "AppCommandGroup"]]:
+        """Returns a list of application commands and groups in this cog."""
+        return self._app_commands_and_groups
+
+    async def cog_load(self) -> None:
+        """
+        A special method that is called when the cog is loaded.
+        This is a good place for any asynchronous setup.
+        Subclasses should override this if they need async setup.
+        """
+        pass
+
+    async def cog_unload(self) -> None:
+        """
+        A special method that is called when the cog is unloaded.
+        This is a good place for any asynchronous cleanup.
+        Subclasses should override this if they need async cleanup.
+        """
+        pass
+
+    # Example of how a listener might be defined within a Cog using the decorator
+    # from .decorators import listener # Would be imported at module level
+    #
+    # @listener(name="ON_MESSAGE_CREATE_CUSTOM") # Explicit name
+    # async def on_my_event(self, message: 'Message'):
+    #     print(f"Cog '{self.cog_name}' received event with message: {message.content}")
+    #
+    # @listener() # Name derived from method: on_ready
+    # async def on_ready(self):
+    #     print(f"Cog '{self.cog_name}' is ready.")

disagreement/ext/commands/converters.py

@@ -0,0 +1,175 @@
+# disagreement/ext/commands/converters.py
+
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, TypeVar, Generic
+from abc import ABC, abstractmethod
+import re
+
+from .errors import BadArgument
+from disagreement.models import Member, Guild, Role
+
+if TYPE_CHECKING:
+    from .core import CommandContext
+
+T = TypeVar("T")
+
+
+class Converter(ABC, Generic[T]):
+    """
+    Base class for custom command argument converters.
+    Subclasses must implement the `convert` method.
+    """
+
+    async def convert(self, ctx: "CommandContext", argument: str) -> T:
+        """
+        Converts the argument to the desired type.
+
+        Args:
+            ctx: The invocation context.
+            argument: The string argument to convert.
+
+        Returns:
+            The converted argument.
+
+        Raises:
+            BadArgument: If the conversion fails.
+        """
+        raise NotImplementedError("Converter subclass must implement convert method.")
+
+
+# --- Built-in Type Converters ---
+
+
+class IntConverter(Converter[int]):
+    async def convert(self, ctx: "CommandContext", argument: str) -> int:
+        try:
+            return int(argument)
+        except ValueError:
+            raise BadArgument(f"'{argument}' is not a valid integer.")
+
+
+class FloatConverter(Converter[float]):
+    async def convert(self, ctx: "CommandContext", argument: str) -> float:
+        try:
+            return float(argument)
+        except ValueError:
+            raise BadArgument(f"'{argument}' is not a valid number.")
+
+
+class BoolConverter(Converter[bool]):
+    async def convert(self, ctx: "CommandContext", argument: str) -> bool:
+        lowered = argument.lower()
+        if lowered in ("yes", "y", "true", "t", "1", "on", "enable", "enabled"):
+            return True
+        elif lowered in ("no", "n", "false", "f", "0", "off", "disable", "disabled"):
+            return False
+        raise BadArgument(f"'{argument}' is not a valid boolean-like value.")
+
+
+class StringConverter(Converter[str]):
+    async def convert(self, ctx: "CommandContext", argument: str) -> str:
+        # For basic string, no conversion is needed, but this provides a consistent interface
+        return argument
+
+
+# --- Discord Model Converters ---
+
+
+class MemberConverter(Converter["Member"]):
+    async def convert(self, ctx: "CommandContext", argument: str) -> "Member":
+        if not ctx.message.guild_id:
+            raise BadArgument("Member converter requires guild context.")
+
+        match = re.match(r"<@!?(\d+)>$", argument)
+        member_id = match.group(1) if match else argument
+
+        guild = ctx.bot.get_guild(ctx.message.guild_id)
+        if guild:
+            member = guild.get_member(member_id)
+            if member:
+                return member
+
+        member = await ctx.bot.fetch_member(ctx.message.guild_id, member_id)
+        if member:
+            return member
+        raise BadArgument(f"Member '{argument}' not found.")
+
+
+class RoleConverter(Converter["Role"]):
+    async def convert(self, ctx: "CommandContext", argument: str) -> "Role":
+        if not ctx.message.guild_id:
+            raise BadArgument("Role converter requires guild context.")
+
+        match = re.match(r"<@&(?P<id>\d+)>$", argument)
+        role_id = match.group("id") if match else argument
+
+        guild = ctx.bot.get_guild(ctx.message.guild_id)
+        if guild:
+            role = guild.get_role(role_id)
+            if role:
+                return role
+
+        role = await ctx.bot.fetch_role(ctx.message.guild_id, role_id)
+        if role:
+            return role
+        raise BadArgument(f"Role '{argument}' not found.")
+
+
+class GuildConverter(Converter["Guild"]):
+    async def convert(self, ctx: "CommandContext", argument: str) -> "Guild":
+        guild_id = argument.strip("<>")  # allow <id> style
+
+        guild = ctx.bot.get_guild(guild_id)
+        if guild:
+            return guild
+
+        guild = await ctx.bot.fetch_guild(guild_id)
+        if guild:
+            return guild
+        raise BadArgument(f"Guild '{argument}' not found.")
+
+
+# Default converters mapping
+DEFAULT_CONVERTERS: dict[type, Converter[Any]] = {
+    int: IntConverter(),
+    float: FloatConverter(),
+    bool: BoolConverter(),
+    str: StringConverter(),
+    Member: MemberConverter(),
+    Guild: GuildConverter(),
+    Role: RoleConverter(),
+    # User: UserConverter(), # Add when User model and converter are ready
+}
+
+
+async def run_converters(ctx: "CommandContext", annotation: Any, argument: str) -> Any:
+    """
+    Attempts to run a converter for the given annotation and argument.
+    """
+    converter = DEFAULT_CONVERTERS.get(annotation)
+    if converter:
+        return await converter.convert(ctx, argument)
+
+    # If no direct converter, check if annotation itself is a Converter subclass
+    if inspect.isclass(annotation) and issubclass(annotation, Converter):
+        try:
+            instance = annotation()  # type: ignore
+            return await instance.convert(ctx, argument)
+        except Exception as e:  # Catch instantiation errors or other issues
+            raise BadArgument(
+                f"Failed to use custom converter {annotation.__name__}: {e}"
+            )
+
+    # If it's a custom class that's not a Converter, we can't handle it by default
+    # Or if it's a complex type hint like Union, Optional, Literal etc.
+    # This part needs more advanced logic for those.
+
+    # For now, if no specific converter, and it's not 'str', raise error or return as str?
+    # Let's be strict for now if an annotation is given but no converter found.
+    if annotation is not str and annotation is not inspect.Parameter.empty:
+        raise BadArgument(f"No converter found for type annotation '{annotation}'.")
+
+    return argument  # Default to string if no annotation or annotation is str
+
+
+# Need to import inspect for the run_converters function
+import inspect