I give up :sadge:

.gitea/workflows/docker-publish.yml

@@ -0,0 +1,103 @@
+name: Docker
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+  workflow_dispatch:
+  schedule:
+    - cron: "@daily"
+
+env:
+  BOT_TOKEN: ${{ secrets.BOT_TOKEN }}
+  TIMEZONE: Europe/Stockholm
+  LOG_LEVEL: Info
+  SQLITE_LOCATION: /data/jobs.sqlite
+
+jobs:
+  build-and-push-docker:
+    runs-on: ubuntu-latest
+    steps:
+      # GitHub Container Registry
+      - uses: https://github.com/docker/login-action@v3
+        if: github.event_name != 'pull_request'
+        with:
+          registry: ghcr.io
+          username: thelovinator1
+          password: ${{ secrets.PACKAGES_WRITE_GITHUB_TOKEN }}
+
+      # Gitea Container Registry
+      - uses: https://github.com/docker/login-action@v3
+        if: github.event_name != 'pull_request'
+        with:
+          registry: git.lovinator.space
+          username: thelovinator
+          password: ${{ secrets.PACKAGES_WRITE_GITEA_TOKEN }}
+
+      # Docker Hub Registry
+      - uses: https://github.com/docker/login-action@v3
+        if: github.event_name != 'pull_request'
+        with:
+          registry: docker.io
+          username: thelovinator
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      # Download the latest commit from the master branch
+      - uses: https://github.com/actions/checkout@v4
+
+      # Set up QEMU
+      - id: qemu
+        uses: https://github.com/docker/setup-qemu-action@v3
+        with:
+          image: tonistiigi/binfmt:master
+          platforms: linux/amd64,linux/arm64
+          cache-image: false
+
+       # Set up Buildx so we can build multi-arch images
+      - uses: https://github.com/docker/setup-buildx-action@v3
+
+      # Set up uv for Python dependency management
+      - uses: astral-sh/setup-uv@v5
+        with:
+          version: "latest"
+
+      # Install dependencies
+      - run: uv sync --all-extras --all-groups
+
+      # Run tests
+      - run: uv run pytest
+
+      # Install the latest version of ruff
+      - uses: https://github.com/astral-sh/ruff-action@v3
+        with:
+          version: "latest"
+
+      # Lint the Python code using ruff
+      - run: ruff check --exit-non-zero-on-fix --verbose
+
+      # Check if the Python code needs formatting
+      - run: ruff format --check --verbose
+
+      # Lint Dockerfile
+      - run: docker build --check .
+
+      # Extract metadata (tags, labels) from Git reference and GitHub events for Docker
+      - id: meta
+        uses: https://github.com/docker/metadata-action@v5
+        with:
+          images: |
+            thelovinator/discord-reminder-bot
+            ghcr.io/thelovinator1/discord-reminder-bot
+          tags: |
+            type=raw,value=latest,enable=${{ gitea.ref == format('refs/heads/{0}', 'master') }}
+
+      # Build and push the Docker image
+      - uses: https://github.com/docker/build-push-action@v6
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: ${{ gitea.event_name != 'pull_request' }}
+          labels: ${{ steps.meta.outputs.labels }}
+          tags: ${{ steps.meta.outputs.tags }}
+          annotations: ${{ steps.meta.outputs.annotations }}

.github/workflows/docker-publish.yml

@@ -1,60 +0,0 @@
-name: Docker
-
-on:
-  # push:
-  # pull_request:
-  workflow_dispatch:
-  # schedule:
-  #   - cron: "0 6 * * *"
-
-env:
-  BOT_TOKEN: ${{ secrets.BOT_TOKEN }}
-  TIMEZONE: Europe/Stockholm
-  LOG_LEVEL: Info
-  SQLITE_LOCATION: /data/jobs.sqlite
-
-jobs:
-  build-and-push-docker:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - run: |
-          if [ -z "${{ env.BOT_TOKEN }}" ]; then
-            echo "BOT_TOKEN not set"
-            exit 1
-          fi
-      - uses: actions/checkout@v4
-      - uses: astral-sh/setup-uv@v5
-        with:
-          python-version: 3.13
-      - run: uv sync --all-extras --dev
-      - run: uv run pytest
-      - uses: docker/setup-qemu-action@v3
-        with:
-          platforms: all
-      - uses: docker/setup-buildx-action@v3
-      - uses: docker/login-action@v3
-        if: github.event_name != 'pull_request'
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      - uses: docker/login-action@v3
-        if: github.event_name != 'pull_request'
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - uses: docker/build-push-action@v6
-        with:
-          context: .
-          platforms: linux/amd64, linux/arm64
-          push: ${{ github.event_name != 'pull_request' }}
-          tags: thelovinator/discord-reminder-bot:latest
-      - uses: docker/build-push-action@v6
-        with:
-          context: .
-          platforms: linux/amd64, linux/arm64
-          push: ${{ github.event_name != 'pull_request' }}
-          tags: ghcr.io/thelovinator1/discord-reminder-bot:latest

.github/workflows/poetry.yml

