easterobot 1.0.0__py3-none-any.whl

easterobot/cli.py

@@ -0,0 +1,127 @@
+"""Module for command line interface."""
+
+import argparse
+import logging
+import sys
+from collections.abc import Sequence
+from typing import NoReturn, Optional
+
+from .bot import DEFAULT_CONFIG_PATH, Easterobot
+from .info import __issues__, __summary__, __version__
+
+LOG_LEVELS = ["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"]
+logger = logging.getLogger(__name__)
+
+
+class HelpArgumentParser(argparse.ArgumentParser):
+    def error(self, message: str) -> NoReturn:  # pragma: no cover
+        """Handle error from argparse.ArgumentParser."""
+        self.print_help(sys.stderr)
+        self.exit(2, f"{self.prog}: error: {message}\n")
+
+
+def get_parser() -> argparse.ArgumentParser:
+    """Prepare ArgumentParser."""
+    parser = HelpArgumentParser(
+        prog="easterobot",
+        description=__summary__,
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s, version {__version__}",
+    )
+
+    # Add subparsers
+    subparsers = parser.add_subparsers(
+        help="desired action to perform",
+        dest="action",
+        required=True,
+    )
+
+    # Add parent parser with common arguments
+    parent_parser = HelpArgumentParser(add_help=False)
+    parent_parser.add_argument(
+        "-v",
+        "--verbose",
+        help="verbose mode, enable DEBUG messages.",
+        action="store_true",
+        required=False,
+    )
+    parent_parser.add_argument(
+        "-t",
+        "--token",
+        help="run using a token and the default configuration.",
+    )
+    parent_parser.add_argument(
+        "-e",
+        "--env",
+        help="load token from DISCORD_TOKEN environnement variable.",
+        action="store_true",
+    )
+
+    # Parser of hello command
+    run_parser = subparsers.add_parser(
+        "run",
+        parents=[parent_parser],
+        help="start the bot.",
+    )
+    run_parser.add_argument(
+        "-c",
+        "--config",
+        help=f"path to configuration, default to {DEFAULT_CONFIG_PATH}.",
+        default=DEFAULT_CONFIG_PATH,
+    )
+
+    # Parser of hello command
+    run_parser = subparsers.add_parser(
+        "generate",
+        parents=[parent_parser],
+        help="generate a configuration.",
+    )
+    run_parser.add_argument(
+        "-i",
+        "--interactive",
+        help="ask questions for create a ready to use config.",
+        action="store_true",
+    )
+    run_parser.add_argument("destination", default=".")
+    return parser
+
+
+def setup_logging(verbose: Optional[bool] = None) -> None:
+    """Do setup logging."""
+    # Setup logging
+    logging.basicConfig(
+        level=logging.DEBUG if verbose else logging.WARNING,
+        format="[%(asctime)s] [%(levelname)s] [%(name)s] %(message)s",
+    )
+
+
+def entrypoint(argv: Optional[Sequence[str]] = None) -> None:
+    """Entrypoint for command line interface."""
+    try:
+        parser = get_parser()
+        args = parser.parse_args(argv)
+        setup_logging(args.verbose)
+        if args.action == "run":
+            bot = Easterobot.from_config(
+                args.config,
+                token=args.token,
+                env=args.env,
+            )
+            bot.auto_run()
+        elif args.action == "generate":
+            Easterobot.generate(
+                destination=args.destination,
+                token=args.token,
+                env=args.env,
+                interactive=args.interactive,
+            )
+        else:
+            parser.error("No command specified")  # pragma: no cover
+    except Exception as err:  # NoQA: BLE001  # pragma: no cover
+        logger.critical("Unexpected error", exc_info=err)
+        logger.critical("Please, report this error to %s.", __issues__)
+        sys.exit(1)

easterobot/commands/__init__.py

@@ -0,0 +1,28 @@
+"""Init package."""
+
+from easterobot.bot import Easterobot
+from easterobot.commands.base import egg_command_group
+from easterobot.commands.basket import basket_command
+from easterobot.commands.disable import disable_command
+from easterobot.commands.edit import edit_command
+from easterobot.commands.enable import enable_command
+from easterobot.commands.help import help_command
+from easterobot.commands.reset import reset_command
+from easterobot.commands.search import search_command
+from easterobot.commands.top import top_command
+
+__all__ = [
+    "basket_command",
+    "disable_command",
+    "edit_command",
+    "egg_command_group",
+    "enable_command",
+    "help_command",
+    "reset_command",
+    "search_command",
+    "top_command",
+]
+
+
+async def setup(bot: Easterobot) -> None:
+    bot.tree.add_command(egg_command_group)

