candidate 0.1.0__py3-none-any.whl

candidate/checkers.py

@@ -0,0 +1,107 @@
+import time
+import re
+import requests
+from .network import req
+from . import config
+import os
+from dotenv import load_dotenv
+from pathlib import Path
+from .config import *
+
+def _cf_solved_set():
+    data = req(f"https://codeforces.com/api/user.status?handle={config.CF_HANDLE}&from=1&count=15")
+    if not data or data.get("status") != "OK":
+        return set()
+    return {
+        f"{s['problem']['contestId']}-{s['problem']['index']}"
+        for s in data["result"]
+        if s.get("verdict") == "OK" and "contestId" in s["problem"]
+    }
+
+def _ac_solved_set(problems):
+    """
+    Queries AtCoder's personal submission list page per active contest, filtered by AC.
+    Fires exactly one request per contest and safely isolates the table rows.
+    """
+    solved = set()
+
+    contest_ids = set()
+    for p in problems:
+        if p.get("platform") == "ac":
+
+            parts = p["url"].split("/")
+            if len(parts) >= 5:
+                contest_ids.add(parts[4])
+
+    hdrs = {
+        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:152.0) Gecko/20100101 Firefox/152.0"
+    }
+    cookies = {"REVEL_SESSION": AC_SESSION_COOKIE}
+
+    # print(contest_ids)
+    # with open("output.txt", "w", encoding="utf-8") as file:
+    #     file.write("\n".join(str(item) for item in contest_ids))
+
+    for contest_id in contest_ids:
+
+        url = f"https://atcoder.jp/contests/{contest_id}/submissions/me?f.Status=AC"
+        try:
+            r = requests.get(url, headers=hdrs, cookies=cookies, timeout=6)
+            if r.status_code == 200:
+                # print(r.text)
+                # with open("out.txt", "w", encoding="utf-8") as file:
+                #     file.write(r.text)
+                table_match = re.search(r'<table[^>]*>([\s\S]*?)</table>', r.text)
+                if table_match:
+                    table_html = table_match.group(1)
+
+                    pids = re.findall(r'/tasks/([a-zA-Z0-9_]+)', table_html)
+                    solved.update(pids)
+        except Exception:
+            pass  
+
+    # print(solved)
+    return solved
+
+def _lc_solved_set():
+    hdrs = {
+        "content-type": "application/json",
+        "cookie": f"LEETCODE_SESSION={LC_SESSION_COOKIE}",
+        "referer": "https://leetcode.com",
+        "x-csrftoken": "dummy",
+    }
+    q_recent = """
+    query recentAcSubmissions($username: String!, $limit: Int!) {
+      recentAcSubmissionList(username: $username, limit: $limit) {
+        titleSlug
+      }
+    }
+    """
+    data = req("https://leetcode.com/graphql", method="POST",
+                headers=hdrs,
+                json_data={"query": q_recent, "variables": {"username": config.LC_HANDLE, "limit": 15}})
+
+    solved = set()
+    if data and not data.get("errors"):
+        for item in (data["data"].get("recentAcSubmissionList") or []):
+            solved.add(item["titleSlug"])
+    return solved
+
+def check_solved(problems):
+    platforms = {p["platform"] for p in problems}
+    solved_sets = {}
+    
+    if "cf" in platforms:
+        solved_sets["cf"] = _cf_solved_set()
+    if "ac" in platforms:
+        ac_probs = [p for p in problems if p["platform"] == "ac"]
+        solved_sets["ac"] = _ac_solved_set(ac_probs)
+    if "lc" in platforms:
+        solved_sets["lc"] = _lc_solved_set()
+
+    result = {}
+    for p in problems:
+        result[p["id"]] = p["id"] in solved_sets.get(p["platform"], set())
+    return result
+
+

candidate/config.py

