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

cf_tool/cli/submitting.py

@@ -0,0 +1,309 @@
+"""Commands for submissions: submit, status, pull, clone."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import click
+
+from cf_tool import judge, languages, ui, views, workspace
+from cf_tool.cli.common import (
+    cf_command,
+    client,
+    code_file_among,
+    ensure_login,
+    problem_folder_of,
+    settings,
+    target_of,
+)
+from cf_tool.cli.completion import complete_problems, complete_problems_and_files
+from cf_tool.errors import CFError
+from cf_tool.workspace import Target
+
+
+def _label(contest: str, problem: str) -> str:
+    """2050A, problem A or contest 2050: what a file name points at."""
+    if contest and problem:
+        return f"{contest}{problem}"
+    return f"problem {problem}" if problem else f"contest {contest}"
+
+
+def _submit_target(
+    target: Target, filename: str, specs: tuple[str, ...], file_given: bool
+) -> Target:
+    """The problem to submit filename to: target, its gaps filled in from what
+    the file's name says. Both a file named for another problem and a target
+    read off the name need a yes first. Off a terminal nobody can say yes
+    (CP Editor calls cf so): a file and a problem both named are taken as
+    meant, anything else is refused."""
+    contest, problem = workspace.named_target(filename, Path.cwd())
+    clash = (target.contest and contest and contest != target.contest) or (
+        target.problem and problem and problem != target.problem
+    )
+    if clash:
+        looks = f"{filename} looks like {_label(contest, problem)}"
+        if not ui.interactive():
+            if file_given and specs:
+                ui.yellow(f"{looks}; submitting it to {target.label} as asked")
+                return target
+            raise CFError(f"{looks}, not {target.label}: name both")
+        question = f"{looks}. Submit it to {target.label}?"
+        if not ui.confirm(question, default=False):
+            raise CFError("Not submitted")
+        return target
+    missing = [
+        value
+        for value, known in ((contest, target.contest), (problem, target.problem))
+        if value and not known
+    ]
+    if not missing:
+        return target
+    target = target_of(specs + tuple(missing))
+    if not ui.interactive():
+        raise CFError(f"Which problem? Name it: cf submit {target.label} {filename}")
+    if not ui.confirm(f"Submit {filename} to {target.label}?", default=True):
+        raise CFError("Not submitted")
+    return target
+
+
+def _language_chooser(key: str, path: Path, asked: str):
+    """choose_language for Client.submit: the language asked for (-l) or set
+    for the file's language, else the family's best; when the form offers
+    none of those, the user picks one of the family (and may keep it)."""
+
+    def choose(offered: dict[str, str]) -> tuple[str, str]:
+        conf = settings().language_settings(key)
+        spec = asked or conf.submit
+        chosen = languages.choose_submit(key, spec, offered)
+        if chosen is not None:
+            return chosen
+        options = languages.family(key, offered)
+        if not options:
+            wanted = spec or languages.display_name(key)
+            raise CFError(f"Codeforces doesn't offer {wanted} here, nor anything like it")
+        old = languages.known_languages().get(spec, spec) if spec else languages.display_name(key)
+        if not ui.interactive():  # NOTE: nobody to ask: the family's best, this once
+            ui.yellow(f"Codeforces doesn't offer {old} here: submitting as {options[0][1]}")
+            return options[0]
+        lang_id = ui.select(
+            f"Codeforces doesn't offer {old} here. Submit {path.name} as:",
+            [(name, lid) for lid, name in options] + [("Don't submit", None)],
+            default=options[0][0],
+        )
+        if lang_id is None:
+            raise CFError("Not submitted")
+        if not asked and ui.confirm(
+            f"Submit {languages.display_name(key)} as {offered[lang_id]} from now on?", default=True
+        ):
+            settings().update("submit", lang_id, table=key)
+        return lang_id, offered[lang_id]
+
+    return choose
+
+
+@click.command()
+@click.argument(
+    "args", nargs=-1, metavar="[PROBLEM] [FILE]", shell_complete=complete_problems_and_files
+)
+@click.option(
+    "-f", "--file", "file_arg", type=click.Path(dir_okay=False), help="The code file to submit."
+)
+@click.option(
+    "-l",
+    "--lang",
+    "language",
+    metavar="NAME|ID",
+    default="",
+    help="The Codeforces language, this once.",
+)
+@cf_command
+def submit(args: tuple[str, ...], file_arg: str | None, language: str) -> None:
+    """Submit your code, then show the verdict as it comes.
+
+    \b
+    cf submit             the code of the problem here
+    cf submit b           problem b of this contest
+    cf submit 2050b a.cpp this file to that problem
+    With several code files around, you pick one (Esc cancels).
+    """
+    named, specs = code_file_among(args)
+    if named and file_arg:
+        raise CFError("Give the code file once: as -f or as an argument")
+    file_arg = file_arg or named
+    cwd = Path.cwd()
+    target = target_of(specs)
+    folder = problem_folder_of(target) if target.problem else workspace.find_problem_folder(cwd)
+    if file_arg:
+        filename, key = workspace.pick_code(file_arg, cwd, settings())
+        path = Path(file_arg).resolve()
+    else:
+        search = folder or cwd
+        name, key = workspace.pick_code(
+            None, search, settings(), contest=target.contest, problem=target.problem
+        )
+        path = (search / name).resolve()
+        filename = str(Path(name)) if search == cwd else _relative(path, cwd)
+    target = _submit_target(target, filename, specs, file_given=bool(file_arg))
+    failed = judge.failed_tests(path)
+    if failed and ui.interactive():
+        tests = ", ".join(failed[:3]) + (" ..." if len(failed) > 3 else "")
+        if not ui.confirm(
+            f"This code failed the test {tests} in cf test. Submit it anyway?", default=False
+        ):
+            raise CFError("Not submitted")
+    c = client()
+    ensure_login(c)
+    source = workspace.read_source(path)
+    submission = c.submit(target, source, _language_chooser(key, path, language), filename=filename)
+    _after_the_verdict(c, target, submission)
+
+
+_ON_TEST_RE = re.compile(r"\bon test (\d+)")  # NOTE: not "on pretest": hidden in a contest
+_SLOW_RE = re.compile(r"\b(?:Time|Memory) limit exceeded")
+
+
+def _after_the_verdict(c, target: Target, submission) -> None:
+    """What helps after a verdict other than accepted:
+    - CPython over a limit: a hint to try PyPy
+    - a failed test (once the contest is over): Codeforces' data of it"""
+    verdict, _ = submission.styled_status()
+    lang = submission.lang.lower()
+    if _SLOW_RE.search(verdict) and "python" in lang and "pypy" not in lang:
+        ui.cyan(
+            "PyPy usually runs the same Python code several times faster, and keeps lists "
+            "of numbers smaller: cf submit -l pypy"
+        )
+    if _ON_TEST_RE.search(verdict):
+        _show_failed_test(c, target, submission.id)
+
+
+def _show_failed_test(c, target: Target, submission_id: int, details=None) -> None:
+    """Codeforces' data of the test a submission failed (details, when
+    already fetched), shown, and kept among the problem's tests when it is
+    all there."""
+    if details is None:
+        try:
+            details = c.details(target, submission_id)
+        except CFError as e:
+            ui.dim(f"Cannot get the failed test's data ({e})")
+            return
+    if details is None or details.failed is None:
+        return
+    failed = details.failed
+    ui.console.print(views.failed_test(failed))
+    folder = problem_folder_of(target) if target.problem else None
+    if failed.cut or folder is None:
+        return
+    saved = workspace.add_test(folder, failed.input, failed.answer, name=f"cf-{failed.number}")
+    ui.green(f"Saved it as the test {saved.name}: cf test {saved.name} runs it again")
+
+
+def _relative(path: Path, cwd: Path) -> str:
+    try:
+        return str(path.relative_to(cwd.resolve()))
+    except ValueError:
+        return str(path)
+
+
+def _submission_id(spec: str) -> int | None:
+    """The submission an argument names (396876324, or its URL); None for
+    anything else."""
+    last = spec.split("?")[0].rstrip("/").split("/")[-1]
+    return int(last) if re.fullmatch(r"\d{7,}", last) else None  # NOTE: a contest: 6 at most
+
+
+@click.command()
+@click.argument(
+    "specs", nargs=-1, metavar="[PROBLEM|CONTEST|SUBMISSION]", shell_complete=complete_problems
+)
+@click.option("--all", "show_all", is_flag=True, help="All of them, not the last 10.")
+@cf_command
+def status(specs: tuple[str, ...], show_all: bool) -> None:
+    """Your submissions to the contest, refreshed until they're judged.
+
+    \b
+    cf status             your latest submissions to the contest here
+    cf status 2050b       to problem 2050B
+    cf status 396876324   that submission, with the test it failed (by id or URL)
+    """
+    if "all" in specs:  # NOTE: cf-tool 0.3's cf watch all
+        show_all, specs = True, tuple(s for s in specs if s != "all")
+    submissions = [n for n in map(_submission_id, specs) if n is not None]
+    if submissions:
+        _status_of_one(specs, submissions[0])
+        return
+    target = target_of(specs)
+    c = client()
+    ensure_login(c)
+    c.watch(target, count=-1 if show_all else 10, problem=target.problem)
+
+
+def _status_of_one(specs: tuple[str, ...], submission_id: int) -> None:
+    """One submission of yours: its verdict and, once the contest is over,
+    the test it failed."""
+    c = client()
+    ensure_login(c)
+    urls = [s for s in specs if "/" in s]
+    target = target_of(urls) if urls else c.find_submission(submission_id)
+    if target is None or not target.contest:
+        raise CFError(
+            f"Submission {submission_id} isn't among your latest ones: give its URL "
+            "(https://codeforces.com/contest/<contest>/submission/<id>)"
+        )
+    details = c.details(target, submission_id)
+    if details is None:
+        raise CFError(
+            "Codeforces shows no test data for it: only for your own submissions, "
+            "once the contest is over"
+        )
+    ui.line(("› ", "cyan bold"), (str(submission_id), "bold"), (f"  {details.problem}", ""))
+    ui.line(("  ", ""), (details.verdict, "bold"))
+    index = re.match(r"\((\w+)\)", details.problem)  # NOTE: "(F) Tea Blend"
+    if not target.problem and index:
+        target = target.with_problem(index.group(1).upper())
+    _show_failed_test(c, target, submission_id, details)
+
+
+@click.command()
+@click.argument("specs", nargs=-1, metavar="[PROBLEM|CONTEST]", shell_complete=complete_problems)
+@click.option("--ac", is_flag=True, help="Accepted ones only.")
+@cf_command
+def pull(specs: tuple[str, ...], ac: bool) -> None:
+    """Download the code of your submissions into the problems' folders."""
+    if "ac" in specs:  # NOTE: cf-tool 0.3's cf pull ac
+        ac, specs = True, tuple(s for s in specs if s != "ac")
+    target = target_of(specs)
+    c = client()
+    ensure_login(c)
+    root = workspace.get_root(Path.cwd(), settings().root_folder())
+
+    def folder_of(index: str) -> Path:
+        problem = target.with_problem(index)
+        return problem_folder_of(problem) or workspace.problem_folder(root, problem)
+
+    if not c.pull(target, folder_of, ac):
+        raise CFError("No code to download")
+
+
+@click.command()
+@click.argument("args", nargs=-1, metavar="[HANDLE]")
+@click.option("--ac", is_flag=True, help="Accepted ones only.")
+@cf_command
+def clone(args: tuple[str, ...], ac: bool) -> None:
+    """Download the code of every submission of a user (default: you)."""
+    if "ac" in args:  # NOTE: cf-tool 0.3's cf clone ac
+        ac = True
+    handles = [arg for arg in args if arg != "ac"]
+    if len(handles) > 1:
+        raise CFError("One handle at a time")
+    handle = handles[0] if handles else None
+    c = client()
+    handle = handle or c.handle
+    if not handle:
+        raise CFError("Whose? Give a handle, or log in with cf login")
+    saved = c.clone(handle, Path.cwd(), ac)
+    ui.green(f"Saved {saved} file{'s' if saved != 1 else ''}")
+
+
+COMMANDS = [submit, status, pull, clone]