@@ -1,38 +0,0 @@
-name: Poetry
-
-on:
-  # push:
-  # pull_request:
-  workflow_dispatch:
-  # schedule:
-  #   - cron: "0 6 * * *"
-
-env:
-  BOT_TOKEN: ${{ secrets.BOT_TOKEN }}
-  TIMEZONE: Europe/Stockholm
-  LOG_LEVEL: Info
-  SQLITE_LOCATION: /data/jobs.sqlite
-
-jobs:
-  test-on-poetry:
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.10", "3.11", "3.12", "3.13"]
-        poetry-version: ["latest", "main"]
-    steps:
-    - run: |
-        if [ -z "${{ env.BOT_TOKEN }}" ]; then
-          echo "BOT_TOKEN not set"
-          exit 1
-        fi
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
-      with:
-        python-version: ${{ matrix.python-version }}
-    - uses: abatilo/actions-poetry@v4
-      with:
-        poetry-version: ${{ matrix.poetry-version }}
-    - run: poetry install
-    - run: poetry run pytest

.github/workflows/uv.yml

@@ -1,41 +0,0 @@
-name: uv
-
-on:
-  # push:
-  # pull_request:
-  workflow_dispatch:
-  # schedule:
-  #   - cron: "0 6 * * *"
-
-env:
-  BOT_TOKEN: ${{ secrets.BOT_TOKEN }}
-  TIMEZONE: Europe/Stockholm
-  LOG_LEVEL: Info
-  SQLITE_LOCATION: /data/jobs.sqlite
-  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-jobs:
-  test-on-uv:
-    name: Install with uv and run tests on Python ${{ matrix.python-version }}
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ["3.10", "3.11", "3.12", "3.13", "pypy"]
-    steps:
-    - run: |
-          if [ -z "${{ env.BOT_TOKEN }}" ]; then
-            echo "BOT_TOKEN not set"
-            exit 1
-          fi
-    - name: Checkout code
-      uses: actions/checkout@v4
-    - name: Install uv and set the python version to ${{ matrix.python-version }}
-      uses: astral-sh/setup-uv@v5
-      with:
-          python-version: ${{ matrix.python-version }}
-          version: "latest"
-    - name: Install dependencies
-      run: uv sync --all-extras --dev
-    - name: Run tests
-      run: uv run pytest

.pre-commit-config.yaml

@@ -29,7 +29,7 @@ repos:
         args: ["--py310-plus"]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.9.6
+    rev: v0.11.10
     hooks:
       - id: ruff-format
       - id: ruff

.vscode/settings.json

@@ -6,6 +6,7 @@
         "asyncio",
         "audioop",
         "autouse",
+        "binfmt",
         "botuser",
         "Buildx",
         "cookiejar",
@@ -16,23 +17,27 @@
         "dotenv",
         "filterwarnings",
         "freezegun",
+        "Gitea",
         "hikari",
         "isort",
         "jobstore",
         "jobstores",
         "Jocke",
         "levelname",
+        "levelno",
         "loguru",
         "Lovinator",
         "pycodestyle",
         "pydocstyle",
         "pyproject",
         "pypy",
+        "pytest",
         "PYTHONDONTWRITEBYTECODE",
         "PYTHONUNBUFFERED",
         "pyupgrade",
         "sqlalchemy",
         "thelovinator",
+        "tonistiigi",
         "uvloop"
     ],
     "python.analysis.typeCheckingMode": "standard"

Dockerfile

@@ -1,13 +1,18 @@
-FROM python:3.13-slim
+FROM --platform=$BUILDPLATFORM python:3.13-slim
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
 ENV PYTHONUNBUFFERED=1
 ENV PYTHONDONTWRITEBYTECODE=1
-COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
+
 RUN useradd -m botuser && mkdir -p /home/botuser/data
 WORKDIR /home/botuser
+
 COPY interactions /home/botuser/interactions
 COPY discord_reminder_bot /home/botuser/discord_reminder_bot
-RUN --mount=type=cache,target=/root/.cache/uv \
-    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+
+RUN --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
     uv sync --no-install-project
+
 VOLUME ["/home/botuser/data/"]
+
 CMD ["uv", "run", "discord_reminder_bot/main.py"]