@@ -0,0 +1,127 @@
+import os
+import browser_cookie3
+from pathlib import Path
+from dotenv import load_dotenv, set_key
+import tomllib
+
+ENV_PATH = Path(__file__).parent.parent.parent / ".env"
+load_dotenv(ENV_PATH)
+
+BROWSER_LOADERS = [
+    ("Chrome",  browser_cookie3.chrome),
+    ("Brave",   browser_cookie3.brave),
+    ("Firefox", browser_cookie3.firefox),
+    ("Safari",  browser_cookie3.safari),
+    ("Edge",    browser_cookie3.edge),
+    ("Opera",   browser_cookie3.opera),
+]
+
+COOKIE_TARGETS = {
+    "LC_SESSION_COOKIE": {
+        "domain":      "leetcode.com",
+        "cookie_name": "LEETCODE_SESSION",
+        "label":       "LeetCode",
+    },
+    "AC_SESSION_COOKIE": {
+        "domain":      "atcoder.jp",
+        "cookie_name": "REVEL_SESSION",
+        "label":       "AtCoder",
+    },
+}
+
+
+def _detect_from_browsers(domain: str, cookie_name: str) -> tuple[str, str]:
+    for browser_name, loader in BROWSER_LOADERS:
+        try:
+            cj    = loader(domain_name=domain)
+            all_cookies = [(c.name, c.value[:20] + "...") for c in cj]
+            print(f"[debug] {browser_name} cookies for {domain}: {all_cookies}")
+            
+            value = next((c.value for c in cj if c.name == cookie_name), "")
+            if value:
+                return value, browser_name
+        except Exception:
+            continue
+    return "", ""
+
+
+def get_cookie(env_key: str) -> str:
+    target      = COOKIE_TARGETS[env_key]
+    domain      = target["domain"]
+    cookie_name = target["cookie_name"]
+    label       = target["label"]
+
+    existing = os.environ.get(env_key, "")
+    if existing:
+        print(f"[cookies] {label}: loaded from .env")
+        return existing
+
+    print(f"[cookies] {label}: scanning browsers...", end=" ", flush=True)
+    value, browser_name = _detect_from_browsers(domain, cookie_name)
+
+    if value:
+        print(f"found in {browser_name}")
+        set_key(ENV_PATH, env_key, value)
+        os.environ[env_key] = value
+        return value
+
+    print("not found")
+    print(
+        f"[cookies] WARNING: Could not auto-detect {label} session cookie.\n"
+        f"          Log in to {domain.lstrip('.')} in any supported browser, then re-run.\n"
+        f"          Or set {env_key} manually in your .env file."
+    )
+    return ""
+
+
+LC_SESSION_COOKIE = get_cookie("LC_SESSION_COOKIE")
+AC_SESSION_COOKIE = get_cookie("AC_SESSION_COOKIE")
+
+CONFIG_PATH = Path(__file__).parent.parent.parent / "config.toml"
+
+def _load() -> dict:
+    if not CONFIG_PATH.exists():
+        raise FileNotFoundError(
+            f"config.toml not found at {CONFIG_PATH}\n"
+            f"Copy config.example.toml to config.toml and fill in your details."
+        )
+    with open(CONFIG_PATH, "rb") as f:
+        return tomllib.load(f)
+
+_cfg = _load()
+_handles    = _cfg.get("handles", {})
+_cf         = _cfg.get("codeforces", {})
+_ac         = _cfg.get("atcoder", {})
+_lc         = _cfg.get("leetcode", {})
+_display    = _cfg.get("display", {})
+
+# Contest defaults (Don't change these)
+DEFAULT_MINUTES = 120
+NUM_PROBLEMS = 4
+CHECK_INTERVAL = 30
+
+# Handles
+CF_HANDLE = _handles.get("codeforces", "")
+AC_HANDLE = _handles.get("atcoder", "")
+LC_HANDLE = _handles.get("leetcode", "")
+
+# Codeforces
+CF_T1     = tuple(_cf.get("tier1",      [1000, 1500]))
+CF_T2     = tuple(_cf.get("tier2",      [1600, 1900]))
+CF_RECENT = _cf.get("recent_max",       1900)
+
+# AtCoder
+AC_T1     = tuple(_ac.get("tier1",      [1000, 1200]))
+AC_T2     = tuple(_ac.get("tier2",      [1300, 1800]))
+AC_RECENT = _ac.get("recent_max",       320)
+
+# LeetCode
+LC_DIFFICULTIES = _lc.get("difficulties", ["MEDIUM", "HARD"])
+LC_RECENT       = _lc.get("recent_max",   2500)
+
+# Display
+SHOW_DIFFICULTY = _display.get("show_difficulties", False)
+
+BAR_FULL = "█"
+BAR_EMPTY = "░"
+URGENCY = "critical"

candidate/fetchers.py

