daylogs 0.2.0__py3-none-any.whl

daylogs/__init__.py

@@ -0,0 +1,3 @@
+"""daylogs — weight, food, expenses, and one daily summary."""
+
+__version__ = "0.2.0"

daylogs/__main__.py

@@ -0,0 +1,160 @@
+"""Entry point.
+
+No arguments launches the TUI. The subcommands exist so the summary and a
+backup can run headless from cron without any code change — and because a
+single-file SQLite database that only exists in one place is one accident away
+from being no database at all.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import datetime as dt
+import sys
+from pathlib import Path
+
+from daylogs import __version__, claude, export, summary
+from daylogs.config import load_config
+from daylogs.db import connect, ensure_schema
+from daylogs.log import setup_logging
+from daylogs.money import MoneyError, check_date
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="day", description="a personal daily log: weight, food, expenses"
+    )
+    parser.add_argument("--version", action="store_true", help="print version and exit")
+    sub = parser.add_subparsers(dest="cmd")
+
+    p_sum = sub.add_parser("summary", help="generate the daily summary and print it")
+    p_sum.add_argument("--date", help="YYYY-MM-DD; defaults to yesterday")
+
+    p_bak = sub.add_parser("backup", help="write a consistent copy of the database")
+    p_bak.add_argument("dest", help="destination directory")
+
+    p_exp = sub.add_parser("export", help="write one CSV per table, readable anywhere")
+    p_exp.add_argument("dest", help="destination directory")
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    try:
+        args = parser.parse_args(argv)
+    except SystemExit as e:
+        return int(e.code) if e.code else 0
+
+    if args.version:
+        print(f"daylogs {__version__}")
+        return 0
+
+    cfg = load_config()
+    if (stale := _legacy_root_to_move(cfg.root)) is not None:
+        print(
+            f"Your data is still under the old name: {stale}\n"
+            f"daylogs was renamed from daybook. Move it, then run again:\n"
+            f"    mv {stale} {cfg.root}\n"
+            f"    mv {cfg.root / 'daybook.db'} {cfg.db_path}",
+            file=sys.stderr,
+        )
+        return 1
+
+    setup_logging()
+    conn = connect(cfg.db_path)
+    ensure_schema(conn)
+
+    try:
+        if args.cmd == "summary":
+            return _summary(conn, cfg, args.date)
+        if args.cmd == "backup":
+            return _backup(conn, Path(args.dest).expanduser())
+        if args.cmd == "export":
+            return _export(conn, Path(args.dest).expanduser())
+        return _tui(conn, cfg)
+    finally:
+        conn.close()
+
+
+def _legacy_root_to_move(root: Path) -> Path | None:
+    """The pre-rename data root, when it holds the only copy of the data.
+
+    Renaming the project moved the default root from ~/Documents/daybook to
+    ~/Documents/daylogs. Without this check the first run after upgrading finds
+    no database, creates an empty one, and presents a working app with none of
+    your history in it — which reads as data loss even though nothing was
+    deleted. Refusing to start is the kinder failure, and it can name the exact
+    two commands that fix it.
+
+    Only fires when the new root is genuinely absent, so it costs nothing on a
+    fresh install and disappears as soon as the move happens. Deletable once no
+    installation predates the rename.
+    """
+    legacy = root.parent / "daybook"
+    if root.exists() or not (legacy / "daybook.db").is_file():
+        return None
+    return legacy
+
+
+def _summary(conn, cfg, date: str | None) -> int:
+    target = date or summary.target_date(dt.date.today().isoformat())
+    try:
+        check_date(target)
+    except MoneyError as e:
+        print(str(e), file=sys.stderr)
+        return 2
+    try:
+        content = asyncio.run(
+            summary.generate(conn, cfg, date=target, runner=claude.run_oneshot_text)
+        )
+    except Exception as e:  # noqa: BLE001 - top-level CLI boundary
+        print(str(e), file=sys.stderr)
+        return 1
+    print(content)
+    return 0
+
+
+def _backup(conn, dest: Path) -> int:
+    """VACUUM INTO writes a consistent single-file copy without stopping the
+    app — exactly what a cron backup to a synced folder needs."""
+    dest.mkdir(parents=True, exist_ok=True)
+    out = dest / f"daylogs-{dt.date.today().isoformat()}.db"
+    out.unlink(missing_ok=True)
+    conn.execute("VACUUM INTO ?", (str(out),))
+    print(out)
+    return 0
+
+
+def _export(conn, dest: Path) -> int:
+    """One CSV per table, so the data is readable without daylogs.
+
+    stdout is *only* the directory, so `cd "$(day export ~/Drive)"` works; the
+    per-table counts go to stderr, where a human sees them and a script does not
+    have to parse around them.
+    """
+    try:
+        written = export.export_csv(conn, dest)
+    except OSError as e:
+        # A path you cannot write to is a typo, not a crash. `summary` already
+        # answers user error with a message and a non-zero exit; printing pathlib's
+        # traceback instead would just be the newest command being the rudest.
+        print(f"cannot export to {dest}: {e.strerror or e}", file=sys.stderr)
+        return 1
+    counts = export.row_counts(conn)
+    for path in written:
+        print(f"{path.name:16} {counts[path.stem]:>7} rows", file=sys.stderr)
+    print(written[0].parent if written else dest)
+    return 0
+
+
+def _tui(conn, cfg) -> int:
+    from daylogs.tui.app import DaylogsApp
+
+    DaylogsApp(cfg, conn).run()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

daylogs/body.py

@@ -0,0 +1,255 @@
+"""Weight and food: reads, writes, trend windows, and BMR.
+
+Every write validates before it touches SQLite, so a bad prompt never
+produces a half-valid row. Deletes return the removed row so the caller can
+push it onto the undo stack.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import re
+import sqlite3
+
+_DATE_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
+_SOURCES = frozenset({"labeled", "estimated"})
+_MAX_KG = 500.0
+
+
+class BodyError(ValueError):
+    pass
+
+
+def _check_date(date: str) -> str:
+    if not _DATE_RE.match(date):
+        raise BodyError(f"date {date!r} must be YYYY-MM-DD")
+    try:
+        dt.date.fromisoformat(date)
+    except ValueError as e:
+        raise BodyError(f"date {date!r} is not a real date") from e
+    return date
+
+
+def _window_start(end_date: str, days: int) -> str:
+    return (dt.date.fromisoformat(end_date) - dt.timedelta(days=days - 1)).isoformat()
+
+
+# ── weight ───────────────────────────────────────────────────────────────
+def add_weight(conn, *, kg: float, date: str, at: int, note: str | None = None) -> int:
+    if not 0 < float(kg) <= _MAX_KG:
+        raise BodyError(f"{kg} kg is not a plausible weight")
+    cur = conn.execute(
+        "INSERT INTO weight (date, measured_at, kg, note) VALUES (?, ?, ?, ?)",
+        (_check_date(date), int(at), float(kg), note or None),
+    )
+    return int(cur.lastrowid)
+
+
+def list_weight(conn, *, since: str | None = None, limit: int = 200) -> list[sqlite3.Row]:
+    sql = "SELECT * FROM weight"
+    args: list = []
+    if since:
+        sql += " WHERE date >= ?"
+        args.append(_check_date(since))
+    sql += " ORDER BY date DESC, measured_at DESC LIMIT ?"
+    args.append(int(limit))
+    return list(conn.execute(sql, args))
+
+
+def latest_weight(conn, *, on_or_before: str | None = None) -> sqlite3.Row | None:
+    sql = "SELECT * FROM weight"
+    args: list = []
+    if on_or_before:
+        sql += " WHERE date <= ?"
+        args.append(_check_date(on_or_before))
+    sql += " ORDER BY date DESC, measured_at DESC LIMIT 1"
+    return conn.execute(sql, args).fetchone()
+
+
+def weight_series(conn, *, end_date: str, days: int) -> list[tuple[str, float]]:
+    """One point per day in the window, ascending. When a day has several
+    readings the latest wins — a morning weigh-in plus a curious evening
+    re-check should not become two points."""
+    rows = conn.execute(
+        """
+        SELECT date, kg FROM weight w
+        WHERE date BETWEEN ? AND ?
+          AND measured_at = (
+              SELECT MAX(measured_at) FROM weight w2 WHERE w2.date = w.date
+          )
+        GROUP BY date
+        ORDER BY date ASC
+        """,
+        (_window_start(_check_date(end_date), days), end_date),
+    ).fetchall()
+    return [(r["date"], r["kg"]) for r in rows]
+
+
+def weight_series_between(
+    conn, *, start: str | None, end: str
+) -> list[tuple[str, float]]:
+    """One point per day between `start` and `end` inclusive, ascending.
+    `start=None` means unbounded. Same last-reading-wins rule as weight_series."""
+    sql = """
+        SELECT date, kg FROM weight w
+        WHERE date <= ?
+          AND measured_at = (
+              SELECT MAX(measured_at) FROM weight w2 WHERE w2.date = w.date
+          )
+    """
+    args: list = [_check_date(end)]
+    if start is not None:
+        sql += " AND date >= ?"
+        args.append(_check_date(start))
+    sql += " GROUP BY date ORDER BY date ASC"
+    return [(r["date"], r["kg"]) for r in conn.execute(sql, args)]
+
+
+def kcal_series_between(conn, *, start: str | None, end: str) -> list[tuple[str, int]]:
+    """Daily calorie totals between `start` and `end`, ascending. Days with no
+    entries are absent rather than zero — a logging gap is not a fast."""
+    sql = "SELECT date, SUM(kcal) AS total FROM food WHERE date <= ?"
+    args: list = [_check_date(end)]
+    if start is not None:
+        sql += " AND date >= ?"
+        args.append(_check_date(start))
+    sql += " GROUP BY date ORDER BY date ASC"
+    return [(r["date"], int(r["total"])) for r in conn.execute(sql, args)]
+
+
+def kcal_average(conn, *, start: str | None, end: str) -> int | None:
+    """Mean intake over the days that actually have entries."""
+    series = kcal_series_between(conn, start=start, end=end)
+    if not series:
+        return None
+    return round(sum(v for _, v in series) / len(series))
+
+
+def weight_delta(conn, *, end_date: str, days: int) -> float | None:
+    series = weight_series(conn, end_date=end_date, days=days)
+    if len(series) < 2:
+        return None
+    return round(series[-1][1] - series[0][1], 2)
+
+
+def update_weight(conn, id: int, **fields) -> bool:
+    return _update(conn, "weight", id, fields, allowed={"kg", "date", "measured_at", "note"})
+
+
+def delete_weight(conn, id: int) -> dict | None:
+    return _delete(conn, "weight", id)
+
+
+# ── food ─────────────────────────────────────────────────────────────────
+def add_food(conn, *, description: str, kcal: int, source: str, date: str, at: int) -> int:
+    if source not in _SOURCES:
+        raise BodyError(f"source must be one of {sorted(_SOURCES)}")
+    if not description.strip():
+        raise BodyError("description must be non-empty")
+    if int(kcal) < 0:
+        raise BodyError("kcal must be >= 0")
+    cur = conn.execute(
+        "INSERT INTO food (date, ate_at, description, kcal, source) VALUES (?, ?, ?, ?, ?)",
+        (_check_date(date), int(at), description.strip(), int(kcal), source),
+    )
+    return int(cur.lastrowid)
+
+
+def list_food(conn, *, date: str) -> list[sqlite3.Row]:
+    return list(
+        conn.execute(
+            "SELECT * FROM food WHERE date = ? ORDER BY ate_at ASC, id ASC",
+            (_check_date(date),),
+        )
+    )
+
+
+def day_kcal(conn, *, date: str) -> int:
+    row = conn.execute(
+        "SELECT COALESCE(SUM(kcal), 0) AS total FROM food WHERE date = ?",
+        (_check_date(date),),
+    ).fetchone()
+    return int(row["total"])
+
+
+def update_food(conn, id: int, **fields) -> bool:
+    if "source" in fields and fields["source"] not in _SOURCES:
+        raise BodyError(f"source must be one of {sorted(_SOURCES)}")
+    return _update(
+        conn,
+        "food",
+        id,
+        fields,
+        allowed={"description", "kcal", "source", "date", "ate_at"},
+    )
+
+
+def restamp(at: int, *, date: str, hhmm: str) -> int | None:
+    """The new epoch-second timestamp for a row whose clock time was edited, or
+    `None` when the minute did not change.
+
+    Stored timestamps carry seconds; the grammar's only time token is `HH:MM`. So
+    re-deriving the timestamp on every edit would quietly shave the seconds off a
+    row whose time nobody touched — and for weight those seconds are the
+    tie-breaker `weight_series` uses to pick a day's reading. Returning `None`
+    means "leave the column alone", which is what the caller wants far more often
+    than a rewrite.
+    """
+    current = dt.datetime.fromtimestamp(int(at))
+    if current.strftime("%H:%M") == hhmm:
+        return None
+    hh, mm = (int(part) for part in hhmm.split(":"))
+    return int(
+        dt.datetime.combine(dt.date.fromisoformat(date), dt.time(hh, mm)).timestamp()
+    )
+
+
+def delete_food(conn, id: int) -> dict | None:
+    return _delete(conn, "food", id)
+
+
+# ── BMR ──────────────────────────────────────────────────────────────────
+def age_from_birthday(birthday: str | None, today: str | None = None) -> int | None:
+    if not birthday:
+        return None
+    try:
+        b = dt.date.fromisoformat(birthday)
+    except ValueError:
+        return None
+    t = dt.date.fromisoformat(today) if today else dt.date.today()
+    return t.year - b.year - ((t.month, t.day) < (b.month, b.day))
+
+
+def compute_bmr(cfg, kg: float | None, today: str | None = None) -> int | None:
+    """Mifflin-St Jeor. None whenever an input is missing — a calorie total with
+    no maintenance baseline is better shown bare than shown against a guess."""
+    if kg is None or cfg.height_cm is None or not cfg.sex:
+        return None
+    age = age_from_birthday(cfg.birthday, today)
+    if age is None:
+        return None
+    base = 10 * float(kg) + 6.25 * float(cfg.height_cm) - 5 * age
+    return round(base + (5 if cfg.sex == "male" else -161))
+
+
+# ── shared row helpers ───────────────────────────────────────────────────
+def _update(conn, table: str, id: int, fields: dict, *, allowed: set[str]) -> bool:
+    fields = {k: v for k, v in fields.items() if v is not None}
+    unknown = set(fields) - allowed
+    if unknown:
+        raise BodyError(f"cannot update {sorted(unknown)} on {table}")
+    if not fields:
+        return False
+    if "date" in fields:
+        _check_date(fields["date"])
+    sets = ", ".join(f"{k} = ?" for k in fields)
+    cur = conn.execute(f"UPDATE {table} SET {sets} WHERE id = ?", (*fields.values(), int(id)))
+    return cur.rowcount > 0
+
+
+def _delete(conn, table: str, id: int) -> dict | None:
+    row = conn.execute(f"SELECT * FROM {table} WHERE id = ?", (int(id),)).fetchone()
+    if row is None:
+        return None
+    conn.execute(f"DELETE FROM {table} WHERE id = ?", (int(id),))
+    return dict(row)

