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

cf_tool/codeforces/session.py

@@ -0,0 +1,103 @@
+"""The login session ($XDG_STATE_HOME/cf/session, mode 0600): the handle, the
+credentials (the password encrypted, see crypto.py), the cookies with the
+User-Agent they were issued to, and the last submission (for cf open --last).
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from cf_tool import paths, ui
+from cf_tool.codeforces.http import CookieDict
+
+# what a submission is remembered by, for cf open --last
+LAST_KEYS = ("kind", "contest", "problem", "group", "submission")
+
+
+@dataclass
+class Session:
+    path: Path
+    handle: str = ""
+    handle_or_email: str = ""
+    password: str = ""  # encrypted, see crypto.py
+    ftaa: str = ""
+    bfaa: str = ""
+    user_agent: str = ""
+    cookies: list[CookieDict] = field(default_factory=list)
+    last_submission: dict[str, str] | None = None
+
+    @classmethod
+    def load(cls, path: Path | None = None) -> "Session":
+        """The session stored at path; an empty one if missing or unreadable."""
+        path = path or paths.session_file()
+        try:
+            data = json.loads(path.read_text(encoding="utf-8"))
+        except FileNotFoundError:
+            return cls(path)
+        except (OSError, ValueError) as e:
+            ui.yellow(f"Ignoring the unreadable session {path} ({e}): run cf login again")
+            return cls(path)
+        if not isinstance(data, dict):
+            ui.yellow(f"Ignoring the malformed session {path}: run cf login again")
+            return cls(path)
+        last = data.get("last_submission")
+        return cls(
+            path=path,
+            handle=_text(data.get("handle")),
+            handle_or_email=_text(data.get("handle_or_email")),
+            password=_text(data.get("password")),
+            ftaa=_text(data.get("ftaa")),
+            bfaa=_text(data.get("bfaa")),
+            user_agent=_text(data.get("user_agent")),
+            cookies=_read_cookies(data.get("cookies")),
+            last_submission=_read_last(last) if isinstance(last, dict) else None,
+        )
+
+    def save(self) -> None:
+        data = {
+            "handle": self.handle,
+            "handle_or_email": self.handle_or_email,
+            "password": self.password,
+            "ftaa": self.ftaa,
+            "bfaa": self.bfaa,
+            "user_agent": self.user_agent,
+            "cookies": self.cookies,
+            "last_submission": self.last_submission,
+        }
+        paths.write_atomic(self.path, json.dumps(data, indent=2) + "\n", mode=0o600)
+
+
+def _text(value: Any) -> str:
+    return value if isinstance(value, str) else ""
+
+
+def _read_cookies(raw: Any) -> list[CookieDict]:
+    if not isinstance(raw, list):
+        return []
+    return [
+        {
+            "name": c["name"],
+            "value": _text(c.get("value")),
+            "domain": c["domain"],
+            "path": _text(c.get("path")) or "/",
+            "secure": bool(c.get("secure")),
+            "expires": c.get("expires") if isinstance(c.get("expires"), (int, float)) else None,
+        }
+        for c in raw
+        if isinstance(c, dict) and _text(c.get("name")) and _text(c.get("domain"))
+    ]
+
+
+def _read_last(last: dict) -> dict[str, str]:
+    """The last submission, also as cf-tool 0.3 saved it (problem_type, contest_id, ...)."""
+    old = {
+        "kind": "problem_type",
+        "contest": "contest_id",
+        "problem": "problem_id",
+        "group": "group_id",
+        "submission": "submission_id",
+    }
+    return {key: _text(last.get(key, last.get(old[key]))) for key in LAST_KEYS}

cf_tool/doctor.py

@@ -0,0 +1,124 @@
+"""cf doctor: check the setup and say how to fix what's wrong, changing
+nothing. It checks, in this order:
+- the settings file
+- each language that matters (the one for starter code, those set in
+  config.toml): its compiler, its starter file, what it submits as
+- the login, over plain HTTP (no browser)
+- Chrome, needed when Cloudflare checks the login"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable, Mapping
+
+from cf_tool import languages
+from cf_tool.codeforces import browser, pages
+from cf_tool.errors import CFError, CloudflareChallengeError
+from cf_tool.settings import Settings
+
+OK, WARN, ERROR = "ok", "warn", "error"
+
+
+@dataclass(frozen=True)
+class Finding:
+    level: str  # OK, WARN or ERROR
+    text: str
+    fix: str = ""  # how to put it right
+
+
+def check_language(
+    key: str,
+    settings: Settings,
+    offered: Mapping[str, str],
+    live: bool,
+    machine: languages.Machine | None = None,
+) -> list[Finding]:
+    """What's wrong with one language; all good: one OK. Errors: no
+    compiler, a missing starter file; a warning: Codeforces doesn't offer
+    the language it is set to submit as (checked when logged in)."""
+    name = languages.display_name(key)
+    try:
+        setup = languages.setup(key, settings, offered=offered, machine=machine)
+    except CFError as e:
+        return [Finding(ERROR, f"{name}: {e}")]
+    findings = []
+    try:
+        _, origin = languages.starter(key, settings)
+    except CFError as e:
+        findings.append(Finding(ERROR, f"{name}: {e}", f"fix template in [{key}] of config.toml"))
+        origin = ""
+    if setup.submit is None:
+        wanted = settings.language_settings(key).submit or name
+        level = WARN if live else OK
+        findings.append(
+            Finding(
+                level,
+                f"{name}: Codeforces doesn't offer {wanted}"
+                + ("" if live else " (not checked: not logged in)"),
+                "cf submit lets you pick another" if live else "",
+            )
+        )
+    if not findings:
+        starter = "the built-in starter" if origin == "built-in" else origin
+        unchecked = "" if live else " (the list isn't checked: not logged in)"
+        findings.append(
+            Finding(
+                OK,
+                f"{name}: {setup.tool}, submits as {setup.submit[1] if setup.submit else '?'}, "
+                f"starts from {starter}{unchecked}",
+            )
+        )
+    return findings
+
+
+def check_login(client) -> tuple[Finding, bool]:
+    """Whether Codeforces sees the saved session logged in: (finding, logged in).
+    - logged in: OK
+    - Cloudflare checks this connection, or it fails: a warning
+    - a saved login that expired: a warning (cf logs in again by itself)
+    - no saved login: an error"""
+    try:
+        body = client.gw.get(client.host, browser_fallback=False)
+    except CloudflareChallengeError:
+        finding = Finding(
+            WARN,
+            "Cloudflare is checking this connection right now",
+            "cf passes the check in a browser when it has to",
+        )
+        return finding, False
+    except CFError as e:
+        return Finding(WARN, f"Cannot reach {client.host}: {e}"), False
+    handle = pages.find_handle(body)
+    if handle:
+        return Finding(OK, f"Logged in as {handle}"), True
+    if client.can_log_in:
+        finding = Finding(
+            WARN, "The saved login has expired", "the next command that needs it logs in again"
+        )
+        return finding, False
+    return Finding(WARN, "Not logged in", "cf login (cf submit also asks when it needs to)"), False
+
+
+def check_chrome(find: Callable[[], "str | None"] = browser.find_chrome) -> Finding:
+    """Whether Chrome is installed: OK, or a warning."""
+    where = find()
+    if where:
+        return Finding(OK, f"Chrome: {where}")
+    return Finding(
+        WARN,
+        "Chrome not found: logging in fails when Cloudflare checks it",
+        "install Google Chrome or Chromium",
+    )
+
+
+def run(settings: Settings, client) -> list[Finding]:
+    """Every finding, in the order cf doctor prints them."""
+    findings = [Finding(WARN, warning, "fix it in config.toml") for warning in settings.warnings]
+    login, logged_in = check_login(client)
+    offered, live = client.languages() if logged_in else (languages.known_languages(), False)
+    keys = list(dict.fromkeys([settings.language or "cpp", *settings.languages]))
+    if not settings.language:
+        findings.append(Finding(OK, "No language picked yet: cf get asks for one"))
+    for key in keys:
+        findings += check_language(key, settings, offered, live)
+    return findings + [login, check_chrome()]

cf_tool/errors.py

@@ -0,0 +1,37 @@
+"""Exception types shared across cf-tool modules.
+
+The login tiers (gateway.py) escalate on CFError, but stop at once on
+LoginRejected (Codeforces said no — another tier would only repeat it) and on
+BrowserUnavailable (no Chrome — a window would fail the same way).
+"""
+
+
+class CFError(Exception):
+    """Base error: message is shown to the user in red, without a traceback."""
+
+
+class NotLoggedInError(CFError):
+    """Raised when Codeforces reports the session is not authenticated."""
+
+    def __init__(self, message: str = "Not logged in: run cf login") -> None:
+        super().__init__(message)
+
+
+class CloudflareChallengeError(CFError):
+    """Raised when a response is a check page (Cloudflare's, or Codeforces' own)
+    instead of real content."""
+
+    def __init__(self, message: str = "Blocked by a Cloudflare challenge") -> None:
+        super().__init__(message)
+
+
+class LoginRejected(CFError):
+    """Codeforces itself rejected the login (e.g. wrong handle or password)."""
+
+
+class BrowserError(CFError):
+    """The browser fallback failed while driving a page."""
+
+
+class BrowserUnavailable(BrowserError):
+    """Chrome/Chromium could not be started at all."""