easterobot 1.3.2__py3-none-any.whl → 1.5.2__py3-none-any.whl

easterobot/games/tic_tac_toe.py

@@ -1,10 +1,12 @@
 """TicTacToe."""
 
+import asyncio
 from typing import Optional
 
 import discord
 from typing_extensions import override
 
+from easterobot.bot import Easterobot
 from easterobot.games.game import Game, Player
 from easterobot.utils import in_seconds
 
@@ -25,25 +27,24 @@ EMOJIS = tuple(EMOJIS_MAPPER)
 class TicTacToe(Game):
     def __init__(
         self,
-        player1: discord.Member,
-        player2: discord.Member,
+        bot: Easterobot,
         message: discord.Message,
+        *members: discord.Member,
     ) -> None:
         """Initialize grid."""
         self.grid: list[Optional[Player]] = [None] * 9
         self.timeout = False
-        self.player1 = Player(player1, 1)
-        self.player2 = Player(player2, 2)
         self.turn = 0
-        super().__init__(message)
+        super().__init__(bot, message, *members)
 
     @override
     async def on_start(self) -> None:
         """Run."""
         await self.update()
+        await self.start_timer(31)
         for emoji in EMOJIS:
+            await asyncio.sleep(0.1)
             await self.message.add_reaction(emoji)
-        await self.start_timer(31)
 
     async def update(self) -> None:
         """Update the message."""
@@ -55,13 +56,13 @@ class TicTacToe(Game):
             user: Optional[Player] = self.current
         elif self.winner:
             forfait = "par forfait " if self.timeout else ""
-            footer = f"\n## Gagnant {forfait}{self.winner.mention} 🎉"
+            footer = f"\n## Gagnant {forfait}{self.winner.member.mention} 🎉"
             user = self.current
         else:
             footer = (
                 "\n## Égalité entre "
-                f"{self.player1.member.mention} "
-                f"et {self.player2.member.mention} 🤝"
+                f"{self.players[0].member.mention} "
+                f"et {self.players[1].member.mention} 🤝"
             )
             user = None
 
@@ -72,9 +73,9 @@ class TicTacToe(Game):
             for col in range(3):
                 index = row * 3 + col
                 player = self.grid[index]
-                if player == self.player1:
+                if player == self.players[0]:
                     piece = "❌"
-                elif player == self.player2:
+                elif player == self.players[1]:
                     piece = "⭕"
                 else:
                     piece = EMOJIS[index]
@@ -98,8 +99,8 @@ class TicTacToe(Game):
         self.message = await self.message.edit(
             embed=embed,
             content=(
-                f"-# {self.player1.member.mention} "
-                f"{self.player2.member.mention}"
+                f"-# {self.players[0].member.mention} "
+                f"{self.players[1].member.mention}"
             ),
             view=None,
         )
@@ -116,15 +117,15 @@ class TicTacToe(Game):
     @property
     def current(self) -> Player:
         """Get current member."""
-        return [self.player1, self.player2][self.turn % 2]
+        return [self.players[0], self.players[1]][self.turn % 2]
 
     def color(self, player: Optional[Player]) -> Optional[discord.Colour]:
         """Color of the embed."""
         if player is None:
             return discord.Colour.from_str("#d4d5d6")
-        if player == self.player1:
+        if player == self.players[0]:
             return discord.Colour.from_str("#F17720")
-        if player == self.player2:
+        if player == self.players[1]:
             return discord.Colour.from_str("#0474BA")
         error_message = f"Invalid player: {player!r}"
         raise ValueError(error_message)
@@ -138,7 +139,7 @@ class TicTacToe(Game):
             self.grid[index] = player
 
             if self._is_winner(player):
-                await self.set_winner(player.member)
+                await self.set_winner(player)
             elif all(cell is not None for cell in self.grid):
                 await self.set_winner(None)
             else:
