codeforces 0.1.2__py3-none-any.whl

cf/__init__.py

@@ -0,0 +1,94 @@
+import sys
+
+# Oldest Python we support, and the newest release this was tested against.
+MIN_PYTHON = (3, 9)
+LATEST_TESTED_PYTHON = (3, 14)
+
+
+def _check_python_version() -> None:
+    """
+    Fail loudly on Python versions we do not support, and warn on untested ones.
+
+    Uses plain print instead of rich: this runs before any third party import,
+    because an unsupported interpreter usually breaks those imports first.
+    """
+    current = ".".join(str(v) for v in sys.version_info[:3])
+
+    if sys.version_info < MIN_PYTHON:
+        minimum = ".".join(str(v) for v in MIN_PYTHON)
+        print(
+            f"ERROR: codeforces-cli needs Python {minimum} or newer, "
+            f"but this is Python {current} ({sys.executable}).\n"
+            f"Install it under a newer interpreter, for example:\n"
+            f"  pipx install --python python3.13 codeforces",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+
+    if sys.version_info[:2] > LATEST_TESTED_PYTHON:
+        latest = ".".join(str(v) for v in LATEST_TESTED_PYTHON)
+        print(
+            f"WARNING: Python {current} is newer than the latest version "
+            f"codeforces-cli was tested on ({latest}). "
+            f"If something breaks, please open an issue.",
+            file=sys.stderr,
+        )
+
+
+_check_python_version()
+
+import click
+from .config import config
+from .contests import contests
+from .parse import parse
+from .submit import submit
+from .run import run
+from .unsolved import unsolved
+from .edit import edit_cmd
+from rich.console import Console
+from rich.table import Table
+from typing import Dict
+
+console = Console()
+
+
+class RichGroup(click.Group):
+    def format_help(self, ctx: click.Context, formatter: click.HelpFormatter):
+        cmds: Dict[str, click.Command] = ctx.command.commands  # type: ignore
+
+        console.print(r"""[bold green]
+
+                  __     ____
+  _________  ____/ /__  / __/___  _____________  _____
+ / ___/ __ \/ __  / _ \/ /_/ __ \/ ___/ ___/ _ \/ ___/
+/ /__/ /_/ / /_/ /  __/ __/ /_/ / /  / /__/  __(__  )
+\___/\____/\__,_/\___/_/  \____/_/   \___/\___/____/
+
+
+        [/]""")
+
+        table = Table(show_header=True, header_style="bold green", show_lines=True)
+        table.add_column("Command", style="bright", justify="left")
+        table.add_column("Description")
+
+        for name, cmd in cmds.items():
+            table.add_row(
+                f"{name} {' '.join(['[dim]{' + e.name + '}[/]' for e in cmd.params])}",  # type: ignore
+                (cmd.help or "No Description").strip()  # type: ignore
+            )
+
+        console.print(table)
+
+
+@click.group(cls=RichGroup)
+def commands():
+    pass
+
+
+commands.add_command(config)
+commands.add_command(contests)
+commands.add_command(parse)
+commands.add_command(run)
+commands.add_command(submit)
+commands.add_command(unsolved)
+commands.add_command(edit_cmd)

cf/config.py

@@ -0,0 +1,40 @@
+import click
+import json
+import os
+from rich.console import Console
+from utils import CFClient
+
+console = Console()
+
+
+@click.command()
+@click.option("--username", prompt="Enter your codeforces username")
+@click.option("--cf_dir", prompt="Enter your codeforces directory")
+def config(username: str, cf_dir: str):
+    """
+    Configure the codeforces cli.
+    """
+
+    client = CFClient(username)
+    if not client.login():
+        # login() already printed why it failed.
+        return
+
+    if cf_dir.startswith("~"):
+        cf_dir = os.path.expanduser('~') + cf_dir[1:]
+    if not os.path.isdir(cf_dir):
+        os.makedirs(cf_dir, exist_ok=True)
+        console.print(f"[dim]Created directory: {cf_dir}[/]")
+
+    cf_dir = os.path.abspath(cf_dir)
+    data = {
+        "dir": cf_dir,
+        "username": username,
+    }
+
+    config_path = os.path.join(os.path.expanduser('~'), "codeforces.uwu")
+    with open(config_path, "w") as f:
+        f.write(json.dumps(data))
+
+    console.print("\n[bold green]Config set![/]\n" + f"dir: {cf_dir}")
+    console.print(f"\nHappy Coding! {username}")

cf/contests.py

@@ -0,0 +1,137 @@
+import click
+from bs4 import BeautifulSoup
+from rich.table import Table
+from rich.console import Console
+from rich.style import Style
+from utils import CFClient, get_config
+
+console = Console()
+
+
+colors = {
+    "red": "#ff1c1d",
+    "orange": "#ff981a",
+    "violet": "#ff55ff",
+    "gray": "#9c9388",
+    "blue": "#254b8c",
+    "admin": "#ffffff",
+    "cyan": "#57fcf2",
+    "green": "#72ff72",
+    "black": "#000000"
+}
+
+
+def format_writer(writer) -> str:
+    if writer.string is None:
+        return f"[white]{writer.contents[0].string}[/white][{colors['red']}]{writer.contents[1]}[/]"
+    else:
+        return f"[{colors[writer['class'][1].split('-')[1]]}]{writer.string.strip()}[/]"
+
+
+@click.command()
+@click.argument("_id", default=0, required=False)
+def contests(_id: str):
+    """
+    Get the list of current or upcoming contests.
+    """
+    config = get_config(console)
+    if config is None:
+        return
+    if "username" not in config:
+        console.print("[bold red]ERROR: [/]Username not set. Please use `cf config`.\n")
+        return
+
+    client = CFClient(config['username'])
+    client.login()
+
+    if _id == 0:
+        console.log("Fetching contest details...")
+        r = client.session.get("https://codeforces.com/contests?complete=true")
+        if r.status_code != 200:
+            console.print(f"[bold red]ERROR:[/] Status Code: {r.status_code}")
+            return
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        table = Table(title="Current or upcoming contests", show_lines=True)
+
+        c = soup.find('div', {'class': 'contestList'}).find('table').find_all('tr')  # type: ignore
+        if not c:
+            console.print("[bold red]An error occured.[/]")
+            return
+        table.add_column("ID", justify="center")
+        for col in c[0].find_all('th'):
+            table.add_column(col.string, justify="center")
+
+        for cont in c[1:]:
+            _id = cont['data-contestid']
+            tds = cont.find_all('td')
+            start = tds[2].a.span.string.strip()
+            start = "\n".join(start.split())
+
+            last = tds[5].contents
+
+            if len(last) == 3:
+                last = last[0].strip() + "\n[#9c9388]" + (last[1].string or last[1].contents[1]).strip() + "[/]"
+            else:
+                last = f"[blue link=https://codeforces.com/contestRegistrants/{_id}]{last[3].contents[1].strip()}\n[/]"
+                last += "Until Closing\n"
+                last += f"[{colors['gray']}]{tds[5].contents[5].span.string.strip()}[/]"
+
+            table.add_row(
+                str(_id),
+                f"[link=https://codeforces.com/contests/{_id}]{(tds[0].string or tds[0].contents[0]).strip()}[/]",
+                "\n".join([format_writer(e) or "" for e in tds[1].find_all('a')]),
+                f"[blue link={tds[2].a['href']}]{start}[/]",
+                tds[3].string.strip(),
+                (tds[4].contents[0].strip() or "Running") + f"\n[{colors['gray']}]" + tds[4].span.string.strip() + "[/]",
+                last
+            )
+
+        console.print("\n\n", table)
+        console.print("[bold green]NOTE:[/] Use `cf contests ID` to view problems of an ongoing contest.\nAnd use `cf parse ID` to parse them.\n")
+    else:
+        console.log("Fetching contest details...")
+        r = client.session.get(f"https://codeforces.com/contest/{_id}")
+        if r.status_code != 200:
+            console.print(f"[bold red]ERROR:[/] Status Code: {r.status_code}")
+            return
+        if len(r.history) > 0:
+            console.print("[bold red]ERROR:[/] The contest has not started yet OR it doesn't exist.")
+            return
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        p_tables = soup.find_all("table", {"class": "problems"})
+        if not p_tables:
+            console.print("[bold red]ERROR:[/] Unable to parse problems table.")
+            return
+
+        problems = p_tables[0].find_all('tr')[1:]
+        contest = soup.find_all("table", {"class": "rtable"})[0].find_all('tr')
+        contest_name = contest[0].th.a.string.strip()
+        contest_time = contest[1].td.span.string.strip()
+        table = Table(title=f"{contest_name} - {contest_time}", show_lines=True)
+
+        table.add_column("#", justify="center")
+        table.add_column("Name", justify="left")
+        table.add_column(" ", justify="center")
+        table.add_column(" ", justify="center")
+
+        for problem in problems:
+            kwargs = {}
+            if "accepted-problem" in (problem.get('class') or []):
+                kwargs['style'] = Style(bgcolor="#00ff00", color="#000000")
+            elif "rejected-problem" in (problem.get('class') or []):
+                kwargs['style'] = Style(bgcolor="red", color="#000000")
+            items = problem.find_all('td')
+            problem_name = items[1].find('a').contents[1].strip()
+            problem_details = items[1].find('div', {'class': 'notice'}).contents
+            table.add_row(
+                items[0].a.string.strip(),
+                f"[link=https://codeforces.com/contest/{_id}/problem/{items[0].a.string.strip()}]{problem_name}[/]",
+                f"[{colors['gray']}]" + problem_details[1].string.strip() + "\n" + problem_details[2].strip() + "[/]",
+                f"[blue link=https://codeforces.com/contest/{_id}/status/{items[0].a.string.strip()}]{items[3].a.contents[1].strip()}[/]",
+                **kwargs
+            )
+
+        console.print("\n\n", table)
+        console.print(f"\n[bold green]NOTE:[/] Use `cf parse {_id}` to parse all the problems and solve them from your terminal.\n\n")

cf/edit.py

@@ -0,0 +1,42 @@
+import click
+import os
+import subprocess
+from rich.console import Console
+from utils import get_config
+
+console = Console()
+
+editor_cmds = {
+    "vscode": "code {path}",
+    "neovim": "nvim {path}",
+    "vim": "vim {path}",
+}
+
+
+@click.command(name="edit")
+@click.argument("contest_id", required=True)
+@click.option("--editor", type=click.Choice(["vscode", "neovim", "vim"]), prompt="Select an editor: ")
+def edit_cmd(contest_id: str, editor: str):
+    """
+    Open a contest directory in an editor. (3 supported)
+    """
+    conf = get_config(console)
+    if conf is None:
+        return
+
+    cf_dir = conf.get("dir")
+    if cf_dir is None:
+        console.print("[bold red]ERROR: [/]The default directory is not set.\nPlease run the `cf config` command.")
+        return
+
+    if not os.path.isdir(cf_dir):
+        console.print("[bold red]ERROR: [/]The default directory does not exist.\nPlease run the `cf config` command.")
+        return
+
+    contest_dir = os.path.join(cf_dir, contest_id)
+    if not os.path.isdir(contest_dir):
+        console.print(f"\n[bold red]ERROR: [/]The contest directory `{contest_dir}` does not exist.")
+        console.print(f"[bold green]TIP: [/]Use `cf parse {contest_id}` to create the directory and parse the contest.")
+        return
+
+    subprocess.run(editor_cmds[editor].format(path=os.path.join(cf_dir, contest_id)), shell=True)

cf/parse.py

@@ -0,0 +1,126 @@
+import click
+import os
+from rich.console import Console
+from bs4 import BeautifulSoup
+from utils import get_config, get_bp, CFClient
+
+console = Console()
+
+# Global client to be initialized once
+_client = None
+
+
+def get_client(username: str) -> CFClient:
+    global _client
+    if _client is None:
+        _client = CFClient(username)
+        _client.login()
+    return _client
+
+
+def parse_problem(contest_id: int, problem: str, cf_dir: str, client: CFClient, print_info: bool = True, bp: str = "_"):
+    r = client.session.get(url=f"https://codeforces.com/contest/{contest_id}/problem/{problem}")
+    if len(r.history) > 0:
+        console.print("[bold red]ERROR:[/] Contest or problem not found OR Contest has not started yet.")
+        return
+    if r.status_code != 200:
+        console.print("[bold red]ERROR: [/]Unable to fetch problem details.")
+        return
+
+    contest_dir = os.path.join(cf_dir, str(contest_id))
+
+    if not os.path.isdir(contest_dir):
+        os.mkdir(contest_dir)
+        console.print(f"[bold green]INFO: [/]Created directory: `{contest_id}`")
+
+    soup = BeautifulSoup(r.text, "html.parser")
+    tests = soup.find('div', {"class": "sample-test"})
+
+    inputs = tests.find_all('div', {'class': 'input'})  # type: ignore
+    outputs = tests.find_all('div', {'class': 'output'})  # type: ignore
+
+    final_inps = []
+    final_outs = []
+
+    for inp in inputs:
+        final_inps.append("\n".join(e.strip() if type(e) == str else e.string.strip() for e in inp.find('pre').contents if not (type(e) != str and e.string is None)))
+
+    for out in outputs:
+        final_outs.append("\n".join(e.strip() if type(e) == str else e.string.strip() for e in out.find('pre').contents if not (type(e) != str and e.string is None)))
+
+    for i in range(len(final_inps)):
+        console.print(f"[bold green]INFO: [/]Parsing sample test case #{i + 1}...")
+        inp = final_inps[i]
+        out = final_outs[i]
+
+        input_file = os.path.join(contest_dir, f"{problem}.{i}.input.test")
+        with open(input_file, "w") as f:
+            f.write(inp)
+
+        output_file = os.path.join(contest_dir, f"{problem}.{i}.output.test")
+        with open(output_file, "w") as f:
+            f.write(out)
+
+    if bp != "_":
+        bp_text = get_bp(bp)
+        if bp_text is None:
+            console.print(f"[bold red]ERROR: [/]No boilerplate file found for `{bp}`.")
+        else:
+            bp_file = os.path.join(contest_dir, f"{problem}.{bp}")
+            with open(bp_file, "w") as f:
+                f.write(bp_text)
+                console.print(f"[bold green]INFO: [/]Created boilerplate `{problem}.{bp}` file.")
+
+    console.print(f"[bold green]Problem {contest_id} {problem} parsed successfully.[/]\n")
+    if print_info:
+        console.print(f"Use `cd {contest_dir}` to move the contest directory.")
+        console.print("Then use `cf run FILENAME` to check the sample test cases.\n")
+
+
+@click.command()
+@click.argument("contest_id", required=True)
+@click.argument("problem", default="_", required=False)
+@click.option("--lang", required=False, default="_")
+def parse(contest_id: int, problem: str, lang: str):
+    """
+    Parse the sample test cases for a problem OR a contest.
+    """
+    problem = problem.lower()
+    data = get_config(console)
+    if data is None:
+        return
+
+    cf_dir = data.get("dir")
+    if cf_dir is None:
+        console.print("[bold red]ERROR: [/]The default directory for parsing is not set.\nPlease run the `cf config` command.")
+        return
+
+    if "username" not in data:
+        console.print("[bold red]ERROR: [/]Username not set. Please use `cf config`.\n")
+        return
+
+    client = get_client(data["username"])
+
+    if problem == "_":
+        r = client.session.get(url=f"https://codeforces.com/contest/{contest_id}")
+        if len(r.history) > 0:
+            console.print("[bold red]ERROR: [/]Contest has not started yet OR it doesn't exist.\n")
+            return
+
+        if r.status_code != 200:
+            console.print(f"[bold red]ERROR: [/]Unable to fetch contest details.\nSTATUS CODE: [bold red]{r.status_code}[/]\n")
+            return
+
+        soup = BeautifulSoup(r.text, "html.parser")
+        p_tables = soup.find_all("table", {"class": "problems"})
+        if not p_tables:
+            console.print("[bold red]ERROR:[/] Unable to parse problems table.")
+            return
+
+        problems = p_tables[0].find_all('tr')[1:]
+        for i, p in enumerate(problems):
+            items = p.find_all('td')
+            p_id = items[0].a.string.strip().lower()
+            parse_problem(contest_id, p_id, cf_dir, client, print_info=(i == len(problems) - 1), bp=lang)
+    else:
+        parse_problem(contest_id, problem, cf_dir, client, bp=lang)

cf/run.py

@@ -0,0 +1,139 @@
+import click
+import time
+import os
+import subprocess
+from rich.console import Console
+from utils import get_config
+from typing import Optional, List, Union
+
+console = Console()
+
+
+def run_cmd(ext: str, file: str) -> Optional[Union[str, List[str]]]:
+    is_linux = os.name == "posix"
+    if ext == "py":
+        return f"python3 {file}" if is_linux else f"py {file}"
+    elif ext == "cpp":
+        return [f"g++ {file}", ("./a.out" if is_linux else "a.exe")]
+    elif ext == "c":
+        return [f"gcc {file}", ("./a.out" if is_linux else "a.exe")]
+    else:
+        console.print("[bold red]ERROR: [/]The file extension is not supported.\n")
+
+
+def get_available_problems(directory: str) -> list:
+    """Get list of available problem IDs from test files."""
+    problems = set()
+    for f in os.listdir(directory):
+        if f.endswith(".input.test"):
+            # Format: {problem}.{num}.input.test
+            parts = f.split(".")
+            if len(parts) >= 3:
+                problems.add(parts[0])
+    return sorted(problems)
+
+
+@click.command()
+@click.argument("file", required=True)
+@click.option("-p", "--problem", default=None, help="Problem ID (e.g., a, b, c)")
+def run(file: str, problem: str):
+    """
+    Check the sample test cases for a problem.
+    """
+    slash = "/" if os.name == "posix" else "\\"
+
+    data = get_config(console)
+    if data is None:
+        return
+
+    cf_dir = data.get("dir")
+    if cf_dir is None:
+        console.print("[bold red]ERROR: [/]The default directory for parsing is not set.\nPlease run the `cf config` command.")
+        return
+
+    cf_dir = os.path.abspath(cf_dir)
+    current_dir = os.getcwd()
+    if not current_dir.startswith(cf_dir) and current_dir != cf_dir:
+        console.print("[bold red]ERROR: [/]The current directory is not a contest directory.\n")
+        return
+
+    c_id = current_dir.split(slash)[-1]
+    if not c_id.isdigit():
+        console.print("[bold red]ERROR: [/]The current directory is not a contest directory.\n")
+        return
+
+    if not os.path.isfile(file):
+        console.print("[bold red]ERROR: [/]The file does not exist.\n")
+        return
+
+    # Get just the filename without path
+    filename = os.path.basename(file)
+    p_ext = filename.split(".")[-1]
+
+    # Determine problem ID
+    if problem:
+        p_id = problem.lower()
+    else:
+        # Try to get from filename (e.g., "a.py" -> "a")
+        p_id = filename.split(".")[0].lower()
+
+    available_problems = get_available_problems(current_dir)
+
+    # Check if p_id matches exactly one problem
+    if p_id not in available_problems:
+        if len(available_problems) == 0:
+            console.print("[bold red]ERROR: [/]No test cases found in this directory. Run `cf parse` first.\n")
+            return
+
+        console.print(f"[bold yellow]WARNING: [/]No test cases found for problem '{p_id}'.")
+        console.print(f"[bold blue]Available problems: [/]{', '.join(available_problems)}\n")
+        p_id = click.prompt("Enter problem ID", type=click.Choice(available_problems, case_sensitive=False)).lower()
+
+    all_inputs = sorted([f for f in os.listdir(current_dir) if f.endswith(".input.test") and f.split(".")[0] == p_id])
+    all_outputs = sorted([f for f in os.listdir(current_dir) if f.endswith(".output.test") and f.split(".")[0] == p_id])
+
+    total_passed = 0
+
+    console.print(f"[bold blue]INFO: [/]Checking {len(all_inputs)} testcase(s)...\n")
+    for i in range(len(all_inputs)):
+        inp = all_inputs[i]
+        out = all_outputs[i]
+
+        cmd = run_cmd(p_ext, file)
+        if cmd is None:
+            return
+
+        if type(cmd) == list:
+            res = subprocess.run(cmd[0].split())
+            if res.returncode != 0:
+                console.print(f"[bold red]COMPILATION ERROR[/] ON TEST CASE {i + 1}\n")
+                continue
+            cmd = cmd[1]
+
+        if type(cmd) == str:
+            t1 = time.perf_counter() * 1000
+            try:
+                with open(inp) as f:
+                    # BUG: for problems that have multiple inputs, this can confuse the user
+                    # however, a good competitive programmar won't be confused by this :)
+                    res = subprocess.run(cmd.split(), input=f.read().strip(), capture_output=True, text=True, timeout=10)  # type: ignore
+            except subprocess.TimeoutExpired:
+                console.print(f"[bold red]DEFAULT TIME LIMIT EXCEEDED (10 seconds)[/] ON TEST CASE {i + 1}\n")
+                continue
+            t2 = time.perf_counter() * 1000
+
+            if res.returncode != 0:
+                console.print(f"[bold red]RUNTIME ERROR[/] ON TEST CASE {i + 1}: {res.stderr}\n")
+                continue
+
+            with open(out) as f:
+                if res.stdout.strip() == f.read().strip():
+                    console.print(f"[bold green]PASSED[/] ON TEST CASE {i + 1}: {t2 - t1:.2f}ms\n")
+                    total_passed += 1
+                else:
+                    console.print(f"[bold red]FAILED[/] ON TEST CASE {i + 1}\n")
+                    console.print(f"\nYour Output:\n{res.stdout.strip()}\n\nExpected Output:\n{open(out).read().strip()}\n")
+
+    console.print(f"[bold blue]INFO: [/]Passed {total_passed}/{len(all_inputs)} testcases.\n")
+    if total_passed == len(all_inputs):
+        console.print("[bold green]SUCCESS: [/]All testcases passed!\nYou can submit using the `cf submit` command.\n")

cf/submit.py

@@ -0,0 +1,165 @@
+import click
+import time
+import json
+import websocket
+import os
+from utils import get_config, CFClient
+from bs4 import BeautifulSoup
+from rich.console import Console
+from rich.live import Live
+
+console = Console()
+
+
+lang_ids = {
+    "py": "70",
+    "c": "43",
+    "cpp": "73",
+    "cs": "79",  # C#
+    "d": "28",  # D
+    "go": "32",  # Golang
+    "hs": "12",  # Haskell
+    "java": "74",
+    "kt": "83",  # Kotlin
+    "ml": "19",  # Ocaml
+    "php": "6",
+    "rb": "67",  # Ruby
+    "rs": "75",  # Rust
+    "js": "55",  # Nodejs
+}
+
+
+@click.command()
+@click.argument("file", required=True)
+def submit(file: str):
+    """
+    Submits your solution
+    """
+    slash = "/" if os.name == "posix" else "\\"
+
+    data = get_config(console)
+    if data is None:
+        return
+
+    cf_dir = data.get("dir")
+    if cf_dir is None:
+        console.print("[bold red]ERROR: [/]The default directory for parsing is not set.\nPlease run the `cf config` command.")
+        return
+
+    current_dir = os.getcwd()
+    cf_dir = os.path.abspath(cf_dir)
+    if not current_dir.startswith(cf_dir) and current_dir != cf_dir:
+        console.print("[bold red]ERROR: [/]The current directory is not a contest directory.\n")
+        return
+
+    c_id = current_dir.split(slash)[-1]
+    if not c_id.isdigit():
+        console.print("[bold red]ERROR: [/]The current directory is not a contest directory.\n")
+        return
+
+    if not os.path.isfile(file):
+        console.print("[bold red]ERROR: [/]The file does not exist.\n")
+        return
+
+    p_id = file.split(".")[0].lower()
+    p_ext = file.split(".")[-1]
+
+    if p_ext not in lang_ids:
+        console.print("[bold red]ERROR: [/]The file extension is not supported.\n")
+        return
+
+    if "username" not in data:
+        console.print("[bold red]ERROR: [/]Username not set. Please use `cf config`.\n")
+        return
+
+    clnt = CFClient(data['username'])
+    if not clnt.login():
+        # login() already printed why it failed.
+        return
+
+    url = f"https://codeforces.com/contest/{c_id}/submit"
+    csrf = clnt.get_csrf(url)
+    url += f"?csrf_token={csrf}"
+    with open(file, "r") as f:
+        source_code = f.read()
+    resp = clnt.session.post(url=url, allow_redirects=True, data={
+        "csrf_token": csrf,
+        "ftaa": "",
+        "bfaa": "",
+        "action": "submitSolutionFormSubmitted",
+        "submittedProblemIndex": p_id,
+        "programTypeId": lang_ids[p_ext],
+        "contestId": c_id,
+        "source": source_code,
+        "tabSize": "4",
+        "sourceCodeConfirmed": "true",
+    })
+    if not resp.url.startswith(f"https://codeforces.com/contest/{c_id}/my"):
+        console.print("[bold red]ERROR: [/] Submission failed.")
+        return
+
+    r = clnt.session.get(f"https://codeforces.com/contest/{c_id}/my")
+    soup = BeautifulSoup(r.text, "html.parser")
+
+    table = soup.find('table', {'class': 'status-frame-datatable'})
+    last_sub = table.find_all('tr')[1]  # type: ignore
+    sub_id = int(last_sub['data-submission-id'])
+    sub_status = last_sub.find('td', {'class': 'status-verdict-cell'})
+    if sub_status['waiting'] == "true":
+        sub_status = "In Queue"
+    else:
+        sub_status = "IDK"
+    sub_time = last_sub.find('td', {'class': 'time-consumed-cell'}).string
+    sub_mem = last_sub.find('td', {'class': 'memory-consumed-cell'}).string
+
+    console.print(f"[bold green]SUBMITTED[/] [bold blue]https://codeforces.com/contest/{c_id}/submission/{sub_id}[/]")
+    live_text = f"""
+Status:     [bold white]{sub_status.strip()}[/]
+Time:       [bold white]{sub_time.strip()}[/]
+Memory:     [bold white]{sub_mem.strip()}[/]
+                    """
+
+    pc = None
+    cc = None
+    metas = soup.find_all('meta')
+
+    for meta in metas:
+        if meta.get('name') == 'pc':
+            pc = meta.get('content')
+        elif meta.get('name') == 'cc':
+            cc = meta.get('content')
+
+    sub_watcher = websocket.WebSocket()
+    sub_watcher.connect(f"wss://pubsub.codeforces.com/ws/s_{pc}/s_{cc}?_={int(time.time())}")
+
+    live = Live(live_text, console=console)
+    live.start()
+    live.refresh()
+    while (True):
+        sub = json.loads(sub_watcher.recv())
+        sub_data = json.loads(sub['text'])['d']
+        live_sub_id = sub_data[1]
+        if live_sub_id == sub_id:
+            status = sub_data[6].strip()
+            test_case = sub_data[8]
+
+            if status == "OK":
+                status_text = "[bold green]ACCEPTED[/]"
+            elif status == "TESTING":
+                status_text = f"[bold]Running on test case: {test_case}[/]"
+            else:
+                status_text = f"[bold red]{' '.join(status.split('_'))}[/] on test case: {test_case}"
+
+            timee = sub_data[9]
+            memory = int(sub_data[10]) // 1000
+            live_text = f"""
+Status:     {status_text}
+Time:       [bold]{timee} ms[/]
+Memory:     [bold]{memory} KB[/]
+            """
+            live.update(live_text)
+            live.refresh()
+            if status != "TESTING":
+                live.stop()
+                sub_watcher.close()
+                break

cf/unsolved.py

@@ -0,0 +1,60 @@
+import click
+from bs4 import BeautifulSoup
+from rich.console import Console
+from rich.table import Table
+from utils import CFClient, get_config
+
+console = Console()
+
+
+@click.command()
+def unsolved():
+    """Show unsolved problems"""
+    conf = get_config(console)
+    if conf is None:
+        return
+
+    if "username" not in conf:
+        console.print("[bold red]ERROR: [/]Username not found in config file. Please run `cf config`.")
+        return
+
+    client = CFClient(conf["username"])
+    if not client.login():
+        # login() already printed why it failed.
+        return
+
+    ps = client.session.get("https://codeforces.com/problemset")
+    if ps.status_code != 200:
+        console.print("[bold red]ERROR: [/]Failed to fetch unsolved problems.")
+        return
+
+    soup = BeautifulSoup(ps.text, "html.parser")
+    unsolved_table = soup.find('table', {'class': 'rtable'})
+    if unsolved_table is None:
+        console.print("[bold red]ERROR: [/]Failed to fetch unsolved problems.")
+        return
+    problems = unsolved_table.find_all('tr')[1:]  # type: ignore
+
+    if len(problems) == 0:
+        console.print("[bold green]WOW: [/]You do not have any unsolved problems.")
+        console.print("(This means any problem where you have submitted a solution but it was not accepted.)")
+        console.print("Obviously you will have several problems that you haven't tried.")
+        return
+
+    table = Table(title="Unsolved Problems", show_header=True, header_style="bold green", show_lines=True)
+    table.add_column("Problem ID", style="bright", justify="left", no_wrap=True)
+    table.add_column("Problem Name", style="bright", justify="left", no_wrap=True)
+    table.add_column("Last Submission", style="bright", justify="left", no_wrap=True)
+    for problem in problems:
+        data = problem.find_all('td')
+        _id = data[0].a.string.strip()
+        p_url = data[0].a['href'].strip()
+        name = data[1].a.string.strip()
+        sub_id = data[2].a.string.strip()
+
+        table.add_row(
+            f"[link=https://codeforces.com{p_url}]{_id}[/]", name,
+            f"[link=https://codeforces.com{data[2].a['href'].strip()}]{sub_id}[/]"
+        )
+
+    console.print(table)

codeforces-0.1.2.dist-info/METADATA

@@ -0,0 +1,75 @@
+Metadata-Version: 2.5
+Name: codeforces
+Version: 0.1.2
+Summary: A simple command line tool to move your competitive programming workflow to your terminal.
+Project-URL: Homepage, https://github.com/Nirlep5252/codeforces-cli
+Author: Nirlep5252
+License-Expression: MIT
+Keywords: cli,codeforces,competitive programming,terminal
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.9
+Requires-Dist: beautifulsoup4>=4.9
+Requires-Dist: click>=7.0
+Requires-Dist: requests>=2.20
+Requires-Dist: rich>=10.0
+Requires-Dist: undetected-chromedriver>=3.5.5
+Requires-Dist: websocket-client>=1.0
+Description-Content-Type: text/markdown
+
+# Codeforces CLI [WORK IN PROGRESS]
+
+A simple command line tool to move your competitive programming workflow to your terminal.
+
+![image](https://i.imgur.com/ZpLElvF.gif)
+
+### How to install?
+
+#### 1. Install using pip
+```
+$ pip install -U codeforces
+$ cf --help
+```
+
+#### 2. Install from source (using uv)
+```
+$ git clone https://github.com/Nirlep5252/codeforces-cli
+$ cd ./codeforces-cli
+$ uv sync
+$ uv run cf --help
+```
+
+**Note:** Chrome browser is required for authentication.
+
+Python 3.9 through 3.14 are supported. Newer versions probably work but are untested, and the CLI warns you when it sees one.
+
+#### Authentication Note
+
+Due to Cloudflare protection on Codeforces, authentication requires opening a browser window once. When you run `cf config` or first use `cf submit`, a browser will open for you to login. After successful login, your session is saved and subsequent commands will work without opening the browser again (until the session expires).
+
+#### Current commands:
+
+`cf config` - save your username and problems-directory (opens browser for login) \
+`cf contests` - list all the current or upcoming contests \
+`cf contests {ID}` - view all the problems of an ongoing contest \
+`cf parse {Contest ID} {Problem ID | Optional} {--lang | Optional}` - parse the problem and its test cases \
+`cf run {FILE}` - check the test cases for the current problem (works based on current directory) \
+`cf submit {FILE}` - submit the problem (requires config) (works based on current directory) \
+`cf unsolved` - return the list of all your unsolved problems \
+`cf edit {CONTEST ID}` - open the contest folder in the editor of choice (only 3 supported so far)
+
+#### TODO commands:
+
+`cf standings {Contest ID | Optional}` - show all the standings of an ongoing of finished contests \
+`cf suggest` - suggest a problem based on your current rating
+
+#### TODO features:
+
+- [ ] Support all languages in run
+- [ ] A problem recommendation system, maybe?

codeforces-0.1.2.dist-info/RECORD

@@ -0,0 +1,13 @@
+cf/__init__.py,sha256=dyX_dvwy5rAK9iOctyMDHolMFaNT7SFoDowt-83ZaWA,2868
+cf/config.py,sha256=Zg1TJoYLHYHzp4vqLwM591IF3AqEA8lUHrp1U4MWb4o,1089
+cf/contests.py,sha256=1vidzLLrgHZ9Rg_1M08DEcpibE4qKCMKQHpau3I2nJ8,5582
+cf/edit.py,sha256=K0q1MaDTFawH48iuu7q83qjLyVFDV99PpBa6KUepZ7U,1370
+cf/parse.py,sha256=b3GA4NgryV2AbvaA9mK7nT2nUG6pqhYqIYU-gboQivY,4731
+cf/run.py,sha256=Teq3C9SQaNTfhavb2z-SPeoAIC3lgxhDBX-3dzq2Pyg,5389
+cf/submit.py,sha256=IIThz06Pdvv667HjXrd61d_xBkc3if4eXgywPg1FjsQ,5075
+cf/unsolved.py,sha256=KO6TpyWuc7URnWfJbpAXtfcyGdqYjs8lvvgnLy74wA4,2202
+utils.py,sha256=6LQDfwgGKdjXvk7BFIuxm9h9kd65LKcZQD3C0FH_fnk,8748
+codeforces-0.1.2.dist-info/METADATA,sha256=TUpfQXCVg5r7Hy1cfjZ0mdxBif3aMldBBS0_EEpNEyk,2948
+codeforces-0.1.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+codeforces-0.1.2.dist-info/entry_points.txt,sha256=vn6DktheP1e5YraK9l7X1q7CQIrf1E2y7ZqU3EYblxk,35
+codeforces-0.1.2.dist-info/RECORD,,

codeforces-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

codeforces-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cf = cf:commands

utils.py

@@ -0,0 +1,235 @@
+import os
+import json
+import re
+import sys
+import types
+import requests
+from bs4 import BeautifulSoup
+from typing import Optional
+from rich.console import Console
+
+
+def _ensure_distutils_version() -> None:
+    """
+    Register a minimal `distutils.version` module when the stdlib one is gone.
+
+    `undetected_chromedriver.patcher` does `from distutils.version import
+    LooseVersion`, and distutils was removed from the stdlib in Python 3.12.
+    Having setuptools installed also papers over this, but it is not a
+    dependency of undetected-chromedriver, so ship our own shim instead.
+    """
+    try:
+        import distutils.version  # noqa: F401
+        return
+    except ImportError:
+        pass
+
+    class LooseVersion:
+        """Port of the distutils class, only what the patcher actually uses."""
+
+        component_re = re.compile(r"(\d+ | [a-z]+ | \.)", re.VERBOSE)
+
+        def __init__(self, vstring: Optional[str] = None):
+            self.vstring = ""
+            self.version = []
+            if vstring:
+                self.parse(vstring)
+
+        def parse(self, vstring: str) -> None:
+            self.vstring = vstring
+            components = [c for c in self.component_re.split(vstring) if c and c != "."]
+            for i, component in enumerate(components):
+                try:
+                    components[i] = int(component)
+                except ValueError:
+                    pass
+            self.version = components
+
+        def __str__(self):
+            return self.vstring
+
+        def __repr__(self):
+            return "LooseVersion ('%s')" % str(self)
+
+        def _key(self, other):
+            if isinstance(other, str):
+                return LooseVersion(other).version
+            if isinstance(other, LooseVersion):
+                return other.version
+            return None
+
+        def __eq__(self, other):
+            key = self._key(other)
+            return NotImplemented if key is None else self.version == key
+
+        def __lt__(self, other):
+            key = self._key(other)
+            return NotImplemented if key is None else self.version < key
+
+        def __le__(self, other):
+            key = self._key(other)
+            return NotImplemented if key is None else self.version <= key
+
+        def __gt__(self, other):
+            key = self._key(other)
+            return NotImplemented if key is None else self.version > key
+
+        def __ge__(self, other):
+            key = self._key(other)
+            return NotImplemented if key is None else self.version >= key
+
+    distutils = sys.modules.get("distutils")
+    if distutils is None:
+        distutils = types.ModuleType("distutils")
+        distutils.__path__ = []  # type: ignore[attr-defined]
+        sys.modules["distutils"] = distutils
+
+    version_module = types.ModuleType("distutils.version")
+    version_module.LooseVersion = LooseVersion  # type: ignore[attr-defined]
+    sys.modules["distutils.version"] = version_module
+    distutils.version = version_module  # type: ignore[attr-defined]
+
+
+def get_config(console: Console) -> Optional[dict]:
+    config_path = os.path.join(os.path.expanduser("~"), "codeforces.uwu")
+    if not config_path:
+        console.print("[bold red]ERROR: [/]Config file not found.\nPlease run `cf config`\n")
+        return
+
+    if not os.path.isfile(config_path):
+        console.print("[bold red]ERROR: [/]Config file not found.\nPlease run `cf config`\n")
+        return
+
+    data = None
+    with open(config_path, "r+") as f:
+        data = json.loads("".join(f.readlines()))
+
+    return data
+
+
+def get_bp(lang: str) -> Optional[str]:
+    bp_dir = os.path.join(os.path.expanduser("~"), "cf_boilerplates")
+
+    if not os.path.isdir(bp_dir):
+        return
+    template_path = os.path.join(bp_dir, "template." + lang)
+    if not os.path.isfile(template_path):
+        return
+
+    with open(template_path, "r") as f:
+        return f.read()
+
+
+class CFClient:
+    def __init__(self, username: str):
+        self.username = username
+        self.session = requests.Session()
+        self.console = Console()
+
+    def login(self) -> bool:
+        # First, try to use saved cookies
+        if self._load_cookies():
+            if self._verify_login():
+                return True
+            # Cookies expired or invalid, need fresh login
+
+        # Need to open browser for login
+        try:
+            _ensure_distutils_version()
+            import undetected_chromedriver as uc
+        except ImportError as e:
+            if getattr(e, "name", None) == "undetected_chromedriver":
+                self.console.print("[bold red]ERROR:[/] undetected-chromedriver is not installed. Run: pip install undetected-chromedriver")
+            else:
+                self.console.print("[bold red]ERROR:[/] undetected-chromedriver is installed but could not be imported.")
+                self.console.print(f"[dim]Details: {e.__class__.__name__}: {e}[/]")
+            return False
+
+        self.console.print("\n[bold cyan]Opening browser for login...[/]")
+        self.console.print("[dim]Please login to Codeforces in the browser window that opens.[/]")
+        self.console.print("[dim]The browser will close automatically once you're logged in.[/]\n")
+
+        try:
+            import time
+
+            options = uc.ChromeOptions()
+            options.add_argument('--no-first-run')
+            options.add_argument('--no-service-autorun')
+            options.add_argument('--password-store=basic')
+
+            driver = uc.Chrome(options=options, use_subprocess=True)
+            driver.get("https://codeforces.com/enter")
+
+            # Wait for login to complete by checking for the username in the page
+            # Poll every second for up to 5 minutes
+            max_wait = 300  # 5 minutes
+            for _ in range(max_wait):
+                time.sleep(1)
+                try:
+                    content = driver.page_source.lower()
+                except Exception:
+                    continue
+                # Check if user is logged in (username appears in header/lang-chooser)
+                if self.username.lower() in content and "logout" in content:
+                    # Extract cookies for requests session
+                    cookies = driver.get_cookies()
+                    for cookie in cookies:
+                        self.session.cookies.set(cookie['name'], cookie['value'], domain=cookie.get('domain', '.codeforces.com'))
+
+                    # Save cookies for future use
+                    self._save_cookies(cookies)
+
+                    self.console.print("[bold green]Login successful![/]")
+                    driver.quit()
+                    return True
+
+            # Timeout
+            self.console.print("[bold red]ERROR:[/] Login timed out (5 minutes). Please try again.")
+            driver.quit()
+            return False
+
+        except Exception as e:
+            self.console.print(f"[bold red]ERROR:[/] Login failed.")
+            self.console.print(f"[dim]Details: {e}[/dim]")
+            if 'driver' in locals():
+                driver.quit()
+            return False
+
+    def _verify_login(self) -> bool:
+        """Check if current session cookies are valid by making a request."""
+        try:
+            # Add browser-like headers
+            self.session.headers.update({
+                'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            })
+            r = self.session.get("https://codeforces.com", timeout=10)
+            return self.username.lower() in r.text.lower() and "logout" in r.text.lower()
+        except Exception:
+            return False
+
+    def _save_cookies(self, cookies: list) -> None:
+        """Save cookies to config for future authenticated requests."""
+        cookie_path = os.path.join(os.path.expanduser("~"), "codeforces.cookies")
+        with open(cookie_path, "w") as f:
+            json.dump(cookies, f)
+
+    def _load_cookies(self) -> bool:
+        """Load saved cookies into the session. Returns True if cookies were loaded."""
+        cookie_path = os.path.join(os.path.expanduser("~"), "codeforces.cookies")
+
+        if not os.path.isfile(cookie_path):
+            return False
+
+        try:
+            with open(cookie_path, "r") as f:
+                cookies = json.load(f)
+            for cookie in cookies:
+                self.session.cookies.set(cookie['name'], cookie['value'], domain=cookie.get('domain', '.codeforces.com'))
+            return True
+        except Exception:
+            return False
+
+    def get_csrf(self, url) -> str:
+        r = self.session.get(url)
+        s = BeautifulSoup(r.text, "html.parser")
+        return s.find_all("span", {"class": "csrf-token"})[0]["data-csrf"]