candidate 0.1.0__tar.gz

candidate-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,137 @@
+# candidate
+
+A CLI tool for competitive programmers to run timed virtual contests using problems from **Codeforces**, **AtCoder**, and **LeetCode**. Problems are pulled from your unsolved pool and tracked in real time as you submit.
+
+---
+
+## Some notable features
+
+- **Virtual contests** on Codeforces, AtCoder, LeetCode, or a mixed set 
+- Provides **tier-based problem selection**: 50% of problems are drawn from tier 1 (easier) and 50% from tier 2 (harder).
+- The tool polls each platform and detects accepted submissions automatically; the contest ends as soon as all problems are solved.
+- It will also auto-detect your session cookies, the tool reads your browser's stored session for AtCoder and LeetCode automatically (Chrome, Brave, Firefox, Safari, Edge, Opera are supported as of now, make sure you use one of these browsers)
+- It supports **tag filtering** (`dp`, `graphs`). Not available in mixed (`x`) mode yet.
+- You can adjust problems by **difficulty ranges and recency** via a `config.toml` file
+
+---
+
+## Requirements
+
+- Python 3.11+
+- For **LeetCode** and **AtCoder**: an account on the respective platform and at least one supported browser installed and logged in (Chrome, Brave, Firefox, Safari, Edge, or Opera)
+- For **Codeforces**: only your handle is needed, no login required
+
+---
+
+## Configuration
+
+Create a `config.toml` file in the project root (in the same directory as `config.example.toml`). Defaults are listed below.
+
+```toml
+
+# don't leave these empty
+
+[handles]
+codeforces = "your_cf_handle" 
+atcoder    = "your_ac_handle" 
+leetcode   = "your_lc_handle"
+
+[codeforces]
+tier1      = [1000, 1500]   # rating range for easier problems 
+tier2      = [1600, 1900]   # rating range for harder problems
+recent_max = 1900 # only include problems from contests >= given number
+
+[atcoder]
+tier1      = [1000, 1200]
+tier2      = [1300, 1800]
+recent_max = 320 # only include problems from ABC/ARC/AGC contests >= given number
+
+[leetcode]
+difficulties = ["MEDIUM", "HARD"] # valid values: "EASY", "MEDIUM", "HARD"
+recent_max   = 2500  # only include problems with number >= given number
+
+[display]
+show_difficulties = false # show difficulty label next to each problem title
+```
+
+If a field is omitted, the following defaults apply:
+
+|Key|Default|
+|---|---|
+|`handles.codeforces`|`""`|
+|`handles.atcoder`|`""`|
+|`handles.leetcode`|`""`|
+|`codeforces.tier1`|`[1000, 1500]`|
+|`codeforces.tier2`|`[1600, 1900]`|
+|`codeforces.recent_max`|`1900`|
+|`atcoder.tier1`|`[1000, 1200]`|
+|`atcoder.tier2`|`[1300, 1800]`|
+|`atcoder.recent_max`|`320`|
+|`leetcode.difficulties`|`["MEDIUM", "HARD"]`|
+|`leetcode.recent_max`|`2500`|
+|`display.show_difficulties`|`false`|
+
+You probably don't want to leave all handles empty. Enter at least one of them.
+
+### `config.toml` options
+
+**`[handles]`**: Your usernames on each platform. Used to filter out problems you've already solved and to check submissions during a contest.
+
+**`[codeforces]`**
+
+- `tier1` / `tier2`: Rating ranges that define the two difficulty buckets. The contest sampler draws 50% of problems from tier 1 and 50% from tier 2.
+- `recent_max`: Filters the problem pool to only include problems from contests with an ID at or above this value.
+
+**`[atcoder]`**
+
+- `tier1` / `tier2`: Same as Codeforces but uses AtCoder's internal difficulty score.
+- `recent_max`: Only problems from ABC/ARC/AGC contests numbered at or above this value are included.
+
+**`[leetcode]`**
+
+- `difficulties`: Which difficulty levels to include in the pool. The sampler treats lower difficulties as tier 1 and higher as tier 2.
+- `recent_max`: Only problems with a frontend ID at or above this value are included.
+
+**`[display]`**
+
+- `show_difficulties`: When `true`, each problem in the contest view shows its difficulty rating or label next to the title. Note that this is OFF by default.
+
+---
+
+## Usage
+
+Just run the tool and follow the interactive setup:
+
+```
+candidate
+```
+
+You will be prompted for:
+
+|Prompt|Description|
+|---|---|
+|**Platform**|`cf` (Codeforces), `ac` (AtCoder), `lc` (LeetCode), `x` (mixed)|
+|**Time limit**|Contest duration in minutes|
+|**Number of problems**|How many problems to include|
+|**Tags**|Optional comma-separated topic filters (e.g. `dp,graphs`). Not supported in mixed mode|
+
+After setup, a preview of the selected problems is shown. Press **Enter** to start the contest or **Ctrl+C** to abort.
+
+During the contest:
+
+- The timer and solve status update every second.
+- Submissions are checked against the platform every 30 seconds.
+- The contest ends automatically when all problems are accepted, or when time runs out.
+- Press **Ctrl+C** at any time to quit early.
+
+---
+
+## Session Cookies
+
+AtCoder and LeetCode require an active session to fetch your submission history and verify solves. `candidate` auto-detects your session cookie from whichever supported browser you use. This requires you to be logged in on both platforms on any supported browser.
+
+Detected cookies are cached in a `.env` file in the project root so subsequent runs are instant. If auto-detection fails (maybe you are not logged in, or the browser is unsupported), the tool will print a clear message explaining how to set the cookie manually in `.env`.
+
+Supported browsers are: **Chrome**, **Brave**, **Firefox**, **Safari**, **Edge**, **Opera**
+
+---

candidate-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires      = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name            = "candidate"
+version         = "0.1.0"
+description     = "CLI tool to practice Competitive Programming and DSA"
+requires-python = ">=3.11"
+
+dependencies    = [
+    "browser-cookie3",
+    "python-dotenv",
+    "requests",
+]
+
+[project.scripts]
+candidate = "candidate.main:run"
+
+[tool.setuptools.packages.find]
+where = ["src"]

candidate-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

candidate-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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/src/candidate.egg-info/PKG-INFO

@@ -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/src/candidate.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/candidate/checkers.py
+src/candidate/config.py
+src/candidate/fetchers.py
+src/candidate/main.py
+src/candidate/network.py
+src/candidate/tracker.py
+src/candidate/ui.py
+src/candidate.egg-info/PKG-INFO
+src/candidate.egg-info/SOURCES.txt
+src/candidate.egg-info/dependency_links.txt
+src/candidate.egg-info/entry_points.txt
+src/candidate.egg-info/requires.txt
+src/candidate.egg-info/top_level.txt

candidate-0.1.0/src/candidate.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

candidate-0.1.0/src/candidate.egg-info/entry_points.txt

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

candidate-0.1.0/src/candidate.egg-info/requires.txt

@@ -0,0 +1,3 @@
+browser-cookie3
+python-dotenv
+requests

candidate-0.1.0/src/candidate.egg-info/top_level.txt

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