daylogs/categories.py

@@ -0,0 +1,88 @@
+"""Expense categories: a constant tuple, extensible from config.toml.
+
+A table with CRUD endpoints, a colour column and a sort order is the obvious
+design and the wrong one here: ten rows that change twice a year do not need a
+table, three foreign keys and a service. There is deliberately no `employment`
+slug — it would only ever classify income, which daylogs does not track.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+FALLBACK_SLUG = "other"
+
+# Vivid warm-earth palette, also used for the good/bad signals in the UI.
+# Each hue's HSV saturation multiplied by 1.55 and value by 1.04, clamped to 1.0.
+PALETTE: tuple[str, ...] = (
+    "#5f7bbe",
+    "#9d81b8",
+    "#63af7b",
+    "#dc9142",
+    "#cc5131",
+    "#67acb9",
+    "#bf8772",
+    "#8d919f",
+    "#88ba68",
+    "#aaa095",
+    "#b7607d",
+    "#9ea64c",
+    "#cf8626",
+    "#78a7ae",
+    "#aa6941",
+    "#739b8e",
+)
+
+
+@dataclass(frozen=True)
+class Category:
+    slug: str
+    display: str
+    color: str
+
+
+BUILTIN: tuple[Category, ...] = (
+    Category("grocery", "Grocery", "#dc9142"),
+    Category("restaurant", "Restaurant", "#cc5131"),
+    Category("transport", "Transport", "#5f7bbe"),
+    Category("housing", "Housing", "#9d81b8"),
+    Category("utilities", "Utilities", "#8d919f"),
+    Category("subscriptions", "Subscriptions", "#67acb9"),
+    Category("entertainment", "Entertainment", "#bf8772"),
+    Category("education", "Education", "#63af7b"),
+    Category(FALLBACK_SLUG, "Other", "#aaa095"),
+)
+
+
+def auto_color(slug: str) -> str:
+    """FNV-1a 32-bit hash into PALETTE. The same slug always yields the same
+    colour, so a config-added category looks stable across machines."""
+    h = 2166136261
+    for ch in slug.encode("utf-8"):
+        h ^= ch
+        h = (h * 16777619) & 0xFFFFFFFF
+    return PALETTE[h % len(PALETTE)]
+
+
+def all_categories(cfg=None) -> tuple[Category, ...]:
+    """Built-ins plus anything config.toml adds. Config cannot shadow a
+    built-in — a typo in config should never silently redefine `grocery`."""
+    extra = getattr(cfg, "extra_categories", ()) or ()
+    builtin_slugs = {c.slug for c in BUILTIN}
+    added = tuple(
+        Category(slug, display or slug, color or auto_color(slug))
+        for slug, display, color in extra
+        if slug not in builtin_slugs
+    )
+    return BUILTIN + added
+
+
+def slugs(cfg=None) -> frozenset[str]:
+    return frozenset(c.slug for c in all_categories(cfg))
+
+
+def get(slug: str, cfg=None) -> Category | None:
+    for c in all_categories(cfg):
+        if c.slug == slug:
+            return c
+    return None

daylogs/claude.py

@@ -0,0 +1,165 @@
+"""Subprocess wrappers for `claude -p`.
+
+Three call shapes: plain text (the daily summary), structured JSON from text
+(a calorie estimate from a description), and structured JSON from an image (a
+calorie estimate from a photo). One error type for all of them, because a
+caller forced to distinguish "binary missing" from "timed out" from "bad
+JSON" is a caller that will forget one of them.
+
+Every invocation passes --no-session-persistence, so daylogs never pollutes
+~/.claude/projects/. Runs under a Max OAuth subscription — no per-token API
+charge.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os.path
+
+log = logging.getLogger(__name__)
+
+CLAUDE_BIN = "claude"
+_STDERR_TAIL = 500
+
+
+class ClaudeError(RuntimeError):
+    """Missing binary, timeout, non-zero exit, or unparseable output."""
+
+
+async def _kill(proc) -> None:
+    """Stop the child and reap it. Safe to call on one that has already exited.
+
+    The `await proc.wait()` makes the reap synchronous rather than eventual. asyncio's
+    child watcher does collect the corpse on its own, but measured at roughly 50 ms
+    later — so without the wait, the process is still there the instant the call it
+    belonged to has finished unwinding, and a zombie still answers `os.kill(pid, 0)`.
+    A test asserts the pid is gone immediately, with no polling, because polling would
+    pass either way.
+    """
+    if proc.returncode is None:
+        proc.kill()
+    await proc.wait()
+
+
+async def _run(argv: list[str], *, timeout_sec: float, label: str) -> bytes:
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *argv, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+        )
+    except FileNotFoundError as e:
+        raise ClaudeError(f"{CLAUDE_BIN} not on PATH") from e
+
+    try:
+        stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout_sec)
+    except TimeoutError as e:
+        await _kill(proc)
+        raise ClaudeError(f"{label} timed out after {timeout_sec}s") from e
+    except BaseException:
+        # Not `Exception`. The case this exists for is cancellation, and
+        # `CancelledError` is a BaseException, so the timeout branch above never sees
+        # it. Both estimate workers are @work(exclusive=True), so pressing `f` again
+        # cancels the first — and without this the model call it had spawned kept
+        # running for up to timeout_sec: unread, billed, and invisible. Re-raised
+        # unchanged, because swallowing it would break the cancellation itself.
+        await _kill(proc)
+        raise
+
+    if proc.returncode != 0:
+        tail = stderr.decode(errors="replace")[-_STDERR_TAIL:]
+        raise ClaudeError(f"{label} exited {proc.returncode}: {tail}")
+    return stdout
+
+
+def _structured(stdout: bytes, label: str) -> dict:
+    try:
+        envelope = json.loads(stdout.decode())
+    except json.JSONDecodeError as e:
+        tail = stdout.decode(errors="replace")[-_STDERR_TAIL:]
+        raise ClaudeError(f"{label} returned non-JSON stdout: {tail}") from e
+    inner = envelope.get("structured_output")
+    if inner is None:
+        raise ClaudeError(f"{label} envelope missing structured_output key")
+    return inner
+
+
+def _model_args(model: str | None) -> list[str]:
+    return ["--model", model] if model else []
+
+
+async def run_oneshot_text(
+    system_prompt: str,
+    user_prompt: str,
+    *,
+    timeout_sec: float,
+    model: str | None = None,
+) -> str:
+    argv = [
+        CLAUDE_BIN,
+        "-p",
+        "--system-prompt",
+        system_prompt,
+        *_model_args(model),
+        "--output-format",
+        "text",
+        "--no-session-persistence",
+        user_prompt,
+    ]
+    stdout = await _run(argv, timeout_sec=timeout_sec, label="claude -p")
+    return stdout.decode().strip()
+
+
+async def run_oneshot_json(
+    *,
+    system_prompt: str,
+    user_prompt: str,
+    json_schema: dict,
+    timeout_sec: float,
+    model: str | None = None,
+) -> dict:
+    argv = [
+        CLAUDE_BIN,
+        "-p",
+        "--system-prompt",
+        system_prompt,
+        *_model_args(model),
+        "--json-schema",
+        json.dumps(json_schema),
+        "--output-format",
+        "json",
+        "--no-session-persistence",
+        user_prompt,
+    ]
+    stdout = await _run(argv, timeout_sec=timeout_sec, label="claude -p (json)")
+    return _structured(stdout, "claude -p (json)")
+
+
+async def run_with_image_json(
+    *,
+    image_path: str,
+    prompt: str,
+    json_schema: dict,
+    timeout_sec: float,
+    model: str | None = None,
+) -> dict:
+    """The prompt must reference the image by absolute path; claude reads it
+    with the Read tool, which --add-dir plus --tools Read grant and nothing
+    else does."""
+    argv = [
+        CLAUDE_BIN,
+        "-p",
+        "--add-dir",
+        os.path.dirname(image_path),
+        "--tools",
+        "Read",
+        *_model_args(model),
+        "--json-schema",
+        json.dumps(json_schema),
+        "--output-format",
+        "json",
+        "--no-session-persistence",
+        prompt,
+    ]
+    stdout = await _run(argv, timeout_sec=timeout_sec, label="claude -p (image)")
+    return _structured(stdout, "claude -p (image)")