easterobot 1.0.0__py3-none-any.whl

easterobot/commands/reset.py

@@ -0,0 +1,121 @@
+"""Module for reset command."""
+
+import asyncio
+from typing import cast
+
+import discord
+from sqlalchemy import and_, delete
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from easterobot.bot import embed
+from easterobot.models import Cooldown, Egg, Hunt
+
+from .base import Context, Interaction, controlled_command, egg_command_group
+
+
+@egg_command_group.command(
+    name="reset", description="Réinitialiser la chasse aux œufs"
+)
+@controlled_command(cooldown=True, administrator=True)
+async def reset_command(ctx: Context) -> None:
+    """Reset command."""
+    await ctx.response.defer(ephemeral=True)
+    view = discord.ui.View(timeout=None)
+    cancel: discord.ui.Button[discord.ui.View] = discord.ui.Button(
+        label="Annuler", style=discord.ButtonStyle.danger
+    )
+    view.add_item(cancel)
+    confirm: discord.ui.Button[discord.ui.View] = discord.ui.Button(
+        label="Confirmer", style=discord.ButtonStyle.success
+    )
+    view.add_item(confirm)
+    done = False
+    cancel_embed = embed(
+        title="Réinitialisation annulée",
+        description="Vous avez annulé la demande de réinitialisation.",
+    )
+    confirm_embed = embed(
+        title="Réinitialisation",
+        description=(
+            "L'ensemble des salons, œufs "
+            "et temps d'attentes ont été réinitialisatiés."
+        ),
+    )
+
+    async def cancel_callback(
+        interaction: Interaction,
+    ) -> None:
+        nonlocal done
+        done = True
+        cancel.disabled = True
+        confirm.disabled = True
+        view.stop()
+        await asyncio.gather(
+            message.edit(view=view),
+            interaction.response.send_message(
+                embed=cancel_embed,
+                ephemeral=True,
+            ),
+        )
+
+    async def confirm_callback(
+        interaction: Interaction,
+    ) -> None:
+        nonlocal done
+        done = True
+        cancel.disabled = True
+        confirm.disabled = True
+        view.stop()
+        await asyncio.gather(
+            message.edit(view=view),
+            interaction.response.defer(ephemeral=True),
+        )
+
+        async with AsyncSession(ctx.client.engine) as session:
+            await session.execute(
+                delete(Hunt).where(Hunt.guild_id == ctx.guild_id)
+            )
+            await session.execute(
+                delete(Egg).where(Egg.guild_id == ctx.guild_id)
+            )
+            await session.execute(
+                delete(Cooldown).where(
+                    and_(
+                        Cooldown.guild_id == ctx.guild_id,
+                        Cooldown.command != "reset",
+                    )
+                )
+            )
+            await session.commit()
+        await interaction.followup.send(
+            embed=confirm_embed,
+            ephemeral=True,
+        )
+
+    cancel.callback = cancel_callback  # type: ignore[assignment]
+    confirm.callback = confirm_callback  # type: ignore[assignment]
+    message = cast(
+        discord.WebhookMessage,
+        await ctx.followup.send(
+            embed=embed(
+                title="Demande de réinitialisation",
+                description=(
+                    "L'ensemble des salons, œufs "
+                    "et temps d'attentes vont être réinitialisatiés."
+                ),
+                # TODO(dashstrom): add timer
+                footer="Vous avez 30 secondes pour confirmer",
+            ),
+            ephemeral=True,
+            view=view,
+        ),
+    )
+    await asyncio.sleep(30.0)
+    if not done:
+        cancel.disabled = True
+        confirm.disabled = True
+        view.stop()
+        await asyncio.gather(
+            message.edit(view=view),
+            ctx.followup.send(embed=cancel_embed, ephemeral=True),
+        )

easterobot/commands/search.py