@@ -150,7 +151,7 @@ class TicTacToe(Game):
     async def on_timeout(self) -> None:
         self.turn += 1
         self.timeout = True
-        await self.set_winner(self.current.member)
+        await self.set_winner(self.current)
         await self.update()
 
     def _is_winner(self, player: Player) -> bool:

easterobot/hunts/hunt.py

@@ -17,6 +17,7 @@ from sqlalchemy import and_, func, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from easterobot.bot import Easterobot
+from easterobot.casino.roulette import RouletteManager
 from easterobot.config import (
     RAND,
     agree,
@@ -24,6 +25,7 @@ from easterobot.config import (
 from easterobot.hunts.luck import HuntLuck
 from easterobot.models import Egg, Hunt
 from easterobot.query import QueryManager
+from easterobot.utils import in_seconds
 
 logger = logging.getLogger(__name__)
 DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
@@ -98,7 +100,7 @@ class HuntQuery(QueryManager):
         )
         return egg_max or 0
 
-    async def get_eggs(
+    async def get_egg_count(
         self,
         session: AsyncSession,
         guild_id: int,
@@ -125,7 +127,7 @@ class HuntQuery(QueryManager):
     ) -> HuntLuck:
         """Get the luck of a member."""
         luck = 1.0
-        egg_count = await self.get_eggs(session, guild_id, user_id)
+        egg_count = await self.get_egg_count(session, guild_id, user_id)
         if egg_count != 0:
             egg_max = await self.get_max_eggs(session, guild_id)
             if egg_max != 0:
@@ -147,6 +149,9 @@ class HuntCog(commands.Cog, HuntQuery):
     @commands.Cog.listener()
     async def on_ready(self) -> None:
         """Handle ready event, can be trigger many time if disconnected."""
+        # Wait main finish
+        await self.bot.init_finished.wait()
+
         # Unlock all eggs
         logger.info("Unlock all previous eggs")
         async with AsyncSession(self.bot.engine) as session:
@@ -155,6 +160,7 @@ class HuntCog(commands.Cog, HuntQuery):
 
         # Start hunt
         logger.info("Start hunt handler")
+        # TODO(dashstrom): rework this
         pending_hunts: set[asyncio.Task[Any]] = set()
         while True:
             if pending_hunts:
@@ -173,6 +179,7 @@ class HuntCog(commands.Cog, HuntQuery):
         description: str,
         *,
         member_id: Optional[int] = None,
+        casino: bool = False,
         send_method: Optional[
             Callable[..., Awaitable[discord.Message]]
         ] = None,
@@ -184,6 +191,14 @@ class HuntCog(commands.Cog, HuntQuery):
             return
         guild = channel.guild
 
+        # Random casino events
+        if casino:
+            casino_event = self.bot.config.casino.sample_event()
+            if casino_event:
+                manager = RouletteManager(self.bot)
+                await manager.run(channel)
+                return
+
         # Get from config
         action = self.bot.config.action.rand()
         emoji = self.bot.egg_emotes.rand()
@@ -200,6 +215,7 @@ class HuntCog(commands.Cog, HuntQuery):
         # Start hunt
         logger.info("Start hunt in %s", channel.jump_url)
         timeout = self.bot.config.hunt.timeout + 1
+        has_game = False
         view = discord.ui.View(timeout=timeout)
         button: discord.ui.Button[Any] = discord.ui.Button(
             label=label,
@@ -253,14 +269,11 @@ class HuntCog(commands.Cog, HuntQuery):
         # 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 vainqueur : <t:{next_hunt:.0f}:R>",
+            + f"\n\n-# Tirage du vainqueur {in_seconds(timeout)}",
             thumbnail=emoji.url,
         )
 
@@ -269,18 +282,18 @@ class HuntCog(commands.Cog, HuntQuery):
             message = await channel.send(embed=emb, view=view)
         else:
             message = await send_method(embed=emb, view=view)
+            message = await message.channel.fetch_message(message.id)
 
         # 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)
+        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
@@ -315,6 +328,7 @@ class HuntCog(commands.Cog, HuntQuery):
 
                     if RAND.random() < self.bot.config.hunt.game:
                         # Update button
+                        has_game = True
                         button.label = "Duel en cours ..."
                         button.style = discord.ButtonStyle.gray
 
@@ -329,7 +343,7 @@ class HuntCog(commands.Cog, HuntQuery):
                         if duel_winner is None:
                             winner = None
                             loser = None
-                        elif duel_winner == loser:
+                        elif duel_winner.member == loser:
                             winner, loser = loser, winner
 
                 if winner:
@@ -358,7 +372,11 @@ class HuntCog(commands.Cog, HuntQuery):
                         )
                     emb = embed(
                         title=text,
-                        description=action.fail.text(loser),
+                        description=(
+                            action.fail.text(loser)
+                            + "\n\n-# Ce message disparaîtra "
+                            + in_seconds(300)
+                        ),
                         image=action.fail.gif,
                     )
                     await channel.send(
@@ -368,8 +386,17 @@ class HuntCog(commands.Cog, HuntQuery):
                     )
 
                 if winner:
-                    # Send embed for the winner
-                    winner_eggs = eggs.get(winner.id, 0) + 1
+                    # Get egg count (or the new counter if game)
+                    if has_game:
+                        winner_eggs = await self.get_egg_count(
+                            session,
+                            winner.guild.id,
+                            winner.id,
+                        )
+                    else:
+                        winner_eggs = eggs.get(winner.id, 0) + 1
+
+                    # Send the winner embed winner
                     emb = embed(
                         title=f"{winner.display_name} récupère un œuf",
                         description=action.success.text(winner),
@@ -488,7 +515,11 @@ class HuntCog(commands.Cog, HuntQuery):
             try:
                 await asyncio.gather(
                     *[
-                        self.start_hunt(hunt_id, self.bot.config.appear.rand())
+                        self.start_hunt(
+                            hunt_id,
+                            self.bot.config.appear.rand(),
+                            casino=True,
+                        )
                         for hunt_id in hunt_ids
                     ]
                 )

easterobot/hunts/rank.py

@@ -2,7 +2,7 @@
 
 from dataclasses import dataclass
 
-from sqlalchemy import func, select
+from sqlalchemy import and_, func, not_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from easterobot.config import agree
@@ -51,6 +51,23 @@ class Ranking:
             return []
         return self.hunters[limit * n : limit * (n + 1)]
 
+    def count_page(self, n: int) -> int:
+        """Count the number of page.
+
+        Example:
+        >>> Ranking([Hunter(1, 1, 3), Hunter(2, 2, 2)]).count_page(10)
+        1
+        >>> Ranking([]).count_page(10)
+        0
+        >>> Ranking([Hunter(i, i, 20 - i) for i in range(10)]).count_page(10)
+        1
+        >>> Ranking([Hunter(i, i, 20 - i) for i in range(11)]).count_page(10)
+        2
+        """
+        if not self.hunters:
+            return 0
+        return (len(self.hunters) - 1) // n + 1
+
     def get(self, member_id: int) -> Hunter:
         """Get a hunter."""
         for hunter in self.hunters:
@@ -62,15 +79,20 @@ class Ranking:
     async def from_guild(
         session: AsyncSession,
         guild_id: int,
+        *,
+        unlock_only: bool = False,
     ) -> "Ranking":
         """Get ranks by page."""
+        where = Egg.guild_id == guild_id
+        if unlock_only:
+            where = and_(where, not_(Egg.lock))
         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)
+            .where(where)
             .group_by(Egg.user_id)
             .order_by(func.count().desc())
         )

