ituring-fetch 0.1.0__py3-none-any.whl

ituring_fetch/__init__.py

@@ -0,0 +1 @@
+"""ituring-fetch: CLI tool to scrape purchased ebooks from ituring.com.cn."""

ituring_fetch/api.py

@@ -0,0 +1,88 @@
+"""API client for ituring.com.cn REST API."""
+from typing import Any
+
+import httpx
+
+from .debug import log, log_request
+from .models import Book, Chapter
+
+BASE_URL = "https://api.ituring.com.cn/api"
+
+
+class IturingAPI:
+    def __init__(self, access_token: str = "", cookies: list[dict[str, Any]] | None = None):
+        headers: dict[str, str] = {
+            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36",
+        }
+        if access_token:
+            headers["Authorization"] = f"Bearer {access_token}"
+
+        self.client = httpx.Client(
+            base_url=BASE_URL,
+            timeout=30.0,
+            headers=headers,
+        )
+        # Also set cookies for dual auth
+        for c in (cookies or []):
+            self.client.cookies.set(
+                name=c["name"],
+                value=c["value"],
+                domain=c.get("domain", ""),
+                path=c.get("path", "/"),
+            )
+
+    def _parse_book(self, data: dict[str, Any]) -> Book:
+        chapters = []
+        ebook = data.get("ebook") or {}
+        for ch_data in ebook.get("chapters", []):
+            chapters.append(Chapter(
+                id=ch_data["id"],
+                subject=ch_data["subject"],
+                is_free=ch_data.get("isFree", True),
+                is_completed=ch_data.get("isCompleted", True),
+            ))
+        return Book(
+            id=data["id"],
+            name=data["name"],
+            author=data.get("authorNameString", ""),
+            chapters=chapters,
+        )
+
+    def get_book(self, book_id: int) -> Book | None:
+        """Fetch book details by ID. Returns None on failure."""
+        url = f"/Book/{book_id}"
+        log_request("GET", url)
+        resp = self.client.get(url)
+        log_request("GET", url, resp.status_code, resp.text[:500] if resp.status_code != 200 else "")
+        if resp.status_code != 200:
+            return None
+        return self._parse_book(resp.json())
+
+    def get_shelf_ebooks(self, page: int = 1) -> list[Book]:
+        """Fetch purchased ebooks list. Returns empty list on failure."""
+        url = "/User/ShelfEBook"
+        params = {"page": page, "query": "", "desc": "true"}
+        log_request("GET", f"{url}?page={page}")
+        resp = self.client.get(url, params=params)
+        log_request("GET", url, resp.status_code, resp.text[:500])
+        if resp.status_code != 200:
+            return []
+        data = resp.json()
+        log(f"ShelfEBook response keys: {list(data.keys())}, bookItems count: {len(data.get('bookItems', []))}")
+        books = []
+        for item in data.get("bookItems", []):
+            books.append(Book(
+                id=item["id"],
+                name=item["name"],
+                author=item.get("authorNameString", ""),
+            ))
+        return books
+
+    def get_profile(self) -> dict[str, Any] | None:
+        """Fetch user profile. Returns None if not logged in."""
+        log_request("GET", "/User/Profile")
+        resp = self.client.get("/User/Profile")
+        log_request("GET", "/User/Profile", resp.status_code, resp.text[:200])
+        if resp.status_code != 200:
+            return None
+        return resp.json()

ituring_fetch/auth.py

