tickwork 0.3.0__py3-none-any.whl

tickwork/__init__.py

@@ -0,0 +1,11 @@
+"""The public tickwork engine: a generic, instance-neutral workflow engine.
+
+It drives states, transitions and sweeps over a queue of work items. It is
+developed in-tree but deliberately names nothing of the instance it runs
+for: no persona, host, repository or person names appear here, and the
+package imports only the standard library, PyYAML and other ``tickwork``
+modules — everything
+instance-specific is supplied by the caller.
+"""
+
+__all__: list[str] = []

tickwork/__main__.py

@@ -0,0 +1,8 @@
+"""Entry point for ``python -m tickwork`` — delegates to the CLI."""
+
+import sys
+
+from tickwork.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

tickwork/cli.py

@@ -0,0 +1,288 @@
+"""The ``tickwork`` command line: ``check`` (the exactly-one-state check),
+``replay`` (re-send recorded LLM calls to a model and score the replies) and
+``effects`` (summarize an effect log).
+
+Runs :func:`~tickwork.workflow_states.check` over a states file, a JSONL
+items file and a YAML logins map supplied on the command line, so a
+standalone tickwork installation can run the exactly-one-state check
+without any instance-specific fetcher:
+
+.. code-block:: text
+
+    tickwork check STATES --items ITEMS --logins LOGINS
+
+* STATES is loaded with :func:`~tickwork.workflow_states.load`; the allowed
+  owner roles are the keys of LOGINS.
+* ITEMS is a JSONL file with one item per line in the shape
+  :func:`~tickwork.workflow_states.evaluate` describes.
+* LOGINS is a YAML mapping of role name to login.
+
+One line is printed per anomaly (repo, issue, pr, matched states) followed
+by a summary line. Exit codes: ``1`` when any anomaly was found, ``0``
+when clean, ``2`` when a file cannot be read, parsed or validated (e.g. a
+states file naming a role that is not a key of LOGINS).
+
+``tickwork effects LOG_DIR [--role ROLE] [--since ISO] [--json]`` summarizes
+an effect log with :func:`~tickwork.effect_log.summarize`. It is read-only:
+it never creates or writes LOG_DIR, and a missing or empty log prints an
+empty summary and exits 0.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime
+import json
+import os
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from tickwork import replay, workflow_states
+from tickwork.effect_log import PENDING, EffectLog, summarize
+from tickwork.providers import OpenAICompatProvider
+
+EMPTY_SUMMARY = {"effects": {}, "finished_later": 0, "unfinished": []}
+
+
+def _read_logins(path: str | Path) -> dict[str, str]:
+    """Read a YAML mapping of role name → login from *path*."""
+    logins = yaml.safe_load(Path(path).read_text(encoding="utf-8"))
+    if not isinstance(logins, dict) or not all(
+        isinstance(role, str) and isinstance(login, str) for role, login in logins.items()
+    ):
+        raise ValueError(f"{path}: logins must be a mapping of role name to login")
+    return logins
+
+
+def _read_items(path: str | Path) -> list[dict[str, Any]]:
+    """Read JSONL items, one dict per line, from *path* (blank lines skipped)."""
+    items: list[dict[str, Any]] = []
+    with open(path, encoding="utf-8") as handle:
+        for lineno, line in enumerate(handle, 1):
+            line = line.strip()
+            if not line:
+                continue
+            item = json.loads(line)
+            if not isinstance(item, dict):
+                raise ValueError(f"{path}:{lineno}: item must be a JSON object")
+            items.append(item)
+    return items
+
+
+def _format_anomaly(anomaly: dict[str, Any]) -> str:
+    return (
+        f"{anomaly['repo']}: issue {anomaly['issue']} pr {anomaly['pr']} "
+        f"matched {', '.join(anomaly['matched']) or 'nothing'}"
+    )
+
+
+# The one CLI provider name, resolving to a stdlib OpenAI-compatible adapter.
+_PROVIDER = "openai-compat"
+
+
+def _length_exact_scorer(record: dict[str, Any], reply: dict[str, Any]) -> dict[str, Any]:
+    """The built-in scorer: response length and whether the reply is an
+    exact match of the recorded response (null when there is nothing to
+    compare against)."""
+    recorded = record.get("response")
+    response = reply.get("response")
+    return {
+        "response_len": len(response) if response is not None else None,
+        "exact_match": None if recorded is None or response is None else response == recorded,
+    }
+
+
+def _run_replay(args: argparse.Namespace) -> int:
+    """Run the generic replay over the given JSONL record paths.
+
+    Only the ``openai-compat`` provider is wired in: importing
+    :mod:`tickwork.providers` in the CLI (not in :mod:`tickwork.replay`)
+    keeps the replay core free of transport code.
+    """
+    if args.provider != _PROVIDER:
+        print(f"tickwork: unknown provider {args.provider!r}", file=sys.stderr)
+        return 2
+    if args.repeats < 1:
+        print(f"tickwork: --repeats must be >= 1 (got {args.repeats})", file=sys.stderr)
+        return 2
+    skips: dict[str, int] = {}
+    lines = 0
+    try:
+        records = replay.read_records(args.records)
+        for metrics in replay.replay(
+            records,
+            OpenAICompatProvider(base_url=args.base_url, key_env=args.key_env),
+            [args.model],
+            {("*", "*"): _length_exact_scorer},
+            repeats=args.repeats,
+            skips=skips,
+        ):
+            print(json.dumps(metrics))
+            lines += 1
+    except (OSError, ValueError) as exc:
+        print(f"tickwork: {exc}", file=sys.stderr)
+        return 2
+    for reason, count in sorted(skips.items()):
+        print(f"skipped {count} record(s): {reason}", file=sys.stderr)
+    return 0 if lines or skips else 1
+
+
+def _roles_in(log_dir: str) -> list[str]:
+    """Role names with a ``<role>.jsonl`` in *log_dir*, sorted. Read-only."""
+    try:
+        names = sorted(os.listdir(log_dir))
+    except (FileNotFoundError, OSError):
+        return []
+    return [name[: -len(".jsonl")] for name in names if name.endswith(".jsonl")]
+
+
+def _rows_for(log_dir: str, role: str) -> list[dict]:
+    """All of *role*'s rows. Read-only: a missing log reads as no rows and the
+    log directory is never created or written."""
+    return EffectLog(log_dir)._read(role)
+
+
+def print_summary(summary: dict, out=None) -> None:
+    """Render ``summarize()``'s object as text. Pure: writes only to *out*."""
+    out = out if out is not None else sys.stdout
+    effects = summary.get("effects") or {}
+    for role in sorted(effects):
+        for effect in sorted(effects[role]):
+            s = effects[role][effect]
+            p50 = "-" if s["p50"] is None else f"{s['p50']}ms"
+            p90 = "-" if s["p90"] is None else f"{s['p90']}ms"
+            line = (
+                f"{role}/{effect}: applied={s['applied']} failed={s['failed']} "
+                f"superseded={s['superseded']} pending={s['pending']} "
+                f"finished_later={s['finished_later']} p50={p50} p90={p90}"
+            )
+            print(line, file=out)
+            for u in summary.get("unfinished") or []:
+                if u["role"] == role and u["effect"] == effect:
+                    print(
+                        f"  unfinished: {u['item']} {u['tick_id']}/{u['seq']}",
+                        file=out,
+                    )
+    if not effects and not summary.get("unfinished"):
+        print("(empty log)", file=out)
+
+
+def _rows_since(rows: list[dict], cutoff: float) -> list[dict]:
+    """Drop whole fold keys whose final status row finished before *cutoff*.
+
+    ``--since`` filters fold keys, not rows: a plan row is written with
+    ``finished: None`` and never rewritten, so dropping only old status rows
+    would leave the plan row to fold to pending and report long-finished
+    work as unfinished. A key ``(item, tick_id, seq)`` — including every
+    status row that resumed it — is dropped when its last row in log order
+    has a status other than ``pending`` and a numeric ``finished`` earlier
+    than the cutoff; keys still pending survive so they stay resumable.
+    """
+    last: dict[tuple, dict] = {}
+    for r in rows:
+        last[(r.get("item"), r.get("tick_id"), r.get("seq"))] = r
+    stale = {
+        key
+        for key, r in last.items()
+        if r.get("status") != PENDING
+        and isinstance(r.get("finished"), (int, float))
+        and r["finished"] < cutoff
+    }
+    return [r for r in rows if (r.get("item"), r.get("tick_id"), r.get("seq")) not in stale]
+
+
+def _effects(args: argparse.Namespace) -> int:
+    """``tickwork effects``: print the effect-log summary. Read-only."""
+    roles = args.role
+    if not roles:
+        roles = _roles_in(args.log_dir)
+    cutoff = _since_epoch(args.since) if args.since else None
+    all_rows: list[dict] = []
+    for role in roles:
+        rows = _rows_for(args.log_dir, role)
+        if cutoff is not None:
+            rows = _rows_since(rows, cutoff)
+        all_rows.extend(rows)
+    summary = summarize(all_rows) if all_rows else EMPTY_SUMMARY
+    if args.json:
+        print(json.dumps(summary, sort_keys=True), file=sys.stdout)
+    else:
+        print_summary(summary)
+    return 0
+
+
+def _since_epoch(iso_date: str) -> float:
+    """Epoch seconds for an ISO date (a date-only string is UTC midnight)."""
+    date = datetime.date.fromisoformat(iso_date)
+    return datetime.datetime(date.year, date.month, date.day, tzinfo=datetime.UTC).timestamp()
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="tickwork", description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+    check_parser = sub.add_parser("check", help="report items matching zero or 2+ states")
+    check_parser.add_argument("states", help="the workflow states file")
+    check_parser.add_argument("--items", required=True, help="a JSONL file of items, one per line")
+    check_parser.add_argument("--logins", required=True, help="a YAML map of role name to login")
+    replay_parser = sub.add_parser(
+        "replay",
+        help="re-send recorded final transcript records to a model and score the replies",
+    )
+    replay_parser.add_argument("records", nargs="+", help="JSONL transcript files (finals)")
+    replay_parser.add_argument("--model", required=True, help="the model to replay each call against")
+    replay_parser.add_argument(
+        "--provider", default=_PROVIDER, help=f"the provider adapter (default {_PROVIDER})"
+    )
+    replay_parser.add_argument("--base-url", required=True, help="the API base URL of the endpoint")
+    replay_parser.add_argument(
+        "--key-env",
+        default="OPENAI_API_KEY",
+        help="the env var carrying the API key (the key itself is never logged)",
+    )
+    replay_parser.add_argument("--repeats", type=int, default=1, help="repeats per record and model")
+    effects = sub.add_parser("effects", help="summarize an effect log (read-only)")
+    effects.add_argument("log_dir", help="the effects log directory (read-only)")
+    effects.add_argument(
+        "--role",
+        action="append",
+        default=None,
+        help="role to summarize (repeatable); default: every <role>.jsonl in LOG_DIR",
+    )
+    effects.add_argument(
+        "--since",
+        default=None,
+        help="ISO date; drop fold keys whose final status row finished before it",
+    )
+    effects.add_argument("--json", action="store_true", help="print the summary as one JSON object")
+    args = parser.parse_args(argv)
+    if args.command == "effects":
+        return _effects(args)
+
+    if args.command == "replay":
+        return _run_replay(args)
+
+    # The evaluation stays inside the guard: workflow_states.load() validates
+    # only the `owner` field, so a predicate naming a role absent from `logins`
+    # raises ValueError here, and that must exit 2 like the other file errors,
+    # not surface as a traceback the shell cannot distinguish from anomalies.
+    try:
+        logins = _read_logins(args.logins)
+        states = workflow_states.load(args.states, set(logins))
+        items = _read_items(args.items)
+        anomalies = workflow_states.check(states, items, logins)
+    except (OSError, ValueError, yaml.YAMLError, json.JSONDecodeError) as exc:
+        print(f"tickwork: {exc}", file=sys.stderr)
+        return 2
+
+    for anomaly in anomalies:
+        print(_format_anomaly(anomaly))
+    print(f"{len(items)} items checked, {len(anomalies)} anomalies")
+    return 1 if anomalies else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tickwork/effect_log.py