easterobot/commands/base.py

@@ -0,0 +1,171 @@
+"""Base module for command."""
+
+import asyncio
+import functools
+import logging
+from collections.abc import Coroutine
+from time import time
+from typing import Any, Callable, TypeVar, Union, cast
+
+import discord
+from discord import app_commands
+from sqlalchemy import and_, delete
+from sqlalchemy.ext.asyncio import AsyncSession
+from typing_extensions import Concatenate, ParamSpec
+
+from easterobot.bot import Easterobot
+from easterobot.models import Cooldown
+
+egg_command_group = app_commands.Group(
+    name="egg",
+    description="Commandes en lien avec Pâque",
+    guild_only=True,
+)
+logger = logging.getLogger(__name__)
+cooldown_lock = asyncio.Lock()
+
+
+class InterruptedCommandError(Exception):
+    pass
+
+
+InteractionChannel = Union[
+    discord.VoiceChannel,
+    discord.StageChannel,
+    discord.TextChannel,
+    discord.ForumChannel,
+    discord.CategoryChannel,
+    discord.Thread,
+    discord.DMChannel,
+    discord.GroupChannel,
+]
+
+
+class Context(discord.Interaction[Easterobot]):
+    user: discord.Member
+    command: "app_commands.Command[Any, ..., Any]"  # type: ignore[assignment]
+    channel: InteractionChannel
+    channel_id: int
+    guild: discord.Guild
+    guild_id: int
+
+
+P = ParamSpec("P")
+T = TypeVar("T")
+Interaction = discord.Interaction[Easterobot]
+Coro = Coroutine[Any, Any, T]
+
+
+def controlled_command(
+    *, cooldown: bool = True, **perms: bool
+) -> Callable[
+    [Callable[Concatenate[Context, P], Coro[None]]],
+    Callable[Concatenate[Interaction, P], Coro[None]],
+]:
+    """Add a cooldown and permission check."""
+
+    def decorator(
+        f: Callable[Concatenate[Context, P], Coro[None]],
+    ) -> Callable[Concatenate[Interaction, P], Coro[None]]:
+        @functools.wraps(f)
+        async def decorated(
+            interaction: Interaction, *args: P.args, **kwargs: P.kwargs
+        ) -> None:
+            # Check if interaction is valid
+            if not isinstance(interaction.command, app_commands.Command):
+                logger.warning("No command provided %s", interaction)
+                return
+            if interaction.channel is None or interaction.channel_id is None:
+                logger.warning("No channel provided %s", interaction)
+                return
+
+            # Preformat event repr
+            event_repr = (
+                f"/{interaction.command.qualified_name} by {interaction.user} "
+                f"({interaction.user.id}) in {interaction.channel.jump_url}"
+            )
+
+            # Check if in guild
+            if interaction.guild is None or interaction.guild_id is None:
+                logger.warning("Must be use in a guild !")
+                return
+            if not isinstance(interaction.user, discord.Member):
+                logger.warning("No channel provided %s", interaction)
+                return
+
+            # Compute needed permissions
+            needed_perms = discord.Permissions(**perms)
+            have_perms = interaction.user.guild_permissions.is_superset(
+                needed_perms
+            )
+            admin_ids = interaction.client.config.admins
+            is_super_admin = (
+                interaction.user.id in admin_ids
+                or interaction.user.id == interaction.client.owner_id
+            )
+            if not have_perms and not is_super_admin:
+                logger.warning("%s failed for wrong permissions", event_repr)
+                await interaction.response.send_message(
+                    "Vous n'avez pas la permission",
+                    ephemeral=True,
+                )
+                return
+
+            # Check command cooldown
+            cmd = interaction.command.name
+            if cooldown:
+                available_at = None
+                async with (
+                    AsyncSession(interaction.client.engine) as session,
+                    cooldown_lock,  # We must use lock for avoid race condition
+                ):
+                    cd_user = await session.get(
+                        Cooldown,
+                        (interaction.user.id, interaction.guild_id, cmd),
+                    )
+                    cd_cmd = interaction.client.config.commands[cmd].cooldown
+                    now = time()
+                    if cd_user is None or now > cd_cmd + cd_user.timestamp:
+                        await session.merge(
+                            Cooldown(
+                                user_id=interaction.user.id,
+                                guild_id=interaction.guild_id,
+                                command=cmd,
+                                timestamp=now,
+                            )
+                        )
+                        await session.commit()
+                    else:
+                        available_at = cd_cmd + cd_user.timestamp
+                if available_at:
+                    logger.warning("%s failed for cooldown", event_repr)
+                    await interaction.response.send_message(
+                        "Vous devez encore attendre "
+                        f"<t:{available_at + 1:.0f}:R>",
+                        ephemeral=True,
+                    )
+                    return
+            logger.info("%s", event_repr)
+            try:
+                await f(cast(Context, interaction), *args, **kwargs)
+            except InterruptedCommandError:
+                logger.exception("InterruptedCommandError occur")
+                async with (
+                    AsyncSession(interaction.client.engine) as session,
+                    cooldown_lock,
+                ):
+                    # This is unsafe
+                    await session.execute(
+                        delete(Cooldown).where(
+                            and_(
+                                Cooldown.guild_id == interaction.guild_id,
+                                Cooldown.user_id == interaction.user.id,
+                                Cooldown.command == cmd,
+                            )
+                        )
+                    )
+                    await session.commit()
+
+        return decorated
+
+    return decorator