discord_reminder_bot/commands/backup.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import datetime
+import json
+import tempfile
+from typing import TYPE_CHECKING
+
+import discord
+from loguru import logger
+
+if TYPE_CHECKING:
+    from apscheduler.schedulers.asyncio import AsyncIOScheduler
+    from discord.interactions import InteractionChannel
+
+
+async def backup_reminder_job(interaction: discord.Interaction, scheduler: AsyncIOScheduler, all_servers: bool) -> None:
+    """Backs up reminder jobs from the scheduler to a JSON file.
+
+    Args:
+        interaction: The discord interaction object that triggered the command.
+        scheduler: The AsyncIOScheduler instance containing the jobs to back up.
+        all_servers: If True, backs up jobs from all servers managed by the
+            scheduler. If False, backs up only jobs associated with the
+            server (guild) where the command was invoked.
+    """
+    logger.info(f"Backing up reminders for {interaction.user} ({interaction.user.id}) in {interaction.channel}")
+    logger.info(f"Arguments: {locals()}")
+
+    # Retrieve all jobs
+    with tempfile.NamedTemporaryFile(mode="r+", delete=False, encoding="utf-8", suffix=".json") as temp_file:
+        # Export jobs to a temporary file
+        scheduler.export_jobs(temp_file.name)
+
+        # Load the exported jobs
+        temp_file.seek(0)
+        jobs_data = json.load(temp_file)
+
+    # Amount of jobs before filtering
+    amount_of_jobs: int = len(jobs_data.get("jobs", []))
+
+    if not all_servers:
+        interaction_channel: InteractionChannel | None = interaction.channel
+        if not interaction_channel:
+            await interaction.followup.send(content="Failed to get channel.", ephemeral=True)
+            return
+
+        if not isinstance(interaction.user, discord.Member):
+            await interaction.followup.send(content="Failed to get user.", ephemeral=True)
+            return
+
+        is_admin: bool = interaction_channel.permissions_for(interaction.user).administrator
+        if not is_admin:
+            await interaction.followup.send(content="You must be an administrator to backup all servers.", ephemeral=True)
+            return
+
+        # Can't be 0 because that's the default value for jobs without a guild
+        guild_id: int = interaction.guild.id if interaction.guild else -1
+        channels_in_this_guild: list[int] = [c.id for c in interaction.guild.channels] if interaction.guild else []
+        logger.debug(f"Guild ID: {guild_id}")
+
+        for job in jobs_data.get("jobs", []):
+            # Check if the job is in the current guild
+            job_guild_id = int(job.get("kwargs", {}).get("guild_id", 0))
+            if job_guild_id and job_guild_id != guild_id:
+                logger.debug(f"Skipping job: {job.get('id')} because it's not in the current guild.")
+                jobs_data["jobs"].remove(job)
+
+            # Check if the channel is in the current guild
+            if job.get("kwargs", {}).get("channel_id") not in channels_in_this_guild:
+                logger.debug(f"Skipping job: {job.get('id')} because it's not in the current guild.")
+                jobs_data["jobs"].remove(job)
+
+    msg: str = "All reminders in this server have been backed up." if not all_servers else "All reminders have been backed up."
+    msg += "\nYou can restore them using `/remind restore`."
+
+    if not all_servers:
+        msg += f"\nAmount of jobs on all servers: {amount_of_jobs}, in this server: {len(jobs_data.get('jobs', []))}"
+        msg += "\nYou can use `/remind backup all_servers:True` to backup all servers."
+    else:
+        msg += f"\nAmount of jobs: {amount_of_jobs}"
+
+    # Write the data to a new file
+    with tempfile.NamedTemporaryFile(mode="w", delete=False, encoding="utf-8", suffix=".json") as output_file:
+        file_name: str = f"reminders-backup-{datetime.datetime.now(tz=scheduler.timezone)}.json"
+        json.dump(jobs_data, output_file, indent=4)
+        output_file.seek(0)
+
+        await interaction.followup.send(content=msg, file=discord.File(output_file.name, filename=file_name))

discord_reminder_bot/commands/event.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import datetime
+
+import discord
+from loguru import logger
+
+from discord_reminder_bot.parsers import parse_time
+
+
+async def add_discord_event(
+    interaction: discord.Interaction,
+    message: str,
+    event_start: str,
+    event_end: str,
+    location: str,
+    reason: str | None = None,
+) -> None:
+    """Creates a new Discord scheduled event based on user input.
+
+    This command handles the creation of a scheduled event within the Discord guild
+    where the interaction originated. It parses the provided start and end times,
+    validates permissions, and creates the event using the Discord API. If the
+    specified start time is in the past, it adjusts the start time to be slightly
+    in the future and starts the event immediately.
+
+    Args:
+        interaction: The discord interaction object representing the command invocation.
+        message: The name or description for the scheduled event.
+        event_start: A string representing the desired start time for the event.
+                     This string will be parsed into a datetime object.
+        event_end: A string representing the desired end time for the event.
+                   This string will be parsed into a datetime object.
+        location: A string specifying the location for the event (e.g., a URL or physical address).
+        reason: An optional string providing a reason for the event creation,
+                visible in the guild's audit log. Defaults to a standard message
+                indicating the creator if None.
+    """
+    logger.info(f"New event from {interaction.user} ({interaction.user.id}) in {interaction.channel}")
+    logger.info(f"Arguments: {locals()}")
+
+    # Check if we have a valid guild
+    guild: discord.Guild | None = interaction.guild
+    if not guild:
+        await interaction.followup.send(content="This command can only be used in a server.", ephemeral=True)
+        return
+
+    # Check if we have permission to create events
+    if not guild.me.guild_permissions.create_events:
+        await interaction.followup.send(content="I don't have permission to create events in this guild.", ephemeral=True)
+        return
+
+    event_start_time: datetime.datetime | None = parse_time(date_to_parse=event_start)
+    event_end_time: datetime.datetime | None = parse_time(date_to_parse=event_end)
+
+    if not event_start_time or not event_end_time:
+        await interaction.followup.send(content=f"Failed to parse time: {event_start} or {event_end}.", ephemeral=True)
+        return
+
+    # If event_start_time is in the past, make it now + 5 seconds
+    start_immediately: bool = False
+    if event_start_time < datetime.datetime.now(event_start_time.tzinfo):
+        start_immediately = True
+        event_start_time = datetime.datetime.now(event_start_time.tzinfo) + datetime.timedelta(seconds=5)
+        await interaction.followup.send(content="Event start time was in the past. Starting event in 5 seconds instead.")
+
+    reason_msg: str = f"Event created by {interaction.user} ({interaction.user.id})."
+
+    event: discord.ScheduledEvent = await guild.create_scheduled_event(
+        name=message,
+        start_time=event_start_time,
+        entity_type=discord.EntityType.external,
+        privacy_level=discord.PrivacyLevel.guild_only,
+        end_time=event_end_time,
+        reason=reason or reason_msg,
+        location=location,
+    )
+
+    if start_immediately:
+        await event.start()
+
+    msg: str = f"Event '{event.name}' created successfully!\n"
+
+    if event.start_time:
+        msg += f"Start Time: <t:{int(event.start_time.timestamp())}:R>\n"
+
+    if event.end_time:
+        msg += f"End Time: <t:{int(event.end_time.timestamp())}:R>\n"
+
+    if event.channel_id:
+        msg += f"Channel: <#{event.channel_id}>\n"
+
+    if event.location:
+        msg += f"Location: {event.location}\n"
+
+    if event.creator_id:
+        msg += f"Created by: <@{event.creator_id}>"
+
+    await interaction.followup.send(content=msg)