@@ -0,0 +1,147 @@
+"""Authentication: credential persistence and login/logout operations."""
+import json
+from pathlib import Path
+from typing import Any
+
+from .debug import log, log_step
+
+CREDS_DIR = Path.home() / ".ituring"
+CREDS_FILE = CREDS_DIR / "credentials.json"
+
+
+def _ensure_dir() -> None:
+    CREDS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def save_credentials(cookies: list[dict[str, Any]], access_token: str = "",
+                     refresh_token: str = "", user_id: str = "",
+                     path: Path | None = None) -> None:
+    """Save credentials (cookies + tokens) to JSON file."""
+    target = path or CREDS_FILE
+    target.parent.mkdir(parents=True, exist_ok=True)
+    data = {
+        "cookies": cookies,
+        "access_token": access_token,
+        "refresh_token": refresh_token,
+        "user_id": user_id,
+    }
+    target.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def load_credentials(path: Path | None = None) -> dict[str, Any]:
+    """Load credentials from JSON file. Returns empty dict if file missing."""
+    target = path or CREDS_FILE
+    if not target.exists():
+        return {}
+    return json.loads(target.read_text(encoding="utf-8"))
+
+
+def load_cookies() -> list[dict[str, Any]]:
+    """Load just the cookies from credentials file."""
+    creds = load_credentials()
+    return creds.get("cookies", [])
+
+
+def load_access_token() -> str:
+    """Load the access token from credentials file."""
+    creds = load_credentials()
+    return creds.get("access_token", "")
+
+
+def delete_credentials(path: Path | None = None) -> None:
+    """Delete the credentials file."""
+    target = path or CREDS_FILE
+    target.unlink(missing_ok=True)
+
+
+def credentials_exist() -> bool:
+    """Check if credentials file exists."""
+    return CREDS_FILE.exists()
+
+
+def login() -> None:
+    """Open browser for manual login, save cookies + token on success."""
+    from playwright.sync_api import sync_playwright
+
+    with sync_playwright() as p:
+        browser = p.chromium.launch(channel="chrome", headless=False)
+        context = browser.new_context(
+            user_agent="Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36"
+        )
+        page = context.new_page()
+
+        page.goto("https://www.ituring.com.cn/login", wait_until="domcontentloaded")
+        log_step("已打开登录页面")
+        print("已打开登录页面，请在浏览器中完成登录...")
+        print("登录成功后，工具将自动保存凭据。")
+
+        try:
+            # Wait for navigation away from login page
+            page.wait_for_url(
+                lambda url: "login" not in url,
+                timeout=300_000,
+            )
+            # Wait for SPA to initialize and tokens to be stored
+            page.wait_for_timeout(3000)
+
+            # Extract tokens from localStorage
+            log_step("登录重定向完成，正在提取 token...")
+            access_token = page.evaluate(
+                "() => localStorage.getItem('accessToken') || ''"
+            )
+            refresh_token = page.evaluate(
+                "() => localStorage.getItem('refreshToken') || ''"
+            )
+            user_id = page.evaluate(
+                "() => localStorage.getItem('userID') || ''"
+            )
+            log(f"accessToken: {'有' if access_token else '无'} (len={len(access_token)})")
+            log(f"refreshToken: {'有' if refresh_token else '无'}")
+            log(f"userID: {user_id}")
+
+            if not access_token:
+                # Retry after a short wait — SPA might still be initializing
+                log_step("token 未就绪，等待 5s 重试...")
+                page.wait_for_timeout(5000)
+                access_token = page.evaluate(
+                    "() => localStorage.getItem('accessToken') || ''"
+                )
+                log(f"重试后 accessToken: {'有' if access_token else '无'}")
+
+            cookies = list(context.cookies())
+            log(f"保存了 {len(cookies)} 个 cookie, token={bool(access_token)}")
+            save_credentials(list(cookies), access_token, refresh_token, user_id)
+
+            if access_token:
+                print("登录成功！凭据已保存。")
+            else:
+                print("登录可能未完成（未检测到 access token），请重试。")
+        except Exception as e:
+            print(f"登录超时或已取消: {e}")
+        finally:
+            browser.close()
+
+
+def logout() -> None:
+    """Delete saved credentials."""
+    delete_credentials()
+    print("已登出，凭据已删除。")
+
+
+def status() -> int:
+    """检查登录状态。返回 0 表示已登录，1 表示未登录。"""
+    creds = load_credentials()
+    if not creds or not creds.get("access_token"):
+        print("未登录。请执行: ituring-fetch login")
+        return 1
+
+    from .api import IturingAPI
+    api = IturingAPI(access_token=creds["access_token"], cookies=creds.get("cookies", []))
+    profile = api.get_profile()
+    if profile is None:
+        print("登录已过期，请重新执行: ituring-fetch login")
+        return 1
+
+    name = profile.get("nickName") or str(profile.get("userId", "未知"))
+    print(f"已登录: {name}")
+    return 0

