leetcode-local-cli 0.7.0__py3-none-any.whl

leetcode_local_cli/problem.py

@@ -0,0 +1,166 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+
+class QuestionIdError(str, Enum):
+    EMPTY = "empty"
+    NOT_DECIMAL = "not_decimal"
+    NOT_POSITIVE = "not_positive"
+    LEADING_ZERO = "leading_zero"
+
+
+QUESTION_ID_ERROR_MESSAGES = {
+    QuestionIdError.EMPTY: "题号不能为空",
+    QuestionIdError.NOT_DECIMAL: "题号必须是正整数",
+    QuestionIdError.NOT_POSITIVE: "题号必须大于 0",
+    QuestionIdError.LEADING_ZERO: "题号不能以 0 开头",
+}
+
+
+@dataclass(frozen=True)
+class ParseQuestionIdResult:
+    question_id: str | None = None
+    error: QuestionIdError | None = None
+
+    @property
+    def ok(self) -> bool:
+        return self.error is None
+
+    @property
+    def error_message(self) -> str | None:
+        if self.error is None:
+            return None
+        return QUESTION_ID_ERROR_MESSAGES[self.error]
+
+
+@dataclass(frozen=True)
+class ProblemSummary:
+    question_id: str
+    title: str
+    title_slug: str
+    difficulty: str
+    paid_only: bool
+    tags: list[str]
+
+
+@dataclass(frozen=True)
+class ProblemDetail:
+    question_id: str
+    submit_question_id: str
+    title: str
+    title_slug: str
+    difficulty: str
+    tags: list[str]
+    content_html: str
+    python_code: str | None
+
+
+def parse_question_id(raw: str) -> ParseQuestionIdResult:
+    text = raw.strip()
+
+    if not text:
+        return ParseQuestionIdResult(error=QuestionIdError.EMPTY)
+
+    if not text.isdecimal():
+        return ParseQuestionIdResult(error=QuestionIdError.NOT_DECIMAL)
+
+    if text == "0":
+        return ParseQuestionIdResult(error=QuestionIdError.NOT_POSITIVE)
+
+    if text.startswith("0"):
+        return ParseQuestionIdResult(error=QuestionIdError.LEADING_ZERO)
+
+    return ParseQuestionIdResult(question_id=text)
+
+
+def normalize_problem_summary(raw: dict[str, Any]) -> ProblemSummary:
+    question_id = raw.get("frontendQuestionId", "")
+    question_id = str(question_id) if isinstance(question_id, (str, int)) else ""
+    title = raw.get("title", "")
+    title = title if isinstance(title, str) else ""
+    title_slug = raw.get("titleSlug", "")
+    title_slug = title_slug if isinstance(title_slug, str) else ""
+    difficulty = raw.get("difficulty", "")
+    difficulty = difficulty if isinstance(difficulty, str) else ""
+    paid_only = bool(raw.get("paidOnly", False))
+    raw_tags = raw.get("topicTags")
+    tags = (
+        [
+            name
+            for tag in raw_tags
+            if isinstance(tag, dict)
+            and isinstance((name := tag.get("name")), str)
+            and name
+        ]
+        if isinstance(raw_tags, list)
+        else []
+    )
+
+    return ProblemSummary(
+        question_id=question_id,
+        title=title,
+        title_slug=title_slug,
+        difficulty=difficulty,
+        paid_only=paid_only,
+        tags=tags,
+    )
+
+
+def normalize_problem_summaries(
+    raw_items: list[dict[str, Any]],
+) -> list[ProblemSummary]:
+    summaries = [normalize_problem_summary(raw) for raw in raw_items]
+    return summaries
+
+
+def find_problem_by_id(
+    problems: list[ProblemSummary], question_id: str
+) -> ProblemSummary | None:
+    for problem in problems:
+        if question_id == problem.question_id:
+            return problem
+    return None
+
+
+def extract_python_code(code_snippets: Any) -> str | None:
+    if not isinstance(code_snippets, list):
+        return None
+    for snippet in code_snippets:
+        if not isinstance(snippet, dict):
+            continue
+        if snippet.get("langSlug") == "python3":
+            code = snippet.get("code")
+            return code if isinstance(code, str) else None
+
+    return None
+
+
+def normalize_problem_detail(raw: dict[str, Any]) -> ProblemDetail:
+    raw_tags = raw.get("topicTags")
+    tags = (
+        [
+            name
+            for tag in raw_tags
+            if isinstance(tag, dict)
+            and isinstance((name := tag.get("name")), str)
+            and name
+        ]
+        if isinstance(raw_tags, list)
+        else []
+    )
+
+    def text(key: str) -> str:
+        value = raw.get(key)
+        return value if isinstance(value, str) else ""
+
+    return ProblemDetail(
+        question_id=text("questionFrontendId"),
+        submit_question_id=text("questionId"),
+        title=text("translatedTitle") or text("title"),
+        title_slug=text("titleSlug"),
+        difficulty=text("difficulty"),
+        tags=tags,
+        content_html=text("translatedContent") or text("content"),
+        python_code=extract_python_code(raw.get("codeSnippets")),
+    )

