easterobot 1.3.1__py3-none-any.whl → 1.5.1__py3-none-any.whl

easterobot/commands/reset.py

@@ -1,7 +1,6 @@
 """Module for reset command."""
 
 import asyncio
-from typing import cast
 
 import discord
 from sqlalchemy import and_, delete
@@ -9,6 +8,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from easterobot.hunts.hunt import embed
 from easterobot.models import Cooldown, Egg, Hunt
+from easterobot.utils import in_seconds
 
 from .base import Context, Interaction, controlled_command, egg_command_group
 
@@ -95,21 +95,18 @@ async def reset_command(ctx: Context) -> None:
 
     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",
+    message = 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."
+                f"\n\n-# Vous devez confirmer {in_seconds(30)}"
             ),
-            ephemeral=True,
-            view=view,
         ),
+        ephemeral=True,
+        view=view,
+        wait=True,
     )
     await asyncio.sleep(30.0)
     if not done:

easterobot/commands/roulette.py

@@ -0,0 +1,34 @@
+"""Command basket."""
+
+import discord
+
+from easterobot.casino.roulette import RouletteManager
+from easterobot.commands.base import (
+    Context,
+    controlled_command,
+    egg_command_group,
+)
+
+
+@egg_command_group.command(
+    name="roulette",
+    description="Lancer la roulette",
+)
+@controlled_command(cooldown=True, manage_channels=True)
+async def roulette_command(
+    ctx: Context,
+) -> None:
+    """Show current user basket."""
+    # Delay the response
+    if not isinstance(ctx.channel, discord.TextChannel):
+        await ctx.response.send_message(
+            "Salon invalide !",
+            ephemeral=True,
+        )
+        return
+    await ctx.response.send_message(
+        "Lancement de la roulette !",
+        ephemeral=True,
+    )
+    roulette = RouletteManager(ctx.client)
+    await roulette.run(ctx.channel)

easterobot/commands/top.py

@@ -1,55 +1,91 @@
 """Command top."""
 
 import logging
-from math import floor
-from typing import Optional
+from typing import TYPE_CHECKING
 
 import discord
-from sqlalchemy import distinct, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from easterobot.hunts.hunt import embed
 from easterobot.hunts.rank import Ranking
-from easterobot.models import Egg
 
-from .base import Context, Interaction, controlled_command, egg_command_group
+from .base import Context, controlled_command, egg_command_group
+
+if TYPE_CHECKING:
+    from easterobot.bot import Easterobot
 
 PAGE_SIZE = 10
 logger = logging.getLogger(__name__)
 
 
-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:
-        ranking = await Ranking.from_guild(session, ctx.guild_id)
-        hunters = ranking.page(page, limit=PAGE_SIZE)
-        morsels: list[str] = []
+class PaginationRanking(discord.ui.View):
+    embed: discord.Embed
+
+    def __init__(
+        self,
+        *,
+        ranking: Ranking,
+        page: int = 0,
+        limit: int = PAGE_SIZE,
+        timeout: int = 180,
+    ) -> None:
+        """Instantiate PaginationRanking."""
+        super().__init__(timeout=timeout)
+        self._page = 0
+        self._limit = limit
+        self._ranking = ranking
+        self.page = page
+
+    @property
+    def page(self) -> int:
+        """Current page."""
+        return self._page
+
+    @page.setter
+    def page(self, n: int) -> None:
+        self._page = min(max(n, 0), self._ranking.count_page(PAGE_SIZE) - 1)
+        self._update()
+
+    def _update(self) -> None:
+        count_page = self._ranking.count_page(PAGE_SIZE)
+        self.previous.disabled = self._page <= 0
+        self.next.disabled = self._page >= count_page - 1
+        hunters = self._ranking.page(self._page, limit=PAGE_SIZE)
         if hunters:
-            morsels.extend(hunter.record for hunter in hunters)
+            text = "\n".join(hunter.record for hunter in hunters)
         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
-            )
+            text = "\n:spider_web: Personne n'a d'œuf"
+        emb = embed(
+            title="Chasse aux œufs",
+            description=text,
+            footer=(f"Page {self._page + 1}/{count_page or 1}"),
         )