discord_reminder_bot/commands/list.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import discord
+from loguru import logger
+
+from discord_reminder_bot.markdown_utils import generate_reminder_summary
+
+if TYPE_CHECKING:
+    from apscheduler.job import Job
+    from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+
+async def list_reminder_job(interaction: discord.Interaction, scheduler: AsyncIOScheduler) -> None:
+    """List all reminder jobs in the scheduler.
+
+    Args:
+        interaction (discord.Interaction): The interaction object for the command.
+        scheduler (AsyncIOScheduler): The scheduler to list the jobs from.
+    """
+    user: discord.User | discord.Member = interaction.user
+    if not isinstance(user, discord.Member):
+        await interaction.followup.send(content="This command can only be used in a server.", ephemeral=True)
+        return
+
+    channel = interaction.channel
+    if not isinstance(channel, discord.TextChannel):
+        await interaction.followup.send(content="This command can only be used in a text channel.", ephemeral=True)
+        return
+
+    logger.info(f"Listing reminders for {user} ({user.id}) in {interaction.channel}")
+    logger.info(f"Arguments: {locals()}")
+
+    jobs: list[Job] = scheduler.get_jobs()
+    if not jobs:
+        await interaction.followup.send(content="No scheduled jobs found in the database.", ephemeral=True)
+        return
+
+    guild: discord.Guild | None = interaction.guild
+    if not guild:
+        await interaction.followup.send(content="Failed to get guild.", ephemeral=True)
+        return
+
+    message: discord.InteractionMessage = await interaction.original_response()
+
+    job_summary: list[str] = generate_reminder_summary(ctx=interaction, bot=interaction.client, scheduler=scheduler)
+
+    for i, msg in enumerate(job_summary):
+        if i == 0:
+            await message.edit(content=msg)
+        else:
+            await interaction.followup.send(content=msg)

discord_reminder_bot/commands/pause.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from apscheduler.jobstores.base import JobLookupError
+
+if TYPE_CHECKING:
+    import discord
+    from apscheduler.job import Job
+    from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+logger: logging.Logger = logging.getLogger("discord_reminder_bot")
+
+
+async def pause_reminder_job(interaction: discord.Interaction, job_id: str, scheduler: AsyncIOScheduler) -> None:
+    """Pauses a specific reminder job in the APScheduler.
+
+    This function attempts to find and pause a job identified by `job_id`
+    within the provided `scheduler`. It logs the action and sends feedback
+    to the user via the Discord interaction, indicating success or failure.
+
+    Args:
+        interaction: The Discord interaction object representing the command invocation.
+        job_id: The unique identifier of the reminder job to pause.
+        scheduler: The AsyncIOScheduler instance managing the reminder jobs.
+    """
+    logger.info("Pausing reminder with ID %s for %s (%s) in %s", job_id, interaction.user, interaction.user.id, interaction.channel)
+    logger.debug("Arguments: %s", locals())
+
+    logger.debug("Attempting to pause job...")
+    try:
+        job: Job | None = scheduler.get_job(job_id)
+        if not job:
+            await interaction.followup.send(content=f"Reminder with ID {job_id} not found.", ephemeral=True)
+            return
+        scheduler.pause_job(job_id)
+        logger.info("Paused job %s.", job_id)
+        await interaction.followup.send(content=f"Reminder with ID {job_id} paused successfully.")
+    except JobLookupError as e:
+        logger.exception("Failed to pause job %s", job_id)
+        await interaction.followup.send(content=f"Failed to pause reminder with ID {job_id}. {e}", ephemeral=True)
+
+    logger.info("Job %s paused in the scheduler.", job_id)

