easterobot 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

easterobot/hunts/hunt.py

@@ -0,0 +1,428 @@
+"""Start a run."""
+
+import asyncio
+import logging
+import time
+from collections.abc import Awaitable
+from datetime import datetime, timezone
+from typing import (
+    Any,
+    Callable,
+    Optional,
+)
+
+import discord
+from discord.ext import commands
+from sqlalchemy import and_, func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from easterobot.bot import Easterobot
+from easterobot.config import (
+    RAND,
+    agree,
+)
+from easterobot.models import Egg, Hunt
+
+logger = logging.getLogger(__name__)
+DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+
+class HuntCog(commands.Cog):
+    def __init__(self, bot: Easterobot) -> None:
+        """Instantiate HuntCog."""
+        self.bot = bot
+
+    @commands.Cog.listener()
+    async def on_ready(self) -> None:
+        """Handle ready event, can be trigger many time if disconnected."""
+        # Unlock all eggs
+        logger.info("Unlock all previous eggs")
+        async with AsyncSession(self.bot.engine) as session:
+            await session.execute(
+                update(Egg).where(Egg.lock).values(lock=False)
+            )
+            await session.commit()
+
+        # Start hunt
+        logger.info("Start hunt handler")
+        pending_hunts: set[asyncio.Task[Any]] = set()
+        while True:
+            if pending_hunts:
+                try:
+                    _, pending_hunts = await asyncio.wait(
+                        pending_hunts, timeout=1
+                    )
+                except Exception as err:  # noqa: BLE001
+                    logger.critical("Unattended exception", exc_info=err)
+            await asyncio.sleep(5)
+            pending_hunts.add(asyncio.create_task(self.loop_hunt()))
+
+    async def start_hunt(  # noqa: C901, PLR0912, PLR0915
+        self,
+        hunt_id: int,
+        description: str,
+        *,
+        member_id: Optional[int] = None,
+        send_method: Optional[
+            Callable[..., Awaitable[discord.Message]]
+        ] = None,
+    ) -> None:
+        """Start an hunt in a channel."""
+        # Get the hunt channel of resolve it
+        channel = await self.bot.resolve_channel(hunt_id)
+        if not channel:
+            return
+        guild = channel.guild
+
+        # Get from config
+        action = self.bot.config.action.rand()
+        emoji = self.bot.egg_emotes.rand()
+
+        # Label and hunters
+        hunters: list[discord.Member] = []
+        label = action.text
+        if member_id is not None:
+            member = channel.guild.get_member(member_id)
+            if member:
+                hunters.append(member)
+                label += " (1)"
+
+        # Start hunt
+        logger.info("Start hunt in %s", channel.jump_url)
+        timeout = self.bot.config.hunt.timeout + 1
+        view = discord.ui.View(timeout=timeout)
+        button: discord.ui.Button[Any] = discord.ui.Button(
+            label=label,
+            style=discord.ButtonStyle.primary,
+            emoji=emoji,
+        )
+        view.add_item(button)
+        lock_update = asyncio.Lock()
+
+        async def button_callback(
+            interaction: discord.Interaction[Any],
+        ) -> None:
+            # Respond later
+            await interaction.response.defer()
+            message = interaction.message
+            user = interaction.user
+            if (
+                message is None  # Message must be loaded
+                or not isinstance(user, discord.Member)  # Must be a member
+            ):
+                logger.warning("Invalid callback for %s", guild)
+                return
+            # Check if user doesn't already claim the egg
+            for hunter in hunters:
+                if hunter.id == user.id:
+                    logger.info(
+                        "Already hunt by %s (%s) on %s",
+                        user,
+                        user.id,
+                        message.jump_url,
+                    )
+                    return
+
+            # Add the user to the current users
+            hunters.append(user)
+
+            # Show information about the hunter
+            logger.info(
+                "Hunt (%d) by %s (%s) on %s",
+                len(hunters),
+                user,
+                user.id,
+                message.jump_url,
+            )
+
+            # Update button counter
+            async with lock_update:
+                button.label = action.text + f" ({len(hunters)})"
+                await message.edit(view=view)
+
+        # Set the button callback
+        button.callback = button_callback  # type: ignore[method-assign]
+
+        # Set next hunt
+        next_hunt = time.time() + timeout
+
+        # Create and embed
+        emb = embed(
+            title="Un œuf a été découvert !",
+            description=description
+            + f"\n\nTirage du vinqueur : <t:{next_hunt:.0f}:R>",
+            thumbnail=emoji.url,
+        )
+
+        # Send the embed in the hunt channel
+        if send_method is None:
+            message = await channel.send(embed=emb, view=view)
+        else:
+            message = await send_method(embed=emb, view=view)
+
+        # TODO(dashstrom): channel is wrong due to the send message !
+        # TODO(dashstrom): Why wait if timeout ???
+        # Wait the end of the hunt
+        message_url = f"{channel.jump_url}/{message.id}"
+        async with channel.typing():
+            try:
+                await asyncio.wait_for(
+                    view.wait(), timeout=self.bot.config.hunt.timeout
+                )
+            except asyncio.TimeoutError:
+                logger.info("End hunt for %s", message_url)
+
+        # Disable button and view after hunt
+        button.disabled = True
+        view.stop()
+        await message.edit(view=view)  # Send the stop info
+
+        # Get if hunt is valid
+        async with AsyncSession(self.bot.engine) as session:
+            has_hunt = await session.scalar(
+                select(Hunt).where(
+                    and_(
+                        Hunt.guild_id == guild.id,
+                        Hunt.channel_id == channel.id,
+                    )
+                )
+            )
+
+        # The egg was not collected
+        if not hunters or not has_hunt:
+            button.label = "L'œuf n'a pas été ramassé"
+            button.style = discord.ButtonStyle.danger
+            logger.info("No Hunter for %s", message_url)
+        else:
+            # Process the winner
+            async with AsyncSession(self.bot.engine) as session:
+                # Get the count of egg by user
+                res = await session.execute(
+                    select(Egg.user_id, func.count().label("count"))
+                    .where(
+                        and_(
+                            Egg.guild_id == guild.id,
+                            Egg.user_id.in_(hunter.id for hunter in hunters),
+                        )
+                    )
+                    .group_by(Egg.user_id)
+                )
+                eggs: dict[int, int] = dict(res.all())  # type: ignore[arg-type]
+                logger.info("Winner draw for %s", message_url)
+
+                ranked_hunters = self.rank_players(hunters, eggs)
+                if len(ranked_hunters) == 1:
+                    winner = ranked_hunters[0]
+                    loser = None
+                else:
+                    winner = ranked_hunters[0]
+                    loser = ranked_hunters[1]
+
+                    if RAND.random() < self.bot.config.hunt.game:
+                        # TODO(dashstrom): edit timer during dual
+                        # Update button
+                        button.label = "Duel en cours ..."
+                        button.style = discord.ButtonStyle.gray
+
+                        # Remove emoji and edit view
+                        await message.edit(view=view)
+                        duel_winner = await self.bot.game.dual(
+                            channel=channel,
+                            reference=message,
+                            user1=winner,
+                            user2=loser,
+                        )
+                        if duel_winner is None:
+                            winner = None
+                            loser = None
+                        elif duel_winner == loser:
+                            winner, loser = loser, winner
+
+                if winner:
+                    # Add the egg to the member
+                    session.add(
+                        Egg(
+                            channel_id=channel.id,
+                            guild_id=channel.guild.id,
+                            user_id=winner.id,
+                            emoji_id=emoji.id,
+                        )
+                    )
+                    await session.commit()
+
+            # Show the embed to loser
+            if loser:
+                loser_name = loser.display_name
+                if len(hunters) == 2:  # noqa: PLR2004
+                    text = f"{loser_name} rate un œuf"
+                else:
+                    text = agree(
+                        "{1} et {0} autre chasseur ratent un œuf",
+                        "{1} et {0} autres chasseurs ratent un œuf",
+                        len(hunters) - 2,
+                        loser_name,
+                    )
+                emb = embed(
+                    title=text,
+                    description=action.fail.text(loser),
+                    image=action.fail.gif,
+                )
+                await channel.send(embed=emb, reference=message)
+
+            if winner:
+                # Send embed for the winner
+                winner_eggs = eggs.get(winner.id, 0) + 1
+                emb = embed(
+                    title=f"{winner.display_name} récupère un œuf",
+                    description=action.success.text(winner),
+                    image=action.success.gif,
+                    thumbnail=emoji.url,
+                    egg_count=winner_eggs,
+                )
+                await channel.send(embed=emb, reference=message)
+
+                # Update button
+                button.label = f"L'œuf a été ramassé par {winner.display_name}"
+                button.style = discord.ButtonStyle.success
+                logger.info(
+                    "Winner is %s (%s) with %s",
+                    winner,
+                    winner.id,
+                    agree("{0} egg", "{0} eggs", winner_eggs),
+                )
+            else:
+                button.label = "L'œuf a été cassé"
+                button.style = discord.ButtonStyle.danger
+                logger.info("No winner %s", message_url)
+
+        # Remove emoji and edit view
+        button.emoji = None
+        await message.edit(view=view)
+
+    def rank_players(
+        self, hunters: list[discord.Member], eggs: dict[int, int]
+    ) -> list[discord.Member]:
+        """Get a random working of player.
+
+        Use their egg and the order of hunt join.
+        """
+        # If only one hunter, give the egg to him
+        if len(hunters) <= 1:
+            return hunters
+        lh = len(hunters)
+
+        # Get egg difference
+        min_eggs = min(eggs.values(), default=0)
+        max_eggs = max(eggs.values(), default=0)
+        diff_eggs = max_eggs - min_eggs
+
+        # Normalize weights
+        w_egg = self.bot.config.hunt.weights.egg
+        w_speed = self.bot.config.hunt.weights.speed
+        w_base = self.bot.config.hunt.weights.base
+        w = w_egg + w_speed + w_base
+        w_egg /= w
+        w_speed /= w
+        w_base /= w
+
+        # Weights by hunters
+        weights = []
+
+        # Compute chances of each hunters
+        for i, h in enumerate(hunters):
+            p_base = 1
+            if diff_eggs != 0:
+                egg = eggs.get(h.id, 0) - min_eggs
+                p_egg = 1 - egg / diff_eggs
+            else:
+                p_egg = 1.0
+
+            p_speed = 1 - i / lh
+            w = p_base * w_base + p_speed * w_speed + p_egg * w_egg
+            weights.append(w)
+
+        # Normalize final probabilities
+        r = sum(weights)
+        weights = [p / r for p in weights]
+        for h, w in zip(hunters, weights):
+            logger.info("%.2f%% - %s (%s)", w * 100, h, h.id)
+
+        rankings = []
+        choices_hunters = list(hunters)
+        while choices_hunters:
+            # Get the winner
+            (hunter,) = RAND.choices(choices_hunters, weights)
+            index = choices_hunters.index(hunter)
+            del choices_hunters[index]
+            del weights[index]
+            rankings.append(hunter)
+        return rankings
+
+    async def loop_hunt(self) -> None:
+        """Manage the schedule of run."""
+        # Create a async session
+        async with AsyncSession(
+            self.bot.engine, expire_on_commit=False
+        ) as session:
+            # Find hunt with next egg available
+            now = time.time()
+            hunts = (
+                await session.scalars(select(Hunt).where(Hunt.next_egg <= now))
+            ).all()
+
+            # For each hunt, set the next run and store the channel ids
+            if hunts:
+                for hunt in hunts:
+                    next_egg = now + self.bot.config.hunt.cooldown.rand()
+                    dt_next = datetime.fromtimestamp(next_egg, tz=timezone.utc)
+                    logger.info(
+                        "Next hunt at %s on %s",
+                        hunt.jump_url,
+                        dt_next.strftime(DATE_FORMAT),
+                    )
+                    hunt.next_egg = next_egg
+                await session.commit()
+            hunt_ids = [hunt.channel_id for hunt in hunts]
+
+        # Call start_hunt for each hunt
+        if hunt_ids:
+            try:
+                await asyncio.gather(
+                    *[
+                        self.start_hunt(hunt_id, self.bot.config.appear.rand())
+                        for hunt_id in hunt_ids
+                    ]
+                )
+            except Exception as err:
+                logger.exception(
+                    "An error occurred during start hunt", exc_info=err
+                )
+
+
+def embed(  # noqa: PLR0913
+    *,
+    title: str,
+    description: Optional[str] = None,
+    image: Optional[str] = None,
+    thumbnail: Optional[str] = None,
+    egg_count: Optional[int] = None,
+    footer: Optional[str] = None,
+) -> discord.Embed:
+    """Create an embed with default format."""
+    new_embed = discord.Embed(
+        title=title,
+        description=description,
+        colour=RAND.randint(0, 1 << 24),
+        type="gifv" if image else "rich",
+    )
+    if image is not None:
+        new_embed.set_image(url=image)
+    if thumbnail is not None:
+        new_embed.set_thumbnail(url=thumbnail)
+    if egg_count is not None:
+        footer = (footer + " - ") if footer else ""
+        footer += "Cela lui fait un total de "
+        footer += agree("{0} œuf", "{0} œufs", egg_count)
+    if footer:
+        new_embed.set_footer(text=footer)
+    return new_embed

