decafe-timer 0.4.3__py3-none-any.whl

decafe_timer/__about__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2025-present Toshihiro Kamiya <kamiya@mbj.nifty.com>
+#
+# SPDX-License-Identifier: MIT
+__version__ = "0.4.3"

decafe_timer/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2025-present Toshihiro Kamiya <kamiya@mbj.nifty.com>
+#
+# SPDX-License-Identifier: MIT
+from .main import main

decafe_timer/main.py

@@ -0,0 +1,672 @@
+import hashlib
+import json
+import random
+import re
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Optional
+
+from appdirs import user_cache_dir
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    Progress,
+    TextColumn,
+)
+
+from .__about__ import __version__
+
+APP_NAME = "coffee_timer"
+APP_AUTHOR = "tos-kamiya"
+
+CACHE_DIR = Path(user_cache_dir(APP_NAME, APP_AUTHOR))
+STATE_FILE = CACHE_DIR / "timer_state.json"
+
+COLORED_CONSOLE = Console(markup=False, highlight=False)
+PLAIN_CONSOLE = Console(color_system=None, markup=False, highlight=False)
+
+EXPIRED_MESSAGES = [
+    "Cooldown expired! ☕ You may drink coffee now.",
+    # やさしく励ましてくれる系
+    "Your break is over -- enjoy your coffee, gently.",
+    "You’ve waited well. Treat yourself to a warm cup.",
+    # ふんわり癒し系
+    "Your coffee time has arrived -- relax and enjoy.",
+    "A warm cup is waiting for you.",
+    "The timer’s done. Brew a moment of comfort.",
+    # ちょっとユーモア系
+    "Permission granted: caffeination may proceed.",
+    "Coffee mode unlocked. Use wisely.",
+    # 行動変容をそっと支援する系
+    "If you choose to, a small cup won’t hurt now.",
+    "Ready when you are. Keep listening to your body.",
+]
+NO_ACTIVE_TIMER_MESSAGE = "No active timer."
+
+
+def _get_console(*, one_line: bool = False, graph_only: bool = False) -> Console:
+    return PLAIN_CONSOLE if (one_line or graph_only) else COLORED_CONSOLE
+
+
+ONE_LINE_BAR_WIDTH = int(max(len(m) for m in EXPIRED_MESSAGES) * 0.7 + 1)
+DURATION_PATTERN = re.compile(r"(\d+)([hms])", re.IGNORECASE)
+FRACTION_SPLIT_PATTERN = re.compile(r"\s*/\s*")
+BAR_FILLED_CHAR = "\U0001d15b"  # black vertical rectangle
+BAR_EMPTY_CHAR = "\U0001d15a"  # white vertical rectangle
+
+INVALID_DURATION_MESSAGE = (
+    "Invalid duration. Use AhBmCs (e.g. 2h30m) or HH:MM:SS. "
+    "You can also use remaining/total like 3h/5h."
+)
+
+
+def _select_expired_message(
+    finish_at: Optional[datetime],
+    duration_sec: Optional[int],
+) -> str:
+    if finish_at is None or duration_sec is None:
+        return random.choice(EXPIRED_MESSAGES)
+    key = f"{finish_at.isoformat()}-{duration_sec}".encode("utf-8")
+    digest = hashlib.sha256(key).digest()
+    index = int.from_bytes(digest[:8], "big") % len(EXPIRED_MESSAGES)
+    return EXPIRED_MESSAGES[index]
+
+
+def _schedule_timer_seconds(remaining_sec: int, total_sec: int):
+    """Create a new timer from seconds, persist it, and return (finish_at, duration_sec)."""
+    if remaining_sec <= 0 or total_sec <= 0:
+        raise ValueError("Duration must be positive.")
+    finish_at = datetime.now() + timedelta(seconds=remaining_sec)
+    save_state(finish_at, total_sec)
+    return finish_at, total_sec
+
+
+def _schedule_timer(hours: int, minutes: int, seconds: int):
+    """Create a new timer, persist it, and return (finish_at, duration_sec)."""
+    duration_sec = _duration_to_seconds(hours, minutes, seconds)
+    return _schedule_timer_seconds(duration_sec, duration_sec)
+
+
+# ------------------------------
+# 永続化まわり
+# ------------------------------
+def _read_state_payload():
+    if not STATE_FILE.exists():
+        return {}
+    try:
+        data = json.loads(STATE_FILE.read_text())
+    except Exception:
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def save_state(finish_at: datetime, duration_sec: int):
+    """終了予定時刻と総時間、現在時刻をキャッシュに保存"""
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    now = datetime.now()
+    payload = {
+        "finish_at": finish_at.isoformat(),
+        "duration_sec": int(duration_sec),
+        "last_saved_at": now.isoformat(),
+    }
+    existing = _read_state_payload()
+    last_finished = existing.get("last_finished")
+    if isinstance(last_finished, dict):
+        payload["last_finished"] = last_finished
+    STATE_FILE.write_text(json.dumps(payload))
+
+
+def load_state():
+    """キャッシュから終了予定時刻と総時間を読み出す"""
+    data = _read_state_payload()
+    finish_at_raw = data.get("finish_at")
+    duration_raw = data.get("duration_sec")
+    if finish_at_raw is None or duration_raw is None:
+        return None
+    try:
+        finish_at = datetime.fromisoformat(finish_at_raw)
+        duration_sec = int(duration_raw)
+    except Exception:
+        return None
+    return finish_at, duration_sec
+
+
+def save_last_finished(finish_at: datetime, duration_sec: int):
+    """直近に終了したタイマーの情報だけを保持"""
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+    payload = {
+        "last_finished": {
+            "finish_at": finish_at.isoformat(),
+            "duration_sec": int(duration_sec),
+        }
+    }
+    STATE_FILE.write_text(json.dumps(payload))
+
+
+def load_last_finished():
+    data = _read_state_payload()
+    last_finished = data.get("last_finished")
+    if not isinstance(last_finished, dict):
+        return None
+    finish_at_raw = last_finished.get("finish_at")
+    duration_raw = last_finished.get("duration_sec")
+    if finish_at_raw is None or duration_raw is None:
+        return None
+    try:
+        finish_at = datetime.fromisoformat(finish_at_raw)
+        duration_sec = int(duration_raw)
+    except Exception:
+        return None
+    return finish_at, duration_sec
+
+
+# ------------------------------
+# タイマー本体
+# ------------------------------
+def _parse_single_duration(duration_str: str):
+    """Parse duration from HH:MM:SS or AhBmCs style into (h, m, s)."""
+    duration_str = duration_str.strip()
+    if not duration_str:
+        raise ValueError
+
+    if ":" in duration_str:
+        parts = duration_str.split(":")
+        if len(parts) != 3:
+            raise ValueError
+        try:
+            h, m, s = map(int, parts)
+        except ValueError as exc:
+            raise ValueError from exc
+        if any(value < 0 for value in (h, m, s)):
+            raise ValueError
+        if h == m == s == 0:
+            raise ValueError
+        return h, m, s
+
+    normalized = duration_str.replace(" ", "").lower()
+    if not normalized:
+        raise ValueError
+
+    pos = 0
+    hours = minutes = seconds = 0
+    for match in DURATION_PATTERN.finditer(normalized):
+        if match.start() != pos:
+            raise ValueError
+        value = int(match.group(1))
+        unit = match.group(2).lower()
+        if unit == "h":
+            hours += value
+        elif unit == "m":
+            minutes += value
+        elif unit == "s":
+            seconds += value
+        pos = match.end()
+
+    if pos != len(normalized):
+        raise ValueError
+
+    if hours == minutes == seconds == 0:
+        raise ValueError
+
+    return hours, minutes, seconds
+
+
+def _duration_to_seconds(hours: int, minutes: int, seconds: int) -> int:
+    return int(timedelta(hours=hours, minutes=minutes, seconds=seconds).total_seconds())
+
+
+def parse_duration(duration_str: str):
+    """Parse duration; support remaining/total with a slash or a single duration.
+
+    Returns (remaining_seconds, total_seconds).
+    """
+    duration_str = duration_str.strip()
+    if not duration_str:
+        raise ValueError(INVALID_DURATION_MESSAGE)
+
+    fraction_parts = FRACTION_SPLIT_PATTERN.split(duration_str, maxsplit=1)
+    if len(fraction_parts) == 2:
+        remaining_raw, total_raw = fraction_parts
+        try:
+            rh, rm, rs = _parse_single_duration(remaining_raw)
+            th, tm, ts = _parse_single_duration(total_raw)
+        except ValueError:
+            raise ValueError(INVALID_DURATION_MESSAGE)
+
+        remaining_sec = _duration_to_seconds(rh, rm, rs)
+        total_sec = _duration_to_seconds(th, tm, ts)
+
+        if remaining_sec <= 0 or total_sec <= 0:
+            raise ValueError(
+                "Duration must be positive (parsed as remaining/total like 3h/5h)."
+            )
+        if remaining_sec > total_sec:
+            raise ValueError(
+                "Remaining duration cannot exceed total duration "
+                "(parsed as remaining/total like 3h/5h)."
+            )
+
+        return remaining_sec, total_sec
+
+    try:
+        h, m, s = _parse_single_duration(duration_str)
+    except ValueError:
+        raise ValueError(INVALID_DURATION_MESSAGE)
+    single_sec = _duration_to_seconds(h, m, s)
+    return single_sec, single_sec
+
+
+def start_timer(
+    hours=0,
+    minutes=0,
+    seconds=0,
+    *,
+    one_line=False,
+    graph_only=False,
+):
+    console = _get_console(one_line=one_line, graph_only=graph_only)
+    try:
+        duration_sec = _duration_to_seconds(hours, minutes, seconds)
+        finish_at, duration_sec = _schedule_timer_seconds(duration_sec, duration_sec)
+    except ValueError as exc:
+        console.print(str(exc))
+        return
+
+    if not one_line and not graph_only:
+        console.print(
+            "Coffee cooldown started. "
+            f"Expires at {finish_at.strftime('%Y-%m-%d %H:%M:%S')}"
+        )
+    run_timer_loop(
+        finish_at,
+        duration_sec,
+        one_line=one_line,
+        graph_only=graph_only,
+    )
+
+
+def run_timer_loop(
+    finish_at: datetime = None,
+    duration_sec: int = None,
+    *,
+    one_line: bool = False,
+    graph_only: bool = False,
+):
+    console = _get_console(one_line=one_line, graph_only=graph_only)
+    # resume 用に state から読み直すケース
+    if finish_at is None or duration_sec is None:
+        state = load_state()
+        if state is None:
+            console.print(NO_ACTIVE_TIMER_MESSAGE)
+            return
+        finish_at, duration_sec = state
+
+    now = datetime.now()
+    if (finish_at - now) <= timedelta(0):
+        try:
+            save_last_finished(finish_at, duration_sec)
+        except Exception:
+            pass
+        console.print(_select_expired_message(finish_at, duration_sec))
+        return
+
+    if one_line or graph_only:
+        _run_ascii_loop(
+            finish_at,
+            duration_sec,
+            graph_only=graph_only,
+        )
+        return
+
+    try:
+        _run_rich_loop(finish_at, duration_sec)
+
+        try:
+            save_last_finished(finish_at, duration_sec)
+        except Exception:
+            pass
+        console.print(_select_expired_message(finish_at, duration_sec))
+
+    except KeyboardInterrupt:
+        console.print("\nInterrupted by user. Timer state saved.")
+
+
+def _run_rich_loop(finish_at: datetime, duration_sec: int):
+    last_saved_minute = None
+    progress = Progress(
+        TextColumn("{task.fields[remaining]}"),
+        BarColumn(bar_width=60),
+        transient=True,
+        console=COLORED_CONSOLE,
+    )
+
+    with progress:
+        task_id = progress.add_task(
+            "",
+            total=duration_sec,
+            remaining="--:--:--",
+        )
+
+        while True:
+            now = datetime.now()
+            remaining = finish_at - now
+            remaining_sec = int(remaining.total_seconds())
+
+            if remaining_sec <= 0:
+                progress.update(
+                    task_id,
+                    completed=0,
+                    remaining="00:00:00",
+                )
+                break
+
+            completed = remaining_sec
+            remaining_str = _format_remaining(remaining_sec)
+
+            progress.update(
+                task_id,
+                completed=completed,
+                remaining=remaining_str,
+            )
+
+            if last_saved_minute != now.minute:
+                save_state(finish_at, duration_sec)
+                last_saved_minute = now.minute
+
+            time.sleep(1)
+
+
+def _run_ascii_loop(
+    finish_at: datetime,
+    duration_sec: int,
+    *,
+    graph_only: bool = False,
+):
+    console = _get_console(one_line=True, graph_only=graph_only)
+    last_saved_minute = None
+    last_line_len = 0
+
+    try:
+        while True:
+            now = datetime.now()
+            remaining = finish_at - now
+            remaining_sec = int(remaining.total_seconds())
+
+            if remaining_sec <= 0:
+                break
+
+            line = _render_one_line(
+                remaining_sec,
+                duration_sec,
+                graph_only=graph_only,
+            )
+            pad = max(last_line_len - len(line), 0)
+            output = line + (" " * pad)
+            console.print(
+                output,
+                end="\r",
+                markup=False,
+                highlight=False,
+            )
+            last_line_len = len(line)
+
+            if last_saved_minute != now.minute:
+                save_state(finish_at, duration_sec)
+                last_saved_minute = now.minute
+
+            time.sleep(1)
+
+    except KeyboardInterrupt:
+        console.print("\nInterrupted by user. Timer state saved.")
+        return
+
+    # Clear the current line before printing the final message.
+    if last_line_len:
+        console.print(" " * last_line_len, end="\r")
+
+    try:
+        save_last_finished(finish_at, duration_sec)
+    except Exception:
+        pass
+
+    console.print(_select_expired_message(finish_at, duration_sec))
+
+
+def _print_snapshot_status(
+    finish_at: datetime,
+    duration_sec: int,
+    *,
+    one_line: bool = False,
+    graph_only: bool = False,
+):
+    console = _get_console(one_line=one_line, graph_only=graph_only)
+    remaining_sec = int((finish_at - datetime.now()).total_seconds())
+    if remaining_sec <= 0:
+        try:
+            save_last_finished(finish_at, duration_sec)
+        except Exception:
+            pass
+        console.print(_select_expired_message(finish_at, duration_sec))
+        return
+
+    if graph_only:
+        line = _render_one_line(
+            remaining_sec,
+            duration_sec,
+            graph_only=True,
+        )
+        console.print(line, markup=False)
+        return
+
+    if one_line:
+        line = _render_one_line(
+            remaining_sec,
+            duration_sec,
+            graph_only=False,
+        )
+        console.print(line, markup=False)
+        return
+
+    expires_at = finish_at.strftime("%Y-%m-%d %H:%M:%S")
+    remaining_str = _format_remaining(remaining_sec)
+    bar_line = _render_one_line(
+        remaining_sec,
+        duration_sec,
+        graph_only=True,
+    )
+    console.print(f"Remaining: {remaining_str}")
+    console.print(f"Expires at: {expires_at}")
+    console.print(bar_line, markup=False)
+
+
+def _format_remaining(remaining_sec: int) -> str:
+    h = remaining_sec // 3600
+    m = (remaining_sec % 3600) // 60
+    s = remaining_sec % 60
+    return f"{h:02d}:{m:02d}:{s:02d}"
+
+
+def _render_one_line(
+    remaining_sec: int,
+    duration_sec: int,
+    *,
+    graph_only: bool = False,
+) -> str:
+    remaining_str = _format_remaining(max(remaining_sec, 0))
+    segments = ONE_LINE_BAR_WIDTH
+    if duration_sec <= 0:
+        bar = BAR_EMPTY_CHAR * segments
+    else:
+        ratio = max(0.0, min(remaining_sec / duration_sec, 1.0))
+        filled_segments = int(ratio * segments + 0.5)
+        filled_segments = max(0, min(filled_segments, segments))
+        empty_segments = segments - filled_segments
+        bar = (BAR_FILLED_CHAR * filled_segments) + (BAR_EMPTY_CHAR * empty_segments)
+    if graph_only:
+        return f"{bar}"
+    return f"{remaining_str} {bar}"
+
+
+def resume_timer(*, one_line=False, graph_only=False):
+    console = _get_console(one_line=one_line, graph_only=graph_only)
+    state = load_state()
+    if state is None:
+        last_finished = load_last_finished()
+        if last_finished is not None:
+            console.print(_select_expired_message(*last_finished))
+        else:
+            if one_line or graph_only:
+                console.print(_select_expired_message(None, None))
+            else:
+                console.print(NO_ACTIVE_TIMER_MESSAGE)
+        return
+
+    finish_at, duration_sec = state
+    if finish_at <= datetime.now():
+        try:
+            save_last_finished(finish_at, duration_sec)
+        except Exception:
+            pass
+        console.print(_select_expired_message(finish_at, duration_sec))
+        return
+    if not one_line and not graph_only:
+        console.print(
+            f"Resuming cooldown. Expires at {finish_at.strftime('%Y-%m-%d %H:%M:%S')}"
+        )
+    run_timer_loop(
+        finish_at,
+        duration_sec,
+        one_line=one_line,
+        graph_only=graph_only,
+    )
+
+
+# ------------------------------
+# エントリポイント
+# ------------------------------
+def main(argv=None):
+    args = _parse_args(argv)
+    resolved = _resolve_timer_state(args)
+    if resolved is None:
+        return
+    finish_at, duration_sec, new_timer_started = resolved
+
+    if args.run:
+        _run_live_mode(
+            args,
+            finish_at,
+            duration_sec,
+            new_timer_started,
+        )
+        return
+
+    _print_snapshot_status(
+        finish_at,
+        duration_sec,
+        one_line=args.one_line,
+        graph_only=args.graph_only,
+    )
+
+
+def _parse_args(argv=None):
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Coffee cooldown timer (rich version)")
+    parser.add_argument(
+        "duration",
+        nargs="?",
+        metavar="DURATION",
+        help=(
+            "Set a new timer (e.g. 2h, 15m30s, 0:25:00, or remaining/total like 3h/5h). "
+            "Omit to resume."
+        ),
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    parser.add_argument(
+        "--one-line",
+        action="store_true",
+        help="Use the single-line ASCII format (time + bar).",
+    )
+    parser.add_argument(
+        "--graph-only",
+        action="store_true",
+        help="Show only the ASCII bar (no time).",
+    )
+    parser.add_argument(
+        "--run",
+        action="store_true",
+        help="Keep updating continuously until the timer expires.",
+    )
+    return parser.parse_args(argv)
+
+
+def _resolve_timer_state(args):
+    console = _get_console(one_line=args.one_line, graph_only=args.graph_only)
+    finish_at = None
+    duration_sec = None
+    new_timer_started = False
+
+    if args.duration:
+        try:
+            remaining_sec, total_sec = parse_duration(args.duration)
+        except ValueError as exc:
+            message = str(exc) if str(exc) else INVALID_DURATION_MESSAGE
+            console.print(message)
+            return None
+        try:
+            finish_at, duration_sec = _schedule_timer_seconds(remaining_sec, total_sec)
+        except ValueError as exc:
+            console.print(str(exc))
+            return None
+        new_timer_started = True
+    else:
+        state = load_state()
+        if state is None:
+            if args.run:
+                console.print(NO_ACTIVE_TIMER_MESSAGE)
+            else:
+                last_finished = load_last_finished()
+                if last_finished is not None:
+                    console.print(_select_expired_message(*last_finished))
+                else:
+                    if args.one_line or args.graph_only:
+                        console.print(_select_expired_message(None, None))
+                    else:
+                        console.print(NO_ACTIVE_TIMER_MESSAGE)
+            return None
+        finish_at, duration_sec = state
+
+    return finish_at, duration_sec, new_timer_started
+
+
+def _run_live_mode(args, finish_at, duration_sec, new_timer_started):
+    console = _get_console(
+        one_line=args.one_line,
+        graph_only=args.graph_only,
+    )
+    if finish_at > datetime.now():
+        if new_timer_started:
+            console.print(
+                "Coffee cooldown started. "
+                f"Expires at {finish_at.strftime('%Y-%m-%d %H:%M:%S')}"
+            )
+        else:
+            console.print(
+                "Resuming cooldown. "
+                f"Expires at {finish_at.strftime('%Y-%m-%d %H:%M:%S')}"
+            )
+    run_timer_loop(
+        finish_at,
+        duration_sec,
+        one_line=args.one_line,
+        graph_only=args.graph_only,
+    )
+
+
+if __name__ == "__main__":
+    main()

decafe_timer-0.4.3.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: decafe-timer
+Version: 0.4.3
+Project-URL: Documentation, https://github.com/Toshihiro Kamiya/decafe-timer#readme
+Project-URL: Issues, https://github.com/Toshihiro Kamiya/decafe-timer/issues
+Project-URL: Source, https://github.com/Toshihiro Kamiya/decafe-timer
+Author-email: Toshihiro Kamiya <kamiya@mbj.nifty.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.8
+Requires-Dist: appdirs
+Requires-Dist: rich
+Description-Content-Type: text/markdown
+
+# decafe-timer
+
+[![PyPI - Version](https://img.shields.io/pypi/v/decafe-timer.svg)](https://pypi.org/project/decafe-timer)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/decafe-timer.svg)](https://pypi.org/project/decafe-timer)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Usage](#usage)
+- [License](#license)
+
+## Installation
+
+```console
+pip install decafe-timer
+```
+
+## Usage
+
+The CLI revolves around three ideas:
+
+1. Passing a duration creates a new cooldown; omitting it resumes whatever is already running. You can use single durations (`2h`, `15m30s`, `0:45:00`) or a remaining/total pair like `3h/5h` (spaces around `/` are allowed, and mixed formats like `3h/4:50:00` work too).
+2. `--run` decides whether to keep the Rich UI updating until the cooldown expires. Without `--run`, the command prints the current status once and exits.
+3. Style flags pick the ASCII layout: default multi-line (`Remaining` / `Expires at` + bar), `--one-line` (`HH:MM:SS 𝅛𝅛𝅛𝅚𝅚…`), or `--graph-only` (just the bar with no time stamp). They’re accepted on any invocation; when paired with `--run`, the live updates switch to that ASCII style instead of the Rich progress bar. Snapshots print `[You may drink coffee now.]` once the timer finishes.
+
+```console
+decafe-timer 45m          # start a new timer, print one snapshot
+decafe-timer 3h/5h        # start with 3h remaining out of a 5h total
+decafe-timer              # resume the latest timer, one snapshot
+decafe-timer --run 45m    # start a new timer and watch it count down
+decafe-timer --run        # resume the Rich UI for an active timer
+decafe-timer --run --one-line 10m  # live ASCII updates instead of Rich
+decafe-timer --graph-only # snapshot with the ASCII bar only
+decafe-timer --version    # show the current version
+```
+
+## License
+
+`decafe-timer` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

decafe_timer-0.4.3.dist-info/RECORD

@@ -0,0 +1,8 @@
+decafe_timer/__about__.py,sha256=TQ-uFlqREnTaUs1BIstUXNi-RbUGM4yYvYUKhQVK9SY,134
+decafe_timer/__init__.py,sha256=qYYWqFTmjMNdoaXtn7Gm0ViSlKMXAp0YJPZhJ0PITJw,135
+decafe_timer/main.py,sha256=eDWlpwnwKdCR3urbch_yHxYzMY_L-4Sppq5xeh_aq8U,19928
+decafe_timer-0.4.3.dist-info/METADATA,sha256=TUeUIGy7ru-p-wHgt8vjLn2qb7G-f4C13kSjS3lR1S4,2757
+decafe_timer-0.4.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+decafe_timer-0.4.3.dist-info/entry_points.txt,sha256=aX-QINfkbeC9PyuSiQH57qe39euSc9DoLnwkgTWpnRg,51
+decafe_timer-0.4.3.dist-info/licenses/LICENSE.txt,sha256=q-cJYG_K766eXSxQ7txWcWQ6nS2OF6c3HTVLesHbesU,1104
+decafe_timer-0.4.3.dist-info/RECORD,,

decafe_timer-0.4.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

decafe_timer-0.4.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+decafe-timer = decafe_timer:main

decafe_timer-0.4.3.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025-present Toshihiro Kamiya <kamiya@mbj.nifty.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.