ituring_fetch/cli.py

@@ -0,0 +1,147 @@
+"""CLI entry point for ituring-fetch."""
+import tempfile
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.progress import Progress
+from rich.table import Table
+
+from .auth import login as do_login, logout as do_logout, status as do_status, load_cookies, load_access_token
+from .api import IturingAPI
+from .converter import assemble_html, check_pandoc, convert
+from .debug import log_step
+from .scraper import fetch_all_chapters
+
+console = Console()
+
+
+@click.group()
+def main() -> None:
+    """ituring-fetch: 从图灵社区抓取已购电子书并转换为 epub/pdf/html。"""
+
+
+@main.command()
+def login() -> None:
+    """打开浏览器窗口让使用者登录图灵社区。"""
+    do_login()
+
+
+@main.command()
+def logout() -> None:
+    """删除保存的图灵社区账号信息。"""
+    do_logout()
+
+
+@main.command()
+def status() -> None:
+    """检查登录状态。"""
+    do_status()
+
+
+@main.command()
+def list_command() -> None:
+    """罗列已购电子书，呈现书籍名称和唯一ID。"""
+    cookies = load_cookies()
+    token = load_access_token()
+    if not token:
+        console.print("[red]未登录，请先执行: ituring-fetch login[/red]")
+        return
+
+    api = IturingAPI(access_token=token, cookies=cookies)
+    log_step(f"正在获取已购电子书列表...")
+    books = api.get_shelf_ebooks()
+
+    if not books:
+        console.print("[yellow]没有找到已购电子书，或登录已过期。[/yellow]")
+        return
+
+    table = Table(title="已购电子书")
+    table.add_column("ID", style="cyan", width=6)
+    table.add_column("书名", style="green")
+    table.add_column("作者", style="dim")
+
+    for b in books:
+        table.add_row(str(b.id), b.name, b.author)
+
+    console.print(table)
+
+
+# Alias 'list' command (avoids shadowing built-in)
+main.add_command(list_command, name="list")
+
+
+@main.command()
+@click.argument("book_id", type=int)
+@click.option("--type", "output_type", type=click.Choice(["epub", "pdf", "html"]), required=True, help="输出格式")
+@click.option("--output", "-o", "output_file", type=click.Path(), default=None, help="输出文件名")
+def fetch(book_id: int, output_type: str, output_file: str | None) -> None:
+    """爬取 ID 对应书籍，生成指定格式的单一文件。"""
+    if output_type in ("epub", "pdf") and not check_pandoc():
+        console.print("[red]请先安装 pandoc: sudo apt install pandoc[/red]")
+        return
+
+    cookies = load_cookies()
+    token = load_access_token()
+    if not token:
+        console.print("[red]未登录，请先执行: ituring-fetch login[/red]")
+        return
+
+    api = IturingAPI(access_token=token, cookies=cookies)
+    log_step(f"正在获取书籍信息 (ID: {book_id})...")
+    console.print(f"正在获取书籍信息 (ID: {book_id})...")
+    book = api.get_book(book_id)
+
+    if book is None:
+        console.print(f"[red]未找到该书籍 (ID: {book_id})，请用 list 命令确认[/red]")
+        return
+
+    console.print(f"书名: [green]{book.name}[/green]")
+    console.print(f"作者: {book.author}")
+    console.print(f"章节数: {len(book.chapters)}")
+
+    chapter_ids = [ch.id for ch in book.chapters]
+
+    console.print("\n正在抓取章节内容...")
+    with Progress() as progress:
+        task = progress.add_task("抓取中...", total=len(chapter_ids))
+
+        def update_progress(current: int, total: int) -> None:
+            progress.update(task, completed=current, description=f"抓取中... ({current}/{total})")
+
+        chapter_html_list = fetch_all_chapters(cookies, book_id, chapter_ids, update_progress)
+
+    # Pair chapters with their HTML
+    chapters_data = []
+    for ch, html_content in zip(book.chapters, chapter_html_list):
+        if not html_content:
+            console.print(f"[yellow]  警告: 章节 '{ch.subject}' 内容为空[/yellow]")
+        chapters_data.append({"subject": ch.subject, "html": html_content})
+
+    valid_chapters = [c for c in chapters_data if c["html"]]
+    if not valid_chapters:
+        console.print("[red]所有章节抓取失败，无法生成文件[/red]")
+        return
+
+    console.print(f"\n成功抓取 {len(valid_chapters)}/{len(chapters_data)} 个章节")
+
+    # Assemble HTML
+    metadata = {"title": book.name, "author": book.author}
+    full_html = assemble_html(valid_chapters, metadata)
+
+    # Determine output path
+    if output_file:
+        out_path = Path(output_file)
+    else:
+        out_path = Path(f"{book.name}.{output_type}")
+
+    with tempfile.NamedTemporaryFile(suffix=".html", mode="w", encoding="utf-8", delete=False) as f:
+        temp_html = Path(f.name)
+        f.write(full_html)
+
+    try:
+        console.print(f"\n正在转换为 {output_type} 格式...")
+        convert(temp_html, out_path, output_type, metadata, cookies)
+        console.print(f"[green]✓ 已生成: {out_path}[/green]")
+    finally:
+        temp_html.unlink(missing_ok=True)