easterobot/info.py

@@ -1,18 +1,28 @@
 """Module holding metadata."""
 
+import logging
 from importlib.metadata import Distribution
 
+logger = logging.getLogger(__name__)
 _DISTRIBUTION = Distribution.from_name(
     "easterobot",
 )
 _METADATA = _DISTRIBUTION.metadata
-
-if "Author" in _METADATA:
-    __author__ = str(_METADATA["Author"])
-    __email__ = str(_METADATA["Author-email"])
+if len(_METADATA) != 0:
+    if "Author" in _METADATA:
+        __author__ = str(_METADATA["Author"])
+        __email__ = str(_METADATA["Author-email"])
+    else:
+        __author__, __email__ = _METADATA["Author-email"][:-1].split(" <", 1)
+    __version__ = _METADATA["Version"]
+    __summary__ = _METADATA["Summary"]
 else:
-    __author__, __email__ = _METADATA["Author-email"][:-1].split(" <", 1)
-__version__ = _METADATA["Version"]
-__summary__ = _METADATA["Summary"]
+    logger.warning("Cannot load package metadata, please reinstall !")
+
+    __author__ = "Unknown"
+    __email__ = "Unknown"
+    __version__ = "Unknown"
+    __summary__ = "Unknown"
+
 __copyright__ = f"{__author__} <{__email__}>"
 __issues__ = "https://github.com/Dashstrom/easterobot/issues"