cf_tool/cli/testing.py

@@ -0,0 +1,354 @@
+"""Commands that run your code: test and stress."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from cf_tool import judge, languages, process, stress as stress_module, ui, workspace
+from cf_tool.build import Program
+from cf_tool.cli.common import (
+    build,
+    cf_command,
+    program,
+    settings,
+    short,
+    target_of,
+)
+from cf_tool.cli.completion import complete_tests
+from cf_tool.errors import CFError
+from cf_tool.languages import Setup
+
+
+def _comparison_options(command):
+    """The options saying how output is compared with answers (cf test, cf stress)."""
+    options = [
+        click.option(
+            "-e",
+            "--epsilon",
+            type=float,
+            help="Accept numbers within this absolute or relative error.",
+        ),
+        click.option(
+            "-i", "--ignore-case", is_flag=True, help="Accept answers in any letter case."
+        ),
+        click.option("--strict", is_flag=True, help="Compare trimmed lines, not just the words."),
+        click.option("--exact", is_flag=True, help="Ignore what the statement allows."),
+        click.option(
+            "--checker",
+            metavar="FILE|CMD",
+            default="",
+            help="Judge with a program, run as: CMD input output answer (exit 0: right).",
+        ),
+    ]
+    for option in reversed(options):
+        command = option(command)
+    return command
+
+
+def helper(folder: Path, kind: str) -> Path | None:
+    """The problem's helper of a kind (gen, brute, checker, interactor) in
+    folder: gen.py, gen2.py, check_a.py; the newest when there are several."""
+    known = languages.code_extensions(settings())
+    found = [
+        entry
+        for entry in folder.glob("*.*")
+        if entry.suffix.lower() in known
+        and workspace.helper_kind(entry.name) == kind
+        and entry.is_file()
+    ]
+    return max(found, key=lambda entry: entry.stat().st_mtime) if found else None
+
+
+def _named_files(*specs: str) -> list[str]:
+    """The files that FILE|CMD options name (python3 check_a.py -> check_a.py):
+    they are helpers, never the code to test."""
+    named = []
+    for spec in filter(None, specs):
+        words = [spec] if Path(spec).is_file() else process.split_command(spec)
+        named += [str(Path(word).resolve()) for word in words if Path(word).is_file()]
+    return named
+
+
+def _program_or_command(spec: str, folder: Path) -> Program:
+    """A code file (built like any other), or a command line to run as it is."""
+    path = Path(spec)
+    if path.is_file() and languages.language_key(path, settings()) is not None:
+        return program(path.resolve())
+    words = process.split_command(spec)
+    if not words:
+        raise CFError(f"Nothing to run in {spec!r}")
+    # NOTE: it runs in the problem's folder (a program's own), even when the
+    # \     command starts with a path to elsewhere (/usr/bin/python3 check.py)
+    source = folder / Path(words[0]).name
+    return Program(source, Setup("command", words[0], spec, None, tuple(words)))
+
+
+def _checker(spec: str, folder: Path | None) -> Program | None:
+    """The checker to judge with: the one given, else checker.* in the problem's folder."""
+    if spec:
+        return _program_or_command(spec, folder or Path.cwd())
+    found = helper(folder, "checker") if folder else None
+    return program(found) if found else None
+
+
+def _problem_and_tests(args: tuple[str, ...]) -> tuple[Path, str | None, list[str]]:
+    """(the problem's folder, the code file named, the tests named) from cf
+    test's arguments, which may name a code file, a problem, and tests."""
+    cwd = Path.cwd()
+    known = languages.code_extensions(settings())
+    files = [a for a in args if Path(a).suffix.lower() in known and Path(a).is_file()]
+    if len(files) > 1:
+        raise CFError(f"One code file at a time, not {' and '.join(files)}")
+    file = files[0] if files else None
+    here = workspace.find_problem_folder(Path(file).resolve().parent if file else cwd)
+    here_tests = {t.name for t in workspace.tests_of(here)} if here else set()
+    specs, names = [], []
+    for arg in args:
+        if arg == file:
+            continue
+        if arg in here_tests or arg.isdigit():
+            names.append(arg)
+        else:
+            specs.append(arg)
+    if specs:
+        target = target_of(specs)
+        folder = workspace.locate(target, cwd, settings().root_folder())
+        if folder is None:
+            raise CFError(f"No folder for {target.label} here: cf get {target.label} sets one up")
+    elif here is not None:
+        folder = here
+    elif workspace.tests_of(cwd):
+        folder = cwd  # NOTE: tests without cf-tool's metadata, cf-tool 0.3's folders
+    else:
+        raise CFError(
+            "Not in a problem's folder: cd into one made by cf get, or name the problem "
+            "(cf test 2050b)"
+        )
+    return folder, file, names
+
+
+def _read_until_end() -> str:
+    return sys.stdin.read()
+
+
+def _add_test(folder: Path) -> workspace.Test:
+    """Type in a new test, its input, then its answer (none: only run it)."""
+    end = "Ctrl-Z, then Enter" if sys.platform == "win32" else "Ctrl-D"
+    ui.cyan(f"The new test's input (end it with {end} on an empty line):")
+    input_text = _read_until_end()
+    if not input_text.strip():
+        raise CFError("No input: no test added")
+    ui.cyan(f"Its answer (end it with {end}; none: only run it):")
+    test = workspace.add_test(folder, input_text, _read_until_end())
+    saved = f"{test.input.name}" + (f" and {test.answer.name}" if test.answer else "")
+    ui.green(f"Added the test {test.name}: tests/{saved}")
+    return test
+
+
+@click.command()
+@click.argument("args", nargs=-1, metavar="[PROBLEM|FILE] [TEST]...", shell_complete=complete_tests)
+@click.option("-w", "--watch", "watch_it", is_flag=True, help="Test again whenever you save.")
+@_comparison_options
+@click.option("--interactor", metavar="FILE|CMD", default="", help="For an interactive problem.")
+@click.option("--add", "add_one", is_flag=True, help="Type in a new test, then run it.")
+@click.option(
+    "--accept", is_flag=True, help="Keep the output of tests without an answer as theirs."
+)
+@cf_command
+def test(
+    args: tuple[str, ...],
+    watch_it: bool,
+    epsilon: float | None,
+    ignore_case: bool,
+    strict: bool,
+    exact: bool,
+    checker: str,
+    interactor: str,
+    add_one: bool,
+    accept: bool,
+) -> None:
+    """Build your code and run it on the problem's tests.
+
+    \b
+    cf test           every test of the problem here
+    cf test 2 my      the tests 2 and my
+    cf test b         problem b of this contest
+    cf test a.cpp     with this code file
+    cf test -w        again whenever you save
+    The statement's rules (numbers within an error, any letter case) apply
+    on their own; the options change them.
+    """
+    folder, file, names = _problem_and_tests(args)
+    info = workspace.load_info(folder)
+    target = (info.target if info else None) or workspace.here(folder) or workspace.Target()
+    if add_one:
+        names = [_add_test(folder).name]
+    found = workspace.tests_of(folder)
+    if not found:
+        raise CFError(
+            f"{short(folder)} has no tests: cf get downloads the samples, cf test --add adds one"
+        )
+    unknown = [name for name in names if name not in {t.name for t in found}]
+    if unknown:
+        listed = ", ".join(t.name for t in found)
+        raise CFError(f"No test {', '.join(unknown)} here (there are {listed})")
+    tests = [t for t in found if t.name in names] if names else found
+    chosen = {t.name for t in tests}
+
+    interactor_program = None
+    spec = interactor or str(helper(folder, "interactor") or "")
+    if spec:
+        interactor_program = _program_or_command(spec, folder)
+    elif info and info.interactive:
+        raise CFError(
+            "This problem is interactive: cf test runs it against an interactor. Write one "
+            "as interactor.cpp (any language) in its folder, or name one with --interactor"
+        )
+
+    if file:
+        name, key = file, languages.language_key(file, settings())
+        path = Path(file).resolve()
+    else:
+        name, key = workspace.pick_code(
+            None,
+            folder,
+            settings(),
+            contest=target.contest,
+            problem=target.problem,
+            action="test",
+            exclude=_named_files(checker, interactor),
+        )
+        path = (folder / name).resolve()
+    solution = program(path, key)
+    check_program = _checker(checker, folder)
+
+    def run_once() -> None:
+        build(solution)
+        for extra in (interactor_program, check_program):
+            if extra is not None:
+                build(extra)
+        check = judge.check_for(
+            info,
+            epsilon=epsilon,
+            ignore_case=ignore_case,
+            strict=strict,
+            exact=exact,
+            checker=check_program,
+        )
+        current = [
+            t for t in workspace.tests_of(folder) if t.name in chosen
+        ]  # NOTE: read again: --accept may have given answers
+        summary = judge.run_tests(
+            solution, current, info=info, check=check, accept=accept, interactor=interactor_program
+        )
+        judge.remember(path, summary)
+        stressed = [name for name in summary.failed if name.startswith("stress-")]
+        if stressed:
+            ui.dim(
+                f"{', '.join(stressed)}: saved by cf stress, with the brute force's answer "
+                "(the next cf stress updates it if the brute force changed)"
+            )
+        # NOTE: an output unlike the sample's isn't confirmed right either
+        if (summary.failed or summary.differs) and not watch_it:
+            sys.exit(1)
+
+    if not watch_it:
+        run_once()
+        return
+
+    def watched() -> list[Path]:
+        files = [path, *(t.input for t in tests), *(t.answer for t in tests if t.answer)]
+        for extra in (interactor_program, check_program):
+            if extra is not None:
+                files.append(extra.source)
+        return files
+
+    judge.watch(watched, run_once)
+
+
+@click.command()
+@click.argument("generator", required=False, type=click.Path(exists=True, dir_okay=False))
+@click.argument("brute", required=False, type=click.Path(exists=True, dir_okay=False))
+@click.argument("solution", required=False, type=click.Path(exists=True, dir_okay=False))
+@click.option("-n", "--tests", default=1000, show_default=True, help="Stop after this many tests.")
+@click.option("--seed", default=1, show_default=True, help="The first test's seed (then +1).")
+@_comparison_options
+@cf_command
+def stress(
+    generator: str | None,
+    brute: str | None,
+    solution: str | None,
+    tests: int,
+    seed: int,
+    epsilon: float | None,
+    ignore_case: bool,
+    strict: bool,
+    exact: bool,
+    checker: str,
+) -> None:
+    """Random tests until your solution and a brute force disagree; that
+    test is saved among the problem's tests.
+
+    \b
+    GENERATOR prints one test for the seed it gets as its argument; BRUTE's
+    output is the answer. They default to gen.* and brute.* in the problem's
+    folder, the solution to your code there (any language for all three).
+    """
+    cwd = Path.cwd()
+    folder = workspace.find_problem_folder(cwd) or cwd
+    info = workspace.load_info(folder)
+    target = (info.target if info else None) or workspace.here(folder) or workspace.Target()
+    gen_path = Path(generator).resolve() if generator else helper(folder, "gen")
+    brute_path = Path(brute).resolve() if brute else helper(folder, "brute")
+    if gen_path is None:
+        raise CFError("No generator: write gen.py (cf new gen.py) or another gen.*, or name one")
+    if brute_path is None:
+        raise CFError(
+            "No brute force: write brute.cpp (cf new brute) or another brute.*, or name one"
+        )
+    if solution:
+        solution_path = Path(solution).resolve()
+    else:
+        name, _ = workspace.pick_code(
+            None,
+            folder,
+            settings(),
+            contest=target.contest,
+            problem=target.problem,
+            action="stress test",
+            exclude=(str(gen_path), str(brute_path), *_named_files(checker)),
+        )
+        solution_path = (folder / name).resolve()
+    programs = [program(gen_path), program(brute_path), program(solution_path)]
+    check_program = _checker(checker, folder)
+    for each in [*programs, *([check_program] if check_program else [])]:
+        build(each)
+    check = judge.check_for(
+        info,
+        epsilon=epsilon,
+        ignore_case=ignore_case,
+        strict=strict,
+        exact=exact,
+        checker=check_program,
+    )
+    if check.any_answer:
+        ui.yellow(
+            "This problem accepts any right answer, so your output and the brute force's "
+            "may differ and both be right: judge with a checker (check*.py or --checker)"
+        )
+    failed = stress_module.stress(
+        folder,
+        *programs,
+        tests=tests,
+        seed=seed,
+        check=check,
+        time_limit=info.time_limit if info else None,
+    )
+    if failed is not None:
+        sys.exit(1)
+
+
+COMMANDS = [test, stress]

cf_tool/codeforces/__init__.py

@@ -0,0 +1,3 @@
+"""Everything that talks to Codeforces: the HTTP transport, the way in
+(Cloudflare and logging in), the session, page parsing, and the operations
+built on them."""