cf-tool-cli 1.0.0__tar.gz

cf_tool_cli-1.0.0/LICENSE

@@ -0,0 +1,48 @@
+MIT License
+
+Copyright (c) 2026 Fau818
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+--------------------------------------------------------------------------------
+
+cf-tool is a Python port of xalanq/cf-tool (https://github.com/xalanq/cf-tool),
+whose license follows:
+
+The MIT License (MIT)
+
+Copyright (c) 2014 Manuel Martínez-Almeida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

cf_tool_cli-1.0.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: cf-tool-cli
+Version: 1.0.0
+Summary: Codeforces from your terminal: get problems, test your code on their samples, submit
+Author: Fau818
+License: MIT
+Project-URL: Homepage, https://github.com/Fau818/cf-tool
+Project-URL: Issues, https://github.com/Fau818/cf-tool/issues
+Project-URL: Changelog, https://github.com/Fau818/cf-tool/blob/main/CHANGELOG.md
+Keywords: codeforces,competitive-programming,cli,cp
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Topic :: Education
+Classifier: Topic :: Software Development :: Testing
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.0
+Requires-Dist: curl_cffi>=0.10.0
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: lxml>=4.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: questionary>=2.0.0
+Requires-Dist: cryptography>=42.0.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: DrissionPage>=4.0.0
+Requires-Dist: tomlkit>=0.12.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.4.0; extra == "dev"
+Requires-Dist: basedpyright>=1.38.0; extra == "dev"
+Dynamic: license-file
+
+# cf-tool
+
+[![CI](https://github.com/Fau818/cf-tool/actions/workflows/ci.yml/badge.svg)](https://github.com/Fau818/cf-tool/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/cf-tool-cli)](https://pypi.org/project/cf-tool-cli/)
+
+Codeforces from your terminal: get a contest, test your code on the samples, submit, and
+watch the verdict. No setup first.
+
+![cf get, cf test and cf submit](https://raw.githubusercontent.com/Fau818/cf-tool/main/docs/images/hero.png)
+
+## Install
+
+```bash
+uv tool install cf-tool-cli   # or: pipx install cf-tool-cli
+```
+
+You need Python 3.10+, a compiler or interpreter for your language, and Google Chrome to
+log in (it works in the background).
+
+## A contest, start to finish
+
+**`cf get 2050`** makes a folder per problem: the statement, the samples and your starter
+code. The first time, cf asks which language you write in.
+
+**`cf test`** builds your code and runs it on the samples. A wrong answer shows the input
+and where your output parts from the answer, down to the test case:
+
+![cf test finding a wrong answer](https://raw.githubusercontent.com/Fau818/cf-tool/main/docs/images/test.png)
+
+**`cf submit`** sends it and shows the verdict as it comes. Once the contest is over, a
+failed test comes with it, as Codeforces keeps it, and is saved for `cf test`:
+
+![a wrong answer and its failed test](https://raw.githubusercontent.com/Fau818/cf-tool/main/docs/images/failed.png)
+
+**`cf status`** lists your submissions, refreshed until they're judged:
+
+![cf status](https://raw.githubusercontent.com/Fau818/cf-tool/main/docs/images/status.png)
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `cf get 2050` / `cf get 2050b` | folders, samples and starter code for a contest or a problem |
+| `cf test [problem] [test...]` | build your code and run it on the problem's tests (`-w`: on every save) |
+| `cf submit [problem] [file]` | submit, then watch the verdict |
+| `cf status [submission]` | your submissions, or one with the test it failed |
+| `cf stress` | random tests until your code and a brute force disagree |
+| `cf race 2050` | count down to the start, then get the problems |
+| `cf open` / `cf problems` / `cf contests` | the problem in the browser, a contest's problems, upcoming contests |
+| `cf pick -r 1600 -t dp` | a random problem you haven't solved |
+| `cf new` / `cf listen` | a code file from your starter code; problems from Competitive Companion |
+| `cf pull` / `cf clone` | download the code of your (or anyone's) submissions |
+| `cf login` / `cf config` / `cf doctor` | log in; settings from menus; check the setup |
+
+More in the [guide](https://github.com/Fau818/cf-tool/blob/main/docs/guide.md): your own
+tests, checkers, interactive problems, settings, CP Editor, Tab completion, coming from
+cf-tool 0.3.
+
+## License
+
+MIT. cf-tool began as a port of [xalanq/cf-tool](https://github.com/xalanq/cf-tool).

cf_tool_cli-1.0.0/README.md

@@ -0,0 +1,61 @@
+# cf-tool
+
+[![CI](https://github.com/Fau818/cf-tool/actions/workflows/ci.yml/badge.svg)](https://github.com/Fau818/cf-tool/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/cf-tool-cli)](https://pypi.org/project/cf-tool-cli/)
+
+Codeforces from your terminal: get a contest, test your code on the samples, submit, and
+watch the verdict. No setup first.
+
+![cf get, cf test and cf submit](https://raw.githubusercontent.com/Fau818/cf-tool/main/docs/images/hero.png)
+
+## Install
+
+```bash
+uv tool install cf-tool-cli   # or: pipx install cf-tool-cli
+```
+
+You need Python 3.10+, a compiler or interpreter for your language, and Google Chrome to
+log in (it works in the background).
+
+## A contest, start to finish
+
+**`cf get 2050`** makes a folder per problem: the statement, the samples and your starter
+code. The first time, cf asks which language you write in.
+
+**`cf test`** builds your code and runs it on the samples. A wrong answer shows the input
+and where your output parts from the answer, down to the test case:
+
+![cf test finding a wrong answer](https://raw.githubusercontent.com/Fau818/cf-tool/main/docs/images/test.png)
+
+**`cf submit`** sends it and shows the verdict as it comes. Once the contest is over, a
+failed test comes with it, as Codeforces keeps it, and is saved for `cf test`:
+
+![a wrong answer and its failed test](https://raw.githubusercontent.com/Fau818/cf-tool/main/docs/images/failed.png)
+
+**`cf status`** lists your submissions, refreshed until they're judged:
+
+![cf status](https://raw.githubusercontent.com/Fau818/cf-tool/main/docs/images/status.png)
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `cf get 2050` / `cf get 2050b` | folders, samples and starter code for a contest or a problem |
+| `cf test [problem] [test...]` | build your code and run it on the problem's tests (`-w`: on every save) |
+| `cf submit [problem] [file]` | submit, then watch the verdict |
+| `cf status [submission]` | your submissions, or one with the test it failed |
+| `cf stress` | random tests until your code and a brute force disagree |
+| `cf race 2050` | count down to the start, then get the problems |
+| `cf open` / `cf problems` / `cf contests` | the problem in the browser, a contest's problems, upcoming contests |
+| `cf pick -r 1600 -t dp` | a random problem you haven't solved |
+| `cf new` / `cf listen` | a code file from your starter code; problems from Competitive Companion |
+| `cf pull` / `cf clone` | download the code of your (or anyone's) submissions |
+| `cf login` / `cf config` / `cf doctor` | log in; settings from menus; check the setup |
+
+More in the [guide](https://github.com/Fau818/cf-tool/blob/main/docs/guide.md): your own
+tests, checkers, interactive problems, settings, CP Editor, Tab completion, coming from
+cf-tool 0.3.
+
+## License
+
+MIT. cf-tool began as a port of [xalanq/cf-tool](https://github.com/xalanq/cf-tool).

cf_tool_cli-1.0.0/cf_tool/__init__.py

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

cf_tool_cli-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_cli-1.0.0/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-1.0.0/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-1.0.0/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]