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

leetcode_local_cli/__init__.py

@@ -0,0 +1 @@
+"""LeetCode local workflow CLI package."""

leetcode_local_cli/__main__.py

@@ -0,0 +1,3 @@
+from .cli import run
+
+run()

leetcode_local_cli/auth.py

@@ -0,0 +1,215 @@
+import json
+import os
+from dataclasses import dataclass
+from enum import Enum
+from getpass import getpass
+from pathlib import Path
+
+import browser_cookie3
+
+LC_DOMAIN = "leetcode.cn"
+# BROWSER_LOADERS = [("Edge", browser_cookie3.edge), ("Chrome", browser_cookie3.chrome)]
+BROWSER_LOADERS = [("Chrome", browser_cookie3.chrome)]
+
+REQUIRED_COOKIE_NAMES = ("LEETCODE_SESSION", "csrftoken")
+PROJECT_ROOT = Path.cwd()
+SESSION_DIR = PROJECT_ROOT / ".leetcode_local_cli"
+SESSION_FILE = SESSION_DIR / "session.json"
+LEGACY_SESSION_DIR = PROJECT_ROOT / ".aether_lc"
+LEGACY_SESSION_FILE = LEGACY_SESSION_DIR / "session.json"
+
+
+class SessionFileStatus(str, Enum):
+    VALID = "valid"
+    MISSING = "missing"
+    INVALID_JSON = "invalid_json"
+    INVALID_STRUCTURE = "invalid_structure"
+    MISSING_COOKIES = "missing_cookies"
+    READ_ERROR = "read_error"
+
+
+@dataclass(frozen=True)
+class SessionFileInspection:
+    status: SessionFileStatus
+    missing_cookie_names: tuple[str, ...] = ()
+    username: str | None = None
+    source: str | None = None
+
+
+class SessionFileError(OSError):
+    pass
+
+
+def _resolve_default_session_file() -> Path:
+    """Move the pre-v0.7 session to the canonical directory when possible."""
+    if SESSION_FILE.exists() or not LEGACY_SESSION_FILE.exists():
+        return SESSION_FILE
+
+    try:
+        SESSION_DIR.mkdir(mode=0o700, parents=True, exist_ok=True)
+        if os.name != "nt":
+            os.chmod(SESSION_DIR, 0o700)
+        LEGACY_SESSION_FILE.replace(SESSION_FILE)
+        if os.name != "nt":
+            os.chmod(SESSION_FILE, 0o600)
+        try:
+            LEGACY_SESSION_DIR.rmdir()
+        except OSError:
+            # Preserve a non-empty legacy directory instead of deleting unrelated data.
+            pass
+    except OSError:
+        if SESSION_FILE.exists():
+            return SESSION_FILE
+        return LEGACY_SESSION_FILE
+
+    return SESSION_FILE
+
+
+def get_cookies_from_browser() -> tuple[str, dict[str, str]] | None:
+    for browser_name, loader in BROWSER_LOADERS:
+        try:
+            cookie_jar = loader(domain_name=LC_DOMAIN)
+
+        except Exception:
+            continue
+
+        cookies_dict: dict[str, str] = {
+            cookie.name: cookie.value
+            for cookie in cookie_jar
+            if (
+                cookie.domain
+                and cookie.domain.lstrip(".").endswith(LC_DOMAIN)
+                and cookie.value is not None
+            )
+        }
+        if all(name in cookies_dict for name in REQUIRED_COOKIE_NAMES):
+            return browser_name, {
+                "LEETCODE_SESSION": cookies_dict["LEETCODE_SESSION"],
+                "csrftoken": cookies_dict["csrftoken"],
+            }
+
+    return None
+
+
+def parse_cookie_header(cookies: str) -> dict[str, str] | None:
+    cookies_dict = {}
+    for item in cookies.split(";"):
+        if "=" in item:
+            key, val = item.strip().split("=", 1)
+            cookies_dict[key] = val
+
+    if all(name in cookies_dict for name in REQUIRED_COOKIE_NAMES):
+        return {
+            "LEETCODE_SESSION": cookies_dict["LEETCODE_SESSION"],
+            "csrftoken": cookies_dict["csrftoken"],
+        }
+
+    return None
+
+
+def get_cookies_from_input() -> dict[str, str] | None:
+    return parse_cookie_header(getpass("请粘贴 Cookie（输入内容不会回显）：\n"))
+
+
+def save_session(session_data: dict, path: Path | None = None) -> None:
+    if path is None:
+        _resolve_default_session_file()
+    file_path = path or SESSION_FILE
+    temporary_file = file_path.with_suffix(f"{file_path.suffix}.tmp")
+    try:
+        file_path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        if path is None and os.name != "nt":
+            os.chmod(file_path.parent, 0o700)
+        descriptor = os.open(
+            temporary_file,
+            os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+            0o600,
+        )
+        with os.fdopen(descriptor, "w", encoding="utf-8") as file:
+            json.dump(session_data, file, indent=4, ensure_ascii=False)
+        os.chmod(temporary_file, 0o600)
+        temporary_file.replace(file_path)
+        os.chmod(file_path, 0o600)
+    except (OSError, TypeError, ValueError) as exc:
+        try:
+            temporary_file.unlink(missing_ok=True)
+        except OSError:
+            pass
+        raise SessionFileError("无法保存 Session 文件") from exc
+
+
+def load_session() -> dict | None:
+    file_path = _resolve_default_session_file()
+    try:
+        with open(file_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return None
+    except json.JSONDecodeError:
+        return None
+    except OSError as exc:
+        raise SessionFileError("无法读取 Session 文件") from exc
+
+
+def inspect_session_file(path: Path | None = None) -> SessionFileInspection:
+    if path is None:
+        path = _resolve_default_session_file()
+
+    try:
+        content = path.read_text(encoding="utf-8")
+
+    except FileNotFoundError:
+        return SessionFileInspection(
+            status=SessionFileStatus.MISSING,
+        )
+
+    except OSError:
+        return SessionFileInspection(
+            status=SessionFileStatus.READ_ERROR,
+        )
+
+    try:
+        data = json.loads(content)
+
+    except json.JSONDecodeError:
+        return SessionFileInspection(
+            status=SessionFileStatus.INVALID_JSON,
+        )
+
+    if not isinstance(data, dict):
+        return SessionFileInspection(
+            status=SessionFileStatus.INVALID_STRUCTURE,
+        )
+
+    cookies = data.get("cookies")
+
+    if not isinstance(cookies, dict):
+        return SessionFileInspection(
+            status=SessionFileStatus.INVALID_STRUCTURE,
+        )
+
+    missing_cookie_names: list[str] = []
+
+    for cookie_name in REQUIRED_COOKIE_NAMES:
+        cookie_value = cookies.get(cookie_name)
+
+        if not isinstance(cookie_value, str) or cookie_value == "":
+            missing_cookie_names.append(cookie_name)
+
+    if missing_cookie_names:
+        return SessionFileInspection(
+            status=SessionFileStatus.MISSING_COOKIES,
+            missing_cookie_names=tuple(missing_cookie_names),
+        )
+
+    username, source = data.get("username"), data.get("source")
+
+    if not isinstance(username, str):
+        username = None
+
+    if not isinstance(source, str):
+        source = None
+
+    return SessionFileInspection(
+        status=SessionFileStatus.VALID, username=username, source=source
+    )

leetcode_local_cli/cli.py

@@ -0,0 +1,217 @@
+import sys
+from typing import Annotated
+
+from typer import Exit, Option, Typer, echo
+
+from leetcode_local_cli.auth import (
+    SessionFileError,
+    get_cookies_from_browser,
+    get_cookies_from_input,
+    save_session,
+)
+from leetcode_local_cli.client import ClientErrorKind, LeetCodeClient
+from leetcode_local_cli.ui import (
+    loading,
+    render_doctor_report,
+    render_submission_result,
+    success,
+    warning,
+    error,
+    render_profile,
+    render_problem_detail,
+    render_problem_list,
+)
+from leetcode_local_cli.service import (
+    client_error_message,
+    get_account_profile,
+    get_doctor_report,
+    get_problem_detail_by_question_id,
+    get_problem_summaries,
+    get_user_status,
+    submit_current_solution,
+)
+from leetcode_local_cli.workspace import (
+    ProblemMetadata,
+    SolutionFileStatus,
+    inspect_solution_file,
+    run_solution_file,
+    write_solution_file,
+)
+from leetcode_local_cli.version import PACKAGE_NAME, get_version
+
+app = Typer(help="力扣中文站本地化刷题 CLI 工具", no_args_is_help=True)
+
+
+def _configure_utf8_output() -> None:
+    """Keep localized CLI output writable when Windows redirects the streams."""
+    for stream in (sys.stdout, sys.stderr):
+        reconfigure = getattr(stream, "reconfigure", None)
+        if callable(reconfigure):
+            reconfigure(encoding="utf-8", errors="backslashreplace")
+
+
+def run() -> None:
+    """Run the command-line application with deterministic UTF-8 output."""
+    _configure_utf8_output()
+    app()
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        echo(f"{PACKAGE_NAME} {get_version()}")
+        raise Exit()
+
+
+@app.callback()
+def main(
+    version: Annotated[
+        bool,
+        Option(
+            "--version",
+            callback=_version_callback,
+            is_eager=True,
+            help="显示版本并退出",
+        ),
+    ] = False,
+) -> None:
+    """力扣中文站本地化刷题 CLI 工具。"""
+
+
+@app.command()
+def login() -> None:
+    with loading("正在读取浏览器 Cookie..."):
+        browser_result = get_cookies_from_browser()
+    if not browser_result:
+        warning("未从浏览器读取到 Cookie，请手动粘贴")
+        source, cookies = "manual", get_cookies_from_input()
+    else:
+        source, cookies = browser_result
+    if not cookies:
+        warning("未获取有效 Cookie")
+        raise Exit(1)
+    with LeetCodeClient(cookies) as client:
+        status_result = client.user_status()
+        status = status_result.data
+        if not status_result.ok:
+            error(client_error_message(status_result.error))
+            raise Exit(1)
+        if isinstance(status, dict) and status.get("isSignedIn"):
+            username = status.get("username")
+            if not isinstance(username, str) or not username:
+                error(client_error_message(ClientErrorKind.INVALID_RESPONSE))
+                raise Exit(1)
+            try:
+                save_session(
+                    {
+                        "site": "leetcode.cn",
+                        "source": source,
+                        "username": username,
+                        "cookies": cookies,
+                    }
+                )
+            except SessionFileError as exc:
+                error(str(exc))
+                raise Exit(1)
+            success("成功登录")
+        else:
+            warning("Cookie 无效或已过期")
+            raise Exit(1)
+
+
+@app.command()
+def status() -> None:
+    user_status = get_user_status()
+    username = user_status.get("username", "未知用户")
+    success(f"在线状态: 当前账号 {username}")
+
+
+@app.command()
+def profile() -> None:
+    account_profile = get_account_profile()
+    render_profile(account_profile)
+
+
+@app.command()
+def get(question_id: str) -> None:
+    problem_detail = get_problem_detail_by_question_id(question_id)
+    render_problem_detail(problem_detail)
+
+
+@app.command()
+def show(limit: int = 50, skip: int = 0) -> None:
+    problem_summaries = get_problem_summaries(limit=limit, skip=skip)
+    render_problem_list(problem_summaries)
+
+
+@app.command()
+def solve(question_id: str) -> None:
+    problem_detail = get_problem_detail_by_question_id(question_id)
+    render_problem_detail(problem_detail)
+    if not problem_detail.python_code:
+        error("题目未提供 Python3 代码模板，无法生成 solution.py")
+        raise Exit(1)
+    if (
+        not problem_detail.question_id
+        or not problem_detail.submit_question_id
+        or not problem_detail.title
+        or not problem_detail.title_slug
+    ):
+        error("题目元信息不完整，无法生成可提交的 solution.py")
+        raise Exit(1)
+    write_solution_file(
+        problem_detail.python_code,
+        ProblemMetadata(
+            problem_id=problem_detail.question_id,
+            submit_question_id=problem_detail.submit_question_id,
+            title=problem_detail.title,
+            title_slug=problem_detail.title_slug,
+        ),
+    )
+
+
+@app.command()
+def test() -> None:
+    inspection = inspect_solution_file()
+    match inspection.status:
+        case SolutionFileStatus.MISSING:
+            error("未找到 solution.py，请先执行 lc solve <题号>")
+            raise Exit(1)
+        case SolutionFileStatus.EMPTY:
+            error("solution.py 当前为空，请先执行 lc solve <题号>")
+            raise Exit(1)
+        case SolutionFileStatus.READ_ERROR:
+            error("无法读取 solution.py，请检查文件权限")
+            raise Exit(1)
+        case SolutionFileStatus.INVALID_SYNTAX:
+            line = (
+                f"第 {inspection.syntax_line} 行"
+                if inspection.syntax_line
+                else "未知行"
+            )
+            error(f"solution.py 存在 Python 语法错误（{line}）")
+            raise Exit(1)
+
+    result = run_solution_file()
+    if result.returncode:
+        error("本地测试失败")
+        raise Exit(result.returncode)
+    success("本地测试通过")
+
+
+@app.command()
+def doctor() -> None:
+    with loading("正在检查本地环境与 LeetCode 连接..."):
+        report = get_doctor_report()
+    render_doctor_report(report)
+    if not report.ok:
+        raise Exit(1)
+
+
+@app.command()
+def submit() -> None:
+    result = submit_current_solution()
+    render_submission_result(result)
+
+
+if __name__ == "__main__":
+    run()