discord_reminder_bot/commands/remove.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from apscheduler.jobstores.base import JobLookupError
+from loguru import logger
+
+from discord_reminder_bot.markdown_utils import generate_markdown_state
+
+if TYPE_CHECKING:
+    import discord
+    from apscheduler.job import Job
+    from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+
+async def remove_reminder_job(interaction: discord.Interaction, job_id: str, scheduler: AsyncIOScheduler) -> None:
+    """Removes a specific reminder job from the scheduler based on its ID.
+
+    This function attempts to find a job associated with the given `job_id`
+    within the provided `scheduler`. If the job exists, it is removed,
+    and a confirmation message detailing the removed job's state is sent
+    as a follow-up to the interaction. If the job cannot be found, or if
+    an error occurs during the removal process (like `JobLookupError`),
+    an appropriate error message is sent as an ephemeral follow-up.
+
+    Args:
+        interaction (discord.Interaction): The Discord interaction object
+            that triggered the command. Used for sending follow-up messages.
+        job_id (str): The unique identifier of the reminder job to be removed.
+        scheduler (AsyncIOScheduler): The APScheduler instance managing the
+            scheduled reminder jobs.
+
+    """
+    logger.debug(f"Removing reminder with ID {job_id} for {interaction.user} ({interaction.user.id}) in {interaction.channel}")
+    logger.debug(f"Arguments: {locals()}")
+
+    try:
+        job: Job | None = scheduler.get_job(job_id)
+        if not job:
+            await interaction.followup.send(content=f"Reminder with ID {job_id} not found.", ephemeral=True)
+            return
+        scheduler.remove_job(job_id)
+        logger.info(f"Removed job {job_id}. {job.__getstate__()}")
+        await interaction.followup.send(
+            content=f"Reminder with ID {job_id} removed successfully.\n{generate_markdown_state(job.__getstate__())}",
+        )
+    except JobLookupError as e:
+        logger.exception(f"Failed to remove job {job_id}")
+        await interaction.followup.send(content=f"Failed to remove reminder with ID {job_id}. {e}", ephemeral=True)
+
+    logger.info(f"Job {job_id} removed from the scheduler.")

discord_reminder_bot/commands/restore.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import json
+import logging
+import tempfile
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import discord
+
+from discord_reminder_bot.parsers import calculate
+
+if TYPE_CHECKING:
+    import discord
+    from apscheduler.job import Job
+    from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+logger: logging.Logger = logging.getLogger("discord_reminder_bot")
+
+
+async def restore_reminder_job(bot: discord.Client, interaction: discord.Interaction, scheduler: AsyncIOScheduler) -> None:  # noqa: PLR0915
+    """Restores reminder jobs from a user-provided JSON backup file.
+
+    Prompts the user via the interaction followup to reply with a JSON file
+    containing the backup data. Waits for a message reply from the same user
+    in the same channel containing a single JSON attachment.
+    Validates the reply and attachment. Downloads the JSON file to a temporary
+    location, loads the job data, filters out any jobs that already exist in the
+    scheduler (based on job ID), and imports the remaining jobs using
+    `scheduler.import_jobs`.
+    Finally, sends a confirmation message listing the newly added jobs or
+    indicates if no new jobs were added.
+
+    Args:
+        bot (discord.Client): The Discord bot client instance, used to wait for
+            the user's reply message.
+        interaction (discord.Interaction): The interaction object representing the
+            command invocation. Used for sending messages back to the user.
+        scheduler (AsyncIOScheduler): The APScheduler instance where the jobs
+            will be restored.
+    """
+    logger.info("Restoring reminders from file for %s (%s) in %s", interaction.user, interaction.user.id, interaction.channel)
+    logger.info("Arguments: %s", locals())
+
+    # Tell to reply with the file to this message
+    await interaction.followup.send(content="Please reply to this message with the backup file.")
+
+    # Get the old jobs
+    old_jobs: list[Job] = scheduler.get_jobs()
+
+    # Wait for the reply
+    while True:
+        try:
+            reply: discord.Message | None = await bot.wait_for("message", timeout=60, check=lambda m: m.author == interaction.user)
+        except TimeoutError:
+            edit_msg = "~~Please reply to this message with the backup file.~~\nTimed out after 60 seconds."
+            await interaction.edit_original_response(content=edit_msg)
+            return
+
+        if not reply:
+            await interaction.followup.send(content="No reply found. Please try again.")
+            continue
+
+        if not reply.channel:
+            await interaction.followup.send(content="No channel found. Please try again.")
+            continue
+
+        # Fetch the message by its ID to ensure we have the latest data
+        reply = await reply.channel.fetch_message(reply.id)
+
+        if not reply or not reply.attachments:
+            await interaction.followup.send(content="No file attached. Please try again.")
+            continue
+        break
+
+    # Get the attachment
+    attachment: discord.Attachment = reply.attachments[0]
+    if not attachment or not attachment.filename.endswith(".json"):
+        await interaction.followup.send(
+            content=f"Invalid file type. Should be a JSON file not '{attachment.filename}'. Please try again.",
+        )
+        return
+
+    jobs_already_exist: list[str] = []
+
+    # Save the file to a temporary file and import the jobs
+    with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8", suffix=".json") as temp_file:
+        logger.info("Saving attachment to %s", temp_file.name)
+        await attachment.save(Path(temp_file.name))
+
+        # Load the jobs data from the file
+        temp_file.seek(0)
+        jobs_data: dict = json.load(temp_file)
+
+        logger.info("Importing jobs from file")
+        logger.debug("Jobs data: %s", jobs_data)
+
+        with tempfile.NamedTemporaryFile(mode="w+", delete=False, encoding="utf-8", suffix=".json") as temp_import_file:
+            # We can't import jobs with the same ID so remove them from the JSON
+            jobs = [job for job in jobs_data.get("jobs", []) if not scheduler.get_job(job.get("id"))]
+            jobs_already_exist = [job.get("id") for job in jobs_data.get("jobs", []) if scheduler.get_job(job.get("id"))]
+            jobs_data["jobs"] = jobs
+            for job_id in jobs_already_exist:
+                logger.debug("Skipping importing '%s' because it already exists in the db.", job_id)
+
+            logger.debug("Jobs data after filtering: %s", jobs_data)
+            logger.info("Jobs already exist: %s", jobs_already_exist)
+
+            # Write the new data to a temporary file
+            json.dump(jobs_data, temp_import_file)
+            temp_import_file.seek(0)
+
+            # Import the jobs
+            scheduler.import_jobs(temp_import_file.name)
+
+    # Get the new jobs
+    new_jobs: list[Job] = scheduler.get_jobs()
+
+    # Get the difference
+    added_jobs: list[Job] = [job for job in new_jobs if job not in old_jobs]
+
+    if added_jobs:
+        msg: str = "Reminders restored successfully.\nAdded jobs:\n"
+        for j in added_jobs:
+            msg += f"* Message: **{j.kwargs.get('message', 'No message found')}** {calculate(j) or 'N/A'}\n"
+
+        await interaction.followup.send(content=msg)
+    else:
+        await interaction.followup.send(content="No new reminders were added.")