@@ -0,0 +1,127 @@
+"""Module for search command."""
+
+import logging
+from typing import Any
+
+import discord
+from sqlalchemy import and_, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from easterobot.bot import embed
+from easterobot.config import RAND, agree
+from easterobot.models import Egg, Hunt
+
+from .base import (
+    Context,
+    InterruptedCommandError,
+    controlled_command,
+    egg_command_group,
+)
+
+logger = logging.getLogger("easterobot")
+
+
+@egg_command_group.command(name="search", description="Rechercher un œuf")
+@controlled_command(cooldown=True)
+async def search_command(ctx: Context) -> None:
+    """Search command."""
+    async with AsyncSession(ctx.client.engine) as session:
+        hunt = await session.scalar(
+            select(Hunt).where(Hunt.channel_id == ctx.channel.id)
+        )
+        if hunt is None:
+            await ctx.response.send_message(
+                "La chasse aux œufs n'est pas activée dans ce salon",
+                ephemeral=True,
+            )
+            return
+    try:
+        await ctx.response.defer(ephemeral=False)
+    except discord.errors.NotFound as err:
+        raise InterruptedCommandError from err
+    name = ctx.user.display_name
+
+    async with AsyncSession(ctx.client.engine) as session:
+        egg_max = await session.scalar(
+            select(
+                func.count().label("max"),
+            )
+            .where(Egg.guild_id == ctx.guild_id)
+            .group_by(Egg.user_id)
+            .order_by(func.count().label("max").desc())
+            .limit(1)
+        )
+        egg_max = egg_max or 0
+        egg_count = await session.scalar(
+            select(func.count().label("count")).where(
+                and_(
+                    Egg.guild_id == ctx.guild.id,
+                    Egg.user_id == ctx.user.id,
+                )
+            )
+        )
+        if egg_count is None:
+            egg_count = 0
+    ratio = egg_count / egg_max if egg_max != 0 else 1.0
+
+    discovered = ctx.client.config.commands.search.discovered
+    prob_d = (discovered.max - discovered.min) * (1 - ratio) + discovered.min
+
+    sample_d = RAND.random()
+    if prob_d > sample_d or egg_count < discovered.shield:
+        sample_s = RAND.random()
+        spotted = ctx.client.config.commands.search.spotted
+        prob_s = (spotted.max - spotted.min) * ratio + spotted.min
+        logger.info("discovered: %.2f > %.2f", prob_d, sample_d)
+        if prob_s > sample_s and egg_count > spotted.shield:
+            logger.info("spotted: %.2f > %.2f", prob_s, sample_s)
+
+            async def send_method(
+                *args: Any, **kwargs: Any
+            ) -> discord.Message:
+                return await ctx.followup.send(*args, **kwargs)  # type: ignore[no-any-return]
+
+            await ctx.client.start_hunt(
+                ctx.channel_id,
+                ctx.client.config.spotted(ctx.user),
+                member_id=ctx.user.id,
+                send_method=send_method,
+            )
+        else:
+            logger.info("found: %.2f > %.2f", prob_s, sample_s)
+            emoji = ctx.client.app_emojis.rand()
+            async with AsyncSession(ctx.client.engine) as session:
+                session.add(
+                    Egg(
+                        channel_id=ctx.channel_id,
+                        guild_id=ctx.guild_id,
+                        user_id=ctx.user.id,
+                        emoji_id=emoji.id,
+                    )
+                )
+                await session.commit()
+
+            logger.info(
+                "%s (%s) got an egg for a total %s in %s",
+                ctx.user,
+                ctx.user.id,
+                agree("{0} egg", "{0} eggs", egg_count),
+                ctx.channel.jump_url,
+            )
+            await ctx.followup.send(
+                embed=embed(
+                    title=f"{name} récupère un œuf",
+                    description=ctx.client.config.hidden(ctx.user),
+                    thumbnail=emoji.url,
+                    egg_count=egg_count + 1,
+                )
+            )
+    else:
+        logger.info("failed: %.2f > %.2f", prob_d, sample_d)
+        await ctx.followup.send(
+            embed=embed(
+                title=f"{name} repart bredouille",
+                description=ctx.client.config.failed(ctx.user),
+                egg_count=egg_count,
+            )
+        )