-        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 hasattr(self, "embed"):
+            emb.colour = self.embed.colour
+        self.embed = emb
+
+    @discord.ui.button(
+        label="<",
+        style=discord.ButtonStyle.gray,
     )
-    if colour is not None:
-        emb.colour = colour
-    return emb, page >= total
+    async def previous(
+        self,
+        interaction: discord.Interaction["Easterobot"],
+        button: discord.ui.Button["PaginationRanking"],  # noqa: ARG002
+    ) -> None:
+        """Get previous page."""
+        self.page -= 1
+        await interaction.response.edit_message(view=self, embed=self.embed)
+
+    @discord.ui.button(label=">", style=discord.ButtonStyle.gray)
+    async def next(
+        self,
+        interaction: discord.Interaction["Easterobot"],
+        button: discord.ui.Button["PaginationRanking"],  # noqa: ARG002
+    ) -> None:
+        """Get next page."""
+        self.page += 1
+        await interaction.response.edit_message(view=self, embed=self.embed)
 
 
 @egg_command_group.command(
@@ -60,35 +96,7 @@ 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)
+    async with AsyncSession(ctx.client.engine) as session:
+        ranking = await Ranking.from_guild(session, ctx.guild_id)
+    view = PaginationRanking(ranking=ranking, timeout=180)
+    await ctx.followup.send(embed=view.embed, ephemeral=True, view=view)

easterobot/config.py

@@ -124,6 +124,21 @@ class ConjugableText(Serializable[str]):
         return text.replace("{user}", f"<@{member.id}>")
 
 
+class CasinoEvent(msgspec.Struct):
+    duration: float
+
+
+class MCasino(msgspec.Struct):
+    probability: float
+    roulette: CasinoEvent
+
+    def sample_event(self) -> Optional[CasinoEvent]:
+        """Get a random event."""
+        if self.probability < RAND.random():
+            return None
+        return self.roulette
+
+
 class RandomItem(
     Serializable[list[T]],  # Stored form
 ):
@@ -258,6 +273,7 @@ class MCommands(msgspec.Struct, forbid_unknown_fields=True):
     help: MCommand
     edit: MCommand
     connect4: MCommand
+    skyjo: MCommand
     info: MCommand
     tictactoe: MCommand
     rockpaperscissor: MCommand
@@ -282,6 +298,7 @@ class MConfig(msgspec.Struct, dict=True):
     database: str
     group: str
     hunt: MHunt
+    casino: MCasino
     conjugation: Conjugation
     failed: RandomConjugableText
     hidden: RandomConjugableText
@@ -314,16 +331,27 @@ class MConfig(msgspec.Struct, dict=True):
             "%(data)s", "/" + self.working_directory.as_posix()
         )
 
+    def is_sleep_hours(self, hour: time) -> bool:
+        """Get if bot is currently in sleep mode.
+
+        Examples:
+            >>> config.is_sleep_hours(time(hour=0, minute=59))
+            False
+            >>> config.is_sleep_hours(time(hour=2))
+            True
+            >>> config.is_sleep_hours(time(hour=1))
+            True
+        """
+        if self.sleep.start < self.sleep.end:
+            return self.sleep.start <= hour < self.sleep.end
+        if self.sleep.start > self.sleep.end:
+            return self.sleep.end > hour or self.sleep.start <= hour
+        return False
+
     def in_sleep_hours(self) -> bool:
         """Get if bot is currently in sleep mode."""
         hour = datetime.now(tz=timezone.utc).time()
-        if self.sleep.start < self.sleep.end:
-            if self.sleep.start < hour < self.sleep.end:
-                return True
-        elif self.sleep.start > self.sleep.end:  # noqa: SIM102
-            if not self.sleep.start < hour < self.sleep.end:
-                return True
-        return False
+        return self.is_sleep_hours(hour)
 
     def verified_token(self) -> str:
         """Get the safe token."""
@@ -409,7 +437,6 @@ class MConfig(msgspec.Struct, dict=True):
                 disable_existing_loggers=False,
                 defaults=defaults,
             )