easterobot/hunts/rank.py

@@ -0,0 +1,82 @@
+"""Start a run."""
+
+from dataclasses import dataclass
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from easterobot.config import agree
+from easterobot.models import Egg
+
+RANK_MEDAL = {1: "🥇", 2: "🥈", 3: "🥉"}
+
+
+@dataclass
+class Hunter:
+    member_id: int
+    rank: int
+    eggs: int
+
+    @property
+    def badge(self) -> str:
+        """Get the ranking badge."""
+        return RANK_MEDAL.get(self.rank, f"`#{self.rank}`")
+
+    @property
+    def record(self) -> str:
+        """Get the records of eggs."""
+        return (
+            f"{self.badge} <@{self.member_id}>\n"
+            f"\u2004\u2004\u2004\u2004\u2004"
+            f"➥ {agree('{0} œuf', '{0} œufs', self.eggs)}"
+        )
+
+
+class Ranking:
+    def __init__(self, hunters: list[Hunter]) -> None:
+        """Initialise Ranking."""
+        self.hunters = hunters
+
+    def all(self) -> list[Hunter]:
+        """Get all hunter."""
+        return self.hunters
+
+    def over(self, limit: int) -> list[Hunter]:
+        """Get all hunter over limit."""
+        return [h for h in self.hunters if h.eggs >= limit]
+
+    def page(self, n: int, *, limit: int) -> list[Hunter]:
+        """Get a hunters by page."""
+        if n < 0 or limit < 0:
+            return []
+        return self.hunters[limit * n : limit * (n + 1)]
+
+    def get(self, member_id: int) -> Hunter:
+        """Get a hunter."""
+        for hunter in self.hunters:
+            if hunter.member_id == member_id:
+                return hunter
+        return Hunter(member_id, min(len(self.hunters), 1), 0)
+
+    @staticmethod
+    async def from_guild(
+        session: AsyncSession,
+        guild_id: int,
+    ) -> "Ranking":
+        """Get ranks by page."""
+        query = (
+            select(
+                Egg.user_id,
+                func.rank().over(order_by=func.count().desc()).label("row"),
+                func.count().label("count"),
+            )
+            .where(Egg.guild_id == guild_id)
+            .group_by(Egg.user_id)
+            .order_by(func.count().desc())
+        )
+        res = await session.execute(query)
+        hunters = [
+            Hunter(member_id, rank, egg_count)
+            for member_id, rank, egg_count in res.all()
+        ]
+        return Ranking(hunters)