ituring_fetch/converter.py

@@ -0,0 +1,151 @@
+"""HTML assembly and format conversion (epub via pandoc, pdf via Playwright)."""
+import base64
+import html as html_module
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any
+
+import httpx
+from playwright.sync_api import sync_playwright
+
+from .debug import log, log_step
+
+
+def check_pandoc() -> bool:
+    """Check if pandoc is available on PATH."""
+    return shutil.which("pandoc") is not None
+
+
+def assemble_html(chapters: list[dict[str, str]], metadata: dict[str, str]) -> str:
+    """Assemble multiple chapters into a single HTML document.
+
+    Args:
+        chapters: List of {"subject": str, "html": str}
+        metadata: {"title": str, "author": str}
+    """
+    title = html_module.escape(metadata.get("title", ""))
+    author = html_module.escape(metadata.get("author", ""))
+
+    toc_items = []
+    body_items = []
+    for i, ch in enumerate(chapters):
+        subject = ch["subject"]
+        safe_subject = html_module.escape(subject)
+        toc_items.append(f'<li><a href="#ch{i}">{safe_subject}</a></li>')
+        body_items.append(f'<h2 id="ch{i}">{safe_subject}</h2>')
+        body_items.append(ch["html"])
+
+    return f"""<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<title>{title}</title>
+<style>
+body {{ font-family: "Noto Serif CJK SC", "Source Han Serif SC", serif; line-height: 1.8; max-width: 800px; margin: 0 auto; padding: 2em; }}
+h1 {{ text-align: center; }}
+h2 {{ margin-top: 2em; border-bottom: 1px solid #ccc; padding-bottom: 0.3em; }}
+.toc {{ background: #f5f5f5; padding: 1em 2em; margin: 1em 0; }}
+img {{ max-width: 100%; }}
+pre {{ background: #f4f4f4; padding: 1em; overflow-x: auto; }}
+code {{ font-family: "Noto Mono", "Source Code Pro", monospace; font-size: 0.9em; }}
+</style>
+</head>
+<body>
+<h1>{title}</h1>
+<p style="text-align:center;color:#888;">{author}</p>
+
+<div class="toc">
+<h3>目录</h3>
+<ol>
+{"".join(toc_items)}
+</ol>
+</div>
+
+{"".join(body_items)}
+</body>
+</html>"""
+
+
+def convert(html_path: Path, output_path: Path, output_type: str,
+            metadata: dict[str, str], cookies: list[dict[str, Any]] | None = None) -> None:
+    """Convert HTML file to target format.
+
+    Args:
+        html_path: Input HTML file path
+        output_path: Output file path
+        output_type: "epub", "pdf", or "html"
+        metadata: {"title": str, "author": str}
+        cookies: Playwright-format cookies for authenticated image fetch
+    """
+    if output_type == "html":
+        shutil.copy(html_path, output_path)
+        return
+
+    if output_type == "pdf":
+        _convert_pdf_playwright(html_path, output_path, cookies or [])
+        return
+
+    if output_type == "epub":
+        _convert_epub(html_path, output_path, metadata, cookies or [])
+        return
+
+
+def _convert_epub(html_path: Path, output_path: Path, metadata: dict[str, str],
+                  cookies: list[dict[str, Any]]) -> None:
+    """Convert HTML to EPUB via pandoc."""
+    title = metadata.get("title", "")
+    author = metadata.get("author", "")
+
+    cmd = [
+        "pandoc",
+        str(html_path),
+        "-o", str(output_path),
+        "--from=html",
+        "--to=epub",
+        "--metadata", f"title={title}",
+    ]
+    if author:
+        cmd.extend(["--metadata", f"author={author}"])
+
+    # Allow image fetch failures — pandoc will use placeholders
+    log_step(f"pandoc epub: {' '.join(cmd)}")
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        log(f"pandoc stderr: {result.stderr[:1000]}")
+        # Retry without image fetching
+        cmd_no_images = cmd + ["--extract-media=/dev/null"]
+        try:
+            subprocess.run(cmd_no_images, check=True)
+        except subprocess.CalledProcessError:
+            raise
+
+
+def _convert_pdf_playwright(html_path: Path, output_path: Path,
+                            cookies: list[dict[str, Any]]) -> None:
+    """Convert HTML to PDF using Playwright's built-in PDF generation."""
+    log_step("使用 Playwright 生成 PDF...")
+    html_content = html_path.read_text(encoding="utf-8")
+
+    with sync_playwright() as p:
+        browser = p.chromium.launch(channel="chrome", headless=True)
+        context = browser.new_context()
+        if cookies:
+            context.add_cookies(cookies)  # type: ignore[reportArgumentType]
+
+        page = context.new_page()
+        # Use data URL to avoid file:// CORS issues with images
+        encoded = base64.b64encode(html_content.encode("utf-8")).decode()
+        page.goto(f"data:text/html;base64,{encoded}", wait_until="networkidle", timeout=60000)
+        page.wait_for_timeout(2000)
+
+        page.pdf(
+            path=str(output_path),
+            format="A4",
+            margin={"top": "2cm", "bottom": "2cm", "left": "2cm", "right": "2cm"},
+            print_background=True,
+        )
+
+        browser.close()
+    log_step(f"PDF 已生成: {output_path}")