@@ -0,0 +1,217 @@
+import random
+from .network import req
+from . import config
+import re
+import requests
+
+def cf_fetch_problems(tags=None):
+    solved_data = req(f"https://codeforces.com/api/user.status?handle={config.CF_HANDLE}&from=1&count=10000")
+    solved = set()
+    if solved_data and solved_data.get("status") == "OK":
+        for s in solved_data["result"]:
+            if s.get("verdict") == "OK" and "contestId" in s["problem"]:
+                solved.add(f"{s['problem']['contestId']}-{s['problem']['index']}")
+
+    pool_data = req("https://codeforces.com/api/problemset.problems")
+    if not pool_data or pool_data.get("status") != "OK":
+        return [], []
+
+    t1, t2 = [], []
+    for p in pool_data["result"]["problems"]:
+        if p.get("contestId", 0) < config.CF_RECENT:
+            continue
+        rating = p.get("rating")
+        if rating is None:
+            continue
+        pid = f"{p['contestId']}-{p['index']}"
+        if pid in solved:
+            continue
+        if tags and not set(tags).intersection(set(p.get("tags", []))):
+            continue
+        entry = {
+            "id":         pid,
+            "title":      f"{p['contestId']}{p['index']} - {p['name']}",
+            "url":        f"https://codeforces.com/problemset/problem/{p['contestId']}/{p['index']}",
+            "difficulty": str(rating),
+            "platform":   "cf",
+        }
+        if config.CF_T1[0] <= rating <= config.CF_T1[1]:
+            t1.append(entry)
+        elif config.CF_T2[0] <= rating <= config.CF_T2[1]:
+            t2.append(entry)
+    return t1, t2
+
+def ac_fetch_problems(tags=None):
+
+    # will return a list of problems respecting specified rating and problem recent-ness
+
+    hdrs = {"User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:152.0) Gecko/20100101 Firefox/152.0"}
+
+    # getting all submissions
+    solved_data = req(
+        f"https://kenkoooo.com/atcoder/atcoder-api/v3/user/submissions?user={config.AC_HANDLE}&from_second=0",
+        headers=hdrs,
+    )
+
+    solved = set() # store solved problem ids
+
+    if solved_data:
+        solved = {s["problem_id"] for s in solved_data if s.get("result") == "AC"}
+    try:
+        # this won't work, atcoder doesn't allow viewing submissions so ignore this
+        live_url = f"https://atcoder.jp/submissions?f.User={config.AC_HANDLE}&f.Status=AC"
+
+        r = requests.get(live_url, headers=hdrs, timeout=10)
+        if r.status_code == 200:
+            live_solved = re.findall(r"/contests/[^/]+/tasks/([a-zA-Z0-9_]+)", r.text)
+            solved.update(live_solved)
+    except Exception:
+        pass
+
+
+    probs  = req("https://kenkoooo.com/atcoder/resources/problems.json",       headers=hdrs) # for problems
+    models = req("https://kenkoooo.com/atcoder/resources/problem-models.json", headers=hdrs) # for rating of problems
+
+    if not probs or not models:
+        return [], []
+
+    t1, t2 = [], []
+    for p in probs:
+        pid = p["id"]
+        if pid in solved:
+            continue
+        parts = pid.split("_")
+
+        if parts and parts[0][:3] in ("abc", "arc", "agc"):
+            try:
+                if int(parts[0][3:]) < config.AC_RECENT:
+                    continue
+            except ValueError:
+                continue
+        else: 
+            continue
+
+        model = models.get(pid)
+        if not model or model.get("difficulty") is None:
+            continue
+        diff = model["difficulty"]
+
+        # our problem entry
+        entry = {
+            "id":         pid,
+            "title":      p["title"],
+            "url":        f"https://atcoder.jp/contests/{p['contest_id']}/tasks/{pid}",
+            "difficulty": f"{diff:.0f}",
+            "platform":   "ac",
+        }
+
+        if config.AC_T1[0] <= diff <= config.AC_T1[1]:
+            t1.append(entry)
+        elif config.AC_T2[0] <= diff <= config.AC_T2[1]:
+            t2.append(entry)
+    return t1, t2
+
+def lc_fetch_problems(tags=None):
+    hdrs = {
+        "content-type": "application/json",
+        "cookie": f"LEETCODE_SESSION={config.LC_SESSION_COOKIE}",
+    }
+    query = """
+    query problemsetQuestionList($categorySlug: String, $limit: Int, $skip: Int, $filters: QuestionListFilterInput) {
+      problemsetQuestionList: questionList(categorySlug: $categorySlug, limit: $limit, skip: $skip, filters: $filters) {
+        data { questionFrontendId title titleSlug difficulty status topicTags { slug } }
+      }
+    }
+    """
+    questions  = []
+    lc_solved  = set()
+    for page in range(30):
+        variables = {
+            "categorySlug": "",
+            "skip": page * 100,
+            "limit": 100,
+            "filters": {"orderBy": "FRONTEND_ID", "sortOrder": "DESCENDING", "premiumOnly": False},
+        }
+        data = req("https://leetcode.com/graphql", method="POST",
+                    headers=hdrs, json_data={"query": query, "variables": variables})
+        if not data or "errors" in data:
+            break
+        batch = data["data"]["problemsetQuestionList"]["data"]
+        if not batch:
+            break
+        for q in batch:
+            if q.get("status") == "ac":
+                lc_solved.add(q["titleSlug"])
+        questions.extend(batch)
+        try:
+            if batch and int(batch[-1]["questionFrontendId"]) < config.LC_RECENT:
+                break
+        except (ValueError, KeyError):
+            pass
+
+    allowed = {d.upper() for d in config.LC_DIFFICULTIES}
+    pool = []
+    for q in questions:
+        if q["titleSlug"] in lc_solved:
+            continue
+        if q.get("status") == "ac":
+            continue
+        try:
+            if int(q["questionFrontendId"]) < config.LC_RECENT:
+                continue
+        except ValueError:
+            continue
+        if q["difficulty"].upper() not in allowed:
+            continue
+        if tags:
+            problem_tags = {t["slug"] for t in q.get("topicTags", [])}
+            if not set(tags).intersection(problem_tags):
+                continue
+        pool.append({
+            "id":         q["titleSlug"],
+            "title":      f"{q['questionFrontendId']}. {q['title']}",
+            "url":        f"https://leetcode.com/problems/{q['titleSlug']}/",
+            "difficulty": q["difficulty"],
+            "platform":   "lc",
+        })
+
+    difficulty_rank = {"EASY": 0, "MEDIUM": 1, "HARD": 2}
+    sorted_diffs    = sorted(allowed, key=lambda d: difficulty_rank.get(d, 1))
+    mid             = len(sorted_diffs) // 2
+
+    t1_diffs = set(sorted_diffs[:max(1, mid)])
+    t2_diffs = set(sorted_diffs[max(1, mid):])
+    if not t2_diffs:
+        t2_diffs = t1_diffs
+        t1_diffs = set()
+
+    t1 = [p for p in pool if p["difficulty"].upper() in t1_diffs]
+    t2 = [p for p in pool if p["difficulty"].upper() in t2_diffs]
+    return t1, t2
+
+def mixed_fetch_problems(tags=None):
+    t1, t2 = [], []
+    for fn in (lc_fetch_problems, cf_fetch_problems):
+        a, b = fn(tags)
+        t1 += a
+        t2 += b
+    return t1, t2
+
+def sample_problems(t1, t2, total):
+
+    # get 'total' number of problems
+
+    t2_q = round(total * 0.5) # adjust to change difficulty of later problems
+    t1_q = total - t2_q
+
+    sel2 = random.sample(t2, min(t2_q, len(t2)))
+
+    t1_q += max(0, t2_q - len(sel2))
+
+    sel1 = random.sample(t1, min(t1_q, len(t1)))
+
+    rem  = total - len(sel1) - len(sel2)
+    if rem > 0:
+        extra_pool = [p for p in t2 if p not in sel2]
+        sel2 += random.sample(extra_pool, min(rem, len(extra_pool)))
+    return sel1 + sel2