leetcode_local_cli/service.py

@@ -0,0 +1,269 @@
+from time import sleep
+
+from typer import Exit
+
+from leetcode_local_cli.auth import (
+    REQUIRED_COOKIE_NAMES,
+    SessionFileError,
+    load_session,
+)
+from leetcode_local_cli.client import ClientErrorKind, LeetCodeClient
+from leetcode_local_cli.doctor import (
+    DoctorReport,
+    DoctorStatus,
+    diagnose_remote,
+    diagnose_session,
+    diagnose_solution,
+)
+from leetcode_local_cli.problem import (
+    ProblemDetail,
+    ProblemSummary,
+    find_problem_by_id,
+    normalize_problem_detail,
+    normalize_problem_summaries,
+    parse_question_id,
+)
+from leetcode_local_cli.ui import error, loading, render_submission_target, warning
+from leetcode_local_cli.workspace import WorkspaceError, parse_solution_submission
+
+
+MAX_ATTEMPTS = 10
+
+
+def client_error_message(kind: ClientErrorKind | None) -> str:
+    match kind:
+        case ClientErrorKind.NETWORK:
+            return "网络请求失败，请检查网络连接"
+
+        case ClientErrorKind.HTTP:
+            return "LeetCode 接口返回异常，请稍后重试"
+
+        case ClientErrorKind.INVALID_JSON:
+            return "LeetCode 返回内容无法解析，请稍后重试"
+
+        case ClientErrorKind.INVALID_RESPONSE:
+            return "LeetCode 接口数据结构异常，可能是接口变更"
+
+        case ClientErrorKind.UNAUTHORIZED:
+            return "登录态无效或已过期，请重新执行 uv run lc login"
+
+        case ClientErrorKind.MISSING_CSRF:
+            return "缺少提交凭证 csrftoken，请重新执行 uv run lc login"
+
+        case _:
+            return "未知客户端错误"
+
+
+def _load_cookies_from_session() -> dict[str, str]:
+    session_check = diagnose_session()
+    if session_check.status is DoctorStatus.FAIL:
+        error(session_check.message)
+        if session_check.suggestion:
+            warning(session_check.suggestion)
+        raise Exit(1)
+    try:
+        session = load_session()
+    except SessionFileError as exc:
+        error(str(exc))
+        raise Exit(1)
+    if not isinstance(session, dict):
+        warning("未找到有效登录态，请先执行 uv run lc login")
+        raise Exit(1)
+    cookies = session.get("cookies")
+    if not isinstance(cookies, dict):
+        error("Session 文件结构无效，请重新执行 uv run lc login")
+        raise Exit(1)
+    valid_cookies: dict[str, str] = {}
+    for name in REQUIRED_COOKIE_NAMES:
+        value = cookies.get(name)
+        if not isinstance(value, str) or not value:
+            error(f"缺少或无效的 Cookie：{name}")
+            warning("请重新执行 uv run lc login")
+            raise Exit(1)
+        valid_cookies[name] = value
+    return valid_cookies
+
+
+def _parse_question_id_or_exit(question_id: str) -> str:
+    parse_result = parse_question_id(question_id)
+    if not parse_result.ok:
+        error(parse_result.error_message or "题号解析失败")
+        raise Exit(1)
+    assert parse_result.question_id is not None
+    return parse_result.question_id
+
+
+def _find_problem_summary_by_question_id_online(
+    client: LeetCodeClient,
+    question_id: str,
+) -> ProblemSummary:
+    limit, skip = 100, 0
+    while True:
+        problem_list_data = client.problem_list(limit=limit, skip=skip)
+        if not problem_list_data.ok:
+            error(client_error_message(problem_list_data.error))
+            raise Exit(1)
+        problem_list = problem_list_data.data
+        if not isinstance(problem_list, dict):
+            error(client_error_message(ClientErrorKind.INVALID_RESPONSE))
+            raise Exit(1)
+        questions = problem_list.get("questions", [])
+        problem_summaries = normalize_problem_summaries(questions)
+        problem_summary = find_problem_by_id(problem_summaries, question_id)
+        if problem_summary:
+            return problem_summary
+        skip += limit
+        total = problem_list.get("total") or 0
+        if not questions or skip >= total:
+            error(f"未找到题号 {question_id}")
+            raise Exit(1)
+
+
+def _validate_show_options(limit: int, skip: int) -> None:
+    if limit <= 0:
+        error("limit 必须是正整数")
+        raise Exit(1)
+    if limit > 100:
+        error("limit 超过单次查询上限，最大为 100")
+        raise Exit(1)
+    if skip < 0:
+        error("skip 必须是非负整数")
+        raise Exit(1)
+
+
+def get_user_status() -> dict:
+    cookies = _load_cookies_from_session()
+    with LeetCodeClient(cookies) as client:
+        user_status = client.user_status()
+    if not user_status.ok:
+        error(client_error_message(user_status.error))
+        raise Exit(1)
+    status = user_status.data
+    if not isinstance(status, dict) or not status.get("isSignedIn"):
+        error(client_error_message(ClientErrorKind.UNAUTHORIZED))
+        raise Exit(1)
+    return user_status.data
+
+
+def get_account_profile() -> dict:
+    cookies = _load_cookies_from_session()
+    with LeetCodeClient(cookies) as client:
+        with loading("正在获取账户信息..."):
+            account_profile = client.account_profile()
+    if not account_profile.ok:
+        error(client_error_message(account_profile.error))
+        raise Exit(1)
+    if not isinstance(account_profile.data, dict):
+        error(client_error_message(ClientErrorKind.INVALID_RESPONSE))
+        raise Exit(1)
+    return account_profile.data
+
+
+def get_problem_summaries(limit: int = 50, skip: int = 0) -> list[ProblemSummary]:
+    _validate_show_options(limit, skip)
+    cookies = _load_cookies_from_session()
+    with LeetCodeClient(cookies) as client:
+        with loading("正在获取题目索引..."):
+            problem_list_data = client.problem_list(limit=limit, skip=skip)
+    if not problem_list_data.ok:
+        error(client_error_message(problem_list_data.error))
+        raise Exit(1)
+    problem_list = problem_list_data.data
+    if not isinstance(problem_list, dict):
+        error(client_error_message(ClientErrorKind.INVALID_RESPONSE))
+        raise Exit(1)
+    questions = problem_list.get("questions", [])
+
+    if not isinstance(questions, list):
+        error("题目获取失败")
+        raise Exit(1)
+    return normalize_problem_summaries(questions)
+
+
+def get_problem_detail_by_question_id(question_id: str) -> ProblemDetail:
+    normalized_question_id = _parse_question_id_or_exit(question_id)
+    cookies = _load_cookies_from_session()
+    with LeetCodeClient(cookies) as client:
+        with loading("正在获取题目索引..."):
+            problem_summary = _find_problem_summary_by_question_id_online(
+                client,
+                normalized_question_id,
+            )
+        with loading("正在获取题目详情..."):
+            problem_detail_data = client.problem_detail(problem_summary.title_slug)
+        if not problem_detail_data.ok:
+            error(client_error_message(problem_detail_data.error))
+            raise Exit(1)
+        if not isinstance(problem_detail_data.data, dict):
+            error(client_error_message(ClientErrorKind.INVALID_RESPONSE))
+            raise Exit(1)
+        problem_detail = normalize_problem_detail(problem_detail_data.data)
+    return problem_detail
+
+
+def get_doctor_report() -> DoctorReport:
+    session_check = diagnose_session()
+    solution_check = diagnose_solution()
+
+    cookies: dict[str, str] | None = None
+    try:
+        session = load_session()
+    except SessionFileError:
+        session = None
+    if isinstance(session, dict):
+        raw_cookies = session.get("cookies")
+        if isinstance(raw_cookies, dict):
+            valid_cookies: dict[str, str] = {}
+            for name in REQUIRED_COOKIE_NAMES:
+                value = raw_cookies.get(name)
+                if not isinstance(value, str) or not value:
+                    break
+                valid_cookies[name] = value
+            else:
+                cookies = valid_cookies
+
+    with LeetCodeClient(cookies) as client:
+        remote_result = client.user_status()
+    connectivity_check, authentication_check = diagnose_remote(remote_result)
+    return DoctorReport(
+        checks=(
+            session_check,
+            connectivity_check,
+            authentication_check,
+            solution_check,
+        )
+    )
+
+
+def submit_current_solution() -> dict | None:
+    try:
+        metadata, code = parse_solution_submission()
+        submit_question_id, title_slug = (
+            metadata.submit_question_id,
+            metadata.title_slug,
+        )
+    except WorkspaceError as exc:
+        error(str(exc))
+        raise Exit(1)
+    render_submission_target(metadata)
+    cookies = _load_cookies_from_session()
+    with LeetCodeClient(cookies) as client:
+        submission_id = client.submit_solution(title_slug, submit_question_id, code)
+        if not submission_id.ok:
+            error(client_error_message(submission_id.error))
+            raise Exit(1)
+
+        for _ in range(MAX_ATTEMPTS):
+            result = client.get_submission_result(submission_id.data)
+            if not result.ok:
+                error(client_error_message(result.error))
+                raise Exit(1)
+            result_data = result.data
+            if not isinstance(result_data, dict):
+                error(client_error_message(ClientErrorKind.INVALID_RESPONSE))
+                raise Exit(1)
+            state = result_data.get("state")
+            if state not in {"PENDING", "STARTED"}:
+                return result_data
+            sleep(0.5)
+    return None

