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

cf_tool/cli/completion.py

@@ -0,0 +1,226 @@
+"""Tab completion: what each argument can be, from the folders around and the
+contest list cf keeps. Never every number: only contests and problems that
+have folders here (or are on now), and code files rather than every file.
+Completers run on every Tab, so they stay quick and never raise or print."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+from typing import Iterable, Union
+
+import click
+from click.shell_completion import CompletionItem, get_completion_class
+
+from cf_tool import languages, paths, workspace
+from cf_tool.errors import CFError
+
+Candidate = Union[str, tuple[str, str]]  # a value, or (value, what it is)
+RECENT_CONTESTS = 8  # contests on or just over offered to cf get
+
+
+def words(incomplete: str, candidates: Iterable[Candidate]) -> list[CompletionItem]:
+    """Completions: the candidates that start with what was typed so far,
+    each once, with what it is when known (zsh and fish show that)."""
+    typed = incomplete.lower()
+    items: dict[str, CompletionItem] = {}
+    for candidate in candidates:
+        value, about = candidate if isinstance(candidate, tuple) else (candidate, "")
+        if value.lower().startswith(typed) and value not in items:
+            items[value] = CompletionItem(value, help=about or None)
+    return list(items.values())
+
+
+def _subfolders(folder: Path) -> list[Path]:
+    try:
+        return sorted(p for p in folder.iterdir() if p.is_dir() and not p.name.startswith("."))
+    except OSError:
+        return []
+
+
+def _problems_of(contest: Path) -> list[tuple[str, str]]:
+    """A contest folder's problems: (folder name, problem name), a -> A. Watermelon."""
+    found = []
+    for child in _subfolders(contest):
+        if (child / workspace.METADATA).is_file():
+            info = workspace.load_info(child)
+            found.append((child.name, info.name if info else ""))
+    return found
+
+
+def _contests_around(cwd: Path) -> dict[str, list[tuple[str, str]]]:
+    """Contests with folders around, by id, with their problems: the one cwd
+    is in, and those in cwd and in the root folder (2050/ holding 2050/a/)."""
+    folders = []
+    current = workspace.contest_folder(cwd)
+    if current is not None:
+        folders.append(current)
+    for base in dict.fromkeys([cwd, _root()]):
+        if base is not None:
+            folders += [f for f in _subfolders(base) if f.name.isdigit()]
+    contests: dict[str, list[tuple[str, str]]] = {}
+    for folder in folders:
+        problems = _problems_of(folder)
+        if not problems:
+            continue
+        info = workspace.load_info(folder / problems[0][0])
+        target = info.target if info else None
+        contest = target.contest if target and target.kind != "acmsguru" else folder.name
+        if contest.isdigit():
+            contests.setdefault(contest, problems)
+    return contests
+
+
+def _root() -> Path | None:
+    from cf_tool.settings import Settings
+
+    try:
+        return Settings.load().root_folder()
+    except (CFError, OSError):
+        return None
+
+
+def _listed_contests() -> list[dict]:
+    """The contest list cf keeps (from cf contests and cf get); [] without one."""
+    try:
+        data = json.loads((paths.STATE_DIR / "contests.json").read_text(encoding="utf-8"))
+        return [c for c in data.get("result", []) if isinstance(c, dict) and "id" in c]
+    except (OSError, ValueError, AttributeError):
+        return []
+
+
+def _named_by_files(cwd: Path) -> list[str]:
+    """The problems this folder's code files are named for (2050A.cpp -> 2050A)."""
+    found = []
+    for name in _code_files(cwd):
+        number, letter = workspace.named_target(name, cwd)
+        if number and letter:
+            found.append(f"{number}{letter}")
+    return found
+
+
+def _code_files(cwd: Path) -> list[str]:
+    """The code files in cwd, helpers left out."""
+    known = languages.code_extensions()
+    try:
+        entries = sorted(cwd.iterdir())
+    except OSError:
+        return []
+    return [
+        e.name
+        for e in entries
+        if e.suffix.lower() in known and e.is_file() and not workspace.is_helper(e.name)
+    ]
+
+
+def _earlier(ctx) -> tuple[str, ...]:
+    """The arguments typed before the one being completed."""
+    for name in ("specs", "args"):
+        value = ctx.params.get(name)
+        if value:
+            return tuple(value)
+    return ()
+
+
+def _problems(ctx, incomplete: str) -> list[Candidate]:
+    """What a problem argument can name here:
+    - after a contest's id (cf submit 2050 _): that contest's problems
+    - the problems of the contest cwd is in, by letter
+    - contests with folders around; once one's id is typed, its problems too
+    - problems that code files here are named for (2050A.cpp)"""
+    try:
+        cwd = Path.cwd()
+        contests = _contests_around(cwd)
+        named = next((a for a in reversed(_earlier(ctx)) if a in contests), None)
+        if named is not None:
+            return list(contests[named])
+        candidates: list[Candidate] = []
+        current = workspace.contest_folder(cwd)
+        if current is not None:
+            candidates += _problems_of(current)
+        names = {str(c["id"]): str(c.get("name", "")) for c in _listed_contests()}
+        for contest, problems in contests.items():
+            count = f"{len(problems)} problem{'s' if len(problems) > 1 else ''} here"
+            candidates.append((contest, names.get(contest) or count))
+            if incomplete == contest:
+                candidates += [(f"{contest}{letter}", name) for letter, name in problems]
+        return candidates + _named_by_files(cwd)
+    except (CFError, OSError):
+        return []  # NOTE: a broken folder only costs the suggestions
+
+
+def _files(incomplete: str) -> list[CompletionItem]:
+    """The code files here; for a path being typed (../, ~/), the shell's own
+    file completion."""
+    if incomplete.startswith((".", "~", "/")) or os.sep in incomplete or "/" in incomplete:
+        return [CompletionItem(incomplete, type="file")]
+    return words(incomplete, _code_files(Path.cwd()))
+
+
+def complete_languages(ctx, param, incomplete: str) -> list[CompletionItem]:
+    """The languages cf-tool knows, by their extension (cpp, py, ...)."""
+    from cf_tool.settings import Settings
+
+    try:
+        extra = list(Settings.load().languages)
+    except (CFError, OSError):
+        extra = []
+    return words(incomplete, [*languages.LANGUAGES, *extra])
+
+
+def complete_problems(ctx, param, incomplete: str) -> list[CompletionItem]:
+    return words(incomplete, _problems(ctx, incomplete))
+
+
+def complete_contests(ctx, param, incomplete: str) -> list[CompletionItem]:
+    """For cf get and cf race: the contests on now or about to start, those
+    just over (from the contest list cf keeps), and the ones around."""
+    now = time.time()
+    listed = sorted(_listed_contests(), key=lambda c: -int(c.get("startTimeSeconds") or 0))
+    soon = [
+        c
+        for c in listed
+        if c.get("phase") == "BEFORE" and 0 <= (c.get("startTimeSeconds") or 0) - now < 86400
+    ]
+    started = [c for c in listed if c.get("phase") != "BEFORE"][:RECENT_CONTESTS]
+    recent = [(str(c["id"]), str(c.get("name", ""))) for c in [*soon, *started]]
+    return words(incomplete, [*_problems(ctx, incomplete), *recent])
+
+
+def complete_problems_and_files(ctx, param, incomplete: str) -> list[CompletionItem]:
+    """For cf submit: the problems around and the code files here."""
+    return [*words(incomplete, _problems(ctx, incomplete)), *_files(incomplete)]
+
+
+def complete_tests(ctx, param, incomplete: str) -> list[CompletionItem]:
+    """For cf test: the tests of the problem here, the problems around, and
+    the code files here."""
+    try:
+        folder = workspace.find_problem_folder(Path.cwd())
+        tests = [t.name for t in workspace.tests_of(folder)] if folder else []
+    except OSError:
+        tests = []
+    return [*words(incomplete, [*tests, *_problems(ctx, incomplete)]), *_files(incomplete)]
+
+
+@click.command()
+@click.argument("shell", required=False, type=click.Choice(["bash", "zsh", "fish"]))
+def completion(shell: str | None) -> None:
+    """Print the Tab-completion script for bash, zsh or fish.
+
+    \b
+    zsh:   eval "$(cf completion zsh)"    in ~/.zshrc, after compinit
+    bash:  eval "$(cf completion bash)"   in ~/.bashrc (bash 4.4+)
+    fish:  cf completion fish | source    in ~/.config/fish/config.fish
+    """
+    from cf_tool.cli import main
+
+    shell = shell or Path(os.environ.get("SHELL", "")).name
+    script = get_completion_class(shell)
+    if script is None:
+        raise click.UsageError(
+            f'Cannot tell your shell ("{shell}"): run cf completion zsh, bash or fish'
+        )
+    click.echo(script(main, {}, "cf", "_CF_COMPLETE").source())