discord_reminder_bot/commands/unpause.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from apscheduler.jobstores.base import JobLookupError
+from loguru import logger
+
+if TYPE_CHECKING:
+    import discord
+    from apscheduler.job import Job
+    from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+
+async def unpause_reminder(interaction: discord.Interaction, job_id: str, scheduler: AsyncIOScheduler) -> None:
+    """Unpauses a scheduled reminder job.
+
+    Finds a job by its ID in the scheduler and resumes it. Sends feedback
+    to the user via the interaction about the success or failure of the operation.
+
+    Args:
+        interaction: The discord interaction object representing the command invocation.
+        job_id: The unique identifier of the reminder job to unpause.
+        scheduler: The scheduler instance to manage the job.
+    """
+    logger.debug(f"Unpausing reminder with ID {job_id} for {interaction.user} ({interaction.user.id}) in {interaction.channel}")
+    logger.debug(f"Arguments: {locals()}")
+
+    try:
+        job: Job | None = scheduler.get_job(job_id)
+        if not job:
+            await interaction.followup.send(content=f"Reminder with ID {job_id} not found.", ephemeral=True)
+            return
+        scheduler.resume_job(job_id)
+        logger.info(f"Unpaused job {job_id}.")
+        await interaction.followup.send(content=f"Reminder with ID {job_id} unpaused successfully.")
+    except JobLookupError as e:
+        logger.exception(f"Failed to unpause job {job_id}")
+        await interaction.followup.send(content=f"Failed to unpause reminder with ID {job_id}. {e}", ephemeral=True)
+
+    logger.info(f"Job {job_id} unpaused in the scheduler.")