easterobot/commands/basket.py

@@ -0,0 +1,99 @@
+"""Command basket."""
+
+from typing import Optional
+
+import discord
+from discord import app_commands
+from sqlalchemy import and_, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from easterobot.bot import embed
+from easterobot.commands.base import (
+    Context,
+    controlled_command,
+    egg_command_group,
+)
+from easterobot.config import agree
+from easterobot.models import Egg
+
+
+@egg_command_group.command(
+    name="basket",
+    description="Regarder le contenu d'un panier",
+)
+@app_commands.describe(
+    user="Membre possèdant le panier à inspecter",
+)
+@controlled_command(cooldown=True)
+async def basket_command(
+    ctx: Context, user: Optional[discord.Member] = None
+) -> None:
+    """Show current user basket."""
+    # Delay the response
+    await ctx.response.defer(ephemeral=True)
+
+    # Set the user of the basket
+    hunter = user or ctx.user
+
+    # Util for accord in some language
+    you = ctx.user == hunter
+
+    async with AsyncSession(ctx.client.engine) as session:
+        morsels = []
+        missing = []
+        user_egg_count = await ctx.client.get_rank(
+            session, ctx.guild_id, hunter.id
+        )
+        rank = user_egg_count[1] if user_egg_count else None
+        res = await session.execute(
+            select(
+                Egg.emoji_id,
+                func.count().label("count"),
+            )
+            .where(
+                and_(
+                    Egg.guild_id == ctx.guild.id,
+                    Egg.user_id == hunter.id,
+                )
+            )
+            .group_by(Egg.emoji_id)
+        )
+        egg_counts: dict[int, int] = dict(res.all())  # type: ignore[arg-type]
+        egg_count = 0
+        for emoji in ctx.client.app_emojis.choices:
+            try:
+                type_count = egg_counts.pop(emoji.id)
+                egg_count += type_count
+                morsels.append(f"{emoji} \xd7 {type_count}")
+            except KeyError:  # noqa: PERF203
+                missing.append(emoji)
+
+        absent_count = sum(egg_counts.values())
+        if absent_count:
+            egg_count += absent_count
+            morsels.insert(0, f"🥚 \xd7 {absent_count}")
+
+        if rank is not None:
+            il = ctx.client.config.conjugate("{Iel} est", hunter)
+            morsels.insert(
+                0,
+                f"**{'Tu es' if you else il} au rang** {rank}\n",
+            )
+
+        their = "te" if you else "lui"
+        if missing:
+            morsels.append(
+                f"\nIl {their} manque : {''.join(map(str, missing))}"
+            )
+        text = "\n".join(morsels).strip()
+        await ctx.followup.send(
+            embed=embed(
+                title=f"Contenu du panier de {hunter.display_name}",
+                description=text,
+                footer=(
+                    f"Cela {their} fait un total de "
+                    + agree("{0} œuf", "{0} œufs", egg_count)
+                ),
+            ),
+            ephemeral=True,
+        )

easterobot/commands/disable.py

@@ -0,0 +1,29 @@
+"""Module for disable hunt."""
+
+from sqlalchemy import delete, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from easterobot.models import Hunt
+
+from .base import Context, controlled_command, egg_command_group
+
+
+@egg_command_group.command(
+    name="disable", description="Désactiver la chasse aux œufs dans le salon"
+)
+@controlled_command(cooldown=True, manage_channels=True)
+async def disable_command(ctx: Context) -> None:
+    """Disable the hunt."""
+    await ctx.response.defer(ephemeral=True)
+    async with AsyncSession(ctx.client.engine) as session:
+        old = await session.scalar(
+            select(Hunt).where(Hunt.channel_id == ctx.channel.id)
+        )
+        if old:
+            await session.execute(
+                delete(Hunt).where(Hunt.channel_id == ctx.channel.id)
+            )
+            await session.commit()
+    await ctx.followup.send(
+        f"Chasse aux œufs{'' if old else ' déjà'} désactivée", ephemeral=True
+    )