cf_tool/cli/configure.py

@@ -0,0 +1,386 @@
+"""cf config's menu: every setting in one list, grouped by language. Each
+setting opens a list whose first choice is the recommended one (already
+selected, so Enter keeps it); Esc goes back. Everything is saved in
+config.toml, which stays open to editing too (cf config --edit)."""
+
+from __future__ import annotations
+
+import copy
+import dataclasses
+import re
+import shutil
+from pathlib import Path
+
+import click
+
+from cf_tool import languages, paths, ui
+from cf_tool.cli.common import client, reset, settings, short
+from cf_tool.errors import CFError
+from cf_tool.settings import Settings
+
+DEFAULT = ""  # the menu value for the recommended choice: the setting goes away
+OTHER = "\0other"  # the menu value for "something not listed"
+RECOMMENDED = "recommended"
+
+# the languages the menus offer; C is left to its files (.c still works),
+# since hardly anybody picks it over C++
+LISTED = [key for key in languages.LANGUAGES if key != "c"]
+
+
+def _offered() -> dict[str, str]:
+    """Codeforces' languages: the submit form's when logged in, else the list read last."""
+    offered, _ = client().languages()
+    return offered
+
+
+def _tools(key: str) -> list[languages.Tool]:
+    language = languages.LANGUAGES.get(key)
+    return language.detect(languages.Machine()) if language else []
+
+
+def _commands(key: str, recommended: bool = False) -> tuple[str, str] | None:
+    """(build, run) as cf-tool runs them now, or as it would without the
+    settings that change them (recommended); None without a compiler."""
+    current = settings()
+    if recommended:
+        current = copy.copy(current)
+        conf = current.language_settings(key)
+        plain = dataclasses.replace(conf, build=None, run=None, flags=())
+        current.languages = {**current.languages, key: plain}
+    try:
+        setup = languages.setup(key, current)
+    except CFError:
+        return None
+    return " ".join(setup.build or ()), " ".join(setup.run)
+
+
+def _shown(command: str) -> str:
+    """A command for reading: home as ~."""
+    return command.replace(str(Path.home()), "~") if command else "(nothing to build)"
+
+
+# ┌──────────────────────────────────────────────────────────┐
+# │                   What each row shows                    │
+# └──────────────────────────────────────────────────────────┘
+
+
+def _compiler_row(key: str) -> str:
+    conf = settings().language_settings(key)
+    label = "Interpreter" if key == "py" else "Compiler"
+    if conf.compiler:
+        return ui.row(label, conf.compiler)
+    tools = _tools(key)
+    if not tools:
+        return ui.row(label, f"none found: {languages.LANGUAGES[key].install_hint()}")
+    return ui.row(label, tools[0].label, RECOMMENDED)
+
+
+def _submit_row(key: str, offered: dict[str, str]) -> str:
+    conf = settings().language_settings(key)
+    chosen = languages.choose_submit(key, conf.submit, offered)
+    if chosen is None:
+        value = f"{conf.submit}, not offered any more" if conf.submit else "nothing offered"
+        return ui.row("Submitted as", value)
+    return ui.row("Submitted as", chosen[1], "" if conf.submit else RECOMMENDED)
+
+
+def _commands_row(key: str) -> str:
+    conf = settings().language_settings(key)
+    if conf.build is not None or conf.run is not None:
+        return ui.row("Build and run", "your own commands")
+    if conf.flags:
+        return ui.row("Build and run", f"recommended + {' '.join(conf.flags)}")
+    return ui.row("Build and run", "the recommended commands", RECOMMENDED)
+
+
+def _starter_row(key: str) -> str:
+    try:
+        _, origin = languages.starter(key, settings())
+    except CFError:
+        return ui.row("Starter code", f"{settings().language_settings(key).template} (missing)")
+    if origin == "built-in":
+        return ui.row("Starter code", "the built-in one", RECOMMENDED)
+    return ui.row("Starter code", short(origin))
+
+
+# ┌──────────────────────────────────────────────────────────┐
+# │                       Picking one                        │
+# └──────────────────────────────────────────────────────────┘
+
+
+def pick_language() -> None:
+    current = settings()
+    keys = [*LISTED, *(k for k in current.languages if k not in languages.LANGUAGES)]
+    key = ui.select(
+        "Which language do you write in? (cf get writes your starter code in it)",
+        [(languages.display_name(k), k) for k in keys],
+        default=current.language or "cpp",
+    )
+    current.update("language", key)
+
+
+def pick_compiler(key: str) -> None:
+    """A language's compiler (or interpreter): the best one found here, one
+    of the others found, or a program named by hand."""
+    tools = _tools(key)
+    conf = settings().language_settings(key)
+    choices = []
+    if tools:
+        choices.append((ui.row(tools[0].label, "", RECOMMENDED), DEFAULT))
+        choices += [(tool.label, tool.program) for tool in tools[1:]]
+    else:
+        ui.warn(f"No compiler found here: {languages.LANGUAGES[key].install_hint()}")
+    if conf.compiler and conf.compiler not in [value for _, value in choices]:
+        choices.append((conf.compiler, conf.compiler))
+    choices.append(("Another program...", OTHER))
+    program = ui.select(
+        f"Which {languages.display_name(key)} compiler?", choices, default=conf.compiler or DEFAULT
+    )
+    if program == OTHER:
+        program = ui.path(
+            "The program (its name on PATH, or its path; Tab completes):",
+            validate=lambda s: bool(shutil.which(str(Path(s.strip()).expanduser())))
+            or "Not a program that runs",
+        )
+        program = str(Path(program).expanduser()) if "/" in program else program
+    if program == DEFAULT:
+        settings().remove("compiler", table=key)
+    else:
+        settings().update("compiler", program, table=key)
+
+
+def pick_submit(key: str) -> None:
+    """The Codeforces language a language is submitted as: the newest of
+    its family, or another picked by name (saved as its id)."""
+    offered = _offered()
+    options = languages.family(key, offered)
+    name = languages.display_name(key)
+    if not options:
+        ui.warn(f"Codeforces offers no {name} language that cf-tool knows of")
+        return
+    conf = settings().language_settings(key)
+    chosen = languages.choose_submit(key, conf.submit, offered) if conf.submit else None
+    lang_id = ui.select(
+        f"Submit {name} to Codeforces as:",
+        [(ui.row(options[0][1], "", RECOMMENDED), DEFAULT)] + [(n, lid) for lid, n in options[1:]],
+        default=chosen[0] if chosen and chosen != options[0] else DEFAULT,
+        search=len(options) > ui.MAX_SHORTCUTS,
+    )
+    if lang_id == DEFAULT:
+        settings().remove("submit", table=key)
+    else:
+        settings().update("submit", lang_id, table=key)
+
+
+def pick_commands(key: str) -> None:
+    """How a language is built and run: the recommended commands, those with
+    flags of yours added, or commands of your own."""
+    name = languages.display_name(key)
+    conf = settings().language_settings(key)
+    recommended = _commands(key, recommended=True)
+    if recommended is None:
+        ui.warn(f"No {name} compiler found here: pick one first")
+        return
+    build, run = recommended
+    ui.line(("Recommended  ", "dim"), ("build  ", "dim"), (_shown(build), "cyan"))
+    ui.line(("             ", "dim"), ("run    ", "dim"), (_shown(run), "cyan"))
+    ui.dim("{src} is your code file, {exe} the program built from it (kept out of your folder)")
+    own = conf.build is not None or conf.run is not None
+    action = ui.select(
+        f"How should {name} be built and run?",
+        [
+            (ui.row("These", "", RECOMMENDED), DEFAULT),
+            ("These, with flags of mine added (like -DLOCAL)...", "flags"),
+            ("Commands of my own...", "own"),
+        ],
+        default="own" if own else "flags" if conf.flags else DEFAULT,
+    )
+    if action == "own":
+        build_text = ui.text(
+            "Build command (empty: nothing to build):",
+            default=" ".join(conf.build) if conf.build is not None else build,
+        )
+        run_text = ui.text(
+            "Run command:",
+            default=" ".join(conf.run) if conf.run is not None else run,
+            allow_empty=False,
+        )
+        settings().update("build", build_text, table=key)
+        settings().update("run", run_text, table=key)
+        settings().remove("flags", table=key)
+        return
+    flags = ui.text("Flags to add:", default=" ".join(conf.flags)) if action == "flags" else ""
+    for setting in ("build", "run"):
+        settings().remove(setting, table=key)
+    if flags:
+        settings().update("flags", flags, table=key)
+    else:
+        settings().remove("flags", table=key)
+
+
+def pick_starter(key: str) -> None:
+    """A language's starter code: the built-in one (or yours in
+    templates/template.<ext>), a file of yours anywhere, or the built-in one
+    copied to templates/ to change it."""
+    own = paths.templates_dir() / f"template.{key}"
+    conf = settings().language_settings(key)
+    if own.is_file():
+        choices = [(ui.row(f"Yours: {short(own)}", "", RECOMMENDED), DEFAULT)]
+    else:
+        choices = [(ui.row("The built-in one", "", RECOMMENDED), DEFAULT)]
+    if conf.template:
+        choices.append((conf.template, conf.template))
+    choices.append(("A file of mine...", OTHER))
+    if not own.is_file() and key in languages.LANGUAGES:
+        choices.append((f"The built-in one, copied to {short(own)} for me to change", "copy"))
+    picked = ui.select(
+        f"Starter code for {languages.display_name(key)}:",
+        choices,
+        default=conf.template or DEFAULT,
+    )
+    if picked == "copy":
+        paths.write_atomic(own, languages.LANGUAGES[key].starter)
+        settings().remove("template", table=key)
+        ui.success(f"Wrote {short(own)}: change it as you like; cf get starts from it")
+        return
+    if picked == OTHER:
+        picked = ui.path(
+            "The file (Tab completes):",
+            validate=lambda s: (bool(s.strip()) and Path(s.strip()).expanduser().is_file())
+            or "Not a file",
+        )
+    if picked == DEFAULT:
+        settings().remove("template", table=key)
+    else:
+        settings().update("template", picked, table=key)
+
+
+def pick_proxy() -> None:
+    current = settings()
+    proxy = ui.text(
+        'Proxy, like "socks5://127.0.0.1:1080" (empty: none, or the environment\'s):',
+        default=current.proxy,
+        validate=lambda s: (not s.strip())
+        or bool(re.fullmatch(r"[\w+-]+://[\w.-]+(:\d+)?/?", s.strip()))
+        or "Like http://127.0.0.1:7890",
+    )
+    if proxy:
+        current.update("proxy", proxy)
+    else:
+        current.remove("proxy")
+
+
+def edit_file() -> None:
+    """Open config.toml in the editor; check it once closed."""
+    path = paths.config_file()
+    current: Settings | None
+    try:
+        current = settings()
+    except CFError as e:  # NOTE: a broken file is opened all the same, to fix it
+        ui.warn(str(e))
+        current = None
+    if current is not None and not path.exists():
+        current.write_default()
+    click.edit(filename=str(path))
+    reset()
+    try:
+        reloaded = Settings.load(path)
+    except CFError as e:
+        raise CFError(f"{e}\nRun cf config --edit again to fix it") from e
+    for warning in reloaded.warnings:
+        ui.warn(warning)
+    ui.success(f"Saved {short(path)}")
+
+
+# ┌──────────────────────────────────────────────────────────┐
+# │                        The menu                          │
+# └──────────────────────────────────────────────────────────┘
+
+_PICKERS = {
+    "compiler": pick_compiler,
+    "submit": pick_submit,
+    "commands": pick_commands,
+    "template": pick_starter,
+}
+
+
+def _shown_languages() -> tuple[list[str], list[str]]:
+    """(the languages the menu shows, those it leaves out): the one for new
+    problems first, then those installed here or set in config.toml."""
+    current = settings()
+    main = current.language or "cpp"
+    shown, missing = [main], []
+    for key in LISTED:
+        if key == main:
+            continue
+        if key in current.languages or _tools(key):
+            shown.append(key)
+        else:
+            missing.append(key)
+    shown += [k for k in current.languages if k not in languages.LANGUAGES and k not in shown]
+    return shown, missing
+
+
+def _language_rows(key: str, offered: dict[str, str]) -> list:
+    rows: list = [ui.Heading(f"── {languages.display_name(key)} ──")]
+    if key in languages.LANGUAGES:
+        rows.append((_compiler_row(key), ("compiler", key)))
+    rows.append((_submit_row(key, offered), ("submit", key)))
+    if key in languages.LANGUAGES:  # NOTE: config.toml's own languages: edit the file
+        rows.append((_commands_row(key), ("commands", key)))
+        rows.append((_starter_row(key), ("template", key)))
+    return rows
+
+
+def menu() -> None:
+    """cf config: every setting in one list, until Done or Esc."""
+    action = "language"
+    while True:
+        current = settings()
+        offered = _offered()
+        shown, missing = _shown_languages()
+        who = client().handle or "not logged in"
+        rows: list = [
+            ui.Heading("── General ──"),
+            (
+                ui.row(
+                    "Language for new problems",
+                    languages.display_name(current.language or "cpp"),
+                    "" if current.language else "not picked yet",
+                ),
+                "language",
+            ),
+            (ui.row("Proxy", current.proxy or "none"), "proxy"),
+        ]
+        for key in shown:
+            rows += _language_rows(key, offered)
+        if missing:
+            names = ", ".join(languages.display_name(k) for k in missing)
+            rows.append(ui.Heading(f"── not installed here: {names} ──"))
+        rows += [
+            ui.Heading(""),
+            ("Edit config.toml in your editor", "edit"),
+            ("Done", "done"),
+        ]
+        values = [r[1] for r in rows if not isinstance(r, ui.Heading)]
+        try:
+            action = ui.select(
+                f"cf-tool settings · {who} · {short(current.file)}",
+                rows,
+                default=action if action in values else "language",
+            )
+        except ui.Canceled:
+            return  # NOTE: Esc on the menu itself: done
+        if action == "done":
+            return
+        try:
+            if isinstance(action, tuple):
+                _PICKERS[action[0]](action[1])
+            elif action == "language":
+                pick_language()
+            elif action == "proxy":
+                pick_proxy()
+            elif action == "edit":
+                edit_file()
+        except ui.Canceled:
+            pass  # NOTE: Esc in a list: back to the menu