discord_reminder_bot/markdown_utils.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+import discord
+from apscheduler.job import Job
+from apscheduler.triggers.date import DateTrigger
+from apscheduler.triggers.interval import IntervalTrigger
+from loguru import logger
+
+from discord_reminder_bot.parsers import get_human_readable_time
+from interactions.api.models.misc import Snowflake
+
+if TYPE_CHECKING:
+    from apscheduler.schedulers.asyncio import AsyncIOScheduler
+    from discord.guild import GuildChannel
+    from discord.types.channel import _BaseChannel
+
+
+def generate_markdown_state(state: dict[str, Any]) -> str:
+    """Format the __getstate__ dictionary for Discord markdown.
+
+    Args:
+        state (dict): The __getstate__ dictionary.
+
+    Returns:
+        str: The formatted string.
+    """
+    if not state:
+        return "```json\nNo state found.\n```"
+
+    # Convert the IntervalTrigger to a string representation
+    for key, value in state.items():
+        if isinstance(value, IntervalTrigger):
+            state[key] = "IntervalTrigger"
+        elif isinstance(value, DateTrigger):
+            state[key] = "DateTrigger"
+        elif isinstance(value, Job):
+            state[key] = "Job"
+        elif isinstance(value, Snowflake):
+            state[key] = str(value)
+
+    try:
+        msg: str = json.dumps(state, indent=4, default=str)
+    except TypeError as e:
+        e.add_note("This is likely due to a non-serializable object in the state. Please check the state for any non-serializable objects.")
+        e.add_note(f"{state=}")
+        logger.error(f"Failed to serialize state: {e}")
+        return "```json\nFailed to serialize state.\n```"
+
+    return "```json\n" + msg + "\n```"
+
+
+def generate_reminder_summary(ctx: discord.Interaction, bot: discord.Client, scheduler: AsyncIOScheduler) -> list[str]:  # noqa: PLR0912
+    """Create a message with all the jobs, splitting messages into chunks of up to 2000 characters.
+
+    Args:
+        ctx (discord.Interaction): The context of the interaction.
+        bot (discord.Client): The Discord bot client.
+        scheduler (AsyncIOScheduler): The scheduler to get the jobs from.
+
+    Returns:
+        list[str]: A list of messages with all the jobs.
+    """
+    jobs: list[Job] = scheduler.get_jobs()
+    msgs: list[str] = []
+
+    guild: discord.Guild | None = None
+    if isinstance(ctx.channel, discord.abc.GuildChannel):
+        guild = ctx.channel.guild
+
+    channels: list[GuildChannel] | list[_BaseChannel] = list(guild.channels) if guild else []
+    channels_in_this_guild: list[int] = [c.id for c in channels]
+    jobs_in_guild: list[Job] = []
+    for job in jobs:
+        guild_id: int = guild.id if guild else -1
+
+        guild_id_from_kwargs = int(job.kwargs.get("guild_id", 0))
+
+        if guild_id_from_kwargs and guild_id_from_kwargs != guild_id:
+            logger.debug(f"Skipping job: {job.id} because it's not in the current guild.")
+            continue
+
+        if job.kwargs.get("channel_id") not in channels_in_this_guild:
+            logger.debug(f"Skipping job: {job.id} because it's not in the current guild.")
+            continue
+
+        logger.debug(f"Adding job: {job.id} to the list.")
+        jobs_in_guild.append(job)
+
+    if len(jobs) != len(jobs_in_guild):
+        logger.info(f"Filtered out {len(jobs) - len(jobs_in_guild)} jobs that are not in the current guild.")
+
+    jobs = jobs_in_guild
+
+    if not jobs:
+        return ["No scheduled jobs found in the database."]
+
+    header = (
+        "You can use the following commands to manage reminders:\n"
+        "Only jobs in the current guild are shown.\n"
+        "`/remind pause <job_id>` - Pause a reminder\n"
+        "`/remind unpause <job_id>` - Unpause a reminder\n"
+        "`/remind remove <job_id>` - Remove a reminder\n"
+        "`/remind modify <job_id>` - Modify the time of a reminder\n"
+        "List of all reminders:\n"
+    )
+
+    current_msg: str = header
+
+    for job in jobs:
+        # Build job-specific message
+        job_msg: str = "```md\n"
+        job_msg += f"# {job.kwargs.get('message', '')}\n"
+        job_msg += f"   * {job.id}\n"
+        job_msg += f"   * {job.trigger} {get_human_readable_time(job)}"
+
+        if job.kwargs.get("user_id"):
+            job_msg += f" <@{job.kwargs.get('user_id')}>"
+        if job.kwargs.get("channel_id"):
+            channel = bot.get_channel(job.kwargs.get("channel_id"))
+            if channel and isinstance(channel, discord.abc.GuildChannel | discord.Thread):
+                job_msg += f" in #{channel.name}"
+
+        if job.kwargs.get("guild_id"):
+            guild = bot.get_guild(job.kwargs.get("guild_id"))
+            if guild:
+                job_msg += f" in {guild.name}"
+            job_msg += f" {job.kwargs.get('guild_id')}"
+
+        job_msg += "```"
+
+        # If adding this job exceeds 2000 characters, push the current message and start a new one.
+        if len(current_msg) + len(job_msg) > 2000:
+            msgs.append(current_msg)
+            current_msg = job_msg
+        else:
+            current_msg += job_msg
+
+    # Append any remaining content in current_msg.
+    if current_msg:
+        msgs.append(current_msg)
+
+    return msgs