-            self.__logging_flag = True
 
     def __str__(self) -> str:
         """Represent the Configuration."""

easterobot/games/{connect.py → connect4.py}

@@ -1,11 +1,12 @@
 """Connect4 and Connect3."""
 
-from functools import partial
+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
 
@@ -22,36 +23,38 @@ EMOJIS_MAPPER = {
     "🔟": 9,
 }
 EMOJIS = tuple(EMOJIS_MAPPER)
+ROWS = 6
+COLS = 7
+WIN_COUNT = 4
 
 
-class Connect(Game):
-    def __init__(  # noqa: PLR0913
+class Connect4(Game):
+    def __init__(
         self,
-        player1: discord.Member,
-        player2: discord.Member,
+        bot: Easterobot,
         message: discord.Message,
-        rows: int,
-        cols: int,
-        win_count: int,
+        *members: discord.Member,
+        rows: int = ROWS,
+        cols: int = COLS,
+        win_count: int = WIN_COUNT,
     ) -> None:
         """Instantiate Connect4."""
         self.grid: list[list[Optional[Player]]] = [
             [None] * rows for _ in range(cols)
         ]
         self.timeout = False
-        self.player1 = Player(player1, 1)
-        self.player2 = Player(player2, 2)
         self.rows = rows
         self.cols = cols
         self.win_count = win_count
         self.turn = 0
-        super().__init__(message)
+        super().__init__(bot, message, *members)
 
     async def on_start(self) -> None:
         """Run."""
         await self.update()
         await self.start_timer(61)
         for emoji in EMOJIS[: self.cols]:
+            await asyncio.sleep(0.1)
             await self.message.add_reaction(emoji)
 
     async def update(self) -> None:
@@ -64,12 +67,12 @@ class Connect(Game):
             player: 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} 🎉"
             player = self.current
         else:
             footer = (
-                f"\n## Égalité entre {self.player1.member.mention} "
-                f"et {self.player2.member.mention} 🤝"
+                f"\n## Égalité entre {self.players[0].member.mention} "
+                f"et {self.players[1].member.mention} 🤝"
             )
             player = None
         content = label
@@ -93,10 +96,7 @@ class Connect(Game):
         )
         self.message = await self.message.edit(
             embed=embed,
-            content=(
-                f"-# {self.player1.member.mention} "
-                f"{self.player2.member.mention}"
-            ),
+            content=f"-# {' '.join(p.member.mention for p in self.players)}",
             view=None,
         )
 
@@ -116,15 +116,15 @@ class Connect(Game):
     @property
     def current(self) -> Player:
         """Get the current member playing."""
-        return [self.player1, self.player2][self.turn % 2]
+        return self.players[self.turn % 2]
 
     def piece(self, member: Optional[Player]) -> str:
         """Get the current member playing."""
         if member is None:
             return "⚪"
-        if member == self.player1:
+        if member == self.players[0]:
             return "🔴"
-        if member == self.player2:
+        if member == self.players[1]:
             return "🟡"
         error_message = f"Invalid member: {member!r}"
         raise ValueError(error_message)
@@ -133,9 +133,9 @@ class Connect(Game):
         """Get the current player playing."""
         if player is None:
             return discord.Colour.from_str("#d4d5d6")  # Grey
-        if player == self.player1:
+        if player == self.players[0]:
             return discord.Colour.from_str("#ca2a3e")  # Red
-        if player == self.player2:
+        if player == self.players[1]:
             return discord.Colour.from_str("#e9bb51")  # Yellow
         error_message = f"Invalid player: {player!r}"
         raise ValueError(error_message)
@@ -160,7 +160,7 @@ class Connect(Game):
             else:
                 return  # Can't be placed
             if winner:
-                await self.set_winner(player.member)
+                await self.set_winner(winner)
             elif all(  # Draw case
                 self.grid[col][-1] is not None for col in range(self.cols)
             ):
@@ -174,7 +174,7 @@ class Connect(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, col: int, row: int, player: Player) -> bool:
@@ -202,6 +202,3 @@ class Connect(Game):
             c += dx
             r += dy
         return count
-
-
-Connect4 = partial(Connect, rows=6, cols=7, win_count=4)