leetcode_to_github.py

#!/usr/bin/env python3
"""
leetcode_to_github.py
======================
Automates:
  1. Fetching your solved LeetCode problems (with full solution code)
  2. Computing stats (by difficulty)
  3. Building a folder structure: Difficulty/Topic/problem.ext
  4. Generating a README.md with stats + a problems table
  5. Pushing everything to GitHub (new or existing repo)

Usage:
    python leetcode_to_github.py

Requires a .env file (copy from .env.example) filled with:
    LEETCODE_SESSION=...
    LEETCODE_CSRF_TOKEN=...
    GITHUB_TOKEN=...
    GITHUB_USERNAME=...
    REPO_NAME=leetcode-solutions
"""

import os
import re
import sys
import time
import subprocess
from pathlib import Path

import requests
from dotenv import load_dotenv
from colorama import init, Fore, Style

init(autoreset=True)
load_dotenv()

LEETCODE_SESSION = os.getenv("LEETCODE_SESSION")
LEETCODE_CSRF_TOKEN = os.getenv("LEETCODE_CSRF_TOKEN")
GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
GITHUB_USERNAME = os.getenv("GITHUB_USERNAME")
REPO_NAME = os.getenv("REPO_NAME", "leetcode-solutions")

OUTPUT_DIR = Path(os.getenv("OUTPUT_DIR", "./" + REPO_NAME))

GRAPHQL_URL = "https://leetcode.com/graphql"
ALL_PROBLEMS_URL = "https://leetcode.com/api/problems/all/"

HEADERS = {
    "Content-Type": "application/json",
    "Referer": "https://leetcode.com",
    "User-Agent": "Mozilla/5.0",
    "x-csrftoken": LEETCODE_CSRF_TOKEN or "",
}

COOKIES = {
    "LEETCODE_SESSION": LEETCODE_SESSION or "",
    "csrftoken": LEETCODE_CSRF_TOKEN or "",
}

DIFFICULTY_MAP = {1: "Easy", 2: "Medium", 3: "Hard"}

LANG_EXT = {
    "python3": "py", "python": "py", "java": "java", "cpp": "cpp",
    "c": "c", "javascript": "js", "typescript": "ts", "csharp": "cs",
    "golang": "go", "kotlin": "kt", "swift": "swift", "rust": "rs",
    "ruby": "rb", "scala": "scala", "php": "php",
}


# ---------- helpers: colored logging ----------

def log_step(msg):
    print(f"{Fore.CYAN}{Style.BRIGHT}{msg}{Style.RESET_ALL}")


def log_info(msg):
    print(f"{Fore.WHITE}    -> {msg}{Style.RESET_ALL}")


def log_success(msg):
    print(f"{Fore.GREEN}{Style.BRIGHT}{msg}{Style.RESET_ALL}")


def log_warn(msg):
    print(f"{Fore.YELLOW}    -> {msg}{Style.RESET_ALL}")


def log_error(msg):
    print(f"{Fore.RED}{Style.BRIGHT}{msg}{Style.RESET_ALL}")


def check_config():
    missing = [k for k, v in {
        "LEETCODE_SESSION": LEETCODE_SESSION,
        "LEETCODE_CSRF_TOKEN": LEETCODE_CSRF_TOKEN,
        "GITHUB_TOKEN": GITHUB_TOKEN,
        "GITHUB_USERNAME": GITHUB_USERNAME,
    }.items() if not v]
    if missing:
        log_error(f"[!] Missing required variables in .env: {', '.join(missing)}")
        sys.exit(1)


# ---------- STEP 1: fetch solved problems ----------

def fetch_solved_problems():
    log_step("[1/5] Fetching solved problems from LeetCode...")
    resp = requests.get(ALL_PROBLEMS_URL, headers=HEADERS, cookies=COOKIES)
    resp.raise_for_status()
    data = resp.json()

    solved = []
    for item in data.get("stat_status_pairs", []):
        if item.get("status") == "ac":
            stat = item["stat"]
            solved.append({
                "id": stat["frontend_question_id"],
                "title": stat["question__title"],
                "slug": stat["question__title_slug"],
                "difficulty": DIFFICULTY_MAP.get(item["difficulty"]["level"], "Unknown"),
            })
    log_info(f"Found {len(solved)} solved problems.")
    return solved


