timer-bot 1.10__tar.gz → 1.11__tar.gz

{timer_bot-1.10 → timer_bot-1.11}/PKG-INFO

@@ -1,28 +1,23 @@
 Metadata-Version: 2.4
 Name: timer-bot
-Version: 1.10
+Version: 1.11
 Summary: Discord Timer Bot
-Author-email: Lionel Panhaleux <lionel.panhaleux+timer@gmail.com>
-Project-URL: Repository, https://github.com/lionel-panhaleux/timer-bot
 Keywords: Discord,timer
+Author: Lionel Panhaleux
+Author-email: Lionel Panhaleux <lionel.panhaleux+timer@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Other Audience
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Environment :: Web Environment
-Requires-Python: >=3.11
+Requires-Dist: hikari>=2.6,<3
+Requires-Python: >=3.13
+Project-URL: Repository, https://github.com/lionel-panhaleux/timer-bot
 Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: discord-py-interactions>=5.14
-Requires-Dist: uvloop>=0.21
-Provides-Extra: dev
-Requires-Dist: black; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
-Requires-Dist: zest.releaser[recommended]; extra == "dev"
-Dynamic: license-file
 
 # timer
 

timer_bot-1.11/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["uv_build>=0.12.13,<0.13"]
+build-backend = "uv_build"
+
+[project]
+name = "timer-bot"
+version = "1.11"
+description = "Discord Timer Bot"
+keywords = [
+    "Discord",
+    "timer",
+]
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.13"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.13",
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Other Audience",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Environment :: Web Environment",
+]
+dependencies = ["hikari>=2.6,<3"]
+
+[[project.authors]]
+name = "Lionel Panhaleux"
+email = "lionel.panhaleux+timer@gmail.com"
+
+[project.scripts]
+timer-bot = "timer_bot:main"
+
+[project.urls]
+Repository = "https://github.com/lionel-panhaleux/timer-bot"
+
+[dependency-groups]
+deploy = ["ansible-core"]
+dev = [
+    "pytest",
+    "ruff",
+    "ty",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py313"

timer_bot-1.10/pyproject.toml → timer_bot-1.11/pyproject.toml.orig

@@ -1,40 +1,42 @@
 [build-system]
-requires = ["setuptools>=68"]
-build-backend = "setuptools.build_meta"
+requires = ["uv_build>=0.12.13,<0.13"]
+build-backend = "uv_build"
 
 [project]
 name = "timer-bot"
-version = "1.10"
+version = "1.11"
 authors = [
     { name = "Lionel Panhaleux", email = "lionel.panhaleux+timer@gmail.com" },
 ]
 description = "Discord Timer Bot"
 keywords = ["Discord", "timer"]
 readme = "README.md"
-requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.13"
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.11",
-    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.13",
     "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Other Audience",
     "Natural Language :: English",
     "Operating System :: OS Independent",
     "Environment :: Web Environment",
 ]
-dependencies = ["discord-py-interactions>=5.14", "uvloop>=0.21"]
-
-[project.optional-dependencies]
-dev = ["black", "ruff", "zest.releaser[recommended]"]
+dependencies = [
+    "hikari>=2.6,<3",
+]
 
 [project.scripts]
-timer-bot = "src.timer_bot:main"
+timer-bot = "timer_bot:main"
 
 [project.urls]
 Repository = "https://github.com/lionel-panhaleux/timer-bot"
 
-[tool.setuptools.packages.find]
-include = ["src*"]
+[dependency-groups]
+deploy = ["ansible-core"]
+dev = ["pytest", "ruff", "ty"]
 
-[tool.zest-releaser]
-create-wheel = true
+[tool.ruff]
+line-length = 100
+target-version = "py313"

timer_bot-1.11/src/timer_bot/__init__.py

