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

leetcode_local_cli/client.py

@@ -0,0 +1,373 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+import httpx
+
+BASE_URL = "https://leetcode.cn"
+USER_AGENT = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) "
+    "Chrome/135.0.0.0 Safari/537.36"
+)
+
+USER_STATUS_QUERY = {
+    "query": """
+        query userStatus {
+            userStatus {
+                isSignedIn
+                username
+                realName
+                avatar
+                isPremium
+            }
+        }
+    """
+}
+
+DIFFICULTY_MAP = {
+    1: "Easy",
+    2: "Medium",
+    3: "Hard",
+}
+
+PROBLEM_LIST_QUERY = """
+query problemsetQuestionList(
+    $categorySlug: String,
+    $limit: Int,
+    $skip: Int,
+    $filters: QuestionListFilterInput
+) {
+    problemsetQuestionList(
+        categorySlug: $categorySlug,
+        limit: $limit,
+        skip: $skip,
+        filters: $filters
+    ) {
+        total
+        questions {
+            frontendQuestionId
+            title
+            titleSlug
+            difficulty
+            paidOnly
+            topicTags {
+                name
+                slug
+            }
+        }
+    }
+}
+"""
+
+QUESTION_DETAIL_QUERY = """
+query questionData($titleSlug: String!) {
+    question(titleSlug: $titleSlug) {
+        questionId
+        questionFrontendId
+        title
+        translatedTitle
+        titleSlug
+        difficulty
+        content
+        translatedContent
+        topicTags {
+            name
+            slug
+        }
+        codeSnippets {
+            lang
+            langSlug
+            code
+        }
+    }
+}
+"""
+
+
+class ClientErrorKind(str, Enum):
+    NETWORK = "network"
+    HTTP = "http"
+    INVALID_JSON = "invalid_json"
+    INVALID_RESPONSE = "invalid_response"
+    UNAUTHORIZED = "unauthorized"
+    MISSING_CSRF = "missing_csrf"
+
+
+@dataclass(frozen=True)
+class ClientResult:
+    data: Any = None
+    error: ClientErrorKind | None = None
+    message: str = ""
+
+    @property
+    def ok(self) -> bool:
+        return self.error is None
+
+
+class LeetCodeClient:
+    def __init__(self, cookies: dict[str, str] | None = None):
+        self.client = httpx.Client(
+            base_url=BASE_URL,
+            follow_redirects=True,
+            timeout=20.0,
+            headers={
+                "User-Agent": USER_AGENT,
+                "Accept": "application/json, text/plain, */*",
+                "Origin": BASE_URL,
+                "Referer": f"{BASE_URL}/",
+            },
+        )
+        if cookies:
+            self.client.cookies.update(cookies)
+
+    def _request_json(
+        self,
+        method: str,
+        path: str,
+        *,
+        timeout: float,
+        **kwargs: Any,
+    ) -> ClientResult:
+        try:
+            response = self.client.request(
+                method,
+                path,
+                timeout=timeout,
+                **kwargs,
+            )
+            response.raise_for_status()
+        except httpx.RequestError:
+            return ClientResult(error=ClientErrorKind.NETWORK)
+        except httpx.HTTPStatusError:
+            return ClientResult(error=ClientErrorKind.HTTP)
+
+        try:
+            result = response.json()
+        except ValueError:
+            return ClientResult(error=ClientErrorKind.INVALID_JSON)
+        if not isinstance(result, dict):
+            return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+        return ClientResult(data=result)
+
+    def user_status(self) -> ClientResult:
+        result = self._request_json(
+            "POST",
+            "/graphql/",
+            json=USER_STATUS_QUERY,
+            timeout=10,
+        )
+        if not result.ok:
+            return result
+        payload = result.data
+        assert isinstance(payload, dict)
+        data = payload.get("data")
+        if not isinstance(data, dict):
+            return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+        status = data.get("userStatus")
+        if not isinstance(status, dict):
+            return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+        is_signed_in = status.get("isSignedIn")
+        username = status.get("username")
+        if not isinstance(is_signed_in, bool) or (
+            is_signed_in and (not isinstance(username, str) or not username)
+        ):
+            return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+        return ClientResult(data=status)
+
+    def problem_stats(self) -> ClientResult:
+        result = self._request_json("GET", "/api/problems/all/", timeout=20)
+        if not result.ok:
+            return result
+        payload = result.data
+        assert isinstance(payload, dict)
+
+        stats = {
+            "solved": {
+                "All": 0,
+                "Easy": 0,
+                "Medium": 0,
+                "Hard": 0,
+            },
+            "total": {
+                "All": 0,
+                "Easy": 0,
+                "Medium": 0,
+                "Hard": 0,
+            },
+        }
+        items = payload.get("stat_status_pairs")
+        if not isinstance(items, list):
+            return ClientResult(
+                error=ClientErrorKind.INVALID_RESPONSE,
+                message="stat_status_pairs is not a list",
+            )
+        for item in items:
+            if not isinstance(item, dict):
+                return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+            difficulty_data = item.get("difficulty")
+            if not isinstance(difficulty_data, dict):
+                return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+            difficulty_level = difficulty_data.get("level")
+            difficulty = (
+                DIFFICULTY_MAP.get(difficulty_level)
+                if isinstance(difficulty_level, int)
+                else None
+            )
+
+            if not difficulty:
+                continue
+
+            stats["total"]["All"] += 1
+            stats["total"][difficulty] += 1
+
+            if item.get("status") == "ac":
+                stats["solved"]["All"] += 1
+                stats["solved"][difficulty] += 1
+
+        return ClientResult(data=stats)
+
+    def account_profile(self) -> ClientResult:
+        status_result = self.user_status()
+        if not status_result.ok:
+            return status_result
+        status = status_result.data
+        problem_profile_result = self.problem_stats()
+        if not problem_profile_result.ok:
+            return problem_profile_result
+        problem_profile = problem_profile_result.data
+        if not isinstance(status, dict):
+            return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+        if not status.get("isSignedIn"):
+            return ClientResult(error=ClientErrorKind.UNAUTHORIZED)
+        if not isinstance(problem_profile, dict):
+            return ClientResult(
+                error=ClientErrorKind.INVALID_RESPONSE,
+                message="problem stats is not a dict",
+            )
+        return ClientResult(
+            data={
+                "username": status.get("username"),
+                "real_name": status.get("realName"),
+                "avatar": status.get("avatar"),
+                "is_premium": status.get("isPremium"),
+                "solved": problem_profile.get("solved"),
+                "total": problem_profile.get("total"),
+            }
+        )
+
+    def problem_list(self, limit: int = 50, skip: int = 0) -> ClientResult:
+        payload = {
+            "operationName": "problemsetQuestionList",
+            "query": PROBLEM_LIST_QUERY,
+            "variables": {
+                "categorySlug": "",
+                "limit": limit,
+                "skip": skip,
+                "filters": {},
+            },
+        }
+        result = self._request_json(
+            "POST",
+            "/graphql/",
+            json=payload,
+            timeout=10,
+        )
+        if not result.ok:
+            return result
+        response_payload = result.data
+        assert isinstance(response_payload, dict)
+        data = response_payload.get("data")
+        if not isinstance(data, dict):
+            return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+        problem_list = data.get("problemsetQuestionList")
+        if not isinstance(problem_list, dict):
+            return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+        questions = problem_list.get("questions")
+        total = problem_list.get("total")
+        if (
+            not isinstance(questions, list)
+            or not all(isinstance(item, dict) for item in questions)
+            or not isinstance(total, int)
+        ):
+            return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+        return ClientResult(data=problem_list)
+
+    def problem_detail(self, title_slug: str) -> ClientResult:
+        payload = {
+            "operationName": "questionData",
+            "query": QUESTION_DETAIL_QUERY,
+            "variables": {
+                "titleSlug": title_slug,
+            },
+        }
+        result = self._request_json(
+            "POST",
+            "/graphql/",
+            json=payload,
+            timeout=10,
+        )
+        if not result.ok:
+            return result
+        response_payload = result.data
+        assert isinstance(response_payload, dict)
+        data = response_payload.get("data")
+        if not isinstance(data, dict):
+            return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+        question = data.get("question")
+        if not isinstance(question, dict):
+            return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+        return ClientResult(data=question)
+
+    def submit_solution(
+        self, title_slug: str, question_id: str, code: str
+    ) -> ClientResult:
+        payload = {
+            "lang": "python3",
+            "question_id": question_id,
+            "typed_code": code,
+        }
+        csrftoken = self.client.cookies.get("csrftoken")
+        if not csrftoken:
+            return ClientResult(error=ClientErrorKind.MISSING_CSRF)
+        result = self._request_json(
+            "POST",
+            f"/problems/{title_slug}/submit/",
+            json=payload,
+            headers={
+                "X-CSRFToken": csrftoken,
+                "Referer": f"{BASE_URL}/problems/{title_slug}/",
+            },
+            timeout=10,
+        )
+        if not result.ok:
+            return result
+        response_payload = result.data
+        assert isinstance(response_payload, dict)
+        submission_id = response_payload.get("submission_id")
+        if not isinstance(submission_id, int) or isinstance(submission_id, bool):
+            return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+        return ClientResult(data=submission_id)
+
+    def get_submission_result(self, submission_id: int) -> ClientResult:
+        result = self._request_json(
+            "GET",
+            f"/submissions/detail/{submission_id}/check/",
+            timeout=10,
+        )
+        if not result.ok:
+            return result
+        payload = result.data
+        assert isinstance(payload, dict)
+        if not isinstance(payload.get("state"), str):
+            return ClientResult(error=ClientErrorKind.INVALID_RESPONSE)
+        return result
+
+    def close(self) -> None:
+        self.client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()