def fetch_topics(slug):
    query = {
        "query": """
        query questionData($titleSlug: String!) {
          question(titleSlug: $titleSlug) {
            topicTags { name }
          }
        }""",
        "variables": {"titleSlug": slug},
    }
    r = requests.post(GRAPHQL_URL, headers=HEADERS, cookies=COOKIES, json=query)
    if r.status_code != 200:
        return ["Uncategorized"]
    tags = r.json().get("data", {}).get("question", {}).get("topicTags", [])
    return [t["name"] for t in tags] or ["Uncategorized"]


def fetch_latest_accepted(slug):
    query = {
        "query": """
        query submissionList($offset: Int!, $limit: Int!, $questionSlug: String!) {
          submissionList(offset: $offset, limit: $limit, questionSlug: $questionSlug) {
            submissions { id statusDisplay lang timestamp }
          }
        }""",
        "variables": {"offset": 0, "limit": 20, "questionSlug": slug},
    }
    r = requests.post(GRAPHQL_URL, headers=HEADERS, cookies=COOKIES, json=query)
    if r.status_code != 200:
        return None
    subs = r.json().get("data", {}).get("submissionList", {}).get("submissions", [])
    accepted = [s for s in subs if s["statusDisplay"] == "Accepted"]
    if not accepted:
        return None
    latest = max(accepted, key=lambda s: int(s["timestamp"]))

    detail_query = {
        "query": """
        query submissionDetails($submissionId: Int!) {
          submissionDetails(submissionId: $submissionId) {
            code
            lang { name }
          }
        }""",
        "variables": {"submissionId": int(latest["id"])},
    }
    r2 = requests.post(GRAPHQL_URL, headers=HEADERS, cookies=COOKIES, json=detail_query)
    if r2.status_code != 200:
        return None
    detail = r2.json().get("data", {}).get("submissionDetails")
    if not detail:
        return None
    return {"code": detail["code"], "lang": detail["lang"]["name"].lower().replace(" ", "")}


def enrich_problems(solved):
    log_step("[1/5] Fetching topics and code for each problem (this may take a while)...")
    enriched = []
    for i, p in enumerate(solved, 1):
        p["topics"] = fetch_topics(p["slug"])
        sub = fetch_latest_accepted(p["slug"])
        p["code"] = sub["code"] if sub else None
        p["lang"] = sub["lang"] if sub else "python3"
        enriched.append(p)
        if i % 10 == 0 or i == len(solved):
            log_info(f"{i}/{len(solved)}")
        time.sleep(0.4)  # avoid getting rate-limited
    return enriched


# ---------- STEP 2: stats ----------

def build_stats(problems):
    log_step("[2/5] Building stats...")
    stats = {"Easy": 0, "Medium": 0, "Hard": 0, "Total": len(problems)}
    for p in problems:
        stats[p["difficulty"]] = stats.get(p["difficulty"], 0) + 1
    return stats


# ---------- STEP 3: folder structure ----------

def slugify_folder(name):
    return re.sub(r"[^a-zA-Z0-9\-]+", "-", name.strip()).strip("-")


def create_folder_structure(problems):
    log_step("[4/5] Building folder structure (Difficulty/Topic)...")
    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
    for p in problems:
        primary_topic = slugify_folder(p["topics"][0]) if p["topics"] else "Uncategorized"
        folder = OUTPUT_DIR / p["difficulty"] / primary_topic
        folder.mkdir(parents=True, exist_ok=True)
        ext = LANG_EXT.get(p["lang"], "txt")
        filename = f"{p['id']:04d}-{slugify_folder(p['title']).lower()}.{ext}"
        code = p["code"] or f"# TODO: add the solution code for {p['title']} manually\n"
        (folder / filename).write_text(code, encoding="utf-8")
    log_info(f"Folders created in {OUTPUT_DIR}")


