lc-crusher 0.1.0__tar.gz

lc_crusher-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,85 @@
+name: Publish to PyPI
+
+on:
+  push:
+    branches: [main]
+    # A docs-only change is not a release.
+    paths-ignore: [README.md]
+  workflow_dispatch:
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v4
+      - name: Check formatting
+        run: uv run --only-group dev black --check src/
+
+  publish:
+    needs: lint
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write  # needed to push git tags
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # full history for tag detection
+
+      - uses: astral-sh/setup-uv@v4
+
+      - name: Get next patch version
+        id: version
+        run: |
+          # Fetch latest published version from PyPI
+          LATEST=$(python3 -c "
+          import urllib.request, json
+          try:
+              with urllib.request.urlopen('https://pypi.org/pypi/lc-crusher/json') as r:
+                  print(json.loads(r.read())['info']['version'])
+          except Exception:
+              print('')
+          ")
+          echo "Latest on PyPI: ${LATEST:-none}"
+
+          if [ -z "$LATEST" ]; then
+            # First release: publish the version declared in pyproject.toml.
+            NEW=$(sed -n 's/^version = "\(.*\)"/\1/p' pyproject.toml)
+          else
+            IFS='.' read -ra V <<< "$LATEST"
+            NEW="${V[0]}.${V[1]}.$((V[2] + 1))"
+          fi
+          echo "Next version:   $NEW"
+          echo "version=$NEW" >> "$GITHUB_OUTPUT"
+
+      - name: Bump version
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+          sed -i "s/^version = \".*\"/version = \"${VERSION}\"/" pyproject.toml
+          sed -i "s/^__version__ = \".*\"/__version__ = \"${VERSION}\"/" src/lc/__init__.py
+          grep "^version" pyproject.toml
+
+      - name: Build
+        run: uv build
+
+      - name: Publish
+        run: uv publish
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
+
+      - name: Tag release
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag "v${{ steps.version.outputs.version }}"
+          git push origin "v${{ steps.version.outputs.version }}"
+
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+          gh release create "v${VERSION}" dist/*.whl dist/*.tar.gz \
+            --title "lc-crusher v${VERSION}" \
+            --notes "Install: pipx install lc-crusher==${VERSION} | https://pypi.org/project/lc-crusher/${VERSION}/"

lc_crusher-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+*.egg-info/
+.DS_Store
+dist/

lc_crusher-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,8 @@
+repos:
+  - repo: local
+    hooks:
+      - id: black
+        name: black
+        entry: uv run black
+        language: system
+        types: [python]

lc_crusher-0.1.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.5
+Name: lc-crusher
+Version: 0.1.0
+Summary: lc (LeetCode Crusher): pick an unsolved problem, borrow a community Python solution, verify it, submit it.
+Classifier: Environment :: Console
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: curl-cffi>=0.7
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: playwright>=1.45
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# lc — LeetCode Crusher
+
+A CLI that picks unsolved LeetCode problems, finds a top-voted community Python
+solution, verifies it against the examples with Run, and submits it.
+
+## Install
+
+```bash
+pipx install lc-crusher
+```
+
+Requires Python 3.10+ and Google Chrome (used only for signing in).
+
+## Usage
+
+```bash
+lc login                         # sign in in a Chrome window; session saved to ~/.config/lc
+lc whoami                        # signed-in user and solved counts
+lc pick -n 10                    # next unsolved problems
+lc crush --dry-run               # verify the next problem without submitting
+lc crush -n 5 -d easy            # solve 5 unsolved easy problems
+lc now                           # run the scheduled job immediately (50 problems)
+lc schedule install daily:23:00  # run every day at 23:00 (macOS launchd)
+lc schedule status | remove
+```
+
+Every accepted problem is appended to `~/Documents/lc-solved.xlsx`, one tab per
+date. Problems a previous run solved or gave up on are never retried unless you
+pass `--retry-failed`.
+
+LeetCode allows one Run/Submit at a time per account, so problems are solved
+sequentially.
+
+## Disclaimer
+
+Automated submissions violate LeetCode's Terms of Service and can get an account
+flagged or banned. Use at your own risk.

lc_crusher-0.1.0/README.md

@@ -0,0 +1,37 @@
+# lc — LeetCode Crusher
+
+A CLI that picks unsolved LeetCode problems, finds a top-voted community Python
+solution, verifies it against the examples with Run, and submits it.
+
+## Install
+
+```bash
+pipx install lc-crusher
+```
+
+Requires Python 3.10+ and Google Chrome (used only for signing in).
+
+## Usage
+
+```bash
+lc login                         # sign in in a Chrome window; session saved to ~/.config/lc
+lc whoami                        # signed-in user and solved counts
+lc pick -n 10                    # next unsolved problems
+lc crush --dry-run               # verify the next problem without submitting
+lc crush -n 5 -d easy            # solve 5 unsolved easy problems
+lc now                           # run the scheduled job immediately (50 problems)
+lc schedule install daily:23:00  # run every day at 23:00 (macOS launchd)
+lc schedule status | remove
+```
+
+Every accepted problem is appended to `~/Documents/lc-solved.xlsx`, one tab per
+date. Problems a previous run solved or gave up on are never retried unless you
+pass `--retry-failed`.
+
+LeetCode allows one Run/Submit at a time per account, so problems are solved
+sequentially.
+
+## Disclaimer
+
+Automated submissions violate LeetCode's Terms of Service and can get an account
+flagged or banned. Use at your own risk.

lc_crusher-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[project]
+name = "lc-crusher"
+version = "0.1.0"
+description = "lc (LeetCode Crusher): pick an unsolved problem, borrow a community Python solution, verify it, submit it."
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Environment :: Console",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3",
+]
+dependencies = [
+    "curl_cffi>=0.7",
+    "openpyxl>=3.1",
+    "playwright>=1.45",
+    "rich>=13.7",
+    "typer>=0.12",
+]
+
+[project.scripts]
+lc = "lc.cli:app"
+
+[dependency-groups]
+dev = ["black>=24.0", "pre-commit>=3.7"]
+
+[tool.black]
+line-length = 120
+target-version = ["py310"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lc"]

lc_crusher-0.1.0/src/lc/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

lc_crusher-0.1.0/src/lc/auth.py

@@ -0,0 +1,92 @@
+import json
+import shutil
+import socket
+import subprocess
+import time
+import urllib.request
+from pathlib import Path
+
+from .client import BASE, LeetCode
+from .config import CONFIG_DIR
+
+LOGIN_URL = f"{BASE}/accounts/login/"
+REQUIRED = ("LEETCODE_SESSION", "csrftoken")
+PROFILE_DIR = CONFIG_DIR / "chrome-profile"
+CHROME_PATHS = [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+]
+
+
+def _chrome() -> str:
+    for path in CHROME_PATHS:
+        if Path(path).exists():
+            return path
+    for name in ("google-chrome", "chromium", "chromium-browser"):
+        if found := shutil.which(name):
+            return found
+    raise RuntimeError("Google Chrome not found")
+
+
+def _free_port() -> int:
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _tab_urls(port: int) -> list[str]:
+    try:
+        with urllib.request.urlopen(f"http://127.0.0.1:{port}/json/list", timeout=2) as r:
+            return [t.get("url", "") for t in json.load(r) if t.get("type") == "page"]
+    except OSError:
+        return []
+
+
+def _signed_in(cookies: dict[str, str]) -> bool:
+    try:
+        return LeetCode(cookies).whoami()["isSignedIn"]
+    except Exception:
+        return False
+
+
+def browser_login(timeout: int = 300) -> dict[str, str]:
+    """Open an ordinary Chrome window and wait for the user to sign in by hand.
+
+    Chrome is launched as a plain process (no automation flags) with a dedicated
+    profile, and nothing attaches to it until a tab sits on leetcode.com outside
+    the login pages. Google refuses sign-in in automation-controlled browsers,
+    so the login itself must be untouched. The profile persists, so later
+    logins are usually instant.
+    """
+    from playwright.sync_api import sync_playwright
+
+    PROFILE_DIR.mkdir(parents=True, exist_ok=True)
+    port = _free_port()
+    proc = subprocess.Popen(
+        [
+            _chrome(),
+            f"--remote-debugging-port={port}",
+            f"--user-data-dir={PROFILE_DIR}",
+            "--no-first-run",
+            "--no-default-browser-check",
+            LOGIN_URL,
+        ],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+    )
+    try:
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            time.sleep(2)
+            urls = _tab_urls(port)
+            if not any(u.startswith(BASE) and "/accounts/" not in u for u in urls):
+                continue
+            with sync_playwright() as p:
+                browser = p.chromium.connect_over_cdp(f"http://127.0.0.1:{port}")
+                cookies = {c["name"]: c["value"] for c in browser.contexts[0].cookies(BASE)}
+            found = {k: cookies.get(k, "") for k in REQUIRED}
+            if all(found.values()) and _signed_in(found):
+                return found
+    finally:
+        proc.terminate()
+    raise TimeoutError(f"No signed-in LeetCode session after {timeout}s")

lc_crusher-0.1.0/src/lc/cli.py

@@ -0,0 +1,325 @@
+import fcntl
+import getpass
+import json
+import subprocess
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.syntax import Syntax
+from rich.table import Table
+
+from . import config
+from .client import LeetCode
+from .crusher import crush
+from .sheet import append_solved
+
+app = typer.Typer(help="lc — LeetCode Crusher", no_args_is_help=True, add_completion=False)
+console = Console()
+
+
+def _client(auth: bool = True) -> LeetCode:
+    cookies = config.load_session()
+    if auth and not cookies:
+        console.print("[red]Not logged in.[/] Run [bold]lc login[/] first.")
+        raise typer.Exit(1)
+    return LeetCode(cookies)
+
+
+def _signed_in(lc: LeetCode) -> dict:
+    me = lc.whoami()
+    if not me["isSignedIn"]:
+        console.print("[red]Session expired.[/] Run [bold]lc login[/] again.")
+        raise typer.Exit(1)
+    return me
+
+
+@app.command()
+def login(
+    manual: bool = typer.Option(False, "--manual", help="Paste cookies instead of opening a browser."),
+    timeout: int = typer.Option(300, help="Seconds to wait for you to finish signing in."),
+):
+    """Sign in to LeetCode and save the session locally."""
+    if manual:
+        cookies = {
+            "LEETCODE_SESSION": getpass.getpass("LEETCODE_SESSION: ").strip(),
+            "csrftoken": getpass.getpass("csrftoken: ").strip(),
+        }
+    else:
+        from .auth import browser_login
+
+        console.print("Opening LeetCode — sign in in the browser window; it closes by itself.")
+        cookies = browser_login(timeout)
+
+    me = LeetCode(cookies).whoami()
+    if not me["isSignedIn"]:
+        console.print("[red]Those cookies are not signed in.[/]")
+        raise typer.Exit(1)
+    config.save_session(cookies)
+    console.print(f"[green]Logged in as[/] [bold]{me['username']}[/]")
+
+
+@app.command()
+def logout():
+    """Forget the saved session."""
+    config.clear_session()
+    console.print("Logged out.")
+
+
+@app.command()
+def whoami():
+    """Show the signed-in user and solved counts."""
+    lc = _client()
+    me = _signed_in(lc)
+    counts = lc.solved_counts(me["username"])
+    premium = " (premium)" if me["isPremium"] else ""
+    console.print(f"[bold]{me['username']}[/]{premium}  solved: " + "  ".join(f"{k}={v}" for k, v in counts.items()))
+
+
+@app.command()
+def pick(
+    difficulty: Optional[str] = typer.Option(None, "-d", "--difficulty", help="easy | medium | hard"),
+    count: int = typer.Option(10, "-n", help="How many to list."),
+):
+    """List the next unsolved problems."""
+    lc = _client()
+    me = _signed_in(lc)
+    table = Table("#", "title", "difficulty")
+    for i, q in enumerate(lc.unsolved(difficulty, include_paid=me["isPremium"])):
+        if i >= count:
+            break
+        table.add_row(q["questionFrontendId"], f"{q['title']} [dim]({q['titleSlug']})[/]", q["difficulty"])
+    console.print(table)
+
+
+@app.command("crush")
+def crush_cmd(
+    slug: Optional[str] = typer.Argument(None, help="Problem slug (e.g. two-sum). Default: next unsolved."),
+    count: int = typer.Option(1, "-n", "--count", help="How many unsolved problems to crush."),
+    difficulty: Optional[str] = typer.Option(None, "-d", "--difficulty", help="easy | medium | hard"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Verify with Run but do not Submit."),
+    show_code: bool = typer.Option(False, "--show-code", help="Print the code that was used."),
+    delay: float = typer.Option(10.0, help="Seconds to wait between problems."),
+    max_articles: int = typer.Option(30, help="Solution articles to scan per problem."),
+    max_submits: int = typer.Option(3, help="Submit attempts per problem before skipping."),
+    sheet: Path = typer.Option(config.SHEET_FILE, help="Excel workbook to log solved problems to (one tab per date)."),
+    retry_failed: bool = typer.Option(False, help="Retry problems a previous run gave up on."),
+    notify: bool = typer.Option(False, help="Show a macOS notification when finished."),
+):
+    """Pick unsolved problem(s), find a working Python solution, run it, submit it."""
+    run_started = datetime.now()
+    if not _acquire_run_lock():
+        console.print("[yellow]Another lc crush is already running.[/] LeetCode allows one at a time.")
+        raise typer.Exit(1)
+    try:
+        lc = _client()
+        me = _signed_in(lc)
+    except typer.Exit:
+        if notify:
+            _notify("lc crush failed", "Not logged in or session expired. Run lc login.")
+        raise
+
+    attempted = set() if (slug or retry_failed) else config.attempted_slugs()
+    slugs = (
+        [slug]
+        if slug
+        else (
+            q["titleSlug"]
+            for q in lc.unsolved(difficulty, include_paid=me["isPremium"])
+            if q["titleSlug"] not in attempted
+        )
+    )
+    target = 1 if slug else count
+    done = failed = 0
+    console.print(f"[dim]{run_started:%Y-%m-%d %H:%M} — target {target}, logging to {sheet}[/]")
+
+    for s in slugs:
+        if done >= target:
+            break
+        try:
+            p = lc.problem(s)
+        except Exception as e:
+            console.print(f"[yellow]skip {s}[/]: {e}")
+            continue
+
+        console.rule(f"[cyan]\\[{done}/{target}][/] [bold]{p.frontend_id}. {p.title}[/] [dim]{p.difficulty}[/]")
+        try:
+            out = crush(lc, p, console.print, max_articles=max_articles, max_submits=max_submits, dry_run=dry_run)
+        except Exception as e:
+            console.print(f"[red]error[/]: {e}")
+            failed += 1
+            continue
+
+        if out.code and show_code:
+            console.print(Syntax(out.code, "python", theme="ansi_dark"))
+        if out.accepted:
+            r = out.result
+            done += 1
+            console.print(
+                f"[bold green]ACCEPTED[/] [cyan]{done}/{target}[/] runtime {r.get('status_runtime')} "
+                f"(beats {r.get('runtime_percentile') or 0:.1f}%), memory {r.get('status_memory')}"
+            )
+            try:
+                append_solved(
+                    sheet,
+                    run_started,
+                    datetime.now(),
+                    {
+                        "frontend_id": p.frontend_id,
+                        "title": p.title,
+                        "slug": p.slug,
+                        "difficulty": p.difficulty,
+                        "runtime": r.get("status_runtime", ""),
+                        "memory": r.get("status_memory", ""),
+                    },
+                )
+            except OSError as e:
+                console.print(f"[yellow]could not write sheet[/]: {e}")
+        elif out.verified and dry_run:
+            done += 1
+            console.print(f"[cyan]verified {done}/{target} (dry run, not submitted)[/]")
+        else:
+            console.print(f"[red]skipped[/]: {out.reason} [cyan]({done}/{target})[/]")
+            failed += 1
+
+        config.append_history(
+            {
+                "at": datetime.now(timezone.utc).isoformat(),
+                "slug": p.slug,
+                "frontend_id": p.frontend_id,
+                "title": p.title,
+                "difficulty": p.difficulty,
+                "accepted": out.accepted,
+                "dry_run": dry_run,
+                "runs": out.runs,
+                "submits": out.submits,
+                "reason": out.reason,
+            }
+        )
+        if slug is None and done < target:
+            time.sleep(delay)
+
+    console.rule()
+    console.print(f"crushed [green]{done}[/], skipped [red]{failed}[/]")
+    if notify:
+        _notify("lc crush finished", f"Solved {done}/{target}, skipped {failed}")
+    if done < target:
+        raise typer.Exit(1)
+
+
+_run_lock = None
+
+
+def _acquire_run_lock() -> bool:
+    """Hold an exclusive flock for the life of the process; the OS releases it on exit."""
+    global _run_lock
+    config.CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    _run_lock = (config.CONFIG_DIR / "crush.lock").open("w")
+    try:
+        fcntl.flock(_run_lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        return True
+    except BlockingIOError:
+        return False
+
+
+@app.command()
+def now(
+    background: bool = typer.Option(
+        False, "--bg", help="Run through launchd in the background; output goes to the log."
+    ),
+):
+    """Run the scheduled crush right now, with the schedule's count and sheet."""
+    from . import schedule
+
+    st = schedule.status()
+    if background:
+        if st is None:
+            console.print("No schedule installed. Run [bold]lc schedule install[/] first.")
+            raise typer.Exit(1)
+        schedule.run_now()
+        console.print(f"Started in background. Follow with: tail -f {config.LOG_DIR / 'crush.log'}")
+        return
+
+    args = st["plist"]["ProgramArguments"] if st else []
+    count = int(args[args.index("-n") + 1]) if "-n" in args else 50
+    sheet = Path(args[args.index("--sheet") + 1]) if "--sheet" in args else config.SHEET_FILE
+    crush_cmd(
+        slug=None,
+        count=count,
+        difficulty=None,
+        dry_run=False,
+        show_code=False,
+        delay=10.0,
+        max_articles=30,
+        max_submits=3,
+        sheet=sheet,
+        retry_failed=False,
+        notify=True,
+    )
+
+
+def _notify(title: str, message: str) -> None:
+    script = f"display notification {json.dumps(message)} with title {json.dumps(title)}"
+    subprocess.run(["osascript", "-e", script], capture_output=True)
+
+
+schedule_app = typer.Typer(help="Run lc crush automatically every day.", no_args_is_help=True)
+app.add_typer(schedule_app, name="schedule")
+
+
+@schedule_app.command("install")
+def schedule_install(
+    spec: str = typer.Argument("daily:23:00", help="When to run: daily:HH:MM (24h). Several times: daily:09:00,21:00"),
+    count: int = typer.Option(50, "-n", "--count", help="Unique problems to solve per run."),
+    sheet: Path = typer.Option(config.SHEET_FILE, help="Excel workbook to log solved problems to."),
+):
+    """Install (or replace) the schedule, e.g. `lc schedule install daily:23:00`."""
+    from . import schedule
+
+    kind, _, times = spec.partition(":")
+    if kind != "daily" or not times:
+        console.print(f"[red]Bad schedule[/] {spec!r}. Use daily:HH:MM, e.g. daily:23:00")
+        raise typer.Exit(1)
+    parsed = []
+    for t in times.split(","):
+        try:
+            h, m = (int(x) for x in t.strip().split(":"))
+        except ValueError:
+            h = m = -1
+        if not (0 <= h < 24 and 0 <= m < 60):
+            console.print(f"[red]Bad time[/] {t!r}. Use 24h HH:MM, e.g. 23:00")
+            raise typer.Exit(1)
+        parsed.append((h, m))
+    path = schedule.install(parsed, count, sheet.expanduser().resolve())
+    console.print(f"[green]Scheduled[/] {count} problems daily at {times} ({path})")
+    console.print(f"Logs: {config.LOG_DIR / 'crush.log'}")
+
+
+@schedule_app.command("status")
+def schedule_status():
+    """Show the installed schedule."""
+    from . import schedule
+
+    st = schedule.status()
+    if st is None:
+        console.print("No schedule installed.")
+        return
+    p = st["plist"]
+    times = ", ".join(f"{t['Hour']:02d}:{t['Minute']:02d}" for t in p["StartCalendarInterval"])
+    console.print(f"{'[green]loaded[/]' if st['loaded'] else '[red]not loaded[/]'}  at {times}")
+    console.print("  " + " ".join(p["ProgramArguments"]))
+
+
+@schedule_app.command("remove")
+def schedule_remove():
+    """Remove the daily schedule."""
+    from . import schedule
+
+    console.print("Removed." if schedule.remove() else "No schedule installed.")
+
+
+if __name__ == "__main__":
+    app()