leetcode_local_cli/doctor.py

@@ -0,0 +1,277 @@
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+import subprocess
+
+from leetcode_local_cli.auth import SessionFileStatus, inspect_session_file
+from leetcode_local_cli.client import ClientErrorKind, ClientResult
+from leetcode_local_cli.workspace import (
+    SolutionFileStatus,
+    inspect_solution_file,
+    run_solution_file,
+)
+
+
+SESSION_CHECK_NAME = "session"
+CONNECTIVITY_CHECK_NAME = "connectivity"
+AUTHENTICATION_CHECK_NAME = "authentication"
+SOLUTION_CHECK_NAME = "solution"
+SOLUTION_RUN_TIMEOUT_SECONDS = 10
+
+
+class DoctorStatus(str, Enum):
+    PASS = "pass"
+    WARNING = "warning"
+    FAIL = "fail"
+
+
+@dataclass(frozen=True)
+class DoctorCheck:
+    name: str
+    status: DoctorStatus
+    message: str
+    suggestion: str | None = None
+
+
+@dataclass(frozen=True)
+class DoctorReport:
+    checks: tuple[DoctorCheck, ...]
+
+    @property
+    def ok(self) -> bool:
+        """Return whether the report contains no failed checks."""
+        return not any(check.status == DoctorStatus.FAIL for check in self.checks)
+
+
+def diagnose_session(path: Path | None = None) -> DoctorCheck:
+    """Translate the local session inspection into a user-facing check.
+
+    The returned check may contain safe metadata and missing cookie names, but
+    it must never include cookie values.
+    """
+    inspection = inspect_session_file(path)
+    match inspection.status:
+        case SessionFileStatus.VALID:
+            username = inspection.username or "未知"
+            source = inspection.source or "未知"
+            return DoctorCheck(
+                name=SESSION_CHECK_NAME,
+                status=DoctorStatus.PASS,
+                message=f"有效（用户：{username}，来源：{source}）",
+            )
+
+        case SessionFileStatus.MISSING:
+            return DoctorCheck(
+                name=SESSION_CHECK_NAME,
+                status=DoctorStatus.FAIL,
+                message="未找到 Session 文件",
+                suggestion="请执行 uv run lc login 创建登录态",
+            )
+
+        case SessionFileStatus.READ_ERROR:
+            return DoctorCheck(
+                name=SESSION_CHECK_NAME,
+                status=DoctorStatus.FAIL,
+                message="无法读取 Session 文件",
+                suggestion="请检查文件权限，或重新执行 uv run lc login",
+            )
+
+        case SessionFileStatus.INVALID_JSON:
+            return DoctorCheck(
+                name=SESSION_CHECK_NAME,
+                status=DoctorStatus.FAIL,
+                message="Session 文件不是有效的 JSON",
+                suggestion="请执行 uv run lc login 重新生成登录态",
+            )
+
+        case SessionFileStatus.INVALID_STRUCTURE:
+            return DoctorCheck(
+                name=SESSION_CHECK_NAME,
+                status=DoctorStatus.FAIL,
+                message="Session 文件结构无效",
+                suggestion="请执行 uv run lc login 重新生成登录态",
+            )
+
+        case SessionFileStatus.MISSING_COOKIES:
+            missing = "、".join(inspection.missing_cookie_names)
+            return DoctorCheck(
+                name=SESSION_CHECK_NAME,
+                status=DoctorStatus.FAIL,
+                message=f"缺少或无效的 Cookie：{missing}",
+                suggestion="请执行 uv run lc login 刷新 Cookie",
+            )
+
+
+def diagnose_solution(path: Path | None = None) -> DoctorCheck:
+    """Inspect solution.py and verify its local entry point in a subprocess."""
+    inspection = inspect_solution_file(path)
+    if inspection.status in {
+        SolutionFileStatus.READY,
+        SolutionFileStatus.NOT_SUBMITTABLE,
+    }:
+        runtime_failure = _diagnose_solution_runtime(path)
+        if runtime_failure is not None:
+            return runtime_failure
+
+    match inspection.status:
+        case SolutionFileStatus.READY:
+            metadata = inspection.metadata
+            target = (
+                f"{metadata.problem_id}. {metadata.title}" if metadata else "未知题目"
+            )
+            return DoctorCheck(
+                name=SOLUTION_CHECK_NAME,
+                status=DoctorStatus.PASS,
+                message=f"solution.py 语法、提交信息与本地运行正常（{target}）",
+            )
+
+        case SolutionFileStatus.MISSING:
+            return DoctorCheck(
+                name=SOLUTION_CHECK_NAME,
+                status=DoctorStatus.WARNING,
+                message="未找到 solution.py",
+                suggestion="请执行 uv run lc solve <题号> 创建解题文件",
+            )
+
+        case SolutionFileStatus.EMPTY:
+            return DoctorCheck(
+                name=SOLUTION_CHECK_NAME,
+                status=DoctorStatus.WARNING,
+                message="solution.py 当前为空",
+                suggestion="请执行 uv run lc solve <题号> 生成解题模板",
+            )
+
+        case SolutionFileStatus.READ_ERROR:
+            return DoctorCheck(
+                name=SOLUTION_CHECK_NAME,
+                status=DoctorStatus.FAIL,
+                message="无法读取 solution.py",
+                suggestion="请检查文件权限",
+            )
+
+        case SolutionFileStatus.INVALID_SYNTAX:
+            line = (
+                f"第 {inspection.syntax_line} 行"
+                if inspection.syntax_line
+                else "未知行"
+            )
+            return DoctorCheck(
+                name=SOLUTION_CHECK_NAME,
+                status=DoctorStatus.FAIL,
+                message=f"solution.py 存在 Python 语法错误（{line}）",
+                suggestion="请修复语法错误后重新执行 uv run lc doctor",
+            )
+
+        case SolutionFileStatus.NOT_SUBMITTABLE:
+            return DoctorCheck(
+                name=SOLUTION_CHECK_NAME,
+                status=DoctorStatus.WARNING,
+                message=f"solution.py 可编译，但暂不可提交：{inspection.detail}",
+                suggestion="请执行 uv run lc solve <题号> 重新生成标准模板",
+            )
+
+
+def _diagnose_solution_runtime(path: Path | None) -> DoctorCheck | None:
+    try:
+        result = run_solution_file(
+            path,
+            timeout=SOLUTION_RUN_TIMEOUT_SECONDS,
+        )
+    except subprocess.TimeoutExpired:
+        return DoctorCheck(
+            name=SOLUTION_CHECK_NAME,
+            status=DoctorStatus.FAIL,
+            message=f"solution.py 本地运行超时（{SOLUTION_RUN_TIMEOUT_SECONDS} 秒）",
+            suggestion="请检查死循环或耗时过长的本地测试",
+        )
+    except OSError:
+        return DoctorCheck(
+            name=SOLUTION_CHECK_NAME,
+            status=DoctorStatus.FAIL,
+            message="无法启动 Python 运行 solution.py",
+            suggestion="请检查当前 Python 环境",
+        )
+    if result.returncode:
+        return DoctorCheck(
+            name=SOLUTION_CHECK_NAME,
+            status=DoctorStatus.FAIL,
+            message=f"solution.py 本地运行失败（退出码：{result.returncode}）",
+            suggestion="请执行 uv run lc test 定位本地测试错误",
+        )
+    return None
+
+
+def diagnose_remote(result: ClientResult) -> tuple[DoctorCheck, DoctorCheck]:
+    """Translate one user-status request into connectivity and auth checks."""
+    if not result.ok:
+        match result.error:
+            case ClientErrorKind.NETWORK:
+                message = "无法连接 LeetCode 中文站"
+                suggestion = "请检查网络连接后重试"
+            case ClientErrorKind.HTTP:
+                message = "LeetCode 中文站返回异常 HTTP 状态"
+                suggestion = "请稍后重试"
+            case ClientErrorKind.INVALID_JSON:
+                message = "LeetCode 中文站响应无法解析"
+                suggestion = "请稍后重试，接口可能暂时异常"
+            case ClientErrorKind.INVALID_RESPONSE:
+                message = "LeetCode 中文站接口结构异常"
+                suggestion = "接口可能已变更，请检查项目更新"
+            case ClientErrorKind.UNAUTHORIZED | ClientErrorKind.MISSING_CSRF:
+                return (
+                    DoctorCheck(
+                        name=CONNECTIVITY_CHECK_NAME,
+                        status=DoctorStatus.PASS,
+                        message="LeetCode 中文站接口可访问",
+                    ),
+                    DoctorCheck(
+                        name=AUTHENTICATION_CHECK_NAME,
+                        status=DoctorStatus.FAIL,
+                        message="登录凭证无效或不完整",
+                        suggestion="请执行 uv run lc login 刷新登录态",
+                    ),
+                )
+            case _:
+                message = "LeetCode 中文站诊断发生未知错误"
+                suggestion = "请稍后重试"
+
+        return (
+            DoctorCheck(
+                name=CONNECTIVITY_CHECK_NAME,
+                status=DoctorStatus.FAIL,
+                message=message,
+                suggestion=suggestion,
+            ),
+            DoctorCheck(
+                name=AUTHENTICATION_CHECK_NAME,
+                status=DoctorStatus.WARNING,
+                message="网络或接口异常，暂时无法验证 Cookie",
+                suggestion="请先解决连接问题后重新执行 uv run lc doctor",
+            ),
+        )
+
+    status = result.data
+    if not isinstance(status, dict):
+        return diagnose_remote(ClientResult(error=ClientErrorKind.INVALID_RESPONSE))
+
+    connectivity = DoctorCheck(
+        name=CONNECTIVITY_CHECK_NAME,
+        status=DoctorStatus.PASS,
+        message="LeetCode 中文站接口连接正常",
+    )
+    if not status.get("isSignedIn"):
+        authentication = DoctorCheck(
+            name=AUTHENTICATION_CHECK_NAME,
+            status=DoctorStatus.FAIL,
+            message="Cookie 无效、已过期或当前未登录",
+            suggestion="请执行 uv run lc login 刷新登录态",
+        )
+    else:
+        username = status.get("username")
+        username = username if isinstance(username, str) and username else "未知用户"
+        authentication = DoctorCheck(
+            name=AUTHENTICATION_CHECK_NAME,
+            status=DoctorStatus.PASS,
+            message=f"Cookie 有效（当前用户：{username}）",
+        )
+    return connectivity, authentication