candidate/main.py

@@ -0,0 +1,187 @@
+import sys
+import time
+import subprocess
+from datetime import datetime, timedelta
+
+from . import config
+from .ui import (
+    tw, clr, clear_screen, draw_banner, draw_contest, draw_done,
+    platform_badge, diff_colour, hyperlink, fmt, C
+)
+from .fetchers import (
+    cf_fetch_problems, ac_fetch_problems, lc_fetch_problems,
+    mixed_fetch_problems, sample_problems
+)
+from .tracker import SolveTracker
+
+def send_notification(msg_title, msg_body):
+    try:
+        subprocess.Popen(["notify-send", "--urgency", config.URGENCY,
+                          "--app-name", "CP Timer", msg_title, msg_body])
+    except FileNotFoundError:
+        pass
+
+def prompt_setup():
+    width = tw()
+    clear_screen()
+    print()
+    draw_banner(width)
+    print()
+
+    print(clr("  CONTEST SETUP", C.WHITE, C.BOLD))
+    print(clr("  " + "─" * 40, C.GREY))
+    print()
+
+    def ask(prompt, default=None):
+        suffix = f" [{default}]" if default is not None else ""
+        val = input(clr(f"  {prompt}{suffix}: ", C.CYAN)).strip()
+        return val if val else str(default)
+
+    platform = ask("Platform (cf / ac / lc / x for mixed)", "lc").lower()
+    while platform not in ("cf", "ac", "lc", "x"):
+        print(clr("  Invalid. Choose cf, ac, lc, or x.", C.RED))
+        platform = ask("Platform", "lc").lower()
+
+    mins_raw = ask("Time limit (minutes)", config.DEFAULT_MINUTES)
+    try:
+        total = int(mins_raw) * 60
+    except ValueError:
+        total = config.DEFAULT_MINUTES * 60
+
+    num_raw = ask("Number of problems", config.NUM_PROBLEMS)
+    try:
+        num = int(num_raw)
+    except ValueError:
+        num = config.NUM_PROBLEMS
+
+    tags_raw = ask("Filter tags (comma-separated, or leave blank)", "")
+    tags = [t.strip() for t in tags_raw.split(",") if t.strip()] if tags_raw else []
+
+    print()
+    print(clr(f"  Fetching problems from {platform.upper()}...", C.YELLOW))
+    print()
+
+    if platform == "cf":
+        t1, t2 = cf_fetch_problems(tags)
+    elif platform == "ac":
+        t1, t2 = ac_fetch_problems(tags)
+    elif platform == "lc":
+        t1, t2 = lc_fetch_problems(tags)
+    else:
+        t1, t2 = mixed_fetch_problems(tags)
+
+    print(clr(f"  Pool: {len(t1)} tier-1 + {len(t2)} tier-2 candidates", C.GREY))
+
+    if not t1 and not t2:
+        print(clr("  No problems found. Check handles / cookie / tags.", C.RED))
+        sys.exit(1)
+
+    problems = sample_problems(t1, t2, num)
+
+    if not problems:
+        print(clr("  Could not sample enough problems.", C.RED))
+        sys.exit(1)
+
+    print(clr(f"  Selected {len(problems)} problems.", C.GREEN))
+    print()
+
+    clear_screen()
+    print()
+    draw_banner(width)
+    print()
+    print(clr("  CONTEST PREVIEW", C.WHITE, C.BOLD))
+    print(clr("  " + "─" * 40, C.GREY))
+    print()
+    print(clr(f"  Platform : {platform.upper()}", C.GREY))
+    print(clr(f"  Duration : {total // 60} min", C.GREY))
+    print(clr(f"  Problems : {len(problems)}", C.GREY))
+    print()
+    print(clr("  " + "─" * 40, C.GREY))
+    
+    for i, prob in enumerate(problems):
+        badge = platform_badge(prob["platform"])
+        title_link = hyperlink(prob["url"], prob["title"])
+        num_str   = clr(f"  {i+1:>2}.", C.GREY)
+        title = clr(title_link, C.WHITE)
+        diff  = clr(f"  {prob['difficulty']}", diff_colour(prob["difficulty"])) if config.SHOW_DIFFICULTY else ""
+        print(f"{num_str} {badge} {title}{diff}")
+    print()
+    print(clr("  " + "─" * 40, C.GREY))
+    print()
+    print(clr("  Press Enter to start the contest, Ctrl+C to abort.", C.CYAN))
+    print()
+    try:
+        input()
+    except KeyboardInterrupt:
+        print(clr("\n  Aborted.\n", C.GREY))
+        sys.exit(0)
+
+    return problems, total
+
+def run():
+    problems, total = prompt_setup()
+
+    start_dt = datetime.now()
+    end_dt   = start_dt + timedelta(seconds=total)
+
+    tracker = SolveTracker(problems, start_dt)
+    tracker.start()
+
+    print("\033[?25l", end="", flush=True)
+
+    try:
+        while True:
+            elapsed = (datetime.now() - start_dt).total_seconds()
+            status, solve_times, last_check = tracker.snapshot()
+
+            width = tw()
+            clear_screen()
+            print()
+            draw_banner(width)
+            print()
+
+            frame = draw_contest(elapsed, total, start_dt, end_dt,
+                                 problems, status, solve_times, last_check, width)
+            print("\n".join(frame), flush=True)
+
+            if elapsed >= total:
+                send_notification("Contest Over", f"Time's up! {sum(status.values())}/{len(problems)} solved.")
+                break
+
+            if tracker.all_solved():
+                send_notification("Contest Complete!", f"All {len(problems)} problems solved in {fmt(elapsed)}!")
+                break
+
+            time.sleep(1)
+
+        # Final results
+        elapsed = (datetime.now() - start_dt).total_seconds()
+        status, solve_times, _ = tracker.snapshot()
+        tracker.stop()
+
+        clear_screen()
+        print()
+        draw_banner(tw())
+        print()
+        lines = draw_done(problems, solve_times, elapsed, total, tw())
+        print("\n".join(lines))
+        print("\a", end="", flush=True)
+
+    except KeyboardInterrupt:
+        elapsed = (datetime.now() - start_dt).total_seconds()
+        status, solve_times, _ = tracker.snapshot()
+        tracker.stop()
+
+        clear_screen()
+        print()
+        draw_banner(tw())
+        print()
+        lines = draw_done(problems, solve_times, elapsed, total, tw())
+        print("\n".join(lines))
+        print(clr("\n  Quit early.\n", C.GREY))
+
+    finally:
+        print("\033[?25h", end="", flush=True)   # restore cursor
+
+if __name__ == "__main__":
+    run()