easterobot/locker.py

@@ -0,0 +1,180 @@
+"""Lock the module."""
+
+import asyncio
+import logging
+from collections.abc import AsyncIterator, Iterable
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
+from types import TracebackType
+from typing import ClassVar, Optional, final
+
+import discord
+from sqlalchemy import and_, func, not_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from typing_extensions import override
+
+from easterobot.config import agree
+from easterobot.models import Egg
+
+logger = logging.getLogger(__name__)
+
+
+async def fetch_unlocked_eggs(
+    session: AsyncSession,
+    guild_id: int,
+    user_id: int,
+    counter: int,
+) -> list[Egg]:
+    """Get the count of unlocked eggs."""
+    return list(
+        (
+            await session.scalars(
+                select(Egg)
+                .where(
+                    and_(
+                        Egg.guild_id == guild_id,
+                        Egg.user_id == user_id,
+                        not_(Egg.lock),
+                    )
+                )
+                .order_by(func.random())  # Randomize
+                .limit(counter)
+            )
+        ).all()
+    )
+
+
+async def fetch_unlocked_egg_count(
+    session: AsyncSession,
+    guild_id: int,
+    user_ids: Iterable[int],
+) -> dict[int, int]:
+    """Get the count of unlocked eggs."""
+    user_ids = list(user_ids)
+    res = await session.execute(
+        select(Egg.user_id, func.count().label("count"))
+        .where(
+            and_(
+                Egg.guild_id == guild_id,
+                Egg.user_id.in_(user_ids),
+                not_(Egg.lock),
+            )
+        )
+        .group_by(Egg.user_id)
+    )
+    result = dict(res.all())  # type: ignore[arg-type]
+    for user_id in user_ids:
+        if user_id not in result:
+            result[user_id] = 0
+    return result
+
+
+class EggLockerError(Exception):
+    pass
+
+
+@final
+class EggLocker(AbstractAsyncContextManager["EggLocker"]):
+    # TODO(dashstrom): memory leak over time
+    _guild_locks: ClassVar[dict[int, asyncio.Lock]] = {}
+
+    def __init__(self, session: AsyncSession, guild_id: int) -> None:
+        """Init EggLocker."""
+        self._session = session
+        self._guild_id = guild_id
+        self._eggs: list[Egg] = []
+
+    @asynccontextmanager
+    async def transaction(self) -> AsyncIterator[None]:
+        """Return guild lock."""
+        if self._guild_id not in self._guild_locks:
+            self._guild_locks[self._guild_id] = asyncio.Lock()
+        async with self._guild_locks[self._guild_id]:
+            yield
+            await self._session.commit()
+
+    async def get(
+        self,
+        member: discord.Member,
+        egg_count: int,
+    ) -> list[Egg]:
+        """Update the egg locker."""
+        eggs = await fetch_unlocked_eggs(
+            self._session,
+            self._guild_id,
+            member.id,
+            egg_count,
+        )
+        if len(eggs) < egg_count:
+            egg_text = agree("œuf", "œufs", len(eggs))
+            error_message = (
+                f"{member.mention} n'a plus que {len(eggs)} {egg_text} "
+                f"disponible sur les {egg_count} demandés"
+            )
+            raise EggLockerError(error_message)
+        for egg in eggs:
+            egg.lock = True
+        self._eggs.extend(eggs)
+        logger.info(
+            "Lock %s egg(s) of %s (%s)",
+            len(eggs),
+            member.name,
+            member.id,
+        )
+        return eggs
+
+    async def delete(self, eggs: Iterable[Egg]) -> None:
+        """Delete eggs."""
+        futures = []
+        for egg in eggs:
+            self._eggs.remove(egg)
+            futures.append(self._session.delete(egg))
+        await asyncio.gather(*futures)
+
+    def update(self, eggs: Iterable[Egg]) -> None:
+        """Update eggs."""
+        for egg in eggs:
+            self._eggs.append(egg)
+            self._session.add(egg)
+
+    async def pre_check(
+        self,
+        members: dict[discord.Member, int],
+    ) -> None:
+        """Return the list of invalid user."""
+        if not members:
+            return
+        member_ids = {member.id: member for member in members}
+        counter = await fetch_unlocked_egg_count(
+            self._session,
+            self._guild_id,
+            member_ids,
+        )
+        for user_id, egg_count in counter.items():
+            member = member_ids[user_id]
+            required = members[member]
+            if egg_count < required:
+                egg_text = agree("œuf", "œufs", egg_count)
+                error_message = (
+                    f"{member.mention} n'a que {egg_count} {egg_text} "
+                    f"disponible sur les {required} demandés"
+                )
+                raise EggLockerError(error_message)
+
+    @override
+    async def __aenter__(self) -> "EggLocker":
+        """Return `self` upon entering the runtime context."""
+        return self
+
+    @override
+    async def __aexit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_value: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> Optional[bool]:
+        """Raise any exception triggered within the runtime context."""
+        async with self.transaction():
+            await self._session.rollback()
+            for egg in self._eggs:
+                egg.lock = False
+        return None