ituring_fetch/debug.py

@@ -0,0 +1,36 @@
+"""Debug logging controlled by ITURING_DEBUG environment variable.
+
+Set ITURING_DEBUG=1 to enable debug output to stderr.
+"""
+import os
+import sys
+import time
+
+
+def _enabled() -> bool:
+    return os.environ.get("ITURING_DEBUG", "") in ("1", "true", "yes")
+
+
+def log(msg: str) -> None:
+    """Write debug message to stderr if ITURING_DEBUG is enabled."""
+    if _enabled():
+        ts = time.strftime("%H:%M:%S")
+        print(f"[DEBUG {ts}] {msg}", file=sys.stderr)
+
+
+def log_request(method: str, url: str, status: int | None = None, body: str = "") -> None:
+    """Log an HTTP request/response."""
+    if _enabled():
+        ts = time.strftime("%H:%M:%S")
+        status_str = f" → {status}" if status else ""
+        print(f"[DEBUG {ts}] {method} {url}{status_str}", file=sys.stderr)
+        if body:
+            preview = body[:500] + ("..." if len(body) > 500 else "")
+            print(f"[DEBUG {ts}]   {preview}", file=sys.stderr)
+
+
+def log_step(msg: str) -> None:
+    """Log a processing step."""
+    if _enabled():
+        ts = time.strftime("%H:%M:%S")
+        print(f"[DEBUG {ts}] ● {msg}", file=sys.stderr)