easterobot/models.py

@@ -1,6 +1,6 @@
 """Module for models."""
 
-from sqlalchemy import BigInteger, Integer
+from sqlalchemy import BigInteger, Boolean, Integer
 from sqlalchemy.orm import (
     DeclarativeBase,
     Mapped,
@@ -29,6 +29,7 @@ class Egg(Base):
         BigInteger, nullable=False, index=True
     )
     emoji_id: Mapped[int] = mapped_column(BigInteger, nullable=True)
+    lock: Mapped[bool] = mapped_column(Boolean, default=False)
 
     @property
     def jump_url(self) -> str:

easterobot/resources/alembic.ini

@@ -0,0 +1,87 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+# Use forward slashes (/) also on windows to provide an os agnostic path
+# Set using the project files
+# script_location = alembic
+
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python>=3.9 or backports.zoneinfo library and tzdata library.
+# Any required deps can installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to alembic/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+# version_path_separator = newline
+#
+# Use os.pathsep. Default configuration used for new projects.
+version_path_separator = os
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# Argument is set from config.yml
+# sqlalchemy.url = sqlite+aiosqlite://easterobot.db
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = %(here)s/.venv/bin/ruff
+# ruff.options = check --fix REVISION_SCRIPT_FILENAME

easterobot/resources/config.example.yml

