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

cf_tool/__init__.py

@@ -0,0 +1,3 @@
+"""cf-tool: Codeforces from your terminal."""
+
+__version__ = "1.0.0"

cf_tool/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running as a module: python -m cf_tool"""
+
+from cf_tool.cli import main
+
+if __name__ == "__main__":
+    main()

cf_tool/build.py

@@ -0,0 +1,211 @@
+"""Building a code file before it runs, with a cache: a source that hasn't
+changed is not compiled again.
+
+Builds live in $XDG_CACHE_HOME/cf/build/<key>/, never next to the code. The
+key covers the source, the build and run commands, the compiler's version
+text and the files in the build's include folders (-I), so a change to any of
+them builds afresh; a C/C++ source with a local `#include "..."` is rebuilt
+every time (the header may have changed). Builds unused for a week are
+removed.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import hashlib
+import os
+import re
+import shutil
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from cf_tool import paths, process
+from cf_tool.errors import CFError
+from cf_tool.languages import Setup
+
+BUILD_TIMEOUT = 300.0  # seconds a compiler may take
+MAX_AGE = 7 * 24 * 3600  # seconds an unused build is kept
+_MARK = ".built"  # in a finished build's folder
+_LOCAL_INCLUDE_RE = re.compile(rb'^\s*#\s*include\s*"', re.MULTILINE)
+_pruned = False
+
+
+class BuildFailed(CFError):
+    """The compiler refused the code; its message is in output."""
+
+    def __init__(self, message: str, output: str) -> None:
+        super().__init__(message)
+        self.output = output
+
+
+@dataclass(frozen=True)
+class Built:
+    cached: bool  # nothing was compiled
+    seconds: float
+    messages: str  # what the compiler printed (warnings)
+
+
+class Program:
+    """A code file and how its language builds and runs it."""
+
+    def __init__(self, source: Path | str, setup: Setup) -> None:
+        self.source = Path(os.path.abspath(source))
+        self.setup = setup
+        self._folder: Path | None = None
+
+    @property
+    def name(self) -> str:
+        return self.source.name
+
+    @property
+    def label(self) -> str:
+        """How messages name it: its file, or a command as it was given."""
+        return self.setup.tool if self.setup.key == "command" else self.name
+
+    def _key(self, code: bytes, headers: str) -> str:
+        digest = hashlib.sha256()
+        for part in (
+            self.setup.fingerprint,
+            "\0".join(self.setup.build or ()),
+            "\0".join(self.setup.run),
+            sys.platform,
+            str(self.source),
+            headers,
+        ):
+            digest.update(part.encode() + b"\1")
+        digest.update(code)
+        return digest.hexdigest()[:32]
+
+    def _values(self, folder: Path | None) -> dict[str, str]:
+        exe = self.source.stem + (".exe" if sys.platform == "win32" else "")
+        values = {"src": str(self.source), "name": self.source.stem, "class": self.source.stem}
+        if folder is not None:
+            copy = folder / (self.setup.copy_as or self.source.name)
+            values.update(dir=str(folder), exe=str(folder / exe), copy=str(copy))
+        return values
+
+    def build(self) -> Built:
+        """Build the program, unless an identical build is cached; returns how
+        it went. Raises BuildFailed with the compiler's output when it fails."""
+        if self.setup.build is None:
+            return Built(cached=True, seconds=0.0, messages="")
+        try:
+            code = self.source.read_bytes()
+        except OSError as e:
+            raise CFError(f"Cannot read {self.source}: {e.strerror or e}") from e
+        headers = _headers_stamp(self.setup.build, self.source.parent)
+        always = headers is None or bool(_LOCAL_INCLUDE_RE.search(code))
+        folder = paths.CACHE_DIR / "build" / self._key(code, headers or "")
+        self._folder = folder
+        if (folder / _MARK).is_file() and not always:
+            with contextlib.suppress(OSError):
+                os.utime(folder / _MARK)  # NOTE: still in use, so not pruned
+            return Built(cached=True, seconds=0.0, messages="")
+        _prune()
+        work = folder.with_name(f"{folder.name}.{os.getpid()}.tmp")
+        shutil.rmtree(work, ignore_errors=True)
+        work.mkdir(parents=True)
+        values = self._values(work)
+        if any("{copy}" in word for word in self.setup.build):
+            shutil.copyfile(self.source, values["copy"])
+        argv = fill(self.setup.build, values)
+        started = time.perf_counter()
+        result = process.run(argv, cwd=self.source.parent, timeout=BUILD_TIMEOUT)
+        seconds = time.perf_counter() - started
+        messages = (result.stdout + result.stderr).decode(errors="replace").strip()
+        if not result.ok:
+            shutil.rmtree(work, ignore_errors=True)
+            if result.status == process.TIMEOUT:
+                raise BuildFailed(f"Building {self.name} took over {BUILD_TIMEOUT:g}s", messages)
+            raise BuildFailed(f"{self.name} doesn't compile ({result.reason()})", messages)
+        (work / _MARK).write_text("", encoding="utf-8")
+        if (folder / _MARK).is_file() and not always:
+            shutil.rmtree(work, ignore_errors=True)  # NOTE: another cf built the same meanwhile
+        else:
+            shutil.rmtree(folder, ignore_errors=True)  # NOTE: a half-built or outdated one
+            try:
+                os.replace(work, folder)
+            except OSError:  # NOTE: another cf put its build there just now
+                shutil.rmtree(work, ignore_errors=True)
+        return Built(cached=False, seconds=seconds, messages=messages)
+
+    def argv(self) -> list[str]:
+        """The command that runs the program (after build())."""
+        if self.setup.build is not None and self._folder is None:
+            raise CFError(f"{self.name} isn't built yet")
+        return fill(self.setup.run, self._values(self._folder))
+
+    def run(self, **options) -> process.Result:
+        """Run the built program in its own folder (see process.run for options)."""
+        return process.run(
+            self.argv(), cwd=self.source.parent, big_stack=self.setup.big_stack, **options
+        )
+
+
+_INCLUDE_FLAGS = ("-isystem", "-iquote", "-idirafter", "-I")
+MAX_HEADERS = 5000  # files under -I folders looked at; more: built every time
+
+
+def _headers_stamp(build: tuple[str, ...], base: Path) -> str | None:
+    """What the build's include folders (-I and the like, other than cf-tool's
+    own) hold, as one text that changes whenever a file there does; None when
+    they hold too many files to look at."""
+    from cf_tool.languages import shim_folder
+
+    folders = []
+    for i, word in enumerate(build):
+        for flag in _INCLUDE_FLAGS:
+            if word == flag and i + 1 < len(build):
+                folders.append(build[i + 1])
+            elif word.startswith(flag) and len(word) > len(flag):
+                folders.append(word[len(flag) :])
+            else:
+                continue
+            break
+    own = shim_folder()
+    stamp = []
+    for name in folders:
+        folder = (base / Path(name).expanduser()).resolve()
+        if "{" in name or folder == own.resolve() or not folder.is_dir():
+            continue
+        for root, _, files in os.walk(folder):
+            for file in files:
+                try:
+                    info = os.stat(os.path.join(root, file))
+                except OSError:
+                    continue
+                stamp.append(f"{root}/{file}:{info.st_mtime_ns}:{info.st_size}")
+                if len(stamp) > MAX_HEADERS:
+                    return None
+    return "\n".join(sorted(stamp))
+
+
+def fill(words: tuple[str, ...] | list[str], values: dict[str, str]) -> list[str]:
+    """The words of a command with its placeholders filled in: {src} {exe}
+    {dir} {name} {class} {copy} (the code, copied into {dir} before the
+    build); one left unknown stays as written."""
+    filled = []
+    for word in words:
+        for key, value in values.items():
+            word = word.replace("{" + key + "}", value)
+        filled.append(word)
+    return filled
+
+
+def _prune() -> None:
+    """Remove builds unused for MAX_AGE (once per run)."""
+    global _pruned
+    if _pruned:
+        return
+    _pruned = True
+    now = time.time()
+    for entry in (paths.CACHE_DIR / "build").glob("*"):
+        try:
+            stamp = entry / _MARK
+            age = now - (stamp.stat().st_mtime if stamp.exists() else entry.stat().st_mtime)
+        except OSError:
+            continue
+        if age > MAX_AGE:
+            shutil.rmtree(entry, ignore_errors=True)