easterobot/commands/edit.py

@@ -0,0 +1,68 @@
+"""Module for edit command."""
+
+import discord
+from sqlalchemy import and_, delete, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from easterobot.bot import embed
+from easterobot.config import RAND, agree
+from easterobot.models import Egg
+
+from .base import Context, controlled_command, egg_command_group
+
+
+@egg_command_group.command(
+    name="edit", description="Editer le nombre d'œufs d'un membre"
+)
+@controlled_command(cooldown=True, administrator=True)
+async def edit_command(
+    ctx: Context,
+    user: discord.Member,
+    oeufs: int,
+) -> None:
+    """Edit command."""
+    oeufs = min(max(oeufs, 0), 100_000)
+    await ctx.response.defer(ephemeral=True)
+    async with AsyncSession(ctx.client.engine) as session:
+        eggs: list[Egg] = list(
+            (
+                await session.scalars(
+                    select(Egg).where(
+                        and_(
+                            Egg.guild_id == ctx.guild_id,
+                            Egg.user_id == user.id,
+                        )
+                    )
+                )
+            ).all()
+        )
+        diff = len(eggs) - oeufs
+        if diff > 0:
+            to_delete = []
+            for _ in range(diff):
+                egg = RAND.choice(eggs)
+                eggs.remove(egg)
+                to_delete.append(egg.id)
+            await session.execute(delete(Egg).where(Egg.id.in_(to_delete)))
+            await session.commit()
+        elif diff < 0:
+            for _ in range(-diff):
+                session.add(
+                    Egg(
+                        guild_id=ctx.guild_id,
+                        channel_id=ctx.channel_id,
+                        user_id=user.id,
+                        emoji_id=ctx.client.app_emojis.rand().id,
+                    )
+                )
+            await session.commit()
+    await ctx.followup.send(
+        embed=embed(
+            title="Edition terminée",
+            description=(
+                f"{user.mention} a maintenant "
+                f"{agree('{0} œuf', '{0} œufs', oeufs)}"
+            ),
+        ),
+        ephemeral=True,
+    )

easterobot/commands/enable.py

@@ -0,0 +1,35 @@
+"""Command enable."""
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from easterobot.models import Hunt
+
+from .base import Context, controlled_command, egg_command_group
+
+
+@egg_command_group.command(
+    name="enable", description="Activer la chasse dans le salon"
+)
+@controlled_command(cooldown=True, manage_channels=True)
+async def enable_command(
+    ctx: Context,
+) -> None:
+    """Enable hunt in a channel."""
+    await ctx.response.defer(ephemeral=True)
+    async with AsyncSession(ctx.client.engine) as session:
+        old = await session.scalar(
+            select(Hunt).where(Hunt.channel_id == ctx.channel.id)
+        )
+        if not old:
+            session.add(
+                Hunt(
+                    channel_id=ctx.channel.id,
+                    guild_id=ctx.guild_id,
+                    next_egg=0,
+                )
+            )
+            await session.commit()
+    await ctx.followup.send(
+        f"Chasse aux œufs{' déjà' if old else ''} activée", ephemeral=True
+    )

easterobot/commands/help.py

@@ -0,0 +1,33 @@
+"""Module for help command."""
+
+from discord.app_commands import AppCommandGroup
+
+from easterobot.bot import embed
+
+from .base import Context, controlled_command, egg_command_group
+
+
+@egg_command_group.command(name="help", description="Obtenir de l'aide")
+@controlled_command(cooldown=True)
+async def help_command(ctx: Context) -> None:
+    """Help command."""
+    emb = embed(
+        title="Liste des commandes",
+        description=ctx.client.description,
+        thumbnail=(
+            ctx.client.user.display_avatar.url if ctx.client.user else None
+        ),
+        footer="Crée par dashstrom",
+    )
+    for command in ctx.client.app_commands:
+        for option in command.options:
+            if not isinstance(option, AppCommandGroup):
+                continue
+            emb.add_field(
+                name=(
+                    f"</{egg_command_group.name} {option.name}:{command.id}>"
+                ),
+                value=f"{option.description}",
+                inline=False,
+            )
+    await ctx.response.send_message(embed=emb, ephemeral=True)