@@ -11,14 +11,17 @@ database: sqlite+aiosqlite://%(data)s/easterobot.db
 group: egg
 hunt:
   timeout: 300.0
+  game: 0.6
   cooldown:
     min: 1200.0
     max: 3000.0
   weights:
+    base: 0.3
     egg: 0.4
-    speed: 0.4
+    speed: 0.3
 commands:
   search:
+    cooldown: 600.0
     discovered:
       shield: 5
       min: 0.5
@@ -27,9 +30,14 @@ commands:
       shield: 10
       min: 0.4
       max: 0.7
-    cooldown: 600.0
   top:
     cooldown: 10.0
+  connect4:
+    cooldown: 120.0
+  rockpaperscissor:
+    cooldown: 120.0
+  tictactoe:
+    cooldown: 120.0
   basket:
     cooldown: 10.0
   reset:

easterobot/resources/credits.txt

@@ -1 +1,5 @@
-https://openclipart.org/detail/169059/easter-eggs-by-viscious-speedViscious-SpeedColorfulEasterEggsclip
+eggs/ https://openclipart.org/detail/169059/easter-eggs-by-viscious-speedViscious-SpeedColorfulEasterEggsclip
+icons/arrow.png https://www.flaticon.com/free-icon/right-arrow_10570067
+icons/end.png https://www.flaticon.com/free-icon/end_5553850
+icons/versus.png https://www.flaticon.com/free-icon/versus_7960356
+icons/wait.png https://www.flaticon.com/free-icon/hourglass_3874060