term-clock-app 1.0.0__py3-none-any.whl

term_clock/__init__.py

@@ -0,0 +1,3 @@
+"""A terminal digital clock that scales to fill the window."""
+
+__version__ = "1.0.0"

term_clock/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

term_clock/cli.py

@@ -0,0 +1,203 @@
+"""Terminal runtime: paints the clock and stays current until CTRL+C."""
+
+from __future__ import annotations
+
+import argparse
+import shutil
+import sys
+import time
+from typing import Callable, Sequence, TextIO
+
+from . import core
+
+_ALT_ON = "\x1b[?1049h"
+_ALT_OFF = "\x1b[?1049l"
+_CURSOR_HIDE = "\x1b[?25l"
+_CURSOR_SHOW = "\x1b[?25h"
+_WRAP_OFF = "\x1b[?7l"
+_WRAP_ON = "\x1b[?7h"
+# Home, erase the visible screen, erase the scrollback. A full-width last
+# line would otherwise wrap and push every frame into the history.
+_CLEAR = "\x1b[H\x1b[2J\x1b[3J"
+
+
+def _nonneg(value: str) -> int:
+    n = int(value)
+    if n < 0:
+        raise argparse.ArgumentTypeError("must be >= 0")
+    return n
+
+
+_TOLERANCE_MS = 2.0
+_LEAD_MAX_MS = 100.0
+
+
+def next_second_ms(now_ms: float) -> float:
+    """Wall-clock millisecond of the next whole second after ``now_ms``."""
+    return (int(now_ms) // 1000 + 1) * 1000.0
+
+
+def sleep_ms(now_ms: float, target_ms: float, lead_ms: float) -> float:
+    """How long to sleep now so we arrive at ``target_ms``, given ``lead_ms``.
+
+    ``lead_ms`` is the estimated sleep overshoot, subtracted from the wait.
+    It is never allowed to skip past the boundary.
+    """
+    remain = target_ms - now_ms
+    if remain <= 0:
+        return 0.0
+    wait = remain - lead_ms
+    if wait <= 0:
+        wait = remain
+    return wait
+
+
+def adjust_lead_ms(lead_ms: float, error_ms: float) -> float:
+    """If we missed the second by more than 2 ms, shift the next sleep."""
+    if abs(error_ms) <= _TOLERANCE_MS:
+        return lead_ms
+    return min(_LEAD_MAX_MS, max(0.0, lead_ms + error_ms))
+
+
+def _wall_ms() -> float:
+    return time.time_ns() / 1_000_000.0
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        prog="term-clock",
+        description="A terminal digital clock that scales to fill the window.",
+    )
+    p.add_argument(
+        "--padding",
+        type=_nonneg,
+        default=1,
+        metavar="N",
+        help="blank rows and columns around the clock (default: 1)",
+    )
+    p.add_argument(
+        "--spacing",
+        type=_nonneg,
+        default=2,
+        metavar="N",
+        help="blank columns between digits (default: 2)",
+    )
+    p.add_argument(
+        "--hour-format",
+        choices=("12", "24"),
+        default=None,
+        dest="hour_format",
+        help="12 or 24 (default: follow the system clock, or 24 if unknown)",
+    )
+    return p.parse_args(argv)
+
+
+def frame_for(
+    t: time.struct_time,
+    cols: int,
+    rows: int,
+    style: core.Style | None = None,
+) -> list[str]:
+    """Build the screen buffer for time ``t`` at the given terminal size."""
+    style = style or core.Style()
+    time_str = core.format_time(
+        t.tm_hour, t.tm_min, t.tm_sec, hour_format=style.hour_format
+    )
+    suffix = core.hour_period(t.tm_hour) if style.hour_format == "12" else ""
+    return core.render(time_str, rows=rows, cols=cols, style=style, suffix=suffix)
+
+
+def _write_diff(out: TextIO, old: Sequence[str], new: Sequence[str]) -> None:
+    """Emit cursor-addressed runs for cells that differ."""
+    for y, (a, b) in enumerate(zip(old, new)):
+        if a == b:
+            continue
+        width = max(len(a), len(b))
+        a = a.ljust(width)
+        b = b.ljust(width)
+        x = 0
+        while x < width:
+            if a[x] == b[x]:
+                x += 1
+                continue
+            start = x
+            while x < width and a[x] != b[x]:
+                x += 1
+            out.write(f"\x1b[{y + 1};{start + 1}H{b[start:x]}")
+
+
+class Painter:
+    """Off-screen current/next buffers; only changed cells are written."""
+
+    def __init__(self, out: TextIO) -> None:
+        self._out = out
+        self._last: list[str] | None = None
+
+    def paint(self, frame: Sequence[str]) -> None:
+        frame = list(frame)
+        if frame == self._last:
+            return
+        if self._last is None or len(self._last) != len(frame):
+            self._out.write(_CLEAR + "\n".join(frame))
+        else:
+            _write_diff(self._out, self._last, frame)
+        self._last = frame
+        self._out.flush()
+
+    def invalidate(self) -> None:
+        self._last = None
+
+
+def run(
+    out: TextIO | None = None,
+    get_size: Callable[[], tuple[int, int]] | None = None,
+    get_time: Callable[[], time.struct_time] | None = None,
+    sleep: Callable[[float], None] = time.sleep,
+    style: core.Style | None = None,
+    now_ms: Callable[[], float] | None = None,
+) -> int:
+    out = out if out is not None else sys.stdout
+    get_size = get_size or (lambda: tuple(shutil.get_terminal_size((80, 24))))
+    get_time = get_time or time.localtime
+    now_ms = now_ms or _wall_ms
+
+    out.write(_ALT_ON + _CURSOR_HIDE + _WRAP_OFF)
+    out.flush()
+    painter = Painter(out)
+    last_size: tuple[int, int] | None = None
+    lead_ms = 0.0
+
+    def paint() -> None:
+        nonlocal last_size
+        cols, rows = get_size()
+        if (cols, rows) != last_size:
+            painter.invalidate()
+            last_size = (cols, rows)
+        painter.paint(frame_for(get_time(), cols=cols, rows=rows, style=style))
+
+    try:
+        while True:
+            paint()
+            target = next_second_ms(now_ms())
+            now = now_ms()
+            wait = sleep_ms(now, target, lead_ms)
+            if wait > 0:
+                sleep(wait / 1000.0)
+            lead_ms = adjust_lead_ms(lead_ms, now_ms() - target)
+    except KeyboardInterrupt:
+        return 0
+    finally:
+        out.write(_WRAP_ON + _CURSOR_SHOW + _ALT_OFF)
+        out.flush()
+
+
+def main(argv: list[str] | None = None) -> int:
+    ns = parse_args(argv)
+    hour_format = ns.hour_format or core.system_hour_format()
+    return run(
+        style=core.Style(
+            padding=ns.padding,
+            spacing=ns.spacing,
+            hour_format=hour_format,
+        ),
+    )