leetcode_local_cli/ui.py

@@ -0,0 +1,250 @@
+from collections.abc import Iterator
+from contextlib import contextmanager
+from html import unescape
+from html.parser import HTMLParser
+import re
+import shutil
+from typing import Any
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from leetcode_local_cli.doctor import DoctorReport, DoctorStatus
+
+console = Console(width=shutil.get_terminal_size(fallback=(120, 24)).columns)
+
+
+def _terminal_width() -> int:
+    return shutil.get_terminal_size(fallback=(console.width, 24)).columns
+
+
+class _ProblemHTMLParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__()
+        self.parts: list[str] = []
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        if tag in {"p", "div", "ul", "ol", "pre"}:
+            self.parts.append("\n")
+        elif tag == "li":
+            self.parts.append("\n- ")
+        elif tag == "br":
+            self.parts.append("\n")
+        elif tag == "sup":
+            self.parts.append("^")
+        elif tag == "sub":
+            self.parts.append("_")
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in {"p", "div", "ul", "ol", "pre"}:
+            self.parts.append("\n")
+
+    def handle_data(self, data: str) -> None:
+        self.parts.append(data)
+
+
+def _html_to_text(content_html: str) -> str:
+    parser = _ProblemHTMLParser()
+    parser.feed(content_html)
+    text = unescape("".join(parser.parts))
+    text = text.replace("\xa0", " ")
+    text = re.sub(r"[ \t]+\n", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+@contextmanager
+def loading(message: str) -> Iterator[None]:
+    with console.status(message, spinner="dots"):
+        yield
+
+
+def success(message: str) -> None:
+    console.print(f"[bold green]{message}[/bold green]")
+
+
+def warning(message: str) -> None:
+    console.print(f"[bold yellow]{message}[/bold yellow]")
+
+
+def error(message: str) -> None:
+    console.print(f"[bold red]{message}[/bold red]")
+
+
+def render_profile(profile: dict[str, Any]) -> None:
+    solved = profile["solved"]
+    total = profile["total"]
+
+    table = Table(title="LeetCode CN Profile")
+    table.add_column("Item", style="cyan", no_wrap=True)
+    table.add_column("Value", style="white")
+
+    table.add_row("Username", str(profile.get("username") or "-"))
+    table.add_row("Real Name", str(profile.get("real_name") or "-"))
+    table.add_row("Premium", "Yes" if profile.get("is_premium") else "No")
+    table.add_row(
+        "Solved",
+        f"All {solved['All']} | Easy {solved['Easy']} | Medium {solved['Medium']} | Hard {solved['Hard']}",
+    )
+    table.add_row(
+        "Total",
+        f"All {total['All']} | Easy {total['Easy']} | Medium {total['Medium']} | Hard {total['Hard']}",
+    )
+
+    console.print(Panel(table, border_style="green", width=_terminal_width()))
+
+
+def render_problem_list(problems: list[Any]) -> None:
+    if not problems:
+        warning("没有可展示的题目")
+        return
+
+    table = Table(
+        title=f"LeetCode CN Problems ({len(problems)})",
+        border_style="cyan",
+        expand=True,
+        width=_terminal_width(),
+    )
+    table.add_column("ID", style="cyan", justify="right", no_wrap=True)
+    table.add_column("Title", style="white", overflow="fold")
+    table.add_column("Difficulty", justify="center", no_wrap=True)
+    table.add_column("Paid", justify="center", no_wrap=True)
+    table.add_column("Tags", style="dim", overflow="fold")
+
+    difficulty_styles = {
+        "Easy": "green",
+        "Medium": "yellow",
+        "Hard": "red",
+    }
+
+    for problem in problems:
+        difficulty = problem.difficulty or "-"
+        difficulty_style = difficulty_styles.get(difficulty, "white")
+        paid_text = (
+            "[yellow]Paid[/yellow]" if problem.paid_only else "[green]Free[/green]"
+        )
+        tags = ", ".join(problem.tags[:4])
+        if len(problem.tags) > 4:
+            tags = f"{tags}, ..."
+
+        table.add_row(
+            problem.question_id,
+            problem.title or "-",
+            f"[{difficulty_style}]{difficulty}[/{difficulty_style}]",
+            paid_text,
+            tags or "-",
+        )
+
+    console.print(table)
+
+
+def render_problem_detail(problem: Any) -> None:
+    tags = ", ".join(problem.tags) if problem.tags else "-"
+
+    meta = Table.grid(padding=(0, 2))
+    meta.add_column(style="cyan", no_wrap=True)
+    meta.add_column(style="white")
+    meta.add_row("ID", problem.question_id)
+    meta.add_row("Slug", problem.title_slug)
+    meta.add_row("Difficulty", problem.difficulty)
+    meta.add_row("Tags", tags)
+
+    title = f"{problem.question_id}. {problem.title}"
+    console.print(
+        Panel(meta, title=title, border_style="cyan", width=_terminal_width())
+    )
+
+    content_text = _html_to_text(problem.content_html)
+    console.print(
+        Panel(
+            content_text or "-",
+            title="题面",
+            border_style="white",
+            width=_terminal_width(),
+        )
+    )
+
+    if not problem.python_code:
+        warning("未找到 Python3 代码模板")
+
+
+def render_submission_target(metadata: Any) -> None:
+    console.print(
+        "[bold cyan]当前提交目标："
+        f"{metadata.problem_id}. {metadata.title} ({metadata.title_slug})"
+        "[/bold cyan]"
+    )
+
+
+def render_doctor_report(report: DoctorReport) -> None:
+    labels = {
+        "session": "Session 文件",
+        "connectivity": "LeetCode 接口",
+        "authentication": "Cookie 登录态",
+        "solution": "solution.py",
+    }
+    status_labels = {
+        DoctorStatus.PASS: ("PASS", "green"),
+        DoctorStatus.WARNING: ("WARNING", "yellow"),
+        DoctorStatus.FAIL: ("FAIL", "red"),
+    }
+    table = Table(title="环境诊断", expand=True)
+    table.add_column("检查项", style="cyan", no_wrap=True)
+    table.add_column("状态", justify="center", no_wrap=True)
+    table.add_column("结果", overflow="fold")
+    table.add_column("建议", overflow="fold")
+
+    for check in report.checks:
+        status_text, status_style = status_labels[check.status]
+        table.add_row(
+            labels.get(check.name, check.name),
+            f"[{status_style}]{status_text}[/{status_style}]",
+            check.message,
+            check.suggestion or "-",
+        )
+
+    border_style = "green" if report.ok else "red"
+    console.print(
+        Panel(
+            table,
+            border_style=border_style,
+            width=_terminal_width(),
+        )
+    )
+
+
+def render_submission_result(result: dict[str, Any] | None) -> None:
+    if result is None:
+        error("判题超时，请稍后到 LeetCode 查看结果")
+        return
+
+    status_msg = str(result.get("status_msg") or "-")
+    runtime = str(result.get("status_runtime") or result.get("runtime") or "-")
+    memory = str(result.get("memory") or "-")
+    total_correct = result.get("total_correct")
+    total_testcases = result.get("total_testcases")
+
+    if status_msg == "Accepted":
+        success("通过")
+    else:
+        error(f"提交失败：{status_msg}")
+
+    table = Table(
+        title="判题结果", border_style="green" if status_msg == "Accepted" else "red"
+    )
+    table.add_column("Item", style="cyan", no_wrap=True)
+    table.add_column("Value", style="white")
+    table.add_row("Status", status_msg)
+    table.add_row("Runtime", runtime)
+    table.add_row("Memory", memory)
+    if total_correct is not None and total_testcases is not None:
+        table.add_row("Cases", f"{total_correct} / {total_testcases}")
+
+    console.print(
+        Panel(
+            table,
+            border_style="green" if status_msg == "Accepted" else "red",
+            width=_terminal_width(),
+        )
+    )

leetcode_local_cli/version.py

@@ -0,0 +1,12 @@
+from importlib.metadata import PackageNotFoundError, version
+
+
+PACKAGE_NAME = "leetcode-local-cli"
+
+
+def get_version() -> str:
+    """Return the installed distribution version."""
+    try:
+        return version(PACKAGE_NAME)
+    except PackageNotFoundError:
+        return "unknown"