ituring_fetch/models.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Chapter:
+    id: int
+    subject: str
+    is_free: bool = True
+    is_completed: bool = True
+
+
+@dataclass
+class Book:
+    id: int
+    name: str
+    author: str = ""
+    chapters: list[Chapter] = field(default_factory=list)

ituring_fetch/scraper.py

@@ -0,0 +1,79 @@
+"""Playwright-based chapter content scraper."""
+import random
+import time
+from typing import Any, Callable
+
+from playwright.sync_api import sync_playwright, BrowserContext
+
+from .debug import log, log_step
+
+CHAPTER_URL = "https://www.ituring.com.cn/book/miniarticle/{chapter_id}?bookID={book_id}&type=minibook"
+
+
+def create_context(cookies: list[dict[str, Any]]) -> tuple:
+    """Create a Playwright browser context with saved cookies.
+
+    Returns:
+        (playwright, browser, context) — caller must clean up all three.
+    """
+    p = sync_playwright().start()
+    browser = p.chromium.launch(channel="chrome", headless=True)
+    context = browser.new_context(
+        user_agent="Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36"
+    )
+    context.add_cookies(cookies)  # type: ignore[reportArgumentType]
+    return p, browser, context
+
+
+def fetch_chapter_html(context: BrowserContext, book_id: int, chapter_id: int) -> str:
+    """Fetch HTML content of a single chapter. Returns empty string on failure."""
+    url = CHAPTER_URL.format(chapter_id=chapter_id, book_id=book_id)
+    page = context.new_page()
+    try:
+        page.goto(url, wait_until="networkidle", timeout=30000)
+        page.wait_for_timeout(1500)
+
+        html = page.evaluate("""() => {
+            const el = document.querySelector('.article-content');
+            return el ? el.innerHTML : '';
+        }""")
+        return html
+    except Exception:
+        return ""
+    finally:
+        page.close()
+
+
+def fetch_all_chapters(
+    cookies: list[dict[str, Any]], book_id: int, chapter_ids: list[int],
+    progress_callback: Callable[[int, int], None] | None = None,
+) -> list[str]:
+    """Fetch all chapters' HTML content.
+
+    Creates a dedicated browser context, fetches each chapter, then cleans up.
+    Sleeps 1-3s between requests to avoid rate limiting.
+    Returns list of HTML strings (one per chapter, empty string for failures).
+    """
+    log_step(f"创建浏览器上下文，准备抓取 {len(chapter_ids)} 个章节...")
+    p, browser, context = create_context(cookies)
+    results: list[str] = []
+
+    try:
+        for i, ch_id in enumerate(chapter_ids):
+            if progress_callback:
+                progress_callback(i + 1, len(chapter_ids))
+
+            html = fetch_chapter_html(context, book_id, ch_id)
+            results.append(html)
+            log(f"章节 {ch_id}: {'OK' if html else '空'} ({len(html)} chars)")
+
+            if i < len(chapter_ids) - 1:
+                delay = random.uniform(1.0, 3.0)
+                log(f"等待 {delay:.1f}s...")
+                time.sleep(delay)
+    finally:
+        context.close()
+        browser.close()
+        p.stop()
+
+    return results