discord_reminder_bot/parsers.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import datetime
+import logging
+import os
+from typing import TYPE_CHECKING
+from zoneinfo import ZoneInfo
+
+import dateparser
+from apscheduler.triggers.cron import CronTrigger
+from apscheduler.triggers.date import DateTrigger
+from apscheduler.triggers.interval import IntervalTrigger
+
+if TYPE_CHECKING:
+    from apscheduler.job import Job
+
+logger: logging.Logger = logging.getLogger("discord_reminder_bot")
+
+
+def parse_time(date_to_parse: str | None, timezone: str | None = os.getenv("TIMEZONE")) -> datetime.datetime | None:
+    """Parse a date string into a datetime object.
+
+    Args:
+        date_to_parse(str): The date string to parse.
+        timezone(str, optional): The timezone to use. Defaults to the TIMEZONE environment variable.
+
+    Returns:
+        datetime.datetime: The parsed datetime object.
+    """
+    if not date_to_parse:
+        logger.error("No date provided to parse.")
+        return None
+
+    if not timezone:
+        logger.error("No timezone provided to parse date.")
+        return None
+
+    logger.info("Parsing date: '%s' with timezone: '%s'", date_to_parse, timezone)
+
+    try:
+        parsed_date: datetime.datetime | None = dateparser.parse(
+            date_string=date_to_parse,
+            settings={
+                "PREFER_DATES_FROM": "future",
+                "TIMEZONE": f"{timezone}",
+                "RETURN_AS_TIMEZONE_AWARE": True,
+                "RELATIVE_BASE": datetime.datetime.now(tz=ZoneInfo(str(timezone))),
+            },
+        )
+    except (ValueError, TypeError):
+        logger.exception("Failed to parse date: '%s'", date_to_parse)
+        return None
+
+    logger.debug("Parsed date: %s with timezone: %s", parsed_date, timezone)
+
+    return parsed_date
+
+
+def calculate(job: Job) -> str:
+    """Calculate the time left for a job.
+
+    Args:
+        job: The job to calculate the time for.
+
+    Returns:
+        str: The time left for the job or "Paused" if the job is paused or has no next run time.
+    """
+    trigger_time = None
+    if isinstance(job.trigger, DateTrigger | IntervalTrigger):
+        if not hasattr(job, "next_run_time"):
+            logger.debug("No next run time found for '%s'", job.id)
+            logger.debug("%s", job.__getstate__())
+            return "Paused"
+        trigger_time = job.next_run_time or None
+
+    elif isinstance(job.trigger, CronTrigger):
+        if not job.next_run_time:
+            logger.debug("No next run time found for '%s', probably paused?", job.id)
+            logger.debug("%s", job.__getstate__())
+            return "Paused"
+
+        trigger_time = job.trigger.get_next_fire_time(None, datetime.datetime.now(tz=job._scheduler.timezone))  # noqa: SLF001
+
+    logger.debug("Trigger type: %s, Trigger time: %s", type(job.trigger), trigger_time)
+
+    if not trigger_time:
+        logger.debug("No trigger time found")
+        return "Paused"
+
+    return f"<t:{int(trigger_time.timestamp())}:R>"
+
+
+def get_human_readable_time(job: Job) -> str:
+    """Get the human-readable time for a job.
+
+    Args:
+        job: The job to get the time for.
+
+    Returns:
+        str: The human-readable time.
+    """
+    trigger_time = None
+    if isinstance(job.trigger, DateTrigger | IntervalTrigger):
+        trigger_time = job.next_run_time or None
+
+    elif isinstance(job.trigger, CronTrigger):
+        if not job.next_run_time:
+            logger.debug("No next run time found for '%s', probably paused?", job.id)
+            logger.debug("%s", job.__getstate__())
+            return "Paused"
+
+        trigger_time = job.trigger.get_next_fire_time(None, datetime.datetime.now(tz=job._scheduler.timezone))  # noqa: SLF001
+
+    if not trigger_time:
+        logger.debug("No trigger time found")
+        return "Paused"
+
+    return trigger_time.strftime("%Y-%m-%d %H:%M:%S")

discord_reminder_bot/settings.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import logging
+import os
+from functools import lru_cache
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+import pytz
+from apscheduler.jobstores.sqlalchemy import SQLAlchemyJobStore
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+
+logger: logging.Logger = logging.getLogger("discord_reminder_bot")
+
+
+config_timezone: str = os.getenv("TIMEZONE", default="")
+if not config_timezone:
+    msg = "Missing timezone. Please set the TIMEZONE environment variable."
+    raise ValueError(msg)
+
+# Test if the timezone is valid
+try:
+    ZoneInfo(config_timezone)
+except (ZoneInfoNotFoundError, ModuleNotFoundError) as e:
+    msg: str = f"Invalid timezone: {config_timezone}. Error: {e}"
+    raise ValueError(msg) from e
+
+sqlite_location: str = os.getenv("SQLITE_LOCATION", default="/jobs.sqlite")
+logger.info("Using SQLite database at: %s", sqlite_location)
+
+
+@lru_cache(maxsize=1)
+def get_scheduler() -> AsyncIOScheduler:
+    """Return the scheduler instance.
+
+    Uses the SQLITE_LOCATION environment variable for the SQLite database location.
+
+    Returns:
+        AsyncIOScheduler: The scheduler instance.
+    """
+    jobstores: dict[str, SQLAlchemyJobStore] = {"default": SQLAlchemyJobStore(url=f"sqlite://{sqlite_location}")}
+    job_defaults: dict[str, bool | int] = {
+        # If coalesce is True, when the scheduler recovers from downtime,
+        # missed executions will be rolled into a single execution rather than
+        # executing each missed run separately. This prevents a backlog of
+        # accumulated executions when the scheduler is down for a period of time.
+        "coalesce": True,
+        # The time (in seconds) how much this job's execution is allowed to be late
+        "misfire_grace_time": 60,
+    }
+    timezone = pytz.timezone(config_timezone)
+    return AsyncIOScheduler(jobstores=jobstores, timezone=timezone, job_defaults=job_defaults)
+
+
+scheduler: AsyncIOScheduler = get_scheduler()

tests/test_main.py

@@ -12,7 +12,7 @@ from apscheduler.triggers.date import DateTrigger
 from apscheduler.triggers.interval import IntervalTrigger
 
 from discord_reminder_bot import main
-from discord_reminder_bot.main import calculate, parse_time
+from discord_reminder_bot.parsers import calculate, parse_time
 
 if TYPE_CHECKING:
     from apscheduler.job import Job