easterobot 1.0.0__tar.gz → 1.1.1__tar.gz

{easterobot-1.0.0 → easterobot-1.1.1}/.vscode/settings.json

@@ -8,6 +8,7 @@
   "files.associations": {
     "settings.json": "jsonc",
     "extensions.json": "jsonc",
+    "*.py.mako": "txt",
     "LICENSE": "txt"
   },
   // Files to exclude

{easterobot-1.0.0 → easterobot-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easterobot
-Version: 1.0.0
+Version: 1.1.1
 Summary: Discord bot for Easter.
 Project-URL: Homepage, https://github.com/Dashstrom/easterobot
 Project-URL: Repository, https://github.com/Dashstrom/easterobot
@@ -8,7 +8,7 @@ Project-URL: Documentation, https://dashstrom.github.io/easterobot
 Author-email: Dashstrom <dashstrom.pro@gmail.com>
 License-File: LICENSE
 Keywords: bot,discord,easter,eggs,hunt
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Framework :: Pytest
 Classifier: Framework :: Sphinx
@@ -27,6 +27,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 Requires-Python: <4.0,>=3.9
 Requires-Dist: aiosqlite>=0.21.0
+Requires-Dist: alembic>=1.15.2
 Requires-Dist: asyncpg>=0.30.0
 Requires-Dist: discord-py>=2.5.2
 Requires-Dist: msgspec>=0.19.0
@@ -135,6 +136,7 @@ Configuration directory
 ..  code-block:: text
 
   data                        Root directory
+  ├── .gitignore              Avoid pushing sensitive data
   ├── config.yml              Configuration file
   ├── easterobot.db           Database
   ├── logs                    Logging directory
@@ -142,10 +144,14 @@ Configuration directory
   │   └── easterobot.log.1    Rotating log file
   └── resources               Resource directory
       ├── config.example.yml  An example of config
-      ├── credits.txt         Credits of eggs emoji
-      ├── eggs                Directory for eggs
-      │   └── egg_01.png      Emoji to use
+      ├── credits.txt         Credits of emotes
+      ├── emotes              Directory loaded as application emotes
+      │   ├── eggs            Directory for eggs
+      │   |   └── egg_01.png  Emoji to use for egg
+      │   └── icons           Misc emotes to load
+      │       └── arrow.png   Emoji used in messages
       ├── logging.conf        Logging configuration
+      ├── alembic.ini         Configure for alembic
       └── logo.png            Logo used by the bot
 
 Development

{easterobot-1.0.0 → easterobot-1.1.1}/README.rst

@@ -98,6 +98,7 @@ Configuration directory
 ..  code-block:: text
 
   data                        Root directory
+  ├── .gitignore              Avoid pushing sensitive data
   ├── config.yml              Configuration file
   ├── easterobot.db           Database
   ├── logs                    Logging directory
@@ -105,10 +106,14 @@ Configuration directory
   │   └── easterobot.log.1    Rotating log file
   └── resources               Resource directory
       ├── config.example.yml  An example of config
-      ├── credits.txt         Credits of eggs emoji
-      ├── eggs                Directory for eggs
-      │   └── egg_01.png      Emoji to use
+      ├── credits.txt         Credits of emotes
+      ├── emotes              Directory loaded as application emotes
+      │   ├── eggs            Directory for eggs
+      │   |   └── egg_01.png  Emoji to use for egg
+      │   └── icons           Misc emotes to load
+      │       └── arrow.png   Emoji used in messages
       ├── logging.conf        Logging configuration
+      ├── alembic.ini         Configure for alembic
       └── logo.png            Logo used by the bot
 
 Development

easterobot-1.1.1/easterobot/alembic/env.py

@@ -0,0 +1,91 @@
+"""Environnement."""
+
+import asyncio
+
+from alembic import context
+from sqlalchemy import pool
+from sqlalchemy.engine import Connection
+from sqlalchemy.ext.asyncio import async_engine_from_config
+
+from easterobot.config import (
+    EXAMPLE_CONFIG_PATH,
+    MConfig,
+    load_config_from_path,
+)
+from easterobot.models import Base
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    if "easterobot_config" in config.attributes:
+        easterobot_config: MConfig = config.attributes["easterobot_config"]
+    else:
+        easterobot_config = load_config_from_path(EXAMPLE_CONFIG_PATH)
+    easterobot_config.configure_logging()
+# add your model's MetaData object here
+# for 'autogenerate' support
+target_metadata = [Base.metadata]
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def do_run_migrations(connection: Connection) -> None:
+    """Run all migrations."""
+    context.configure(connection=connection, target_metadata=target_metadata)
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+async def run_async_migrations() -> None:
+    """In this scenario we need to create an Engine.
+
+    Then we associate a connection with the context.
+    """
+    connectable = async_engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    async with connectable.connect() as connection:
+        await connection.run_sync(do_run_migrations)
+
+    await connectable.dispose()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode."""
+    asyncio.run(run_async_migrations())
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

easterobot-1.1.1/easterobot/alembic/script.py.mako

@@ -0,0 +1,28 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}

easterobot-1.1.1/easterobot/alembic/versions/2f0d4305e320_init_database.py

@@ -0,0 +1,67 @@
+"""init database.
+
+Revision ID: 2f0d4305e320
+Revises:
+Create Date: 2025-04-19 12:04:53.107440
+
+"""
+
+from collections.abc import Sequence
+from typing import Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "2f0d4305e320"
+down_revision: Union[str, None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "cooldown",
+        sa.Column("user_id", sa.BigInteger(), nullable=False),
+        sa.Column("guild_id", sa.BigInteger(), nullable=False),
+        sa.Column("command", sa.String(), nullable=False),
+        sa.Column("timestamp", sa.Float(), nullable=False),
+        sa.PrimaryKeyConstraint("user_id", "guild_id", "command"),
+    )
+    op.create_table(
+        "egg",
+        sa.Column(
+            "id",
+            sa.BigInteger().with_variant(sa.Integer(), "sqlite"),
+            autoincrement=True,
+            nullable=False,
+        ),
+        sa.Column("guild_id", sa.BigInteger(), nullable=False),
+        sa.Column("channel_id", sa.BigInteger(), nullable=False),
+        sa.Column("user_id", sa.BigInteger(), nullable=False),
+        sa.Column("emoji_id", sa.BigInteger(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_egg_guild_id"), "egg", ["guild_id"], unique=False)
+    op.create_index(op.f("ix_egg_user_id"), "egg", ["user_id"], unique=False)
+    op.create_table(
+        "hunt",
+        sa.Column("channel_id", sa.BigInteger(), nullable=False),
+        sa.Column("guild_id", sa.BigInteger(), nullable=False),
+        sa.Column("next_egg", sa.Float(), nullable=False),
+        sa.PrimaryKeyConstraint("channel_id"),
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table("hunt")
+    op.drop_index(op.f("ix_egg_user_id"), table_name="egg")
+    op.drop_index(op.f("ix_egg_guild_id"), table_name="egg")
+    op.drop_table("egg")
+    op.drop_table("cooldown")
+    # ### end Alembic commands ###

easterobot-1.1.1/easterobot/alembic/versions/940c3b9c702d_add_lock_on_eggs.py

@@ -0,0 +1,38 @@
+"""add lock on eggs.
+
+Revision ID: 940c3b9c702d
+Revises: 2f0d4305e320
+Create Date: 2025-04-19 12:52:02.245048
+
+"""
+
+from collections.abc import Sequence
+from typing import Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "940c3b9c702d"
+down_revision: Union[str, None] = "2f0d4305e320"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.add_column(
+        "egg",
+        sa.Column(
+            "lock", sa.Boolean(), nullable=False, server_default=sa.text("0")
+        ),
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_column("egg", "lock")
+    # ### end Alembic commands ###

easterobot-1.1.1/easterobot/bot.py

@@ -0,0 +1,215 @@
+"""Main program."""
+
+import logging
+import logging.config
+import pathlib
+import shutil
+from getpass import getpass
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Optional,
+    TypeVar,
+    Union,
+)
+
+import discord
+import discord.app_commands
+import discord.ext.commands
+from alembic.command import upgrade
+from sqlalchemy.ext.asyncio import create_async_engine
+
+if TYPE_CHECKING:
+    from easterobot.games.game import GameCog
+    from easterobot.hunts.hunt import HuntCog
+
+from .config import (
+    DEFAULT_CONFIG_PATH,
+    EXAMPLE_CONFIG_PATH,
+    RESOURCES,
+    MConfig,
+    RandomItem,
+    dump_yaml,
+    load_config_from_buffer,
+    load_config_from_path,
+)
+
+T = TypeVar("T")
+
+logger = logging.getLogger(__name__)
+INTENTS = discord.Intents.all()
+
+
+class Easterobot(discord.ext.commands.Bot):
+    owner: discord.User
+    game: "GameCog"
+    hunt: "HuntCog"
+
+    def __init__(self, config: MConfig) -> None:
+        """Initialise Easterbot."""
+        super().__init__(
+            command_prefix=".",
+            description="Bot discord pour faire la chasse aux œufs",
+            activity=discord.Game(name="rechercher des œufs"),
+            intents=INTENTS,
+        )
+        self.config = config
+
+        # Attributes
+        self.app_commands: list[discord.app_commands.AppCommand] = []
+        self.app_emojis: dict[str, discord.Emoji] = {}
+
+        # Configure logging
+        self.config.configure_logging()
+
+        # Update database
+        upgrade(self.config.alembic_config(), "head")
+
+        # Open database
+        logger.info("Open database %s", self.config.database_uri)
+        self.engine = create_async_engine(
+            self.config.database_uri,
+            echo=False,
+        )
+
+    @classmethod
+    def from_config(
+        cls,
+        path: Union[str, Path] = DEFAULT_CONFIG_PATH,
+        *,
+        token: Optional[str] = None,
+        env: bool = False,
+    ) -> "Easterobot":
+        """Instantiate Easterobot from config."""
+        config = load_config_from_path(path, token=token, env=env)
+        return Easterobot(config)
+
+    @classmethod
+    def generate(
+        cls,
+        destination: Union[Path, str],
+        *,
+        token: Optional[str],
+        env: bool,
+        interactive: bool,
+    ) -> "Easterobot":
+        """Generate all data."""
+        destination = Path(destination).resolve()
+        destination.mkdir(parents=True, exist_ok=True)
+        config_data = EXAMPLE_CONFIG_PATH.read_bytes()
+        config = load_config_from_buffer(config_data, token=token, env=env)
+        config.attach_default_working_directory(destination)
+        if interactive:
+            while True:
+                try:
+                    config.verified_token()
+                    break
+                except (ValueError, TypeError):
+                    config.token = getpass("Token: ")
+        config._resources = pathlib.Path("resources")  # noqa: SLF001
+        shutil.copytree(
+            RESOURCES, destination / "resources", dirs_exist_ok=True
+        )
+        config_path = destination / "config.yml"
+        config_path.write_bytes(dump_yaml(config))
+        (destination / ".gitignore").write_bytes(b"*\n")
+        return Easterobot(config)
+
+    def is_super_admin(
+        self,
+        user: Union[discord.User, discord.Member],
+    ) -> bool:
+        """Get if user is admin."""
+        return (
+            user.id in self.config.admins
+            or user.id in (self.owner.id, self.owner_id)
+            or (self.owner_ids is not None and user.id in self.owner_ids)
+        )
+
+    async def resolve_channel(
+        self,
+        channel_id: int,
+    ) -> Optional[discord.TextChannel]:
+        """Resolve channel."""
+        channel = self.get_channel(channel_id)
+        if channel is None:
+            try:
+                channel = await self.fetch_channel(channel_id)
+            except (discord.NotFound, discord.Forbidden):
+                return None
+        if not isinstance(channel, discord.TextChannel):
+            return None
+        return channel
+
+    # Method that loads cogs
+    async def setup_hook(self) -> None:
+        """Setup hooks."""
+        await self.load_extension(
+            "easterobot.commands", package="easterobot.commands.__init__"
+        )
+        await self.load_extension(
+            "easterobot.games", package="easterobot.games.__init__"
+        )
+        await self.load_extension(
+            "easterobot.hunts", package="easterobot.hunts.__init__"
+        )
+
+    def auto_run(self) -> None:
+        """Run the bot with the given token."""
+        self.run(token=self.config.verified_token())
+
+    async def on_ready(self) -> None:
+        """Handle ready event, can be trigger many time if disconnected."""
+        # Sync bot commands
+        logger.info("Syncing command")
+        await self.tree.sync()
+        self.app_commands = await self.tree.fetch_commands()
+
+        # Sync bot owner
+        app_info = await self.application_info()
+        self.owner = app_info.owner
+        logger.info("Owner is %s (%s)", self.owner.display_name, self.owner.id)
+
+        # Load emojis
+        await self._load_emojis()
+
+        # Load eggs
+        eggs_path = (self.config.resources / "emotes" / "eggs").resolve()
+        self.egg_emotes = RandomItem(
+            [self.app_emojis[path.stem] for path in eggs_path.glob("**/*")]
+        )
+
+        # Log all available guilds
+        async for guild in self.fetch_guilds():
+            logger.info("Guild %s (%s)", guild, guild.id)
+        logger.info(
+            "Logged on as %s (%s) !",
+            self.user,
+            getattr(self.user, "id", "unknown"),
+        )
+
+    async def _load_emojis(self) -> None:
+        emojis = {
+            emoji.name: emoji
+            for emoji in await self.fetch_application_emojis()
+        }
+        emotes_path = (self.config.resources / "emotes").resolve()
+        self.app_emojis = {}
+        for emote in emotes_path.glob("**/*"):
+            if not emote.is_file():
+                continue
+            name = emote.stem
+            if emote.stem not in emojis:
+                logger.info(
+                    "Missing emoji %s, create emoji on application",
+                    name,
+                )
+                image_data = emote.read_bytes()
+                emoji = await self.create_application_emoji(
+                    name=name,
+                    image=image_data,
+                )
+                self.app_emojis[name] = emoji
+            else:
+                logger.info("Load emoji %s", name)
+                self.app_emojis[name] = emojis[name]

{easterobot-1.0.0 → easterobot-1.1.1}/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-1.0.0 → easterobot-1.1.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",
 ]