cf_tool/cli/__init__.py

@@ -0,0 +1,117 @@
+"""The cf command. Each command's body stays thin: work out the problem and
+the file meant, then call one function; errors end in a red line, not a
+traceback (CF_DEBUG=1 shows the traceback too)."""
+
+from __future__ import annotations
+
+import contextlib
+import signal
+
+import click
+
+from cf_tool import __version__, settings as settings_module, ui
+from cf_tool.cli import account, problems, setup, submitting, testing
+from cf_tool.cli.completion import completion
+
+# cf-tool 0.3's command names, still understood
+ALIASES = {"parse": "get", "gen": "new", "watch": "status", "list": "problems"}
+
+# the commands in the order the help lists them
+ORDER = [
+    "get",
+    "test",
+    "submit",
+    "status",
+    "race",
+    "open",
+    "problems",
+    "contests",
+    "pick",
+    "stress",
+    "listen",
+    "new",
+    "pull",
+    "clone",
+    "login",
+    "logout",
+    "langs",
+    "config",
+    "doctor",
+    "upgrade",
+    "completion",
+]
+
+
+class Group(click.Group):
+    """Commands listed in a useful order, and the old names as aliases."""
+
+    def get_command(self, ctx, cmd_name):
+        return super().get_command(ctx, ALIASES.get(cmd_name, cmd_name))
+
+    def list_commands(self, ctx):
+        names = super().list_commands(ctx)
+        return sorted(names, key=lambda name: ORDER.index(name) if name in ORDER else len(ORDER))
+
+
+@click.group(cls=Group, context_settings={"help_option_names": ["-h", "--help"]})
+# NOTE: CP Editor reads the version as the digits after a v
+@click.version_option(__version__, prog_name="cf", message="cf-tool v%(version)s")
+@click.pass_context
+def main(ctx: click.Context) -> None:
+    """cf-tool: Codeforces from your terminal.
+
+    \b
+    cf get 2050       folders, samples and starter code for contest 2050
+    cd 2050/a
+    cf test           build and run your code on the samples
+    cf submit         submit it, and watch the verdict
+    """
+    if ctx.invoked_subcommand == "completion":
+        return  # NOTE: its output is a script the shell evaluates; notes would break it
+    # NOTE: a stopped cf (kill, a tool's timeout) unwinds like Ctrl-C, so the
+    # \     browser or program it started is closed, not left running
+    with contextlib.suppress(ValueError):  # NOTE: only possible in the main thread
+        signal.signal(signal.SIGTERM, _interrupt)
+    try:
+        notes = settings_module.migrate()
+    except OSError as e:
+        notes = [f"Could not move your old settings ({e})"]
+    for note in notes:
+        ui.yellow(note)
+
+
+def _interrupt(signum, frame) -> None:
+    raise KeyboardInterrupt
+
+
+# one line each in cf --help
+SHORT_HELP = {
+    "get": "Set up problems: folders, samples, starter code",
+    "test": "Run your code on the problem's tests",
+    "submit": "Submit your code and watch the verdict",
+    "status": "Your submissions, refreshed until judged",
+    "race": "Count down to a contest, then get its problems",
+    "open": "Open a problem, the standings, or a submission",
+    "problems": "A contest's problems and how many solved them",
+    "contests": "Upcoming contests",
+    "pick": "A random unsolved problem to practice on",
+    "stress": "Random tests until your code and a brute force differ",
+    "listen": "Receive problems from Competitive Companion",
+    "new": "A code file from your starter code",
+    "pull": "Download the code of your submissions",
+    "clone": "Download the code of all of a user's submissions",
+    "login": "Log in to Codeforces",
+    "logout": "Forget your login",
+    "langs": "How each language is built, run and submitted",
+    "config": "Open the settings in your editor",
+    "doctor": "Check the setup and say how to fix it",
+    "upgrade": "Check GitHub for a newer cf-tool",
+    "completion": "The Tab-completion script for your shell",
+}
+
+for module in (problems, testing, submitting, account, setup):
+    for command in module.COMMANDS:
+        main.add_command(command)
+main.add_command(completion)
+for name, text in SHORT_HELP.items():
+    main.commands[name].short_help = text