@@ -0,0 +1,426 @@
+import asyncio
+import contextlib
+import logging
+import os
+import typing
+
+import hikari
+import hikari.impl
+
+logger = logging.getLogger()
+bot = hikari.GatewayBot(
+    os.environ["DISCORD_TOKEN"],
+    intents=hikari.Intents.NONE,
+    logs="DEBUG" if __debug__ else "INFO",
+)
+
+DEBUG_GUILD = 161406117686149120
+THRESHOLDS = [0, 60, 300, 900, 1800]
+DISPLAY_SECONDS = 5 * 60
+PAUSE_TIMEOUT = 1800
+RUNNING_TIMER_HELP = (
+    "- `/timer display` to display it anew\n"
+    "- `/timer pause` to pause\n"
+    "- `/timer resume` to resume\n"
+    "- `/timer stop` to terminate it\n"
+    "- `/timer add` to add time to it\n"
+    "- `/timer sub` to substract time from it\n"
+)
+
+NO_TIMER = "No timer running in this channel. Use `/timer start` to start one."
+
+type Interaction = hikari.CommandInteraction | hikari.ComponentInteraction
+
+
+class CommandFailed(Exception):
+    """A refusal of the user's request, answered ephemerally with its content or embed."""
+
+    def __init__(
+        self, content: str = "", embed: hikari.UndefinedOr[hikari.Embed] = hikari.UNDEFINED
+    ):
+        super().__init__(content)
+        self.content = content
+        self.embed = embed
+
+
+def _now() -> float:
+    return asyncio.get_running_loop().time()
+
+
+def time_str(time: float) -> str:
+    seconds = round(time % 60)
+    if seconds > 59 or time > DISPLAY_SECONDS:
+        seconds = 0
+    minutes = round((time - seconds) % 3600 / 60)
+    if minutes > 59:
+        minutes = 0
+    hours = round((time - minutes * 60 - seconds) / 3600)
+    if time > 3569:
+        return f"{hours}:{minutes:0>2} remaining"
+    if time > DISPLAY_SECONDS:
+        return f"{minutes} minutes remaining"
+    if minutes:
+        return f"{minutes}′ {seconds:0>2}″ remaining"
+    if time > 0:
+        return f"{seconds} seconds remaining"
+    return "time!"
+
+
+class Timer:
+    """One countdown, in TIMERS under its channel until run() ends.
+
+    Once run() is started, commands only change state and set `wake`, and run() alone writes
+    to the channel. A command can still land while a write is awaited: state read before an
+    await is stale after it.
+    """
+
+    def __init__(
+        self, channel_id: hikari.Snowflake, author_id: hikari.Snowflake, time: int, secured: bool
+    ):
+        self.channel_id = channel_id
+        self.author_id = author_id
+        self.secured = secured
+        self.deadline = _now() + time
+        self.paused_left: float | None = None
+        self.resume_at = 0.0
+        self.thresholds: list[int] = []
+        self.message_id: hikari.Snowflake | None = None
+        self.repost = False
+        self.stopped = False
+        self.wake = asyncio.Event()
+        self.task: asyncio.Task[None] | None = None
+        self._set_thresholds()
+
+    def left(self) -> float:
+        if self.paused_left is not None:
+            return self.paused_left
+        return max(0.0, self.deadline - _now())
+
+    def _set_thresholds(self) -> None:
+        left = self.left()
+        self.thresholds = [limit for limit in THRESHOLDS if left > limit or limit == 0]
+        self.thresholds += [hour * 3600 for hour in range(1, int(left // 3600) + 1)]
+
+    def adjust(self, time: int) -> None:
+        if self.paused_left is None:
+            self.deadline += time
+        else:
+            self.paused_left = max(0.0, self.paused_left + time)
+        self._set_thresholds()
+        self.refresh()
+
+    def pause(self) -> None:
+        if self.paused_left is None:
+            self.paused_left = self.left()
+            self.resume_at = _now() + PAUSE_TIMEOUT
+            self.wake.set()
+
+    def resume(self) -> None:
+        if self.paused_left is not None:
+            self.deadline = _now() + self.paused_left
+            self.paused_left = None
+            self.wake.set()
+
+    def refresh(self) -> None:
+        """Post the embed anew, at the bottom of the channel."""
+        self.repost = True
+        self.wake.set()
+
+    def stop(self) -> None:
+        self.stopped = True
+        self.wake.set()
+
+    async def run(self) -> None:
+        try:
+            while True:
+                if self.paused_left is not None:
+                    delay = self.resume_at - _now()
+                else:
+                    left = self.left()
+                    delay = 1.1 if left < DISPLAY_SECONDS + 30 else 30
+                    if self.thresholds:
+                        delay = min(delay, left - self.thresholds[-1])
+                with contextlib.suppress(TimeoutError):
+                    await asyncio.wait_for(self.wake.wait(), delay)
+                if self.paused_left is not None and _now() >= self.resume_at:
+                    self.resume()
+                # after resume(), whose wake this pass serves: cleared later, it renders twice
+                self.wake.clear()
+                if self.stopped:
+                    if self.message_id:
+                        await self._delete(self.message_id)
+                    logger.info("[%s] Timer stopped", self.channel_id)
+                    if self.left() > 0:
+                        await bot.rest.create_message(
+                            self.channel_id, "Stopped with " + time_str(self.left())
+                        )
+                    return
+                await self.render()
+                if self.left() <= 0:
+                    logger.info("[%s] Timer finished", self.channel_id)
+                    return
+        except hikari.ClientHTTPResponseError as e:
+            logger.info("[%s] Timer dropped, Discord refused: %s", self.channel_id, e)
+            if self.message_id:
+                await self._delete(self.message_id)
+        except Exception:
+            logger.exception("[%s] Timer crashed", self.channel_id)
+        finally:
+            if TIMERS.get(self.channel_id) is self:
+                del TIMERS[self.channel_id]
+
+    async def render(self) -> None:
+        left = self.left()
+        rows: list[hikari.impl.MessageActionRowBuilder] = []
+        if left <= 0:
+            title = "Timer finished"
+            description = "Use `/timer start` to start a new timer."
+        else:
+            description = "Use the buttons or the `/timer` commands to manipulate the timer."
+            row = hikari.impl.MessageActionRowBuilder()
+            if self.paused_left is None:
+                title = time_str(left)
+                row.add_interactive_button(
+                    hikari.ButtonStyle.PRIMARY, "pause", emoji="⏱", label="Pause"
+                )
+            else:
+                title = "Timer paused: " + time_str(left)
+                row.add_interactive_button(
+                    hikari.ButtonStyle.SUCCESS, "resume", emoji="▶️", label="Resume"
+                )
+            row.add_interactive_button(hikari.ButtonStyle.DANGER, "stop", emoji="🛑", label="Stop")
+            rows = [row]
+        embed = hikari.Embed(title=title, description=description)
+        if self.repost and self.message_id:
+            await self._delete(self.message_id)
+            self.message_id = None
+        self.repost = False
+        if self.message_id:
+            try:
+                await bot.rest.edit_message(
+                    self.channel_id, self.message_id, embed=embed, components=rows
+                )
+            except hikari.ClientHTTPResponseError as e:
+                logger.info("[%s] Failed to edit message: %s", self.channel_id, e)
+                old_message_id = self.message_id
+                message = await bot.rest.create_message(
+                    self.channel_id, embed=embed, components=rows
+                )
+                self.message_id = message.id
+                await self._delete(old_message_id)
+        else:
+            message = await bot.rest.create_message(self.channel_id, embed=embed, components=rows)
+            self.message_id = message.id
+        left = self.left()
+        if self.thresholds and self.thresholds[-1] >= left:
+            # hikari parses no user mention unless told to: the ping would not notify
+            await bot.rest.create_message(
+                self.channel_id,
+                f"<@{self.author_id}> {time_str(self.thresholds.pop())}",
+                user_mentions=[self.author_id],
+            )
+
+    async def _delete(self, message_id: hikari.Snowflake) -> None:
+        try:
+            await bot.rest.delete_message(self.channel_id, message_id)
+        except hikari.ClientHTTPResponseError as e:
+            logger.info("[%s] Failed to delete message: %s", self.channel_id, e)
+
+
+TIMERS: dict[hikari.Snowflake, Timer] = {}
+
+
+async def _answer(interaction: Interaction, content: str = "", **kwargs: typing.Any) -> None:
+    await interaction.create_initial_response(
+        hikari.ResponseType.MESSAGE_CREATE, content, flags=hikari.MessageFlag.EPHEMERAL, **kwargs
+    )
+
+
+def _timer(interaction: Interaction) -> Timer:
+    timer = TIMERS.get(interaction.channel_id)
+    if not timer:
+        raise CommandFailed(NO_TIMER)
+    return timer
+
+
+def _owned_timer(interaction: Interaction, verb: str) -> Timer:
+    timer = _timer(interaction)
+    if timer.secured and interaction.user.id != timer.author_id:
+        raise CommandFailed(f"This is a secured timer, only the owner can {verb} it.")
+    return timer
+
+
+async def timer_start(
+    interaction: hikari.CommandInteraction, hours: int, minutes: int = 0, secured: bool = False
+) -> None:
+    channel_id = interaction.channel_id
+    if channel_id in TIMERS:
+        embed = hikari.Embed(title="Timer already running", description=RUNNING_TIMER_HELP)
+        raise CommandFailed(embed=embed)
+    total_time = hours * 3600 + minutes * 60
+    if not total_time:
+        embed = hikari.Embed(title="No time", description="Hours and minutes cannot both be zero.")
+        raise CommandFailed(embed=embed)
+    # claimed before the first await: a start racing this one finds the channel busy
+    timer = TIMERS[channel_id] = Timer(channel_id, interaction.user.id, total_time, secured)
+    try:
+        await _answer(interaction, "Starting Timer")
+        logger.info("[%s] Start timer: %sh %smin", channel_id, hours, minutes)
+        try:
+            await timer.render()
+        except hikari.ClientHTTPResponseError as e:
+            logger.info("[%s] Failed to start: %s", channel_id, e)
+            if timer.message_id:
+                await timer._delete(timer.message_id)
+            await interaction.edit_initial_response(
+                "**Failed to start**\nTimer bot requires permission to send messages"
+            )
+            return
+        timer.task = asyncio.create_task(timer.run())
+    finally:
+        if timer.task is None:
+            del TIMERS[channel_id]
+
+
+async def timer_pause(interaction: Interaction) -> None:
+    timer = _owned_timer(interaction, "pause")
+    timer.pause()
+    if interaction.user.id != timer.author_id:
+        await interaction.create_initial_response(
+            hikari.ResponseType.MESSAGE_CREATE,
+            f"<@{timer.author_id}> timer paused by {interaction.user.mention}",
+            user_mentions=[timer.author_id],
+        )
+    else:
+        await _answer(interaction, "Timer paused")
+
+
+async def timer_resume(interaction: Interaction) -> None:
+    timer = _owned_timer(interaction, "resume")
+    timer.resume()
+    timer.refresh()
+    await _answer(interaction, "Timer resumed")
+
+
+async def timer_stop(interaction: Interaction) -> None:
+    _owned_timer(interaction, "stop").stop()
+    await _answer(interaction, "Timer stopped")
+
+
+async def timer_add(interaction: hikari.CommandInteraction, minutes: int) -> None:
+    _owned_timer(interaction, "modify").adjust(minutes * 60)
+    await interaction.create_initial_response(
+        hikari.ResponseType.MESSAGE_CREATE, f"Time added ({minutes}min)"
+    )
+
+
+async def timer_sub(interaction: hikari.CommandInteraction, minutes: int) -> None:
+    _owned_timer(interaction, "modify").adjust(-minutes * 60)
+    await interaction.create_initial_response(
+        hikari.ResponseType.MESSAGE_CREATE, f"Time substracted ({minutes}min)"
+    )
+
+
+async def timer_display(interaction: hikari.CommandInteraction) -> None:
+    _timer(interaction).refresh()
+    await _answer(interaction, "Timer displayed")
+
+
+def _minutes(min_value: int, max_value: int, required: bool) -> hikari.CommandOption:
+    return hikari.CommandOption(
+        type=hikari.OptionType.INTEGER,
+        name="minutes",
+        description="Number of minutes",
+        is_required=required,
+        min_value=min_value,
+        max_value=max_value,
+    )
+
+
+def _subcommand(name: str, description: str, *options: hikari.CommandOption):
+    return hikari.CommandOption(
+        type=hikari.OptionType.SUB_COMMAND,
+        name=name,
+        description=description,
+        options=list(options),
+    )
+
+
+TIMER_COMMAND = hikari.impl.SlashCommandBuilder(
+    "timer",
+    "Countdown timer",
+    options=[
+        _subcommand(
+            "start",
+            "Start a timer",
+            hikari.CommandOption(
+                type=hikari.OptionType.INTEGER,
+                name="hours",
+                description="Number of hours",
+                is_required=True,
+                min_value=0,
+                max_value=24,
+            ),
+            _minutes(0, 59, required=False),
+            hikari.CommandOption(
+                type=hikari.OptionType.BOOLEAN,
+                name="secured",
+                description="Only the owner can modify a secure timer (default false)",
+            ),
+        ),
+        _subcommand("pause", "pause the timer"),
+        _subcommand("resume", "resume the timer"),
+        _subcommand("stop", "stop the timer"),
+        _subcommand("add", "Add time", _minutes(1, 1440, required=True)),
+        _subcommand("sub", "Substract time", _minutes(1, 1440, required=True)),
+        _subcommand("display", "Display the timer anew"),
+    ],
+)
+COMMANDS: dict[str, typing.Callable[..., typing.Awaitable[None]]] = {
+    "start": timer_start,
+    "pause": timer_pause,
+    "resume": timer_resume,
+    "stop": timer_stop,
+    "add": timer_add,
+    "sub": timer_sub,
+    "display": timer_display,
+}
+#: embeds posted by an earlier process still carry these custom_ids
+BUTTONS: dict[str, typing.Callable[[Interaction], typing.Awaitable[None]]] = {
+    "pause": timer_pause,
+    "resume": timer_resume,
+    "stop": timer_stop,
+}
+
+
+@bot.listen()
+async def on_started(event: hikari.StartedEvent) -> None:
+    application = await bot.rest.fetch_application()
+    # a PUT replaces the whole set: commands no longer declared here are deleted
+    await bot.rest.set_application_commands(
+        application, [TIMER_COMMAND], guild=DEBUG_GUILD if __debug__ else hikari.UNDEFINED
+    )
+    logger.info("Commands registered")
+
+
+@bot.listen()
+async def on_interaction(event: hikari.InteractionCreateEvent) -> None:
+    interaction = event.interaction
+    if isinstance(interaction, hikari.CommandInteraction) and interaction.command_name == "timer":
+        subcommand = interaction.options[0]
+        name, handler = subcommand.name, COMMANDS[subcommand.name]
+        kwargs = {option.name: option.value for option in subcommand.options or ()}
+    elif isinstance(interaction, hikari.ComponentInteraction) and interaction.custom_id in BUTTONS:
+        name, handler = interaction.custom_id, BUTTONS[interaction.custom_id]
+        kwargs = {}
+    else:
+        return
+    logger.info("[%s] %s by %s %s", interaction.channel_id, name, interaction.user.username, kwargs)
+    try:
+        await handler(interaction, **kwargs)
+    except CommandFailed as e:
+        await _answer(interaction, e.content, embed=e.embed)
+
+
+def main() -> None:
+    bot.run()

timer_bot-1.10/CHANGELOG.rst

@@ -1,137 +0,0 @@
-Changelog
-=========
-
-1.10 (2025-04-26)
------------------
-
-- Bump discord-py-interactions
-
-
-1.9 (2024-12-01)
-----------------
-
-- Fix dependencies
-
-
-1.8 (2024-12-01)
-----------------
-
-- Upgrade to discord-py-interactions 5.13
-
-1.7 (2024-02-06)
-----------------
-
-- Fix python 3.11 install for Debian 12
-
-
-1.6 (2023-11-04)
-----------------
-
-- Fix timer updater after 1h (new Discord limitation)
-
-
-1.5 (2023-11-03)
-----------------
-
-- Bump discord-py-interactions version
-
-
-1.4 (2023-11-03)
-----------------
-
-- Fix timer update when finishing (display as finished, not with 1 or 2 seconds left)
-- Add "secured" option so that only the owner can modify the timer
-- Send message when missing permissions
-
-1.3 (2022-12-01)
-----------------
-
-- Fix error messages when there's no timer running
-
-
-1.2 (2022-08-27)
-----------------
-
-- Now works in threads and voice channel chats
-
-
-1.1 (2022-08-27)
-----------------
-
-- Fix connection (no guild message access)
-- Fix time boundary display (exactly 1 hour was not displayed properly)
-
-1.0 (2022-08-27)
-----------------
-
-- V1.0
-- Improve time display on boundaries (no more 1:60 or going from 5min to 4'35'')
-
-
-0.12 (2022-08-27)
------------------
-
-- Switch to slash commands
-- Use real buttons instead of reactions
-
-0.11 (2021-03-17)
------------------
-
-- Fix pausing user mention
-
-
-0.10 (2021-03-02)
------------------
-
-- Resuming a paused timer with a "timer resume" message could cause the timer to crash. Fixed it.
-
-
-0.9 (2020-11-03)
-----------------
-
-- Fix pause reaction
-
-
-0.8 (2020-07-22)
-----------------
-
-- Fix pause timeout (after 30mn) and `timer resume` display
-- Improve help message
-
-0.7 (2020-07-05)
-----------------
-
-- Fixed the pause timer feature
-
-
-0.6 (2020-06-22)
-----------------
-
-- Mention author when finished
-
-
-0.5 (2020-06-22)
-----------------
-
-- Mention timer author on thresholds and when paused by someone else
-
-
-0.4 (2020-05-30)
-----------------
-
-- Fixed a bug when pause and resume where used successively
-- Added "pause", "add" and "sub" commands
-- Better time input parsing
-- More proper hours:minutes display (with padding zeroes)
-
-
-0.3 (2020-05-28)
-----------------
-
-- First version on pypi.
-
-
-0.2 (2020-05-28)
-----------------
-
-- First published version.

timer_bot-1.10/MANIFEST.in

@@ -1,7 +0,0 @@
-include LICENSE README.md CHANGELOG.rst
-
-graft src
-exclude Makefile
-
-global-exclude */__pycache__/*
-global-exclude *.egg-info/*

timer_bot-1.10/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-

timer_bot-1.10/src/timer_bot.py

@@ -1,583 +0,0 @@
-from typing import Optional, Union
-import asyncio
-import logging
-import os
-
-import interactions
-
-import interactions.api.events
-import interactions.client.errors
-
-
-logger = logging.getLogger()
-bot = interactions.Client(
-    token=os.getenv("DISCORD_TOKEN") or "",
-    # intents=interactions.Intents.new(guild_messages=True),
-    delete_unused_application_cmds=True,
-    debug_scope=161406117686149120 if __debug__ else interactions.MISSING,
-    logging_level=logging.DEBUG if __debug__ else logging.INFO,
-)
-
-
-@interactions.listen()
-async def on_ready():
-    """Login success"""
-    logger.info(f"Logged in as {bot.user.username}")
-
-
-@interactions.listen()
-async def on_startup():
-    """Startup success"""
-    logger.info("Started")
-
-
-@interactions.listen()
-async def on_error(error: interactions.api.events.Error):
-    logger.error("API error: %s", error)
-
-
-#: fixed list of times on which to send a notification
-THRESHOLDS = [
-    0,  # finished
-    1 * 60,  # 1min
-    5 * 60,  # 5min
-    15 * 60,  # 15min
-    30 * 60,  # 30min
-]
-
-#: timer embed will display seconds starting from this point int time
-DISPLAY_SECONDS = 5 * 60
-
-#: pause will timeout after this amount of seconds
-PAUSE_TIMEOUT = 1800
-
-#: help message for a running timer
-RUNNING_TIMER_HELP = (
-    "- `/timer display` to display it anew\n"
-    "- `/timer pause` to pause\n"
-    "- `/timer resume` to resume\n"
-    "- `/timer stop` to terminate it\n"
-    "- `/timer add` to add time to it\n"
-    "- `/timer sub` to substract time from it\n"
-)
-
-
-class Timer:
-    """Timer object: one per channel"""
-
-    def __init__(
-        self,
-        channel: interactions.GuildChannel,
-        author: interactions.Member,
-        time: int,
-        secured: bool,
-        log_prefix: str = "",
-    ):
-        self.channel = channel
-        self.author = author
-        self.secured = secured
-        self.start_time: float = 0
-        self.total_time: int = 0
-        self.time_left: float = 0
-        self.log_prefix = log_prefix + "|internal"
-        self.thresholds: list[int] = []
-        self.adjust_time(time)
-        # internals
-        self.message: Optional[interactions.Message] = None
-        self.countdown_future = None  # waiting for time to refresh
-        self.resume_future = None  # waiting for resume
-
-    def adjust_time(self, time: int):
-        self.total_time += time
-        self.time_left += time
-        self.thresholds = [limit for limit in THRESHOLDS if self.time_left > limit]
-        # add a threshold on every hour
-        for limit in range(1, int(self.time_left // 3600) + 1):
-            self.thresholds.append(limit * 3600)
-
-    async def countdown(self):
-        """Countdown: update embed, send notifications"""
-        while self.time_left > 0:
-            # update time_left
-            if not self.resume_future:
-                time_spent = max(0, asyncio.get_event_loop().time() - self.start_time)
-                self.time_left = max(0, self.total_time - time_spent)
-            await self._send_or_update_message()
-            # update frequency depends on time left
-            if self.resume_future:
-                paused_time = asyncio.get_event_loop().time()
-                try:
-                    logging.debug(f"[{self.log_prefix}] Wait for resume")
-                    await self.resume_future
-                except asyncio.CancelledError:
-                    logging.debug(f"[{self.log_prefix}] Pause cancelled - resume")
-                except asyncio.TimeoutError:
-                    logging.debug(f"[{self.log_prefix}] Pause timed out - resume")
-                finally:  # in any case resume.
-                    logging.debug(f"[{self.log_prefix}] Timer resume")
-                    self.resume_future = None
-                    self.start_time += asyncio.get_event_loop().time() - paused_time
-            else:
-                if self.time_left < DISPLAY_SECONDS + 30:
-                    # minimum because of Discord rate limitation
-                    self.countdown_future = asyncio.ensure_future(asyncio.sleep(1.1))
-                else:
-                    self.countdown_future = asyncio.ensure_future(asyncio.sleep(30))
-                try:
-                    logging.debug(f"[{self.log_prefix}] Wait for countdown")
-                    await self.countdown_future
-                except asyncio.CancelledError:
-                    logging.debug(f"[{self.log_prefix}] Countdown canceled")
-                finally:  # in any case resume.
-                    self.countdown_future = None
-        # final "Finished" update
-        await self._send_or_update_message()
-
-    async def run(self):
-        """Run the timer, update the client.TIMERS map accordingly."""
-        logging.debug(f"[{self.log_prefix}] Run")
-        TIMERS[self.channel] = self
-        self.start_time = asyncio.get_event_loop().time()
-        try:
-            await self.countdown()
-        except asyncio.CancelledError:
-            logger.info(f"[{self.log_prefix}] Timer cancelled")
-            # at that point aiohttp may be closed in case of SIGINT/SIGTERM
-        except asyncio.TimeoutError:
-            logger.exception(f"[{self.log_prefix}] Timeout - something went wrong")
-            await self.stop()
-        except Exception:
-            logger.exception(f"[{self.log_prefix}] Unhandled exception")
-            raise
-        finally:
-            del TIMERS[self.channel]
-
-    async def stop(self):
-        """Stops the timer."""
-        logging.debug(f"[{self.log_prefix}] Stop")
-        if self.time_left > 0:
-            await self.channel.send("Stopped with " + self.time_str())
-        self.time_left = -1
-        logger.info(f"[{self.log_prefix}] Timer stopped")
-        if self.countdown_future:
-            self.countdown_future.cancel()
-        if self.resume_future:
-            self.resume_future.cancel()
-        if self.message:
-            await self.message.delete()
-            self.message = None
-
-    async def pause(self):
-        """Pauses the timer."""
-        # don't pause twice
-        if self.resume_future:
-            return
-        logging.debug(f"[{self.log_prefix}] Pause")
-        self.resume_future = asyncio.ensure_future(asyncio.sleep(PAUSE_TIMEOUT))
-        # cancel countdown
-        if self.countdown_future:
-            self.countdown_future.cancel()
-            self.countdown_future = None
-
-    async def refresh(self, resume=True):
-        """Display a new embed."""
-        logging.debug(f"[{self.log_prefix}] Refresh")
-        if self.message:
-            await self.message.delete()
-            self.message = None
-        if self.resume_future:
-            # this cancels the countdown_future internally
-            if resume:
-                self.resume_future.cancel()
-            else:
-                await self._send_or_update_message()
-        elif self.countdown_future:
-            self.countdown_future.cancel()
-
-    async def _send_or_update_message(self):
-        """The running timer embed"""
-        if self.time_left < 1:
-            title = "Timer finished"
-            components = []
-            description = "Use `/timer start` to start a new timer."
-        elif self.resume_future:
-            title = "Timer paused: " + self.time_str()
-            components = [button_resume, button_stop]
-            description = (
-                "Use the buttons or the `/timer` commands to manipulate the timer."
-            )
-        else:
-            title = self.time_str()
-            components = [button_pause, button_stop]
-            description = (
-                "Use the buttons or the `/timer` commands to manipulate the timer."
-            )
-        embeds = [interactions.Embed(title=title, description=description)]
-        if self.message:
-            try:
-                self.message = await self.message.edit(
-                    embeds=embeds, components=components
-                )
-            # messages older than 1h cannot be edited too much, at some point it fails
-            except interactions.errors.LibraryException as e:
-                logger.info("Failed to edit message: %s", e)
-                old_message = self.message
-                self.message = await self.channel.send(
-                    embeds=embeds, components=components
-                )
-                if old_message:
-                    try:
-                        await old_message.delete()
-                    except interactions.errors.LibraryException as e:
-                        logger.info("Failed to delete old message: %s", e)
-                        pass
-        else:
-            self.message = await self.channel.send(embeds=embeds, components=components)
-        if self.thresholds and self.thresholds[-1] >= self.time_left >= 0:
-            await self.channel.send(
-                f"{self.author.mention} {self._time_str(self.thresholds.pop())}"
-            )
-
-    def time_str(self):
-        """Time string for the current time left."""
-        return self._time_str(self.time_left)
-
-    @staticmethod
-    def _time_str(time):
-        """Returns a human readable string for given time (int) in seconds"""
-        seconds = round(time % 60)
-        if seconds > 59 or time > DISPLAY_SECONDS:
-            seconds = 0
-        minutes = round((time - seconds) % 3600 / 60)
-        if minutes > 59:
-            minutes = 0
-        hours = round((time - minutes * 60 - seconds) / 3600)
-        if time > 3569:
-            return f"{hours}:{minutes:0>2} remaining"
-        if time > DISPLAY_SECONDS:
-            return f"{minutes} minutes remaining"
-        if minutes:
-            return f"{minutes}′ {seconds:0>2}″ remaining"
-        if time > 0:
-            return f"{seconds} seconds remaining"
-        return "time!"
-
-
-TIMERS: dict[interactions.Snowflake : Timer] = {}
-timer_base = interactions.SlashCommand(name="timer")
-
-
-def _get_prefix(ctx: interactions.SlashContext):
-    """Prefix used for log messages"""
-    if ctx.guild:
-        prefix = f"{ctx.guild.name}"
-        logger.debug("CTX: %s", ctx)
-        logger.debug("channel: %s", ctx.channel)
-        logger.debug("channel_id: %s", ctx.channel_id)
-        if ctx.channel:
-            prefix += f":{ctx.channel.name}"
-    else:
-        prefix = f"{ctx.author.name}"
-    return prefix
-
-
-@timer_base.subcommand(
-    sub_cmd_name="start",
-    sub_cmd_description="Start a timer",
-)
-@interactions.slash_option(
-    name="hours",
-    opt_type=interactions.OptionType.INTEGER,
-    description="Number of hours",
-    required=True,
-    min_value=0,
-    max_value=24,
-)
-@interactions.slash_option(
-    name="minutes",
-    opt_type=interactions.OptionType.INTEGER,
-    description="Number of minutes",
-    required=False,
-    min_value=0,
-    max_value=59,
-)
-@interactions.slash_option(
-    name="secured",
-    opt_type=interactions.OptionType.BOOLEAN,
-    description="Only the owner can modify a secure timer (default false)",
-    required=False,
-)
-async def timer_start(
-    ctx: interactions.SlashContext,
-    hours: int,
-    minutes: int = 0,
-    secured: bool = False,
-):
-    """Start a timer"""
-    # channel info will miss from threads and voice channels chats
-    # see https://github.com/interactions-py/library/issues/1041
-    if ctx.channel is interactions.MISSING:
-        ctx.channel = await ctx.client.get_channel(ctx.channel_id)
-    prefix = _get_prefix(ctx)
-    # timer already running in channel
-    if ctx.channel_id in TIMERS:
-        await ctx.send(
-            embeds=[
-                interactions.Embed(
-                    title="Timer already running", description=RUNNING_TIMER_HELP
-                )
-            ],
-            ephemeral=True,
-        )
-        return
-    # no timer running in channel
-    total_time = hours * 3600 + minutes * 60
-    if total_time:
-        timer = Timer(ctx.channel, ctx.author, total_time, secured, prefix)
-        await ctx.send("Starting Timer", ephemeral=True)
-        logger.info(f"[{prefix}] Start timer: {hours}h {minutes}min")
-        try:
-            await timer.run()
-        except interactions.client.errors.LibraryException:
-            await ctx.edit(
-                "**Failed to start**\nTimer bot requires permission to send messages"
-            )
-        logger.info(f"[{prefix}] Timer finished")
-    else:
-        await ctx.send(
-            embeds=[
-                interactions.Embed(
-                    title="No time",
-                    description="Hours and minutes cannot both be zero.",
-                )
-            ],
-            ephemeral=True,
-        )
-
-
-@timer_base.subcommand(sub_cmd_name="pause", sub_cmd_description="pause the timer")
-async def timer_pause(ctx: interactions.SlashContext):
-    """Pause the timer"""
-    await _pause_timer(ctx)
-
-
-@timer_base.subcommand(sub_cmd_name="resume", sub_cmd_description="resume the timer")
-async def timer_resume(ctx: interactions.SlashContext):
-    """Resume the timer"""
-    await _resume_timer(ctx)
-
-
-@timer_base.subcommand(sub_cmd_name="stop", sub_cmd_description="stop the timer")
-async def timer_stop(ctx: interactions.SlashContext):
-    """Stop the timer"""
-    await _stop_timer(ctx)
-
-
-@timer_base.subcommand(
-    sub_cmd_name="add",
-    sub_cmd_description="Add time",
-)
-@interactions.slash_option(
-    name="minutes",
-    opt_type=interactions.OptionType.INTEGER,
-    description="Number of minutes",
-    required=True,
-    min_value=1,
-    max_value=1440,
-)
-async def timer_add(ctx: interactions.SlashContext, minutes: int):
-    """Add time to the timer"""
-    timer = TIMERS.get(ctx.channel, None)
-    if not timer:
-        await ctx.send(
-            "No timer running in this channel. Use `/timer start` to start one.",
-            ephemeral=True,
-        )
-        return
-    prefix = _get_prefix(ctx)
-    if timer.secured and ctx.author.id != timer.author.id:
-        await ctx.send(
-            "This is a secured timer, only the owner can modify it.", ephemeral=True
-        )
-        return
-    timer.adjust_time(minutes * 60)
-    await timer.refresh(resume=False)
-    logger.info(f"[{prefix}] Added {minutes}min and refreshed")
-    await ctx.send(f"Time added ({minutes}min)")
-
-
-@timer_base.subcommand(
-    sub_cmd_name="sub",
-    sub_cmd_description="Substract time",
-)
-@interactions.slash_option(
-    name="minutes",
-    opt_type=interactions.OptionType.INTEGER,
-    description="Number of minutes",
-    required=True,
-    min_value=1,
-    max_value=1440,
-)
-async def timer_sub(ctx: interactions.SlashContext, minutes: int):
-    """Substract time from the timer"""
-    timer = TIMERS.get(ctx.channel, None)
-    if not timer:
-        await ctx.send(
-            "No timer running in this channel. Use `/timer start` to start one.",
-            ephemeral=True,
-        )
-        return
-    prefix = _get_prefix(ctx)
-    if timer.secured and ctx.author.id != timer.author.id:
-        await ctx.send(
-            "This is a secured timer, only the owner can modify it.", ephemeral=True
-        )
-        return
-    timer.adjust_time(-minutes * 60)
-    await timer.refresh(resume=False)
-    logger.info(f"[{prefix}] Substracted {minutes}min and refreshed")
-    await ctx.send(f"Time substracted ({minutes}min)")
-
-
-@timer_base.subcommand(
-    sub_cmd_name="display", sub_cmd_description="Display the timer anew"
-)
-async def timer_display(ctx: interactions.SlashContext):
-    """Discplay the timer anew"""
-    timer = TIMERS.get(ctx.channel, None)
-    if not timer:
-        await ctx.send(
-            "No timer running in this channel. Use `/timer start` to start one.",
-            ephemeral=True,
-        )
-        return
-    prefix = _get_prefix(ctx)
-    await timer.refresh(resume=False)
-    await ctx.send("Timer displayed", ephemeral=True)
-    logger.info(f"[{prefix}] Refreshed")
-
-
-button_pause = interactions.Button(
-    style=interactions.ButtonStyle.PRIMARY,
-    label="Pause",
-    custom_id="pause",
-    emoji=interactions.PartialEmoji.from_str("⏱"),
-)
-
-button_resume = interactions.Button(
-    style=interactions.ButtonStyle.SUCCESS,
-    label="Resume",
-    custom_id="resume",
-    emoji=interactions.PartialEmoji.from_str("▶️"),
-)
-
-button_stop = interactions.Button(
-    style=interactions.ButtonStyle.DANGER,
-    label="Stop",
-    custom_id="stop",
-    emoji=interactions.PartialEmoji.from_str("🛑"),
-)
-
-
-@interactions.component_callback("pause")
-async def button_pause_response(ctx: interactions.ComponentContext):
-    await _pause_timer(ctx)
-
-
-@interactions.component_callback("resume")
-async def button_resume_response(ctx: interactions.ComponentContext):
-    await _resume_timer(ctx)
-
-
-@interactions.component_callback("stop")
-async def button_stop_response(ctx: interactions.ComponentContext):
-    await _stop_timer(ctx)
-
-
-async def _pause_timer(
-    ctx: Union[interactions.SlashContext, interactions.ComponentContext],
-):
-    timer = TIMERS.get(ctx.channel, None)
-    if not timer:
-        await ctx.send(
-            "No timer running in this channel. Use `/timer start` to start one.",
-            ephemeral=True,
-        )
-        return
-    prefix = _get_prefix(ctx)
-    if timer.secured and ctx.author.id != timer.author.id:
-        await ctx.send(
-            "This is a secured timer, only the owner can pause it.", ephemeral=True
-        )
-        return
-    await timer.pause()
-    logger.info(f"[{prefix}] Paused")
-    if ctx.author.id != timer.author.id:
-        ephemeral = False
-        message = f"{timer.author.mention} timer paused by {ctx.author.mention}"
-    else:
-        ephemeral = True
-        message = "Timer paused"
-    await ctx.send(message, ephemeral=ephemeral)
-
-
-async def _resume_timer(
-    ctx: Union[interactions.SlashContext, interactions.ComponentContext],
-):
-    timer = TIMERS.get(ctx.channel, None)
-    if not timer:
-        await ctx.send(
-            "No timer running in this channel. Use `/timer start` to start one.",
-            ephemeral=True,
-        )
-        return
-    prefix = _get_prefix(ctx)
-    if timer.secured and ctx.author.id != timer.author.id:
-        await ctx.send(
-            "This is a secured timer, only the owner can resume it.", ephemeral=True
-        )
-        return
-    await timer.refresh()
-    await ctx.send("Timer resumed", ephemeral=True)
-    logger.info(f"[{prefix}] Refreshed and resumed")
-
-
-async def _stop_timer(
-    ctx: Union[interactions.SlashContext, interactions.ComponentContext],
-):
-    timer = TIMERS.get(ctx.channel, None)
-    if not timer:
-        await ctx.send(
-            "No timer running in this channel. Use `/timer start` to start one.",
-            ephemeral=True,
-        )
-        return
-    if timer.secured and ctx.author.id != timer.author.id:
-        await ctx.send(
-            "This is a secured timer, only the owner can stop it.", ephemeral=True
-        )
-        return
-    await timer.stop()
-    await ctx.send("Timer stopped", ephemeral=True)
-
-
-bot.add_listener(on_ready)
-bot.add_listener(on_startup)
-bot.add_command(timer_start)
-bot.add_command(timer_stop)
-bot.add_command(timer_pause)
-bot.add_command(timer_resume)
-bot.add_command(timer_display)
-bot.add_command(timer_add)
-bot.add_command(timer_sub)
-bot.add_component_callback(button_pause_response)
-bot.add_component_callback(button_resume_response)
-bot.add_component_callback(button_stop_response)
-
-
-def main():
-    """Entrypoint"""
-    logger.addHandler(logging.StreamHandler())
-    logger.setLevel(logging.DEBUG if __debug__ else logging.INFO)
-    bot.start()
-    logger.setLevel(logging.NOTSET)

timer_bot-1.10/timer_bot.egg-info/SOURCES.txt

@@ -1,7 +0,0 @@
-CHANGELOG.rst
-LICENSE
-MANIFEST.in
-README.md
-pyproject.toml
-src/__init__.py
-src/timer_bot.py