# ---------- STEP 4: README ----------

def build_readme(problems, stats):
    log_step("[3/5] Building README.md...")
    lines = []
    lines.append(f"# LeetCode Solutions — {GITHUB_USERNAME}\n")
    lines.append("Automated sync from LeetCode to GitHub using Python.\n")
    lines.append("## 📊 Stats\n")
    lines.append(f"- **Total solved:** {stats['Total']}")
    lines.append(f"- 🟢 Easy: {stats.get('Easy', 0)}")
    lines.append(f"- 🟡 Medium: {stats.get('Medium', 0)}")
    lines.append(f"- 🔴 Hard: {stats.get('Hard', 0)}\n")

    lines.append("## 📁 Structure\n")
    lines.append("```")
    lines.append("Easy|Medium|Hard/")
    lines.append("  └── Topic/")
    lines.append("        └── 0001-two-sum.py")
    lines.append("```\n")

    lines.append("## ✅ Problems\n")
    lines.append("| # | Title | Difficulty | Topics |")
    lines.append("|---|-------|-----------|--------|")
    for p in sorted(problems, key=lambda x: x["id"]):
        link = f"https://leetcode.com/problems/{p['slug']}/"
        topics = ", ".join(p["topics"])
        lines.append(f"| {p['id']} | [{p['title']}]({link}) | {p['difficulty']} | {topics} |")

    readme_path = OUTPUT_DIR / "README.md"
    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
    readme_path.write_text("\n".join(lines), encoding="utf-8")
    log_info(f"README written to {readme_path}")


# ---------- STEP 5: push to GitHub ----------

def ensure_github_repo():
    r = requests.get(
        f"https://api.github.com/repos/{GITHUB_USERNAME}/{REPO_NAME}",
        headers={"Authorization": f"token {GITHUB_TOKEN}"},
    )
    if r.status_code == 200:
        return
    log_warn("Repo does not exist yet, creating it...")
    r = requests.post(
        "https://api.github.com/user/repos",
        headers={"Authorization": f"token {GITHUB_TOKEN}"},
        json={"name": REPO_NAME, "description": "Automated LeetCode solutions sync", "private": False},
    )
    r.raise_for_status()


def push_to_github():
    log_step("[5/5] Pushing to GitHub...")
    ensure_github_repo()
    remote_url = f"https://{GITHUB_TOKEN}@github.com/{GITHUB_USERNAME}/{REPO_NAME}.git"

    def run(cmd):
        subprocess.run(cmd, cwd=OUTPUT_DIR, check=True)

    if not (OUTPUT_DIR / ".git").exists():
        run(["git", "init"])
        run(["git", "checkout", "-b", "main"])

    run(["git", "add", "."])
    result = subprocess.run(["git", "diff", "--cached", "--quiet"], cwd=OUTPUT_DIR)
    if result.returncode == 0:
        log_warn("Nothing new to commit locally (will still push any pending local commits).")
    else:
        run(["git", "commit", "-m", f"sync: {len(list(OUTPUT_DIR.rglob('*.py')))} solutions updated"])

    run(["git", "remote", "remove", "origin"]) if subprocess.run(
        ["git", "remote"], cwd=OUTPUT_DIR, capture_output=True, text=True
    ).stdout.strip() else None
    run(["git", "remote", "add", "origin", remote_url])
    run(["git", "push", "-u", "origin", "main", "--force"])
    log_info(f"Pushed to https://github.com/{GITHUB_USERNAME}/{REPO_NAME}")


def main():
    check_config()
    solved = fetch_solved_problems()
    if not solved:
        log_error("[!] No solved problems found. Check your LEETCODE_SESSION.")
        sys.exit(1)
    problems = enrich_problems(solved)
    stats = build_stats(problems)
    build_readme(problems, stats)
    create_folder_structure(problems)
    push_to_github()
    log_success("\n✅ Done, everything synced successfully!")


if __name__ == "__main__":
    main()