easterobot/models.py

@@ -37,6 +37,15 @@ class Egg(Base):
         guild_id = self.guild_id or "@me"
         return f"{DISCORD_URL}/{guild_id}/{self.channel_id}/{self.id}"
 
+    def duplicate(self) -> "Egg":
+        """Duplicate the egg."""
+        return Egg(
+            guild_id=self.guild_id,
+            channel_id=self.channel_id,
+            user_id=self.user_id,
+            emoji_id=self.emoji_id,
+        )
+
 
 class Hunt(Base):
     __tablename__ = "hunt"

easterobot/resources/config.example.yml

@@ -11,11 +11,15 @@ logs:
 database: sqlite+aiosqlite://%(data)s/easterobot.db
 group: egg
 sleep:
-  start: '23:00:00'
-  end: '09:00:00'
+  start: '01:00:00'
+  end: '10:00:00'
   divide_hunt: 2
   divide_discovered: 2
   divide_spotted: 1.5
+casino:
+  probability: 0.05
+  roulette:
+    duration: 300
 hunt:
   timeout: 300.0
   cooldown:
@@ -45,6 +49,8 @@ commands:
     cooldown: 120.0
   tictactoe:
     cooldown: 120.0
+  skyjo:
+    cooldown: 120.0
   info:
     cooldown: 30.0
   basket:

easterobot/resources/credits.txt

@@ -3,3 +3,5 @@ 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
+skyjo/ https://github.com/Dashstrom/easterobot
+placements/ https://github.com/Dashstrom/easterobot