easterobot/commands/top.py

@@ -0,0 +1,105 @@
+"""Command top."""
+
+import logging
+from math import floor
+from typing import Optional
+
+import discord
+from sqlalchemy import distinct, func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from easterobot.bot import embed
+from easterobot.config import agree
+from easterobot.models import Egg
+
+from .base import Context, Interaction, controlled_command, egg_command_group
+
+PAGE_SIZE = 10
+logger = logging.getLogger(__name__)
+
+
+def record_top(rank: str, user_id: int, count: int) -> str:
+    """Format the current user."""
+    return (
+        f"{rank} <@{user_id}>\n"
+        f"\u2004\u2004\u2004\u2004\u2004"
+        f"➥ {agree('{0} œuf', '{0} œufs', count)}"
+    )
+
+
+async def embed_rank(
+    ctx: Context,
+    page: int,
+    colour: Optional[discord.Colour] = None,
+) -> tuple[discord.Embed, bool]:
+    """Embed for rank."""
+    async with AsyncSession(ctx.client.engine) as session:
+        egg_counts = await ctx.client.get_ranks(
+            session, ctx.guild_id, PAGE_SIZE, page
+        )
+        morsels = []
+        if egg_counts:
+            for user_id, rank, egg_count in egg_counts[:10]:
+                morsels.append(record_top(rank, user_id, egg_count))
+        else:
+            morsels.append("\n:spider_web: Personne n'a d'œuf")
+        total = await session.scalar(
+            select(func.count(distinct(Egg.user_id)).label("count")).where(
+                Egg.guild_id == ctx.guild_id
+            )
+        )
+        if total is None:
+            total = 0
+            logger.warning("No total egg !")
+        total = floor(total / PAGE_SIZE)
+    text = "\n".join(morsels)
+    emb = embed(
+        title="Chasse aux œufs",
+        description=text,
+        footer=f"Page {page + 1}/{total + 1}",
+    )
+    if colour is not None:
+        emb.colour = colour
+    return emb, page >= total
+
+
+@egg_command_group.command(
+    name="top", description="Classement des chasseurs d'œufs"
+)
+@controlled_command(cooldown=True)
+async def top_command(ctx: Context) -> None:
+    """Top command."""
+    await ctx.response.defer(ephemeral=True)
+
+    view = discord.ui.View(timeout=None)
+    previous_page: discord.ui.Button[discord.ui.View] = discord.ui.Button(
+        label="<", style=discord.ButtonStyle.gray, disabled=True
+    )
+    view.add_item(previous_page)
+    next_page: discord.ui.Button[discord.ui.View] = discord.ui.Button(
+        label=">", style=discord.ButtonStyle.gray
+    )
+    view.add_item(next_page)
+    page = 0
+
+    async def edit(interaction: Interaction) -> None:
+        previous_page.disabled = page <= 0
+        emb, next_page.disabled = await embed_rank(
+            ctx, page, base_embed.colour
+        )
+        await interaction.response.edit_message(view=view, embed=emb)
+
+    async def previous_callback(interaction: Interaction) -> None:
+        nonlocal page
+        page = max(page - 1, 0)
+        await edit(interaction)
+
+    async def next_callback(interaction: Interaction) -> None:
+        nonlocal page
+        page += 1
+        await edit(interaction)
+
+    previous_page.callback = previous_callback  # type: ignore[assignment]
+    next_page.callback = next_callback  # type: ignore[assignment]
+    base_embed, next_page.disabled = await embed_rank(ctx, page)
+    await ctx.followup.send(embed=base_embed, ephemeral=True, view=view)