candidate/network.py

@@ -0,0 +1,22 @@
+import time
+import requests
+
+
+def req(url, method="GET", headers=None, json_data=None, retries=3):
+    for attempt in range(retries):
+        try:
+            if method == "POST":
+                r = requests.post(url, headers=headers, json=json_data, timeout=15)
+            else:
+                r = requests.get(url, headers=headers, timeout=12)
+            r.raise_for_status()
+            return r.json()
+        except requests.exceptions.HTTPError as e:
+            sc = e.response.status_code
+            if sc in (429, 500, 502, 503, 504):
+                time.sleep(2 ** attempt)
+            else:
+                return None
+        except Exception:
+            time.sleep(2 ** attempt)
+    return None

candidate/tracker.py

@@ -0,0 +1,54 @@
+import threading
+from datetime import datetime
+from .checkers import check_solved
+from .config import CHECK_INTERVAL
+
+class SolveTracker:
+    def __init__(self, problems, start_dt):
+        self.problems    = problems
+        self.start_dt    = start_dt
+        self.status      = {p["id"]: False for p in problems}
+        self.solve_times = {}
+        self.last_check  = None
+        self._lock       = threading.Lock()
+        self._stop       = threading.Event()
+
+    def start(self):
+        self._thread = threading.Thread(target=self._loop, daemon=True)
+        self._thread.start()
+
+    def stop(self):
+        self._stop.set()
+
+    def _loop(self):
+        self._do_check()
+        while not self._stop.is_set():
+            slept = 0
+            while slept < CHECK_INTERVAL and not self._stop.is_set():
+                self._stop.wait(1)
+                slept += 1
+            if not self._stop.is_set():
+                self._do_check()
+
+    def _do_check(self):
+        check_started = datetime.now()
+        with self._lock:
+            self.last_check = check_started
+        try:
+            fresh   = check_solved(self.problems)
+            elapsed = (datetime.now() - self.start_dt).total_seconds()
+            with self._lock:
+                for pid, solved in fresh.items():
+                    if solved and not self.status[pid]:
+                        self.solve_times[pid] = elapsed
+                    self.status[pid] = solved
+        except Exception:
+            pass
+
+    def snapshot(self):
+        with self._lock:
+            return dict(self.status), dict(self.solve_times), self.last_check
+
+    def all_solved(self):
+        with self._lock:
+            return all(self.status.values())

