cf-tool-cli 1.0.0__py3-none-any.whl

cf_tool/views.py

@@ -0,0 +1,306 @@
+"""Rich renderables: submission table/panel, problem list, failed-sample diff,
+a submission's failed test.
+
+Pure functions from data to renderables — printing (and live refresh) is
+the caller's business. Every foreign string goes in as Text, never markup.
+"""
+
+from __future__ import annotations
+
+import operator
+from datetime import datetime, timezone
+from typing import Callable
+
+from rich import box
+from rich.console import Group, RenderableType
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from cf_tool import ui
+from cf_tool.codeforces.pages import Contest, ProblemRow, Submission, TestDetail
+from cf_tool.workspace import Cases
+
+HEADER = f"bold {ui.ACCENT}"
+
+LinesAlike = Callable[[str, str], bool]  # (output line, answer line): counts as it?
+
+# a failed sample shows at most this many lines of input / of the diff
+INPUT_LINES = 30
+DIFF_LINES = 40
+
+
+def submission_table(submissions: list[Submission], problem_id: str = "") -> Table:
+    """Recent submissions (cf status), optionally one problem's."""
+    table = Table(box=box.ROUNDED, border_style=ui.MUTED, header_style=HEADER)
+    # long columns may wrap on narrow terminals; the short ones never do
+    for column in ("#", "when", "problem", "lang", "status", "time", "memory"):
+        table.add_column(column, justify="center", no_wrap=column in ("#", "time", "memory"))
+    for sub in submissions:
+        if problem_id and sub.problem_index() != problem_id.lower():
+            continue
+        status, style = sub.styled_status()
+        table.add_row(
+            str(sub.id),
+            Text(sub.when),
+            Text(sub.name),
+            Text(sub.lang),
+            Text(status, style=ui.styled(style)),
+            sub.parse_time(),
+            sub.parse_memory(),
+        )
+    return table
+
+
+def submission_panel(sub: Submission, boxed: bool = True) -> Panel | Table:
+    """One submission in detail (after cf submit); unboxed, its lines read
+    "status: Accepted" for programs reading them."""
+    status, style = sub.styled_status()
+    grid = Table.grid(padding=(0, 1))
+    grid.add_column(justify="right", style=HEADER)
+    grid.add_column()
+    grid.add_row("#:", str(sub.id))
+    grid.add_row("when:", Text(sub.when))
+    grid.add_row("prob:", Text(sub.name))
+    grid.add_row("lang:", Text(sub.lang))
+    grid.add_row("status:", Text(status, style=ui.styled(style or "white")))
+    grid.add_row("time:", sub.parse_time() if sub.end else "-")
+    grid.add_row("memory:", sub.parse_memory() if sub.end else "-")
+    if not boxed:
+        return grid
+    border = ui.styled(style) if sub.end and style else ui.MUTED
+    return Panel(grid, box=box.ROUNDED, border_style=border, expand=False)
+
+
+def problems_table(problems: list[ProblemRow]) -> Table:
+    """A contest's problems (cf problems): solved rows green, failed ones red."""
+    table = Table(box=box.ROUNDED, border_style=ui.MUTED, header_style=HEADER)
+    for column in ("#", "problem", "passed", "limit", "IO"):
+        table.add_column(column, justify="center")
+    for prob in problems:
+        style = ""
+        if "accepted" in prob.state:
+            style = f"black on {ui.SUCCESS}"
+        elif "rejected" in prob.state:
+            style = f"black on {ui.ERROR}"
+        table.add_row(
+            *(Text(v) for v in (prob.id, prob.name, prob.passed, prob.limit, prob.io)),
+            style=style,
+        )
+    return table
+
+
+_DAYS = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
+_MONTHS = ("Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec")
+
+
+def _when(moment: float) -> str:
+    """A moment in local time: "Sat Nov 1 14:35" (English names whatever the locale)."""
+    local = datetime.fromtimestamp(moment)
+    return f"{_DAYS[local.weekday()]} {_MONTHS[local.month - 1]} {local.day} {local:%H:%M}"
+
+
+def _until(seconds: float) -> str:
+    """A wait in words: "35 min", "5 h 12 min", "3 days 4 h"."""
+    minutes = max(0, int(seconds // 60))
+    days, minutes = divmod(minutes, 24 * 60)
+    hours, minutes = divmod(minutes, 60)
+    if days:
+        return f"{days} day{'s' if days > 1 else ''} {hours} h"
+    return f"{hours} h {minutes} min" if hours else f"{minutes} min"
+
+
+def _length(seconds: int) -> str:
+    """A contest's length: "2:15", or "14 days" for long ones."""
+    if seconds >= 24 * 3600:
+        days = round(seconds / (24 * 3600))
+        return f"{days} day{'s' if days > 1 else ''}"
+    return f"{seconds // 3600}:{seconds % 3600 // 60:02d}"
+
+
+def contests_table(contests: list[Contest], now: float) -> Table:
+    """Upcoming contests (`cf contests`), soonest first."""
+    table = Table(box=box.ROUNDED, border_style=ui.MUTED, header_style=HEADER)
+    for column in ("#", "contest", "starts", "in", "length"):
+        table.add_column(column, no_wrap=column != "contest")
+    for contest in contests:
+        table.add_row(
+            str(contest.id),
+            Text(contest.name),
+            _when(contest.start),
+            _until(contest.start - now),
+            _length(contest.duration),
+        )
+    return table
+
+
+def _ics_text(value: str) -> str:
+    return value.replace("\\", "\\\\").replace(";", "\\;").replace(",", "\\,").replace("\n", "\\n")
+
+
+def _ics_fold(line: str) -> str:
+    """A content line folded to 75 characters, as calendars expect."""
+    parts = [line[:75]] + [" " + line[i : i + 74] for i in range(75, len(line), 74)]
+    return "\r\n".join(parts)
+
+
+def to_ics(contests: list[Contest], host: str, now: float) -> str:
+    """contests as an iCalendar file to import into a calendar app."""
+
+    def stamp(moment: float) -> str:
+        return datetime.fromtimestamp(moment, timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+
+    lines = ["BEGIN:VCALENDAR", "VERSION:2.0", "PRODID:-//cf-tool//Codeforces contests//EN"]
+    for contest in contests:
+        url = f"{host}/contests/{contest.id}"
+        lines += [
+            "BEGIN:VEVENT",
+            f"UID:contest-{contest.id}@codeforces.com",
+            f"DTSTAMP:{stamp(now)}",
+            f"DTSTART:{stamp(contest.start)}",
+            f"DTEND:{stamp(contest.start + contest.duration)}",
+            f"SUMMARY:{_ics_text(contest.name)}",
+            f"URL:{url}",
+            f"DESCRIPTION:{_ics_text(url)}",
+            "END:VEVENT",
+        ]
+    lines.append("END:VCALENDAR")
+    return "".join(_ics_fold(line) + "\r\n" for line in lines)
+
+
+def _clip(lines: list[str], limit: int) -> Text:
+    text = Text("\n".join(lines[:limit]))
+    if len(lines) > limit:
+        text.append(f"\n… {len(lines) - limit} more lines", style=ui.MUTED)
+    return text
+
+
+def program_output(text: str, title: str = "Output") -> Group:
+    """Text a program printed (or got), under a -----title----- heading; its
+    first lines only."""
+    heading = Text(f"── {title.lower()} ──", style=ui.ACCENT)
+    if not text.strip():
+        return Group(heading, Text(f"(no {title.lower()})", style=ui.MUTED))
+    return Group(heading, _clip(text.rstrip("\n").split("\n"), INPUT_LINES))
+
+
+def _diff_rows(
+    rows: list[int], out_lines: list[str], ans_lines: list[str], same: LinesAlike = operator.eq
+) -> Table:
+    """Output and answer side by side for these line indexes, differences marked."""
+    diff = Table(box=box.SIMPLE_HEAD, header_style=HEADER, pad_edge=False)
+    diff.add_column("#", justify="right", style=ui.MUTED)
+    diff.add_column("output")
+    diff.add_column("answer")
+    for i in rows:
+        out = out_lines[i] if i < len(out_lines) else None
+        ans = ans_lines[i] if i < len(ans_lines) else None
+        alike = out is not None and ans is not None and same(out, ans)
+        diff.add_row(
+            str(i + 1),
+            (
+                Text("(missing)", style=ui.MUTED)
+                if out is None
+                else Text(out, style="" if alike else ui.ERROR)
+            ),
+            (
+                Text("(missing)", style=ui.MUTED)
+                if ans is None
+                else Text(ans, style="" if alike else ui.SUCCESS)
+            ),
+        )
+    return diff
+
+
+def _failing_case(
+    input_lines: list[str],
+    out_lines: list[str],
+    ans_lines: list[str],
+    cases: Cases,
+    same: LinesAlike,
+) -> Group | None:
+    """The first test case of a multi-test sample that differs: its input and
+    lines only; None when the saved layout doesn't fit these files."""
+    input_cases, answer_cases = cases
+    if len(input_cases) != len(input_lines) or len(answer_cases) != len(ans_lines):
+        return None  # NOTE: the sample was edited after cf parse
+    bad = sorted(
+        {
+            answer_cases[i]
+            for i in range(len(ans_lines))
+            if i >= len(out_lines) or not same(out_lines[i], ans_lines[i])
+        }
+    )
+    total = max(input_cases, default=0)
+    if not bad:  # NOTE: every case matches, so the output only runs longer
+        extra = list(range(len(ans_lines), len(out_lines)))[:DIFF_LINES]
+        return Group(
+            Text("Extra output after the last test case", style=ui.ERROR),
+            _diff_rows(extra, out_lines, ans_lines, same),
+        )
+    case = bad[0]
+    others = f" (also {', '.join(map(str, bad[1:]))})" if len(bad) > 1 else ""
+    rows = [i for i, c in enumerate(answer_cases) if c == case][:DIFF_LINES]
+    case_input = [line for line, c in zip(input_lines, input_cases) if c == case]
+    return Group(
+        Text(f"Test case {case} of {total} differs{others}", style=ui.ERROR),
+        Text(f"── input of test case {case} ──", style=ui.ACCENT),
+        _clip(case_input, INPUT_LINES),
+        _diff_rows(rows, out_lines, ans_lines, same),
+    )
+
+
+def failed_sample(
+    input_text: str,
+    out_lines: list[str],
+    ans_lines: list[str],
+    cases: Cases | None = None,
+    same: LinesAlike = operator.eq,
+) -> Group:
+    """What went wrong in a sample (same: whether an output line counts as
+    its answer line):
+    - multi-test, with cases known: the first differing test case only
+    - otherwise: the input, then output and answer side by side"""
+    input_lines = input_text.rstrip("\n").split("\n")
+    if cases is not None:
+        view = _failing_case(input_lines, out_lines, ans_lines, cases, same)
+        if view is not None:
+            return view
+    total = max(len(out_lines), len(ans_lines))
+    first_bad = next(
+        (
+            i
+            for i in range(total)
+            if i >= len(out_lines) or i >= len(ans_lines) or not same(out_lines[i], ans_lines[i])
+        ),
+        0,
+    )
+    # long outputs: show a window starting a little before the first difference
+    start = max(0, first_bad - 5) if total > DIFF_LINES else 0
+    stop = min(total, start + DIFF_LINES)
+    parts: list[RenderableType] = [
+        Text("── input ──", style=ui.ACCENT),
+        _clip(input_lines, INPUT_LINES),
+        _diff_rows(list(range(start, stop)), out_lines, ans_lines, same),
+    ]
+    if start or stop < total:
+        parts.append(Text(f"lines {start + 1}–{stop} of {total}", style=ui.MUTED))
+    return Group(*parts)
+
+
+def failed_test(detail: TestDetail) -> Group:
+    """The test a submission failed, as Codeforces shows it: what the checker
+    said, then input, output and answer like a failed sample."""
+    cut = ", cut short by Codeforces" if detail.cut else ""
+    parts: list[RenderableType] = [Text(f"── test {detail.number}{cut} ──", style=ui.ACCENT)]
+    if detail.checker:
+        parts.append(Text.assemble(("checker: ", ui.ERROR), detail.checker))
+    parts.append(
+        failed_sample(
+            detail.input,
+            detail.output.strip().splitlines(),
+            detail.answer.strip().splitlines(),
+            same=lambda out, ans: out.split() == ans.split(),
+        )
+    )
+    return Group(*parts)