ituring_fetch-0.1.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: ituring-fetch
+Version: 0.1.0
+Summary: CLI tool to scrape purchased ebooks from ituring.com.cn
+Author-email: yms_hi <yms_hi@Outlook.com>
+Requires-Python: >=3.11
+Requires-Dist: click>=8
+Requires-Dist: httpx>=0.27
+Requires-Dist: playwright>=1.40
+Requires-Dist: rich>=13
+Description-Content-Type: text/markdown
+
+# ituring-fetch
+
+把图灵社区已购电子书扒下来，转成 epub/pdf/html。
+
+## 安装
+
+```bash
+git clone <repo>
+cd ituring_fetch
+uv sync
+playwright install chromium   # 或者用系统自带的 Chrome
+```
+
+依赖：Python 3.11+、pandoc（epub 格式需要）、Chrome/Chromium。
+
+## 使用
+
+```bash
+# 登录（会弹出浏览器窗口）
+uv run ituring-fetch login
+
+# 看看登录没
+uv run ituring-fetch status
+
+# 列出已购电子书
+uv run ituring-fetch list
+
+# 抓取一本书
+uv run ituring-fetch fetch 1143 --type=epub
+uv run ituring-fetch fetch 1143 --type=pdf
+uv run ituring-fetch fetch 1143 --type=html
+
+# 指定输出文件名
+uv run ituring-fetch fetch 1143 --type=pdf -o mybook.pdf
+
+# 登出
+uv run ituring-fetch logout
+```
+
+`list` 输出的第一列就是书籍 ID。
+
+## 调试
+
+出问题时设个环境变量看详细日志：
+
+```bash
+ITURING_DEBUG=1 uv run ituring-fetch fetch 1143 --type=pdf
+```
+
+会往 stderr 打请求/响应细节。
+
+## 原理
+
+登录时用 Playwright 打开浏览器，你手动登录后，程序从 localStorage 里取出 access token，跟 cookie 一起存到 `~/.ituring/credentials.json`。
+
+后续操作：
+- `list` 和书籍信息直接调 `api.ituring.com.cn` 的接口，带 Bearer token
+- 章节内容用 Playwright headless 渲染页面，抽 `.article-content` 的 HTML
+- 合并所有章节，pandoc 转 epub，Playwright 内置 PDF 引擎出 pdf

ituring_fetch-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+ituring_fetch/__init__.py,sha256=2KhedlgmuNnHU09K4VujfJNDvD9HgXik1q7L7loQg1Q,78
+ituring_fetch/api.py,sha256=S-G9zHkStOO-knmodyA0Jd_NnqsOEmsvlEQ883IQ-P0,3180
+ituring_fetch/auth.py,sha256=R-5OFfmdGWGldZnfEvaemEtegATL430Yy3Qtxrsj728,5220
+ituring_fetch/cli.py,sha256=ziy77Co5pItcNS90tzR4i6saDdORt8PLyi_YGwRuG_g,4931
+ituring_fetch/converter.py,sha256=61uO6X1LFATwy6NFMtjCPVtFRRDx1_zpsEWShLgEnRc,4905
+ituring_fetch/debug.py,sha256=9ptYkRhMCrnR1dNNOI7Op-KsAR_E1a2YLs-I8o8Cm4g,1122
+ituring_fetch/models.py,sha256=lZ8ka6wj21OKBACQSGwSrng-rFUOt30YbYfuk1i1z7I,283
+ituring_fetch/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ituring_fetch/scraper.py,sha256=eUO7OYeCeVn8oVRedhCGPrz4wUthadIYqh7_Yc6SQ3w,2696
+ituring_fetch-0.1.0.dist-info/METADATA,sha256=NoE9DQMIwJXgTB_N2zuzt4UrTCCPq9SkPQ6JYpQsOOo,1745
+ituring_fetch-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+ituring_fetch-0.1.0.dist-info/entry_points.txt,sha256=qKDY1RYVbZZlm0iejgmlO2dfIFg3k1L-ulc2Bq7YShw,57
+ituring_fetch-0.1.0.dist-info/RECORD,,

ituring_fetch-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ituring_fetch-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ituring-fetch = ituring_fetch.cli:main