cf_tool/cli/account.py

@@ -0,0 +1,32 @@
+"""Commands for your Codeforces account: login and logout."""
+
+from __future__ import annotations
+
+import click
+
+from cf_tool import ui
+from cf_tool.cli.common import ask_login, cf_command, client
+
+
+@click.command()
+@cf_command
+def login() -> None:
+    """Log in to Codeforces (the password is saved encrypted, so an expired
+    login renews itself)."""
+    c = client()
+    if c.handle:
+        ui.plain(f"Logged in as {c.handle} now; logging in again.")
+    ask_login(c)
+
+
+@click.command()
+@cf_command
+def logout() -> None:
+    """Forget your login: the saved password and session."""
+    c = client()
+    who = c.handle
+    c.logout()
+    ui.green(f"Logged out{f' {who}' if who else ''}")
+
+
+COMMANDS = [login, logout]

cf_tool/cli/common.py

@@ -0,0 +1,262 @@
+"""What the commands share: error handling, the settings and the client
+(loaded once per run), finding the problem a command means, logging in on
+the spot, the language for starter code, and building a program."""
+
+from __future__ import annotations
+
+import functools
+import getpass
+import os
+import sys
+import traceback
+import webbrowser
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from cf_tool import languages, ui, workspace
+from cf_tool.build import BuildFailed, Program
+from cf_tool.errors import CFError
+from cf_tool.settings import Settings
+from cf_tool.workspace import ProblemInfo, Target
+
+if TYPE_CHECKING:
+    from cf_tool.codeforces.client import Client
+
+
+def fail(message: str) -> None:
+    if os.environ.get("CF_DEBUG"):
+        traceback.print_exc()
+    ui.red(message)
+    sys.exit(1)
+
+
+def cf_command(f):
+    """A command whose errors end in a red line, not a traceback."""
+
+    @functools.wraps(f)
+    def wrapper(*args, **kwargs):
+        try:
+            return f(*args, **kwargs)
+        except CFError as e:
+            fail(str(e))
+        except OSError as e:  # NOTE: unreadable or unwritable files and the like
+            fail(str(e))
+        except ui.Canceled:
+            ui.dim("Canceled.")
+            sys.exit(1)
+        except KeyboardInterrupt:
+            print("\nInterrupted.")
+            sys.exit(1)
+
+    return wrapper
+
+
+# ┌──────────────────────────────────────────────────────────┐
+# │                  Settings and the client                 │
+# └──────────────────────────────────────────────────────────┘
+
+_settings: Settings | None = None
+_client: "Client | None" = None
+
+
+def settings() -> Settings:
+    """The settings, read once per run; their warnings are shown then."""
+    global _settings
+    if _settings is None:
+        _settings = Settings.load()
+        for warning in _settings.warnings:
+            ui.yellow(warning)
+    return _settings
+
+
+def client() -> "Client":
+    global _client
+    if _client is None:
+        from cf_tool.codeforces.client import Client
+
+        _client = Client(settings())
+    return _client
+
+
+def reset() -> None:
+    """Forget the settings and client read so far (tests run many commands)."""
+    global _settings, _client
+    _settings = _client = None
+
+
+def open_url(url: str) -> None:
+    ui.line(("Opening ", "cyan"), (url, ""))
+    webbrowser.open(url)
+
+
+def short(path: Path | str) -> str:
+    """A path for messages: relative to the current folder when inside it,
+    else with the home folder as ~."""
+    path = Path(path)
+    try:
+        relative = path.resolve().relative_to(Path.cwd().resolve())
+        return str(relative) if str(relative) != "." else "."
+    except ValueError:
+        pass
+    text, home = str(path), str(Path.home())
+    return "~" + text[len(home) :] if text == home or text.startswith(home + os.sep) else text
+
+
+# ┌──────────────────────────────────────────────────────────┐
+# │                   The problem meant                      │
+# └──────────────────────────────────────────────────────────┘
+
+
+def target_of(specs: tuple[str, ...] | list[str], cwd: Path | None = None) -> Target:
+    """The target the arguments name, with the folder filling in the rest."""
+    cwd = cwd or Path.cwd()
+    return workspace.parse_target(list(specs), workspace.here(cwd))
+
+
+def problem_folder_of(target: Target, cwd: Path | None = None) -> Path | None:
+    """The folder of target's problem, wherever it is from here."""
+    return workspace.locate(target, cwd or Path.cwd(), settings().root_folder())
+
+
+def code_file_among(args: tuple[str, ...]) -> tuple[str | None, tuple[str, ...]]:
+    """(the code file among the arguments, the other arguments): an existing
+    file in a known language is the file, not a problem."""
+    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)}")
+    return (files[0] if files else None), tuple(a for a in args if a not in files)
+
+
+# ┌──────────────────────────────────────────────────────────┐
+# │                  Languages and programs                  │
+# └──────────────────────────────────────────────────────────┘
+
+
+def starter_language(asked: str | None = None) -> str:
+    """The language for starter code: the one asked for (-l), else the
+    setting; the first time, the user picks one and it is saved."""
+    current = settings()
+    if asked:
+        key = languages.language_key(asked, current) or asked.lower().lstrip(".")
+        if key not in languages.LANGUAGES and key not in current.languages:
+            raise CFError(f"cf-tool doesn't know the language {asked!r} (cf langs lists them)")
+        return key
+    if current.language:
+        return current.language
+    if not ui.interactive():  # NOTE: nobody to ask: C++, this once
+        ui.yellow("No language picked yet: writing C++ (set language in cf config, or give -l)")
+        return "cpp"
+    keys = [
+        *(
+            key for key in languages.LANGUAGES if key != "c"
+        ),  # NOTE: C++ covers it; .c files still work
+        *(key for key in current.languages if key not in languages.LANGUAGES),
+    ]
+    key = ui.select(
+        "Which language do you write in?",
+        [(languages.display_name(key), key) for key in keys],
+        default="cpp",
+    )
+    current.update("language", key)
+    ui.green(
+        f"Starter code in {languages.display_name(key)} from now on "
+        f"(the language in {short(current.file)}; -l picks another once)"
+    )
+    return key
+
+
+def program(path: Path, key: str | None = None) -> Program:
+    """The code file and how its language builds and runs it here."""
+    key = key or languages.language_key(path, settings())
+    if key is None:
+        raise CFError(f"cf-tool doesn't know what language {path.name} is in")
+    return Program(path, languages.setup(key, settings(), source=path))
+
+
+def build(target: Program) -> None:
+    """Build a program (unless its build is cached), saying so; a compiler
+    error is shown in full, then raised as CFError."""
+    if target.setup.build is None:
+        return
+    try:
+        with ui.status(f"Building {target.name} with {target.setup.tool}..."):
+            built = target.build()
+    except BuildFailed as e:
+        if e.output:
+            ui.plain(e.output)
+        raise CFError(str(e)) from None
+    if not built.cached:
+        ui.line((f"Built {target.name} with {target.setup.tool} in {built.seconds:.1f}s", "dim"))
+    if built.messages:
+        ui.plain(built.messages)
+
+
+def write_starter(folder: Path, target: Target, info: ProblemInfo | None, key: str) -> Path | None:
+    """Write the starter code into a problem's folder as <problem>.<ext>,
+    unless the folder has code in that language already; returns the file
+    written, if any."""
+    language = languages.LANGUAGES.get(key)
+    extensions = language.extensions if language else (key,)
+    has_code = any(
+        entry.suffix.lower().lstrip(".") in extensions and not workspace.is_helper(entry.name)
+        for entry in (folder.iterdir() if folder.is_dir() else [])
+    )
+    path = folder / f"{target.problem.lower()}.{key}"
+    if has_code or path.exists():
+        return None
+    text, _ = languages.starter(key, settings())
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        languages.render(text, starter_values(target, info)), encoding="utf-8", newline=""
+    )
+    return path
+
+
+def starter_values(target: Target | None, info: ProblemInfo | None) -> dict[str, str]:
+    """What starter code's placeholders are filled with."""
+    from cf_tool.codeforces.session import Session
+
+    return {
+        "handle": _client.handle if _client is not None else Session.load().handle,
+        "problem": target.label if target and target.problem else "",
+        "name": info.name if info else "",
+        "url": info.url if info else "",
+    }
+
+
+# ┌──────────────────────────────────────────────────────────┐
+# │                        Logging in                        │
+# └──────────────────────────────────────────────────────────┘
+
+
+def ask_login(c: "Client") -> None:
+    """Ask for the handle and password, and log in."""
+    current = c.session.handle_or_email
+    who = ui.text(
+        "Handle or email:",
+        default=current,
+        validate=lambda s: bool(s.strip()) or "Your Codeforces handle or email",
+        allow_empty=False,
+    )
+    if sys.stdin.isatty():
+        ui.dim("The password stays hidden as you type it.")
+        password = getpass.getpass("Password: ")
+    else:
+        # NOTE: piped in (printf ... | cf login): nothing to hide, and getpass
+        # \     would only warn that it cannot hide it
+        ui.cyan("Password:")
+        password = ui.scanline()
+    if not password:
+        raise CFError("No password: not logged in")
+    c.login(who, password)
+
+
+def ensure_login(c: "Client") -> None:
+    """Log in first when no login is saved (a terminal asks for one)."""
+    if c.can_log_in:
+        return
+    if not ui.interactive():
+        raise CFError("Not logged in: run cf login")
+    ui.yellow("You're not logged in to Codeforces yet.")
+    ask_login(c)