term_clock/core.py

@@ -0,0 +1,345 @@
+"""Pure, side-effect-free clock rendering.
+
+Everything here is deterministic and unit-tested. The runtime shell in
+``cli.py`` supplies the current time and terminal size and paints the result.
+
+Big digits
+----------
+Seven-segment bars drawn with full blocks ``█``. Horizontal bars run across,
+vertical bars run down. Convex corners are cut with a 1:1 45-degree stair of
+``◤ ◥ ◣ ◢`` -- one column per row, no sampling, no off-angle hypotenuses.
+"""
+
+from __future__ import annotations
+
+import locale
+from dataclasses import dataclass
+
+BLOCK = "█"
+
+_DIGIT_SEGMENTS = {
+    0: "ABCDEF", 1: "BC", 2: "ABGED", 3: "ABGCD", 4: "FGBC",
+    5: "AFGCD", 6: "AFGCDE", 7: "ABC", 8: "ABCDEFG", 9: "ABCDFG",
+}
+
+# 45° cut: (step-x, step-y, glyph on the diagonal)
+_CUT = {
+    "UL": (1, 1, "◢"),
+    "UR": (-1, 1, "◣"),
+    "DL": (1, -1, "◥"),
+    "DR": (-1, -1, "◤"),
+}
+
+
+def format_time(h: int, m: int, s: int, hour_format: str = "24") -> str:
+    """Return ``hh:mm:ss`` (zero-padded). ``hour_format`` is ``"24"`` or ``"12"``."""
+    if not (0 <= h < 24 and 0 <= m < 60 and 0 <= s < 60):
+        raise ValueError(f"time out of range: {h}:{m}:{s}")
+    if hour_format == "12":
+        h = h % 12 or 12
+    elif hour_format != "24":
+        raise ValueError(f"unknown hour format: {hour_format}")
+    return f"{h:02d}:{m:02d}:{s:02d}"
+
+
+def hour_period(h: int) -> str:
+    """``AM`` before noon, ``PM`` from noon inclusive."""
+    if not (0 <= h < 24):
+        raise ValueError(f"hour out of range: {h}")
+    return "AM" if h < 12 else "PM"
+
+
+def system_hour_format(t_fmt: str | None = None) -> str:
+    """``12`` or ``24`` from the environment's time format; ``24`` if unknown."""
+    if t_fmt is None:
+        t_fmt = _locale_t_fmt()
+    if not t_fmt:
+        return "24"
+    if "%I" in t_fmt or "%p" in t_fmt or "%r" in t_fmt:
+        return "12"
+    return "24"
+
+
+def _locale_t_fmt() -> str | None:
+    try:
+        locale.setlocale(locale.LC_TIME, "")
+    except locale.Error:
+        pass
+    try:
+        return locale.nl_langinfo(locale.T_FMT)
+    except (AttributeError, ValueError, locale.Error):
+        return None
+
+
+TEXT_LINE_LIMIT = 7
+
+
+def choose_mode(rows: int) -> str:
+    """``"art"`` when there is real headroom (>= 8 lines), else ``"text"``."""
+    return "art" if rows > TEXT_LINE_LIMIT else "text"
+
+
+@dataclass(frozen=True)
+class Style:
+    """User-facing layout knobs."""
+
+    padding: int = 1
+    spacing: int = 2
+    hour_format: str = "24"
+
+
+@dataclass(frozen=True)
+class Layout:
+    """Stroke thickness and the two inner spans of a seven-segment cell."""
+
+    t: int
+    hw: int
+    vh: int
+    gap: int
+    colon_w: int
+
+    @property
+    def digit_w(self) -> int:
+        return 2 * self.t + self.hw
+
+    @property
+    def digit_h(self) -> int:
+        return 3 * self.t + 2 * self.vh
+
+
+def colon_metrics(digit_h: int) -> tuple[int, int, int]:
+    """``(dot_w, dot_h, gap)`` for two axis-aligned colon dots.
+
+    The pair spans at most one third of ``digit_h`` (floored at 3 rows so a
+    tiny digit still gets two dots with a hole between them).
+    """
+    cap = digit_h // 3
+    span = cap if cap >= 3 else min(3, max(digit_h, 0))
+    if span < 3:
+        return max(1, span), max(1, span), 0
+    gap = 1 if span < 6 else max(1, span // 4)
+    dot_h = max(1, (span - gap) // 2)
+    gap = span - 2 * dot_h
+    if gap < 1:
+        dot_h = max(1, (span - 1) // 2)
+        gap = span - 2 * dot_h
+    # 1-row dots are two cells wide so they stay visible; larger dots stay square.
+    dot_w = 2 if dot_h == 1 else dot_h
+    return dot_w, dot_h, gap
+
+
+def colon_width(digit_h: int) -> int:
+    return colon_metrics(digit_h)[0]
+
+
+def _segment_rects(lay: Layout):
+    t, w, h = lay.t, lay.digit_w, lay.digit_h
+    hg = t + lay.vh
+    return {
+        "A": (0, w, 0, t),
+        "D": (0, w, h - t, h),
+        "G": (0, w, hg, hg + t),
+        "F": (0, t, 0, hg + t),
+        "B": (w - t, w, 0, hg + t),
+        "E": (0, t, hg, h),
+        "C": (w - t, w, hg, h),
+    }
+
+
+def _fill_rects(ink, rects, names):
+    for name in names:
+        x0, x1, y0, y1 = rects[name]
+        for y in range(y0, y1):
+            for x in range(x0, x1):
+                ink[y][x] = True
+
+
+def _convex_corners(ink):
+    h, w = len(ink), len(ink[0])
+
+    def on(x, y):
+        return 0 <= x < w and 0 <= y < h and ink[y][x]
+
+    out = []
+    for y in range(h):
+        for x in range(w):
+            if not ink[y][x]:
+                continue
+            up, dn = not on(x, y - 1), not on(x, y + 1)
+            lf, rt = not on(x - 1, y), not on(x + 1, y)
+            if up and rt and not on(x + 1, y - 1) and on(x, y + 1) and on(x - 1, y):
+                out.append((x, y, "UR"))
+            elif up and lf and not on(x - 1, y - 1) and on(x, y + 1) and on(x + 1, y):
+                out.append((x, y, "UL"))
+            elif dn and rt and not on(x + 1, y + 1) and on(x, y - 1) and on(x - 1, y):
+                out.append((x, y, "DR"))
+            elif dn and lf and not on(x - 1, y + 1) and on(x, y - 1) and on(x + 1, y):
+                out.append((x, y, "DL"))
+    return out
+
+
+def _cut_corner(grid, cx, cy, n, kind):
+    """1:1 45° stair of size ``n``: put the triangle on the diagonal, clear outside."""
+    sx, sy, glyph = _CUT[kind]
+    h, w = len(grid), len(grid[0])
+    for k in range(n):
+        x_diag, y = cx + sx * (n - 1 - k), cy + sy * k
+        if 0 <= x_diag < w and 0 <= y < h:
+            grid[y][x_diag] = glyph
+        for j in range(n - 1 - k):
+            x = cx + sx * j
+            if 0 <= x < w and 0 <= y < h:
+                grid[y][x] = " "
+
+
+def _raster(ink, t: int) -> list[str]:
+    grid = [["█" if cell else " " for cell in row] for row in ink]
+    n = max(1, t // 2)
+    for cx, cy, kind in _convex_corners(ink):
+        _cut_corner(grid, cx, cy, n, kind)
+    return ["".join(row) for row in grid]
+
+
+def paint(ch: str, lay: Layout) -> list[str]:
+    """One glyph (``0``–``9`` or ``:``) as ``digit_h`` rows of ``digit_w`` / ``colon_w``."""
+    h = lay.digit_h
+    if ch == ":":
+        w = max(1, lay.colon_w)
+        ink = [[" "] * w for _ in range(h)]
+        dw, dh, dgap = colon_metrics(h)
+        dw = min(dw, w)
+        span = 2 * dh + dgap
+        y0 = max(0, (h - span) // 2)
+        x0 = max(0, (w - dw) // 2)
+        for y in range(y0, y0 + dh):
+            for x in range(x0, x0 + dw):
+                ink[y][x] = "█"
+        y1 = y0 + dh + dgap
+        for y in range(y1, y1 + dh):
+            for x in range(x0, x0 + dw):
+                if 0 <= y < h:
+                    ink[y][x] = "█"
+        return ["".join(row) for row in ink]
+
+    w = lay.digit_w
+    ink = [[False] * w for _ in range(h)]
+    _fill_rects(ink, _segment_rects(lay), _DIGIT_SEGMENTS[int(ch)])
+    return _raster(ink, lay.t)
+
+
+def _clock_width(lay: Layout, time_str: str) -> int:
+    w = 0
+    for i, ch in enumerate(time_str):
+        if i:
+            w += lay.gap
+        w += lay.colon_w if ch == ":" else lay.digit_w
+    return w
+
+
+def _suffix_span(suffix: str, gap: int) -> int:
+    return (gap + len(suffix)) if suffix else 0
+
+
+def _label(time_str: str, suffix: str) -> str:
+    return f"{time_str} {suffix}" if suffix else time_str
+
+
+MAX_ASPECT = 1.5
+
+
+def fit(
+    rows: int,
+    cols: int,
+    time_str: str = "12:34:56",
+    style: Style | None = None,
+    suffix: str = "",
+) -> Layout | None:
+    """Largest layout that fits the inner (padded) frame.
+
+    Default cell is 5t×5t; each axis may stretch by at most ``MAX_ASPECT``.
+    """
+    style = style or Style()
+    pad = max(0, style.padding)
+    gap = max(0, style.spacing)
+    rows = max(0, rows - 2 * pad)
+    cols = max(0, cols - 2 * pad - _suffix_span(suffix, gap))
+    n_d = sum(c != ":" for c in time_str) or 1
+    n_c = time_str.count(":")
+    n_g = max(0, len(time_str) - 1)
+    best: Layout | None = None
+    for t in range(1, rows + 1):
+        if 5 * t > rows:
+            break
+        max_h = min(rows, int(5 * t * MAX_ASPECT))
+        colon_w = colon_width(max_h)
+        lo = Layout(t, 3 * t, t, gap, colon_w)
+        if lo.digit_h > rows or _clock_width(lo, time_str) > cols:
+            continue
+        vh = (max_h - 3 * t) // 2
+        if vh < t:
+            continue
+        max_w = min(
+            (cols - n_c * colon_w - n_g * gap) // n_d,
+            int(5 * t * MAX_ASPECT),
+        )
+        hw = max_w - 2 * t
+        if hw < 3 * t:
+            hw = 3 * t
+        lay = Layout(t, hw, vh, gap, colon_width(3 * t + 2 * vh))
+        if lay.digit_h > rows or _clock_width(lay, time_str) > cols:
+            continue
+        best = lay
+    return best
+
+
+def render_art(
+    time_str: str,
+    rows: int,
+    cols: int,
+    lay: Layout,
+    suffix: str = "",
+) -> list[str]:
+    blocks = [paint(ch, lay) for ch in time_str]
+    gap = " " * lay.gap
+    body = [gap.join(parts) for parts in zip(*blocks)]
+    if suffix and body:
+        extra = gap + suffix
+        mid = len(body) // 2
+        body = [
+            line + (extra if i == mid else " " * len(extra))
+            for i, line in enumerate(body)
+        ]
+    bw = len(body[0]) if body else 0
+    left = max(0, (cols - bw) // 2)
+    top = max(0, (rows - len(body)) // 2)
+
+    grid = [" " * cols for _ in range(rows)]
+    for i, line in enumerate(body):
+        if 0 <= top + i < rows:
+            grid[top + i] = (" " * left + line)[:cols].ljust(cols)
+    return grid
+
+
+def _render_text(time_str: str, rows: int, cols: int) -> list[str]:
+    grid = [" " * cols for _ in range(rows)]
+    row = (rows - 1) // 2 if rows else 0
+    if 0 <= row < rows:
+        grid[row] = time_str.center(cols)[:cols].ljust(cols)
+    return grid
+
+
+def render(
+    time_str: str,
+    rows: int,
+    cols: int,
+    style: Style | None = None,
+    suffix: str = "",
+) -> list[str]:
+    """Return exactly ``rows`` lines of exactly ``cols`` chars."""
+    style = style or Style()
+    rows, cols = max(rows, 0), max(cols, 0)
+    if choose_mode(rows) == "art":
+        lay = fit(rows, cols, time_str, style=style, suffix=suffix)
+        if lay is not None:
+            return render_art(time_str, rows, cols, lay, suffix=suffix)
+    return _render_text(_label(time_str, suffix), rows, cols)

term_clock_app-1.0.0.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: term-clock-app
+Version: 1.0.0
+Summary: A terminal digital clock that scales to fill the window.
+Author: Lorenzo Wood
+License: MIT License
+        
+        Copyright (c) 2026 Lorenzo Wood
+        
+        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 ANY 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.
+        
+Project-URL: Homepage, https://github.com/lorenzowood/term-clock
+Project-URL: Repository, https://github.com/lorenzowood/term-clock
+Project-URL: Issues, https://github.com/lorenzowood/term-clock/issues
+Keywords: clock,terminal,tui,ssh
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Terminals
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# term-clock
+
+A digital clock for the terminal. It shows `hh:mm:ss`, stays on the wall-clock
+second, and grows to fill the window.
+
+Works over SSH the same way it works locally: alternate screen, no flicker,
+CTRL+C returns you to the prompt.
+
+## Install
+
+```sh
+pip install term-clock-app
+```
+
+The PyPI name is `term-clock-app` because `term-clock` / `termclock` is already taken. The command you run is still `term-clock`.
+
+From a clone:
+
+```sh
+pip install -e .
+```
+
+Python 3.9 or newer. No runtime dependencies.
+
+## Run
+
+```sh
+term-clock
+# or
+python -m term_clock
+```
+
+```sh
+term-clock --padding 1 --spacing 2          # defaults
+term-clock --padding 2 --spacing 4
+term-clock --hour-format 12
+term-clock --hour-format 24
+```
+
+Press **CTRL+C** to quit.
+
+## Options
+
+| Flag | Default | Meaning |
+| --- | --- | --- |
+| `--padding N` | `1` | Blank rows and columns on every side |
+| `--spacing N` | `2` | Blank columns between digits |
+| `--hour-format {12,24}` | system clock, or `24` | 12-hour with AM/PM, or 24-hour |
+
+The default hour format follows the environment's time locale
+(`LC_TIME` / `T_FMT`) when that can be read. If it cannot, the clock uses 24-hour.
+
+## Display
+
+- **7 or fewer lines**: a plain text clock, centred.
+- **8+ lines**: large seven-segment digits drawn with full blocks `█` for
+  horizontal and vertical bars, and the four triangles `◤ ◥ ◣ ◢` for 45°
+  corner cuts (one column per row — never sampled, never an off-angle
+  diagonal). They grow to fill the window (each axis stretched by at most
+  1.5× before the rest becomes centring margin). If the window is too small
+  for a readable clock, it falls back to the text version.
+- **Colons**: two small axis-aligned blocks (no diagonals), centred, spanning
+  at most one third of the digit height.
+- **12-hour**: AM or PM sits to the right of the digits.
+- **Timing**: after each flip the process sleeps until the next wall-clock
+  second, then measures how late or early it woke (target: within 2 ms) and
+  shortens or lengthens the following sleep. A resize is picked up on the
+  next second. Unchanged cells are not rewritten.
+
+## Develop
+
+```sh
+pip install -e ".[dev]"
+pytest
+```
+
+Pure rendering lives in `term_clock/core.py` (unit-tested). The terminal loop
+is in `term_clock/cli.py`.
+
+See `DESIGN.md` for the design and the TDD log.
+
+## License
+
+MIT. See `LICENSE`.

term_clock_app-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+term_clock/__init__.py,sha256=FCWCxOtWNxoFYGnWNaY0QpBCUSM6p4dAUs3xWModr_w,86
+term_clock/__main__.py,sha256=U5jx9QzjN2RqqGk0yeidxMg7M9UjpfmLguJCGcYl-jg,95
+term_clock/cli.py,sha256=bmAF_NgjmjjBBzmMnjWP9MPEbFoZ1pGeya-ZVuiAn6g,5870
+term_clock/core.py,sha256=OHgHkAOXblanrEJ6lpyiHlAjhh_yi96QBxuzb_aCQe8,10146
+term_clock_app-1.0.0.dist-info/licenses/LICENSE,sha256=Z4k4VhFP4iaRvZllMQ8fgXvNkMT7RN0jXeLm1ZDMkP8,1073
+term_clock_app-1.0.0.dist-info/METADATA,sha256=m2Ai1QxaOnQ0s7VEQ_xnT79holRXrWMIfUPRFJO_mXs,4811
+term_clock_app-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+term_clock_app-1.0.0.dist-info/entry_points.txt,sha256=r__jaa5HuQ9_J0lFs2YV7ImP93t2-MSvIGP1tX4sEKQ,51
+term_clock_app-1.0.0.dist-info/top_level.txt,sha256=RpaMim6Fw_aR_gwWWycwZwjjzo3cQ2BFcHImV0lXUA8,11
+term_clock_app-1.0.0.dist-info/RECORD,,

term_clock_app-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

term_clock_app-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+term-clock = term_clock.cli:main

term_clock_app-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lorenzo Wood
+
+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 ANY 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.

term_clock_app-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+term_clock