@@ -0,0 +1,319 @@
+"""Append-only JSONL effect log, instance-neutral.
+
+Ship records every write *before* applying it, then marks the row
+applied / failed / superseded with timing. The next tick resumes unfinished
+effects before deciding again, because once a write has landed the item may
+no longer be in the state that produced it — re-deciding alone can never
+finish the job ("Partial ship").
+
+Nothing here is specific to one deployment: the log directory is the
+object's constructor parameter, every call names its role explicitly (there
+is no default role), and the module imports only the standard library.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import sys
+import time
+
+# Status vocab. A reader folds rows by (item, tick_id, seq): the latest status
+# row wins; only an `applied` finish counts as done.
+APPLIED = "applied"
+FAILED = "failed"
+SUPERSEDED = "superseded"
+PENDING = "pending"
+DONE_STATUSES = frozenset({APPLIED, SUPERSEDED})
+
+
+def fold(rows: list[dict]) -> dict[tuple, str]:
+    """Latest status per (item, tick_id, seq) key."""
+    latest: dict[tuple, str] = {}
+    for r in rows:
+        key = (r.get("item"), r.get("tick_id"), r.get("seq"))
+        latest[key] = r.get("status")
+    return latest
+
+
+class EffectLog:
+    """The append-only JSONL effect log for one directory: one file per role.
+
+    ``role`` is required on every call that does not take it from a row —
+    no default — so an omitted role is a TypeError, never a write into some
+    default role's file. A row that carries no ``role`` of its own is a
+    ValueError; ``apply`` raises it *before* running the effect so no
+    not-logged effect ever runs.
+    """
+
+    def __init__(self, log_dir: str):
+        self.log_dir = log_dir
+
+    def path(self, role: str) -> str:
+        """The JSONL file for *role*'s effects: ``<log dir>/<role>.jsonl``."""
+        return os.path.join(self.log_dir, f"{role}.jsonl")
+
+    def _append(self, row: dict) -> dict:
+        path = self.path(row["role"])
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "a", encoding="utf-8") as f:
+            f.write(json.dumps(row, sort_keys=True) + "\n")
+        return row
+
+    def _read(self, role: str) -> list[dict]:
+        """All rows for *role*. A missing or unreadable log reads as empty."""
+        try:
+            with open(self.path(role), encoding="utf-8") as f:
+                lines = f.readlines()
+        except (FileNotFoundError, OSError):
+            return []
+        rows: list[dict] = []
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                data = json.loads(line)
+            except ValueError:
+                continue  # a corrupt line never blinds the reader to the rest
+            if isinstance(data, dict):
+                rows.append(data)
+        return rows
+
+    def _status_row(self, row, status, error=None, *, started=None, finished=None, ms=None):
+        role = row.get("role")
+        if not role:
+            raise ValueError(
+                f"row for item {row.get('item')!r} has no 'role': a status row names its "
+                "role explicitly, never a default role's file"
+            )
+        return {
+            "role": role,
+            "item": row["item"],
+            "tick_id": row["tick_id"],
+            "seq": row["seq"],
+            "effect": row["effect"],
+            "payload": row.get("payload"),
+            "head_sha": row.get("head_sha"),
+            "status": status,
+            "started": started,
+            "finished": finished,
+            "ms": ms,
+            "error": error,
+        }
+
+    def plan(self, item, tick_id, effects, head_sha=None, *, role):
+        """Log one ``pending`` row per effect BEFORE any of them is applied, then
+        return the rows in order. ``effects`` is a list of ``(effect_name,
+        payload)`` pairs; ``seq`` numbers them within this plan (0-based).
+        ``item`` is ``<repo>#<n>``; ``head_sha`` pins resume to the exact commit
+        the rows were decided for, and every row of one plan carries the same
+        ``tick_id`` for the reader to fold by. Each append is best-effort: a
+        failed log write is skipped so a logging outage never blocks the ship
+        (that row simply never makes it into the log; the pending in-memory row
+        is still returned so the caller can apply its effect).
+        """
+        rows = [
+            {
+                "role": role,
+                "item": item,
+                "tick_id": tick_id,
+                "seq": seq,
+                "effect": effect,
+                "payload": payload,
+                "head_sha": head_sha,
+                "status": PENDING,
+                "started": None,
+                "finished": None,
+                "ms": None,
+                "error": None,
+            }
+            for seq, (effect, payload) in enumerate(effects)
+        ]
+        for row in rows:
+            try:
+                self._append(row)
+            except OSError as e:
+                print(f"[effect_log] plan append failed for {item}: {e}", file=sys.stderr)
+                continue  # a failed log write never blocks the ship
+        return rows
+
+    def mark(self, row, status, error=None, *, started=None, finished=None, ms=None):
+        """Append a status row for *row* (a ``plan()`` row). Statuses are
+        ``applied``, ``failed`` and ``superseded``; ``superseded`` marks a row
+        void because the item's head has moved on (the resume path marks each
+        remaining row itself).
+
+        Timing is supplied by ``apply()`` (``started``/``finished`` wall-clock
+        + an ``ms`` duration measured around the write): ``mark()`` alone records
+        the *state change* — ``started``/``finished`` are the moment the status
+        landed (defaulting to now), and ``ms`` stays None because no write was
+        measured. A bare ``mark()`` never claims an ``ms`` the code never took.
+        """
+        if started is None:
+            started = time.time()
+        if finished is None:
+            finished = started
+        return self._append(self._status_row(row, status, error, started=started, finished=finished, ms=ms))
+
+    def apply(self, row, fn):
+        """Run ``fn`` and mark *row* ``applied`` or ``failed`` with timing around
+        it. Returns ``fn()``'s result; the exception (if any) propagates so the
+        caller keeps today's control flow — the log only records what happened.
+
+        The status append is best-effort here too: an OSError landing on the
+        log write is reported as a logging failure, never as the effect having
+        failed. A row with no ``role`` is a ValueError raised *before* ``fn``
+        runs — the effect never runs for a row that can't be logged."""
+        if not row.get("role"):
+            raise ValueError(
+                f"row for item {row.get('item')!r} has no 'role': refusing to run an "
+                "effect that cannot be logged to its role's file"
+            )
+        started = time.time()
+        pc_start = time.perf_counter()
+        wall_finished = None
+        ms = None
+        try:
+            result = fn()
+        except Exception as e:
+            ms = round((time.perf_counter() - pc_start) * 1000, 3)
+            wall_finished = time.time()
+            try:
+                self.mark(row, FAILED, str(e), started=started, finished=wall_finished, ms=ms)
+            except OSError as le:
+                print(f"[effect_log] apply mark (failed) append error: {le}", file=sys.stderr)
+            raise
+        wall_finished = time.time()
+        ms = round((time.perf_counter() - pc_start) * 1000, 3)
+        try:
+            self.mark(row, APPLIED, None, started=started, finished=wall_finished, ms=ms)
+        except OSError as le:
+            print(f"[effect_log] apply mark (applied) append error: {le}", file=sys.stderr)
+        return result
+
+    def latest_plans(self, rows: list[dict]) -> dict:
+        """The latest plan (by log order) per item, as ``{item: [pending rows]}``
+        with each row annotated with its folded status. A plan is keyed by its
+        ``tick_id`` — pending rows of an *earlier* plan for the same item never
+        leak into the latest one's row list, so the returned rows are always one
+        plan's, in that plan's seq order."""
+        plans: dict[str, list[dict]] = {}
+        latest_tick: dict[str, str] = {}
+        status_by_key = fold(rows)
+        pending_rows = [r for r in rows if r.get("status") == PENDING]
+        # The item's latest plan is the LAST pending row in log order — a re-plan
+        # replaces any earlier draft, whose rows never resume.
+        for r in pending_rows:
+            latest_tick[r.get("item")] = r.get("tick_id")
+        for r in pending_rows:
+            item = r.get("item")
+            if r.get("tick_id") != latest_tick.get(item):
+                continue  # an older draft of this item — a re-plan replaced it
+            key = (item, r.get("tick_id"), r.get("seq"))
+            plans.setdefault(item, []).append({**r, "status": status_by_key.get(key, PENDING)})
+        return plans
+
+    def unfinished(self, role: str):
+        """Items whose latest plan still has rows that are neither ``applied`` nor
+        ``superseded``: ``{item: [pending rows in seq order]}``. A missing or
+        empty log reads as no unfinished items. Never raises."""
+        pending = self.latest_plans(self._read(role))
+        out: dict[str, list[dict]] = {}
+        for item, rows in pending.items():
+            live = [r for r in rows if r["status"] not in DONE_STATUSES]
+            if live:
+                out[item] = sorted(live, key=lambda r: r.get("seq", 0))
+        return out
+
+
+def _percentile(values: list, p: int):
+    """Nearest-rank percentile of *values* — ``idx = ceil(p/100 * n) - 1``, no
+    interpolation, stdlib only. Empty input is ``None``, never ``0``."""
+    if not values:
+        return None
+    ordered = sorted(values)
+    return ordered[math.ceil(p / 100 * len(ordered)) - 1]
+
+
+def _empty_stats() -> dict:
+    return {
+        "applied": 0,
+        "failed": 0,
+        "superseded": 0,
+        "pending": 0,
+        "p50": None,
+        "p90": None,
+        "finished_later": 0,
+    }
+
+
+def summarize(rows: list[dict]) -> dict:
+    """A JSON-able, read-only summary of effect-log *rows*.
+
+    Rows are folded by ``(item, tick_id, seq)`` — the latest status row wins —
+    and counted per ``(role, effect)`` as ``applied`` / ``failed`` /
+    ``superseded`` / ``pending``; a folded ``pending`` key is its item's still
+    unfinished work. ``p50``/``p90`` are nearest-rank percentiles over ``ms``
+    on folded-``applied`` keys only (``mark()`` records a state change without
+    measuring a write and leaves ``ms`` None; only ``apply()`` measures it),
+    and stay ``None`` when no applied ``ms`` exists. ``finished_later`` counts
+    fold keys — one each — whose status sequence holds a ``failed`` row
+    followed, later in log order, by an ``applied`` row for the same key: a
+    resume finished it. ``unfinished`` lists the folded-pending rows in log
+    order. The command never writes to the log directory.
+    """
+    folded_rows: dict[tuple, dict] = {}
+    for r in rows:
+        key = (r.get("item"), r.get("tick_id"), r.get("seq"))
+        folded_rows[key] = r  # the last row in log order wins, like fold()
+
+    groups: dict = {}
+    ms_by_group: dict[tuple, list] = {}
+    for _key, r in folded_rows.items():
+        gkey = (r.get("role"), r.get("effect"))
+        stats = groups.setdefault(gkey[0], {}).setdefault(gkey[1], _empty_stats())
+        status = r.get("status")
+        if status == APPLIED:
+            stats["applied"] += 1
+            ms = r.get("ms")
+            if ms is not None:
+                ms_by_group.setdefault(gkey, []).append(ms)
+        elif status == FAILED:
+            stats["failed"] += 1
+        elif status == SUPERSEDED:
+            stats["superseded"] += 1
+        else:
+            stats["pending"] += 1
+
+    for gkey, ms_values in ms_by_group.items():
+        stats = groups[gkey[0]][gkey[1]]
+        stats["p50"] = _percentile(ms_values, 50)
+        stats["p90"] = _percentile(ms_values, 90)
+
+    finished_later = 0
+    seen_failed: set[tuple] = set()
+    for r in rows:  # log order: a `failed` row finished by a later `applied` row
+        key = (r.get("item"), r.get("tick_id"), r.get("seq"))
+        if r.get("status") == FAILED:
+            seen_failed.add(key)
+        elif r.get("status") == APPLIED and key in seen_failed:
+            groups.setdefault(r.get("role"), {}).setdefault(r.get("effect"), _empty_stats())[
+                "finished_later"
+            ] += 1
+            finished_later += 1
+            seen_failed.discard(key)  # count each fold key once
+
+    unfinished = [
+        {
+            "role": r.get("role"),
+            "item": r.get("item"),
+            "tick_id": r.get("tick_id"),
+            "seq": r.get("seq"),
+            "effect": r.get("effect"),
+        }
+        for r in folded_rows.values()
+        if r.get("status") not in (APPLIED, FAILED, SUPERSEDED)
+    ]
+    return {"effects": groups, "finished_later": finished_later, "unfinished": unfinished}