candidate/ui.py

@@ -0,0 +1,253 @@
+import shutil
+from datetime import datetime
+from .config import BAR_FULL, BAR_EMPTY, SHOW_DIFFICULTY, CHECK_INTERVAL
+
+class C:
+    RESET  = "\033[0m"
+    BOLD   = "\033[1m"
+    DIM    = "\033[2m"
+    WHITE  = "\033[97m"
+    CYAN   = "\033[96m"
+    GREEN  = "\033[92m"
+    YELLOW = "\033[93m"
+    RED    = "\033[91m"
+    GREY   = "\033[90m"
+    BLUE   = "\033[94m"
+
+def clr(text, *codes):
+    return "".join(codes) + text + C.RESET
+
+def hyperlink(url, text):
+    return f"\033]8;;{url}\033\\{text}\033]8;;\033\\"
+
+def tw():
+    return shutil.get_terminal_size((80, 24)).columns
+
+def fmt(seconds):
+    seconds = max(0, int(seconds))
+    h, r = divmod(seconds, 3600)
+    m, s = divmod(r, 60)
+    return f"{h:02d}:{m:02d}:{s:02d}"
+
+def clear_screen():
+    print("\033[2J\033[H", end="", flush=True)
+
+BANNER = [
+    "  ██████╗██████╗     ████████╗██╗███╗   ███╗███████╗██████╗ ",
+    " ██╔════╝██╔══██╗       ██╔══╝██║████╗ ████║██╔════╝██╔══██╗",
+    " ██║     ██████╔╝       ██║   ██║██╔████╔██║█████╗  ██████╔╝",
+    " ██║     ██╔═══╝        ██║   ██║██║╚██╔╝██║██╔══╝  ██╔══██╗",
+    " ╚██████╗██║            ██║   ██║██║ ╚═╝ ██║███████╗██║  ██║",
+    "  ╚═════╝╚═╝            ╚═╝   ╚═╝╚═╝     ╚═╝╚══════╝╚═╝  ╚═╝",
+]
+
+def draw_banner(width):
+    bw  = max(len(l) for l in BANNER)
+    pad = max(0, (width - bw) // 2)
+    for line in BANNER:
+        print(clr(" " * pad + line, C.CYAN, C.BOLD))
+
+def progress_bar(elapsed, total, width):
+    ratio  = min(elapsed / total, 1.0) if total else 1.0
+    filled = int(ratio * width)
+    colour = C.GREEN if ratio < 0.5 else (C.YELLOW if ratio < 0.8 else C.RED)
+    return clr(BAR_FULL * filled, colour, C.BOLD) + clr(BAR_EMPTY * (width - filled), C.GREY)
+
+def diff_colour(diff_str):
+    d = diff_str.upper()
+    if d in ("EASY",) or (d.isdigit() and int(d) < 1200):
+        return C.GREEN
+    if d in ("MEDIUM",) or (d.isdigit() and 1200 <= int(d) < 1800):
+        return C.YELLOW
+    return C.RED
+
+def platform_badge(platform):
+    badges = {"cf": clr(" CF ", C.BOLD, C.BLUE),
+              "ac": clr(" AC ", C.BOLD, C.CYAN),
+              "lc": clr(" LC ", C.BOLD, C.YELLOW)}
+    return badges.get(platform, platform.upper())
+
+def draw_contest(elapsed, total, start_dt, end_dt,
+                 problems, solve_status, solve_times, last_check, width):
+    remaining = max(0, total - elapsed)
+    ratio     = min(elapsed / total, 1.0) if total else 1.0
+
+    if remaining <= 300:
+        clk_col = (C.RED, C.BOLD)
+    elif remaining <= 900:
+        clk_col = (C.YELLOW, C.BOLD)
+    else:
+        clk_col = (C.WHITE, C.BOLD)
+
+    inner_w = min(width - 4, 70)
+    box_w   = inner_w + 4
+    lpad    = max(0, (width - box_w) // 2)
+    ind     = " " * lpad
+    border  = clr("│", C.GREY)
+
+    def hline(): return ind + clr("┌" + "─" * (box_w - 2) + "┐", C.GREY)
+    def bline(): return ind + clr("└" + "─" * (box_w - 2) + "┘", C.GREY)
+    def mline(): return ind + clr("├" + "─" * (box_w - 2) + "┤", C.GREY)
+
+    def cline(s, raw=None):
+        vis = raw if raw is not None else len(s)
+        pad = inner_w - vis
+        lp  = pad // 2
+        rp  = pad - lp
+        return ind + border + "  " + " " * lp + s + " " * rp + "  " + border
+
+    def lline(s, raw=None):
+        vis  = raw if raw is not None else len(s)
+        rpad = inner_w - vis
+        return ind + border + "  " + s + " " * rpad + "  " + border
+
+    out = []
+    out.append(hline())
+    rem_s = fmt(remaining)
+    out.append(cline(clr(rem_s, *clk_col), raw=len(rem_s)))
+
+    sub = f"elapsed {fmt(elapsed)}  /  total {fmt(total)}"
+    out.append(cline(clr(sub, C.GREY), raw=len(sub)))
+    out.append(mline())
+
+    bar = progress_bar(elapsed, total, inner_w)
+    out.append(ind + border + "  " + bar + "  " + border)
+
+    pct = f"{ratio*100:5.1f}%"
+    out.append(cline(clr(pct, C.DIM), raw=len(pct)))
+    out.append(mline())
+
+    ts = f"started {start_dt.strftime('%H:%M:%S')}   ends {end_dt.strftime('%H:%M:%S')}"
+    out.append(cline(clr(ts, C.GREY), raw=len(ts)))
+    out.append(mline())
+
+    solved_count = sum(1 for p in problems if solve_status.get(p["id"]))
+    header = f"  PROBLEMS  {solved_count}/{len(problems)} solved"
+    out.append(lline(clr(header, C.WHITE, C.BOLD), raw=len(header)))
+    out.append(mline())
+
+    for i, prob in enumerate(problems):
+        pid      = prob["id"]
+        is_done  = solve_status.get(pid, False)
+        solved_t = solve_times.get(pid)
+
+        glyph = clr("[+]", C.GREEN, C.BOLD) if is_done else clr("[ ]", C.GREY)
+        badge = platform_badge(prob["platform"])
+
+        if is_done and solved_t:
+            right_str  = f"+{fmt(solved_t)}"
+            right_disp = clr(right_str, C.GREEN)
+            right_raw  = len(right_str)
+        elif SHOW_DIFFICULTY:
+            diff_str   = prob["difficulty"]
+            right_str  = f"{diff_str:>6}"
+            right_disp = clr(right_str, diff_colour(diff_str))
+            right_raw  = len(right_str)
+        else:
+            right_str  = ""
+            right_disp = ""
+            right_raw  = 0
+
+        fixed_raw  = 3 + 1 + 4 + 1
+        right_slot = right_raw + (2 if right_raw else 0)
+        max_title  = inner_w - fixed_raw - right_slot
+
+        title_plain = prob["title"]
+        if len(title_plain) > max_title:
+            title_plain = title_plain[:max_title - 1] + "…"
+
+        title_linked = hyperlink(prob["url"], title_plain)
+        title_col    = C.GREEN if is_done else C.WHITE
+        title_disp   = clr(title_linked, title_col)
+
+        content_raw = len(title_plain)
+        pad = max(0, inner_w - fixed_raw - content_raw - right_slot)
+
+        line = (glyph + " " + badge + " " +
+                title_disp +
+                " " * pad +
+                ("  " if right_raw else "") +
+                right_disp)
+
+        out.append(lline(line, raw=inner_w))
+
+    out.append(mline())
+
+    if last_check:
+        age = int((datetime.now() - last_check).total_seconds())
+        chk = f"last checked {age}s ago  |  polls every {CHECK_INTERVAL}s  |  Ctrl+C to quit"
+    else:
+        chk = f"waiting for first check...  |  Ctrl+C to quit"
+    out.append(cline(clr(chk, C.GREY), raw=len(chk)))
+    out.append(bline())
+
+    return out
+
+def draw_done(problems, solve_times, elapsed, total, width):
+    inner_w = min(width - 4, 70)
+    box_w   = inner_w + 4
+    lpad    = max(0, (width - box_w) // 2)
+    ind     = " " * lpad
+    border  = clr("│", C.GREY)
+
+    def hline(): return ind + clr("┌" + "─" * (box_w - 2) + "┐", C.GREY)
+    def bline(): return ind + clr("└" + "─" * (box_w - 2) + "┘", C.GREY)
+    def mline(): return ind + clr("├" + "─" * (box_w - 2) + "┤", C.GREY)
+    def cline(s, raw=None):
+        vis = raw if raw is not None else len(s)
+        pad = inner_w - vis
+        lp  = pad // 2; rp = pad - lp
+        return ind + border + "  " + " " * lp + s + " " * rp + "  " + border
+    def lline(s, raw=None):
+        vis = raw if raw is not None else len(s)
+        return ind + border + "  " + s + " " * max(0, inner_w - vis) + "  " + border
+
+    solved_count = sum(1 for p in problems if solve_times.get(p["id"]) is not None)
+    all_done     = solved_count == len(problems)
+
+    lines = []
+    lines.append(hline())
+    msg     = "ALL PROBLEMS SOLVED" if all_done else "CONTEST OVER"
+    msg_col = C.GREEN if all_done else C.RED
+    lines.append(cline(clr(msg, msg_col, C.BOLD), raw=len(msg)))
+    sub = f"{solved_count}/{len(problems)} solved  |  {fmt(elapsed)} elapsed"
+    lines.append(cline(clr(sub, C.GREY), raw=len(sub)))
+    lines.append(mline())
+
+    if SHOW_DIFFICULTY:
+        hdr = f"  {'#':>2}  {'Problem':<33}  {'Diff':>6}  {'Time':>10}"
+    else:
+        hdr = f"  {'#':>2}  {'Problem':<42}  {'Time':>10}"
+    lines.append(lline(clr(hdr, C.WHITE, C.BOLD), raw=len(hdr)))
+    lines.append(mline())
+
+    for i, prob in enumerate(problems):
+        pid    = prob["id"]
+        st     = solve_times.get(pid)
+        done   = st is not None
+        t_str  = f"+{fmt(st)}" if done else "unsolved"
+        t_col  = C.GREEN if done else C.GREY
+        t_disp = clr(f"{t_str:>10}", t_col)
+
+        if SHOW_DIFFICULTY:
+            title = prob["title"]
+            if len(title) > 33: title = title[:32] + "…"
+            diff_disp = clr(f"{prob['difficulty']:>6}", diff_colour(prob["difficulty"]))
+            title_link = hyperlink(prob["url"], title)
+            title_disp = clr(title_link, C.WHITE if done else C.DIM)
+            row_plain  = f"  {i+1:>2}  {title:<33}  "
+            row_disp   = clr(f"  {i+1:>2}  ", C.WHITE if done else C.DIM) + title_disp + clr("  ", C.RESET)
+            vis        = len(row_plain) + 6 + 2 + 10
+            lines.append(lline(row_disp + diff_disp + clr("  ", C.RESET) + t_disp, raw=vis))
+        else:
+            title = prob["title"]
+            if len(title) > 42: title = title[:41] + "…"
+            title_link = hyperlink(prob["url"], title)
+            title_disp = clr(title_link, C.WHITE if done else C.DIM)
+            row_plain  = f"  {i+1:>2}  {title:<42}  "
+            row_disp   = clr(f"  {i+1:>2}  ", C.WHITE if done else C.DIM) + title_disp + clr("  ", C.RESET)
+            vis        = len(row_plain) + 10
+            lines.append(lline(row_disp + t_disp, raw=vis))
+
+    lines.append(bline())
+    return lines

candidate-0.1.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: candidate
+Version: 0.1.0
+Summary: CLI tool to practice Competitive Programming and DSA
+Requires-Python: >=3.11
+Requires-Dist: browser-cookie3
+Requires-Dist: python-dotenv
+Requires-Dist: requests

candidate-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+candidate/checkers.py,sha256=SgoFYBeCFceEpP7Ip4qCsD407sGLalWcLYT4HmFog4I,3390
+candidate/config.py,sha256=V_2B7sMXV5AMZrr5RG0tPyUuLU8BQ4M_Bj-x2jS7pEk,3766
+candidate/fetchers.py,sha256=VO51D58uPbUvlK7Fn3SdKIW2GqN6CG9NUflCdZ9AQT4,7436
+candidate/main.py,sha256=Gfx2hygmUIp-LF96CogO8q4bnxlc4WX9Un7GKit0fZw,5708
+candidate/network.py,sha256=ulRyZKTKeRpTUkArBGTdUfdvyywENiwNvz3UWgB1e4Y,714
+candidate/tracker.py,sha256=IXVfExpvYhGGTLrfPkmCUlz9-cEUzMivWrvElkNQJDw,1721
+candidate/ui.py,sha256=gpCXYGpAtaQ6-1omroMOaUcb3q79fhAxXRbRteMCbC4,9773
+candidate-0.1.0.dist-info/METADATA,sha256=2e9VG8hau01uGXHj3TCOyYI6DktTP5_pAa6oPZtNMx8,223
+candidate-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+candidate-0.1.0.dist-info/entry_points.txt,sha256=QXrDXR1CtoOwcJMV7IIRsjB02meJ-dN4NIs5I9Z23n0,49
+candidate-0.1.0.dist-info/top_level.txt,sha256=HoEnDxpH3OIqLkmFJQx0suM3RENzTxSSsD6izSr07Eg,10
+candidate-0.1.0.dist-info/RECORD,,

candidate-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

candidate-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+candidate = candidate.main:run

candidate-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+candidate