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

easterobot/cli.py

@@ -6,11 +6,17 @@ import sys
 from collections.abc import Sequence
 from typing import NoReturn, Optional
 
-from .bot import DEFAULT_CONFIG_PATH, Easterobot
+from alembic.config import CommandLine
+
+from easterobot.config import load_config_from_path
+
+from .bot import Easterobot
+from .config import DEFAULT_CONFIG_PATH
 from .info import __issues__, __summary__, __version__
 
 LOG_LEVELS = ["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"]
 logger = logging.getLogger(__name__)
+cmd_alembic = CommandLine(prog="easterobot alembic")
 
 
 class HelpArgumentParser(argparse.ArgumentParser):
@@ -61,7 +67,7 @@ def get_parser() -> argparse.ArgumentParser:
         action="store_true",
     )
 
-    # Parser of hello command
+    # Parser for run command
     run_parser = subparsers.add_parser(
         "run",
         parents=[parent_parser],
@@ -74,19 +80,40 @@ def get_parser() -> argparse.ArgumentParser:
         default=DEFAULT_CONFIG_PATH,
     )
 
-    # Parser of hello command
-    run_parser = subparsers.add_parser(
+    # Parser for generate command
+    generate_parser = subparsers.add_parser(
         "generate",
         parents=[parent_parser],
         help="generate a configuration.",
     )
-    run_parser.add_argument(
+    generate_parser.add_argument(
         "-i",
         "--interactive",
         help="ask questions for create a ready to use config.",
         action="store_true",
     )
-    run_parser.add_argument("destination", default=".")
+    generate_parser.add_argument("destination", default=".")
+
+    # Parser for alembic
+    alembic_parser = subparsers.add_parser(
+        "alembic",
+        parents=[cmd_alembic.parser],  # type: ignore[list-item]
+        help="use alembic with bot context.",
+        add_help=False,
+    )
+    for action in alembic_parser._actions:  # noqa: SLF001
+        if "--config" in action.option_strings:
+            alembic_parser._handle_conflict_resolve(  # noqa: SLF001
+                None,  # type: ignore[arg-type]
+                [("--config", action), ("-c", action)],
+            )
+            break
+    alembic_parser.add_argument(
+        "-c",
+        "--config",
+        help=f"path to configuration, default to {DEFAULT_CONFIG_PATH}.",
+        default=DEFAULT_CONFIG_PATH,
+    )
     return parser
 
 
@@ -101,27 +128,39 @@ def setup_logging(verbose: Optional[bool] = None) -> None:
 
 def entrypoint(argv: Optional[Sequence[str]] = None) -> None:
     """Entrypoint for command line interface."""
+    args = list(sys.argv[1:] if argv is None else argv)
     try:
         parser = get_parser()
-        args = parser.parse_args(argv)
-        setup_logging(args.verbose)
-        if args.action == "run":
+        namespace = parser.parse_args(args)
+        if namespace.action == "run":
+            setup_logging(namespace.verbose)
             bot = Easterobot.from_config(
-                args.config,
-                token=args.token,
-                env=args.env,
+                namespace.config,
+                token=namespace.token,
+                env=namespace.env,
             )
             bot.auto_run()
-        elif args.action == "generate":
+        elif namespace.action == "generate":
+            setup_logging(namespace.verbose)
             Easterobot.generate(
-                destination=args.destination,
-                token=args.token,
-                env=args.env,
-                interactive=args.interactive,
+                destination=namespace.destination,
+                token=namespace.token,
+                env=namespace.env,
+                interactive=namespace.interactive,
             )
+        elif namespace.action == "alembic":
+            if not hasattr(namespace, "cmd"):
+                # see http://bugs.python.org/issue9253, argparse
+                # behavior changed incompatibly in py3.3
+                parser.error("too few arguments")
+            else:
+                config = load_config_from_path(namespace.config)
+                cfg = config.alembic_config(namespace)
+                cmd_alembic.run_cmd(cfg, namespace)
         else:
             parser.error("No command specified")  # pragma: no cover
     except Exception as err:  # NoQA: BLE001  # pragma: no cover
+        setup_logging(verbose=True)
         logger.critical("Unexpected error", exc_info=err)
         logger.critical("Please, report this error to %s.", __issues__)
         sys.exit(1)

easterobot/commands/__init__.py

@@ -6,6 +6,11 @@ from easterobot.commands.basket import basket_command
 from easterobot.commands.disable import disable_command
 from easterobot.commands.edit import edit_command
 from easterobot.commands.enable import enable_command
+from easterobot.commands.game import (
+    connect4_command,
+    rockpaperscissor_command,
+    tictactoe_command,
+)
 from easterobot.commands.help import help_command
 from easterobot.commands.reset import reset_command
 from easterobot.commands.search import search_command
@@ -13,13 +18,16 @@ from easterobot.commands.top import top_command
 
 __all__ = [
     "basket_command",
+    "connect4_command",
     "disable_command",
     "edit_command",
     "egg_command_group",
     "enable_command",
     "help_command",
     "reset_command",
+    "rockpaperscissor_command",
     "search_command",
+    "tictactoe_command",
     "top_command",
 ]
 

easterobot/commands/base.py

@@ -33,8 +33,6 @@ InteractionChannel = Union[
     discord.VoiceChannel,
     discord.StageChannel,
     discord.TextChannel,
-    discord.ForumChannel,
-    discord.CategoryChannel,
     discord.Thread,
     discord.DMChannel,
     discord.GroupChannel,
@@ -98,10 +96,8 @@ def controlled_command(
             have_perms = interaction.user.guild_permissions.is_superset(
                 needed_perms
             )
-            admin_ids = interaction.client.config.admins
-            is_super_admin = (
-                interaction.user.id in admin_ids
-                or interaction.user.id == interaction.client.owner_id
+            is_super_admin = interaction.client.is_super_admin(
+                interaction.user
             )
             if not have_perms and not is_super_admin:
                 logger.warning("%s failed for wrong permissions", event_repr)
@@ -113,7 +109,7 @@ def controlled_command(
 
             # Check command cooldown
             cmd = interaction.command.name
-            if cooldown:
+            if cooldown and not is_super_admin:
                 available_at = None
                 async with (
                     AsyncSession(interaction.client.engine) as session,

easterobot/commands/basket.py

@@ -7,13 +7,14 @@ from discord import app_commands
 from sqlalchemy import and_, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from easterobot.bot import embed
 from easterobot.commands.base import (
     Context,
     controlled_command,
     egg_command_group,
 )
 from easterobot.config import agree
+from easterobot.hunts.hunt import embed
+from easterobot.hunts.rank import Ranking
 from easterobot.models import Egg
 
 
@@ -41,10 +42,8 @@ async def basket_command(
     async with AsyncSession(ctx.client.engine) as session:
         morsels = []
         missing = []
-        user_egg_count = await ctx.client.get_rank(
-            session, ctx.guild_id, hunter.id
-        )
-        rank = user_egg_count[1] if user_egg_count else None
+        ranking = await Ranking.from_guild(session, ctx.guild_id)
+        hunter_rank = ranking.get(hunter.id)
         res = await session.execute(
             select(
                 Egg.emoji_id,
@@ -60,7 +59,7 @@ async def basket_command(
         )
         egg_counts: dict[int, int] = dict(res.all())  # type: ignore[arg-type]
         egg_count = 0
-        for emoji in ctx.client.app_emojis.choices:
+        for emoji in ctx.client.egg_emotes.choices:
             try:
                 type_count = egg_counts.pop(emoji.id)
                 egg_count += type_count
@@ -73,12 +72,11 @@ async def basket_command(
             egg_count += absent_count
             morsels.insert(0, f"🥚 \xd7 {absent_count}")
 
-        if rank is not None:
-            il = ctx.client.config.conjugate("{Iel} est", hunter)
-            morsels.insert(
-                0,
-                f"**{'Tu es' if you else il} au rang** {rank}\n",
-            )
+        il = ctx.client.config.conjugate("{Iel} est", hunter)
+        morsels.insert(
+            0,
+            f"**{'Tu es' if you else il} au rang** {hunter_rank.badge}\n",
+        )
 
         their = "te" if you else "lui"
         if missing:

easterobot/commands/edit.py

@@ -1,11 +1,12 @@
 """Module for edit command."""
 
 import discord
+from discord import app_commands
 from sqlalchemy import and_, delete, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from easterobot.bot import embed
 from easterobot.config import RAND, agree
+from easterobot.hunts.hunt import embed
 from easterobot.models import Egg
 
 from .base import Context, controlled_command, egg_command_group
@@ -18,10 +19,9 @@ from .base import Context, controlled_command, egg_command_group
 async def edit_command(
     ctx: Context,
     user: discord.Member,
-    oeufs: int,
+    oeufs: app_commands.Range[int, 0, 10_000],
 ) -> None:
     """Edit command."""
-    oeufs = min(max(oeufs, 0), 100_000)
     await ctx.response.defer(ephemeral=True)
     async with AsyncSession(ctx.client.engine) as session:
         eggs: list[Egg] = list(
@@ -52,7 +52,7 @@ async def edit_command(
                         guild_id=ctx.guild_id,
                         channel_id=ctx.channel_id,
                         user_id=user.id,
-                        emoji_id=ctx.client.app_emojis.rand().id,
+                        emoji_id=ctx.client.egg_emotes.rand().id,
                     )
                 )
             await session.commit()

easterobot/commands/game.py

@@ -0,0 +1,187 @@
+"""Module for disable hunt."""
+
+import asyncio
+from typing import Callable, Optional
+
+import discord
+from discord import app_commands
+from sqlalchemy import and_, func, not_, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from easterobot.config import RAND
+from easterobot.games.connect import Connect4
+from easterobot.games.game import Game
+from easterobot.games.rock_paper_scissor import RockPaperScissor
+from easterobot.games.tic_tac_toe import TicTacToe
+from easterobot.hunts.rank import Ranking
+from easterobot.models import Egg
+
+from .base import Context, controlled_command, egg_command_group
+
+lock = asyncio.Lock()
+
+
+async def get_unlocked_eggs(
+    session: AsyncSession, member: discord.Member, counter: int
+) -> list[Egg]:
+    """Get the count of unlocked eggs."""
+    return list(
+        (
+            await session.scalars(
+                select(Egg)
+                .where(
+                    and_(
+                        Egg.guild_id == member.guild.id,
+                        Egg.user_id == member.id,
+                        not_(Egg.lock),
+                    )
+                )
+                .order_by(func.random())  # Randomize
+                .limit(counter)
+            )
+        ).all()
+    )
+
+
+async def game_dual(  # noqa: C901, D103, PLR0912
+    ctx: Context,
+    member: Optional[discord.Member],
+    bet: int,
+    cls: Callable[[discord.Member, discord.Member, discord.Message], Game],
+) -> None:
+    # If no member choose a random play in the guild with enough egg
+    if member is None:
+        if bet == 0:
+            members = [m for m in ctx.guild.members if m.id != ctx.user.id]
+        else:
+            # TODO(dashstrom): can chose member with locked eggs
+            async with AsyncSession(ctx.client.engine) as session:
+                ranking = await Ranking.from_guild(session, ctx.guild_id)
+            hunters = ranking.over(bet)
+            mapper_member = {m.id: m for m in ctx.guild.members}
+            members = [
+                mapper_member[h.member_id]
+                for h in hunters
+                if h.member_id != ctx.user.id and h.member_id in mapper_member
+            ]
+        if members:
+            member = RAND.choice(members)
+        else:
+            await ctx.response.send_message(
+                "Aucun utilisateur trouvé !",
+                ephemeral=True,
+            )
+            return
+
+    # Validate user
+    if (member.bot or member == ctx.user) and not ctx.client.is_super_admin(
+        member
+    ):
+        await ctx.response.send_message(
+            "L'utilisateur n'est pas valide !",
+            ephemeral=True,
+        )
+        return
+
+    # Check if user has enough eggs for ask
+    async with AsyncSession(ctx.client.engine) as session:
+        e1, e2 = await asyncio.gather(
+            get_unlocked_eggs(session, ctx.user, bet),
+            get_unlocked_eggs(session, member, bet),
+        )
+        if len(e1) < bet:
+            await ctx.response.send_message(
+                "Vous n'avez pas assez d'oeufs",
+                ephemeral=True,
+            )
+            return
+        if len(e2) < bet:
+            await ctx.response.send_message(
+                f"{member.mention} n'a pas assez d'oeufs",
+                ephemeral=True,
+            )
+            return
+
+    msg = await ctx.client.game.ask_dual(ctx, member, bet=bet)
+    if msg:
+        # Check if user still have enough eggs and lock them
+        async with AsyncSession(ctx.client.engine) as session:
+            async with lock:
+                e1, e2 = await asyncio.gather(
+                    get_unlocked_eggs(session, ctx.user, bet),
+                    get_unlocked_eggs(session, member, bet),
+                )
+                if len(e1) < bet:
+                    await ctx.response.send_message(
+                        "Vous n'avez plus assez d'oeufs",
+                        ephemeral=True,
+                    )
+                    return
+                for e in e1:
+                    e.lock = True
+                if len(e2) < bet:
+                    await ctx.response.send_message(
+                        f"{member.mention} n'a plus assez d'oeufs",
+                        ephemeral=True,
+                    )
+                    return
+                for e in e2:
+                    e.lock = True
+                await session.commit()
+
+            # Play the game
+            game = cls(ctx.user, member, msg)
+            await ctx.client.game.run(game)
+            winner = await game.wait_winner()
+
+            # Give eggs to the winner or remove previous one
+            async with lock:
+                for e in e1:
+                    e.lock = False
+                    if winner:
+                        e.user_id = winner.id
+                for e in e2:
+                    e.lock = False
+                    if winner:
+                        e.user_id = winner.id
+                await session.commit()
+
+
+@egg_command_group.command(
+    name="connect4", description="Lancer une partie de puissance 4."
+)
+@controlled_command(cooldown=True)
+async def connect4_command(
+    ctx: Context,
+    member: Optional[discord.Member] = None,
+    bet: app_commands.Range[int, 0] = 0,
+) -> None:
+    """Run a Connect4."""
+    await game_dual(ctx, member, bet, Connect4)
+
+
+@egg_command_group.command(
+    name="tictactoe", description="Lancer une partie de morpion."
+)
+@controlled_command(cooldown=True)
+async def tictactoe_command(
+    ctx: Context,
+    member: discord.Member,
+    bet: app_commands.Range[int, 0] = 0,
+) -> None:
+    """Run a tictactoe."""
+    await game_dual(ctx, member, bet, TicTacToe)
+
+
+@egg_command_group.command(
+    name="rockpaperscissor",
+    description="Lancer une partie de pierre papier ciseaux.",
+)
+@controlled_command(cooldown=True)
+async def rockpaperscissor_command(
+    ctx: Context,
+    member: discord.Member,
+    bet: app_commands.Range[int, 0] = 0,
+) -> None:
+    """Run a rockpaperscissor."""
+    await game_dual(ctx, member, bet, RockPaperScissor)

easterobot/commands/help.py

@@ -2,7 +2,7 @@
 
 from discord.app_commands import AppCommandGroup
 
-from easterobot.bot import embed
+from easterobot.hunts.hunt import embed
 
 from .base import Context, controlled_command, egg_command_group
 

easterobot/commands/reset.py

@@ -7,7 +7,7 @@ import discord
 from sqlalchemy import and_, delete
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from easterobot.bot import embed
+from easterobot.hunts.hunt import embed
 from easterobot.models import Cooldown, Egg, Hunt
 
 from .base import Context, Interaction, controlled_command, egg_command_group

easterobot/commands/search.py

@@ -7,8 +7,8 @@ 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.hunts.hunt import embed
 from easterobot.models import Egg, Hunt
 
 from .base import (
@@ -81,7 +81,7 @@ async def search_command(ctx: Context) -> None:
             ) -> discord.Message:
                 return await ctx.followup.send(*args, **kwargs)  # type: ignore[no-any-return]
 
-            await ctx.client.start_hunt(
+            await ctx.client.hunt.start_hunt(
                 ctx.channel_id,
                 ctx.client.config.spotted(ctx.user),
                 member_id=ctx.user.id,
@@ -89,7 +89,7 @@ async def search_command(ctx: Context) -> None:
             )
         else:
             logger.info("found: %.2f > %.2f", prob_s, sample_s)
-            emoji = ctx.client.app_emojis.rand()
+            emoji = ctx.client.egg_emotes.rand()
             async with AsyncSession(ctx.client.engine) as session:
                 session.add(
                     Egg(

easterobot/commands/top.py

@@ -8,8 +8,8 @@ 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.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
@@ -18,15 +18,6 @@ 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,
@@ -34,13 +25,11 @@ async def embed_rank(
 ) -> 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))
+        ranking = await Ranking.from_guild(session, ctx.guild_id)
+        hunters = ranking.page(page, limit=PAGE_SIZE)
+        morsels: list[str] = []
+        if hunters:
+            morsels.extend(hunter.record for hunter in hunters)
         else:
             morsels.append("\n:spider_web: Personne n'a d'œuf")
         total = await session.scalar(