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

easterobot/config.py

@@ -1,9 +1,12 @@
 """Main program."""
 
+import logging
+import logging.config
 import os
 import pathlib
 import random
 from abc import ABC, abstractmethod
+from argparse import Namespace
 from collections.abc import Iterable
 from typing import (
     Any,
@@ -17,6 +20,7 @@ from typing import (
 
 import discord
 import msgspec
+from alembic.config import Config
 from typing_extensions import TypeGuard, get_args, get_origin, override
 
 RAND = random.SystemRandom()
@@ -24,7 +28,11 @@ RAND = random.SystemRandom()
 T = TypeVar("T")
 V = TypeVar("V")
 Members = Union[discord.Member, list[discord.Member]]
+
+HERE = pathlib.Path(__file__).parent.resolve()
 RESOURCES = pathlib.Path(__file__).parent.resolve() / "resources"
+DEFAULT_CONFIG_PATH = pathlib.Path("config.yml")
+EXAMPLE_CONFIG_PATH = RESOURCES / "config.example.yml"
 
 
 class Serializable(ABC, Generic[V]):
@@ -167,12 +175,14 @@ class MCooldown(msgspec.Struct):
 class MWeights(msgspec.Struct):
     egg: float
     speed: float
+    base: float
 
 
 class MHunt(msgspec.Struct):
     timeout: float
     cooldown: MCooldown
     weights: MWeights
+    game: float
 
 
 class MCommand(msgspec.Struct):
@@ -219,7 +229,7 @@ class MText(msgspec.Struct):
 Conjugation = dict[str, MGender]
 
 
-class MCommands(msgspec.Struct):
+class MCommands(msgspec.Struct, forbid_unknown_fields=True):
     search: SearchCommand
     top: MCommand
     basket: MCommand
@@ -228,6 +238,9 @@ class MCommands(msgspec.Struct):
     disable: MCommand
     help: MCommand
     edit: MCommand
+    connect4: MCommand
+    tictactoe: MCommand
+    rockpaperscissor: MCommand
 
     def __getitem__(self, key: str, /) -> MCommand:
         """Get a command."""
@@ -256,13 +269,20 @@ class MConfig(msgspec.Struct, dict=True):
     appear: RandomItem[str]
     action: RandomItem[MText]
     commands: MCommands
+    token: Optional[Union[str, msgspec.UnsetType]] = msgspec.UNSET
     _resources: Optional[Union[pathlib.Path, msgspec.UnsetType]] = (
         msgspec.field(name="resources", default=msgspec.UNSET)
     )
     _working_directory: Optional[Union[pathlib.Path, msgspec.UnsetType]] = (
         msgspec.field(name="working_directory", default=msgspec.UNSET)
     )
-    token: Optional[Union[str, msgspec.UnsetType]] = msgspec.UNSET
+
+    @property
+    def database_uri(self) -> str:
+        """Get async string for database."""
+        return self.database.replace(
+            "%(data)s", "/" + self.working_directory.as_posix()
+        )
 
     def verified_token(self) -> str:
         """Get the safe token."""
@@ -320,6 +340,36 @@ class MConfig(msgspec.Struct, dict=True):
         conj.attach(self.conjugation)
         return conj(member)
 
+    def alembic_config(self, namespace: Optional[Namespace] = None) -> Config:
+        """Get alembic config."""
+        config_alembic = str(self.resources / "alembic.ini")
+        cfg = Config(
+            file_=config_alembic,
+            ini_section="alembic" if namespace is None else namespace.name,
+            cmd_opts=namespace,
+            attributes={
+                "easterobot_config": self,
+            },
+        )
+        cfg.set_main_option("sqlalchemy.url", self.database_uri)
+        cfg.set_main_option("script_location", str(HERE / "alembic"))
+        return cfg
+
+    def configure_logging(self) -> None:
+        """Configure logging."""
+        if self.use_logging_file and not hasattr(self, "__logging_flag"):
+            logging_file = self.resources / "logging.conf"
+            defaults = {"data": self.working_directory.as_posix()}
+            if not logging_file.is_file():
+                error_message = f"Cannot find message: {str(logging_file)!r}"
+                raise FileNotFoundError(error_message)
+            logging.config.fileConfig(
+                logging_file,
+                disable_existing_loggers=False,
+                defaults=defaults,
+            )
+            self.__logging_flag = True
+
 
 def _dec_hook(typ: type[T], obj: Any) -> T:
     # Get the base type
@@ -371,7 +421,7 @@ def convert(obj: Any, typ: type[T]) -> T:
     )
 
 
-def load_config(
+def load_config_from_buffer(
     data: Union[bytes, str],
     token: Optional[str] = None,
     *,
@@ -388,6 +438,20 @@ def load_config(
     return config
 
 
+def load_config_from_path(
+    path: Union[str, pathlib.Path],
+    token: Optional[str] = None,
+    *,
+    env: bool = False,
+) -> MConfig:
+    """Load config."""
+    path = pathlib.Path(path)
+    data = path.read_bytes()
+    config = load_config_from_buffer(data, token=token, env=env)
+    config.attach_default_working_directory(path.parent)
+    return config
+
+
 def agree(
     singular: str,
     plural: str,

easterobot/games/__init__.py

@@ -0,0 +1,14 @@
+"""Init package."""
+
+from easterobot.bot import Easterobot
+from easterobot.games.game import GameCog
+
+__all__ = [
+    "GameCog",
+]
+
+
+async def setup(bot: Easterobot) -> None:
+    game_cog = GameCog(bot)
+    bot.game = game_cog
+    await bot.add_cog(game_cog)

easterobot/games/connect.py

@@ -0,0 +1,206 @@
+"""Connect4 and Connect3."""
+
+import datetime
+from functools import partial
+from typing import Optional
+
+import discord
+from discord.utils import format_dt
+from typing_extensions import override
+
+from easterobot.games.game import Game, Player
+
+EMOJIS_MAPPER = {
+    "1️⃣": 0,
+    "2️⃣": 1,
+    "3️⃣": 2,
+    "4️⃣": 3,
+    "5️⃣": 4,
+    "6️⃣": 5,
+    "7️⃣": 6,
+    "8️⃣": 7,
+    "9️⃣": 8,
+    "🔟": 9,
+}
+EMOJIS = tuple(EMOJIS_MAPPER)
+
+
+class Connect(Game):
+    def __init__(  # noqa: PLR0913
+        self,
+        player1: discord.Member,
+        player2: discord.Member,
+        message: discord.Message,
+        rows: int,
+        cols: int,
+        win_count: int,
+    ) -> 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)
+
+    async def on_start(self) -> None:
+        """Run."""
+        await self.update()
+        for emoji in EMOJIS[: self.cols]:
+            await self.message.add_reaction(emoji)
+        self.start_timer(60)
+
+    async def update(self) -> None:
+        """Update the text."""
+        footer = ""
+        label = ""
+        if not self.terminate:
+            label = self.piece(self.current)
+            label += f" Joueur actuel : {self.current.member.mention}\n\n"
+            player: Optional[Player] = self.current
+        elif self.winner:
+            forfait = "par forfait " if self.timeout else ""
+            footer = f"\n## Gagnant {forfait}{self.winner.mention} 🎉"
+            player = self.current
+        else:
+            footer = (
+                f"\n## Égalité entre {self.player1.member.mention} "
+                f"et {self.player2.member.mention} 🤝"
+            )
+            player = None
+        content = label
+        content += "│".join(EMOJIS[: self.cols])
+        content += "\n"
+        content += "\n".join(
+            "│".join(self.piece(self.grid[y][x]) for y in range(self.cols))
+            for x in reversed(range(self.rows))
+        )
+        content += footer
+        now = datetime.datetime.now() + datetime.timedelta(seconds=62)  # noqa: DTZ005
+        if not self.terminate:
+            content += f"\n\nFin du tour {format_dt(now, style='R')}"
+        embed = discord.Embed(description=content, color=self.color(player))
+        embed.set_author(
+            name="Partie terminée" if self.terminate else "Partie en cours",
+            icon_url=(
+                player.member.display_avatar.url
+                if player
+                else self.bot.app_emojis["end"].url
+            ),
+        )
+        self.message = await self.message.edit(
+            embed=embed,
+            content="",
+            view=None,
+        )
+
+    async def on_reaction(
+        self,
+        member_id: int,
+        reaction: discord.PartialEmoji,
+    ) -> None:
+        """Add a reaction to the message."""
+        if (
+            reaction.name not in EMOJIS[: self.cols]
+            or member_id != self.current.member.id
+        ):
+            return
+        await self.place(EMOJIS_MAPPER[reaction.name], self.current)
+
+    @property
+    def current(self) -> Player:
+        """Get the current member playing."""
+        return [self.player1, self.player2][self.turn % 2]
+
+    def piece(self, member: Optional[Player]) -> str:
+        """Get the current member playing."""
+        if member is None:
+            return "⚪"
+        if member == self.player1:
+            return "🔴"
+        if member == self.player2:
+            return "🟡"
+        error_message = f"Invalid member: {member!r}"
+        raise ValueError(error_message)
+
+    def color(self, player: Optional[Player]) -> Optional[discord.Colour]:
+        """Get the current player playing."""
+        if player is None:
+            return discord.Colour.from_str("#d4d5d6")  # Grey
+        if player == self.player1:
+            return discord.Colour.from_str("#ca2a3e")  # Red
+        if player == self.player2:
+            return discord.Colour.from_str("#e9bb51")  # Yellow
+        error_message = f"Invalid player: {player!r}"
+        raise ValueError(error_message)
+
+    async def place(
+        self,
+        col: int,
+        player: Player,
+    ) -> None:
+        """Place a jetton."""
+        async with self.lock:
+            if self.terminate:
+                return
+            winner = None
+            for row in range(self.rows):
+                if self.grid[col][row] is None:
+                    await self.stop_timer()
+                    self.grid[col][row] = player
+                    if self._is_winner(col, row, player):
+                        winner = player
+                    break
+            else:
+                return  # Can't be placed
+            if winner:
+                await self.set_winner(player.member)
+            elif all(  # Draw case
+                self.grid[col][-1] is not None for col in range(self.cols)
+            ):
+                await self.set_winner(None)
+            else:
+                self.turn += 1
+                self.start_timer(60)
+            await self.update()
+
+    @override
+    async def on_timeout(self) -> None:
+        self.turn += 1
+        self.timeout = True
+        await self.set_winner(self.current.member)
+        await self.update()
+
+    def _is_winner(self, col: int, row: int, player: Player) -> bool:
+        directions = [(1, 0), (0, 1), (1, 1), (1, -1)]
+        for dx, dy in directions:
+            if (
+                self._count_consecutive(col, row, dx, dy, player)
+                + self._count_consecutive(col, row, -dx, -dy, player)
+                - 1
+            ) >= self.win_count:
+                return True
+        return False
+
+    def _count_consecutive(
+        self, col: int, row: int, dx: int, dy: int, player: Player
+    ) -> int:
+        count = 0
+        c, r = col, row
+        while (
+            0 <= c < self.cols
+            and 0 <= r < self.rows
+            and self.grid[c][r] == player
+        ):
+            count += 1
+            c += dx
+            r += dy
+        return count
+
+
+Connect4 = partial(Connect, rows=6, cols=7, win_count=4)

easterobot/games/game.py

@@ -0,0 +1,262 @@
+"""Base class for game."""
+
+import asyncio
+import contextlib
+import datetime
+import logging
+from collections.abc import Coroutine
+from dataclasses import dataclass
+from typing import Any, Callable, Optional
+from uuid import uuid4
+
+import discord
+from discord.ext import commands
+from discord.message import convert_emoji_reaction
+from discord.utils import format_dt
+
+from easterobot.bot import Easterobot
+from easterobot.commands.base import Context, Interaction, InteractionChannel
+from easterobot.config import RAND
+
+logger = logging.getLogger(__name__)
+AsyncCallback = Callable[[], Coroutine[Any, Any, None]]
+Button = discord.ui.Button[discord.ui.View]
+
+
+class GameError(Exception):
+    pass
+
+
+class InvalidActionError(GameError):
+    pass
+
+
+class InvalidPlayerError(GameError):
+    @staticmethod
+    def from_player(member: discord.Member) -> "InvalidPlayerError":
+        """Create error from a member."""
+        return InvalidPlayerError(
+            f"Player {member!r} is not included in the game"
+        )
+
+
+@dataclass
+class Player:
+    member: discord.Member
+    number: int
+
+
+class Game:
+    bot: Easterobot
+
+    def __init__(self, message: discord.Message) -> None:
+        """Instantiate Game."""
+        self.id = uuid4()
+        self.message = message
+        self.terminate = False
+        self.winner: Optional[discord.Member] = None
+        self.lock = asyncio.Lock()
+        self._cleanup: Optional[AsyncCallback] = None
+        self._completion: Optional[AsyncCallback] = None
+        self._end_event = asyncio.Event()
+        self._reset_countdown_event = asyncio.Event()
+        self._timeout_task: Optional[asyncio.Task[None]] = None
+
+    async def set_completion(self, callback: AsyncCallback) -> None:
+        """Get the current state for a player."""
+        self._completion = callback
+
+    async def wait_winner(self) -> Optional[discord.Member]:
+        """Wait the end of the game."""
+        await self._end_event.wait()
+        return self.winner
+
+    async def on_start(self) -> None:
+        """Get the current state for a player."""
+
+    async def on_reaction(
+        self,
+        member_id: int,
+        reaction: discord.PartialEmoji,
+    ) -> None:
+        """Add a reaction to the message."""
+
+    async def on_timeout(self) -> None:
+        """Can when game timeout."""
+
+    async def set_winner(self, winner: Optional[discord.Member]) -> None:
+        """Remove the game from the manager."""
+        self.terminate = True
+        self.winner = winner
+        if self._cleanup is not None:
+            await self._cleanup()
+        if self._completion is not None:
+            await self._completion()
+        self._end_event.set()
+
+    def start_timer(self, seconds: float) -> str:
+        """Start the timer for turn."""
+        now = datetime.datetime.now() + datetime.timedelta(seconds=seconds)  # noqa: DTZ005
+        dt = format_dt(now, style="R")
+        self._timeout_task = asyncio.create_task(self._timeout_worker(seconds))
+        return dt
+
+    async def stop_timer(self) -> None:
+        """Stop the timer and wait it end."""
+        if self._timeout_task:
+            self._reset_countdown_event.set()
+            await self._timeout_task
+            self._timeout_task = None
+            self._reset_countdown_event = asyncio.Event()
+
+    async def _timeout_worker(self, seconds: float) -> None:
+        """Timeout action."""
+        event = self._reset_countdown_event
+        try:
+            await asyncio.wait_for(event.wait(), timeout=seconds)
+        except asyncio.TimeoutError:
+            if not event.is_set():
+                async with self.lock:
+                    await self.on_timeout()
+
+    def __repr__(self) -> str:
+        """Get game representation."""
+        return (
+            f"<{self.__class__.__qualname__} "
+            f"id={self.id!r} message={self.message!r} "
+            f"terminate={self.terminate!r} winner={self.winner!r}"
+            ">"
+        )
+
+    def __str__(self) -> str:
+        """Get game representation."""
+        return Game.__repr__(self)  # Enforce usage of Game class for __str__
+
+
+class GameCog(commands.Cog):
+    def __init__(self, bot: Easterobot) -> None:
+        """Manage all games."""
+        self.bot = bot
+        self._games: dict[int, Game] = {}
+
+    async def dual(
+        self,
+        channel: InteractionChannel,
+        reference: discord.Message,
+        user1: discord.Member,
+        user2: discord.Member,
+    ) -> Optional[discord.Member]:
+        """Start a dual between two players."""
+        from easterobot.games.connect import Connect4
+        from easterobot.games.rock_paper_scissor import RockPaperScissor
+        from easterobot.games.tic_tac_toe import TicTacToe
+
+        cls = RAND.choice([Connect4, TicTacToe, RockPaperScissor])
+        now = datetime.datetime.now() + datetime.timedelta(seconds=63)  # noqa: DTZ005
+        dt = format_dt(now, style="R")
+        msg = await channel.send(
+            f"{user1.mention} et {user2.mention} vont s'affronter {dt} ...",
+            reference=reference,
+        )
+        await asyncio.sleep(63)
+        game: Game = cls(user1, user2, msg)  # type: ignore[operator]
+        await self.run(game)
+        return await game.wait_winner()
+
+    async def run(self, game: Game) -> None:
+        """Attach the game to the manager."""
+        message_id = game.message.id
+
+        async def _cleanup() -> None:
+            if message_id in self._games:
+                del self._games[message_id]
+            else:
+                logger.warning("Missing game: %s", game)
+            await game.message.clear_reactions()
+
+        self._games[message_id] = game
+        game._cleanup = _cleanup  # noqa: SLF001
+        game.bot = self.bot
+        await game.on_start()
+
+    async def ask_dual(
+        self,
+        ctx: Context,
+        member: discord.Member,
+        bet: int,
+    ) -> Optional[discord.Message]:
+        """Send basic message for initialization."""
+        future: asyncio.Future[bool] = asyncio.Future()
+        accept = False
+
+        view = discord.ui.View()
+        yes_btn: Button = discord.ui.Button(
+            label="Accepter", style=discord.ButtonStyle.green, emoji="⚔️"
+        )
+        no_btn: Button = discord.ui.Button(
+            label="Refuser", style=discord.ButtonStyle.red, emoji="🛡️"
+        )
+
+        async def yes(interaction: Interaction) -> Any:
+            if interaction.user.id == member.id:
+                future.set_result(True)
+            await interaction.response.defer()
+
+        async def no(interaction: Interaction) -> Any:
+            if interaction.user.id == member.id:
+                future.set_result(False)
+            await interaction.response.defer()
+
+        yes_btn.callback = yes  # type: ignore[method-assign,assignment]
+        no_btn.callback = no  # type: ignore[method-assign,assignment]
+        view.add_item(yes_btn)
+        view.add_item(no_btn)
+        now = datetime.datetime.now() + datetime.timedelta(seconds=180)  # noqa: DTZ005
+        dt = format_dt(now, style="R")
+        result = await ctx.response.send_message(
+            f"{member.mention}, {ctx.user.mention} "
+            f"vous demande en duel pour `{bet}` œufs ⚔️"
+            f"\nVous devez repondre {dt} !",
+            view=view,
+        )
+        message = result.resource
+        if not isinstance(message, discord.Message):
+            error_message = f"Invalid kind of message: {message!r}"
+            raise TypeError(error_message)
+        with contextlib.suppress(asyncio.TimeoutError):
+            accept = await asyncio.wait_for(future, timeout=180)
+        if not accept:
+            await message.edit(
+                content=(
+                    f"{member.mention}, {ctx.user.mention} a refusé le duel 🛡️"
+                ),
+                view=None,
+            )
+            return None
+        if not isinstance(result.resource, discord.Message):
+            error_message = f"Invalid kind of message: {result.resource!r}"
+            raise TypeError(error_message)
+        return result.resource
+
+    @commands.Cog.listener()
+    async def on_raw_reaction_add(
+        self, payload: discord.RawReactionActionEvent
+    ) -> None:
+        """Handle reaction."""
+        if payload.message_author_id is None:
+            return
+        if self.bot.user and payload.user_id == self.bot.user.id:
+            return
+        if payload.message_id in self._games:
+            # Use connection for faster remove
+            emoji = convert_emoji_reaction(payload.emoji)
+            game = self._games[payload.message_id]
+            await asyncio.gather(
+                self.bot._connection.http.remove_reaction(  # noqa: SLF001
+                    payload.channel_id,
+                    payload.message_id,
+                    emoji,
+                    payload.user_id,
+                ),
+                game.on_reaction(payload.user_id, payload.emoji),
+            )