dongchedi-cli 0.1.0__py3-none-any.whl

dongchedi_cli/__init__.py

@@ -0,0 +1,3 @@
+"""懂车帝数据查询 CLI。"""
+
+__version__ = "0.1.0"

dongchedi_cli/cli.py

@@ -0,0 +1,795 @@
+"""dcd 命令行入口。
+
+免登录子命令：rank / brands / series / cars / specs / reviews / search / dealer
+需登录态子命令：series-info（HTML SSR）/ me（账号信息）
+
+登录态来源（auth-import 写入，或 --cookie-file / DCD_COOKIE_FILE 指定）：
+  dcd auth-import <playwright-state.json>  # playwright-cli state-save 的产物
+
+约定：
+- 表格结果走 stdout，进度与提示走 stderr，可安全重定向
+- 所有子命令支持 --json 输出原始接口数据
+- 退出码：0 成功 / 1 接口或网络错误
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import time
+import unicodedata
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+
+from . import __version__
+
+BASE = "https://www.dongchedi.com"
+COMMON = {"aid": "1839", "app_name": "auto_web_pc"}
+UA = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+)
+TIMEOUT = 20
+
+
+class DcdError(RuntimeError):
+    pass
+
+
+# ---------- 登录态 ----------
+
+DEFAULT_COOKIE_FILE = Path.home() / ".config" / "dcd" / "cookies.txt"
+
+
+def load_cookies(explicit: str | None) -> dict[str, str]:
+    """读取 Netscape 格式 Cookie 文件，返回 name -> value。"""
+    if explicit:
+        path = Path(explicit).expanduser()
+    elif os.environ.get("DCD_COOKIE_FILE"):
+        path = Path(os.environ["DCD_COOKIE_FILE"]).expanduser()
+    else:
+        path = DEFAULT_COOKIE_FILE
+    if not path.is_file():
+        raise DcdError(
+            f"缺少登录态 Cookie: {path} 不存在；"
+            "先运行 `dcd auth-import <playwright-state.json>` 导入，"
+            "或用 --cookie-file / DCD_COOKIE_FILE 指定"
+        )
+    cookies: dict[str, str] = {}
+    for line in path.read_text(encoding="utf-8").splitlines():
+        line = line.rstrip("\r")
+        # curl 等导出的 Netscape 文件用 "#HttpOnly_" 前缀标记 HttpOnly cookie
+        if line.startswith("#HttpOnly_"):
+            line = line[len("#HttpOnly_") :]
+        elif not line or line.startswith("#"):
+            continue
+        fields = line.split("\t")
+        if len(fields) >= 7 and fields[5]:
+            cookies[fields[5]] = fields[6]
+    if not cookies:
+        raise DcdError(f"Cookie 文件没有有效条目: {path}")
+    return cookies
+
+
+def cookie_header(cookies: dict[str, str]) -> str:
+    # urllib 请求头按 latin-1 编码，这里转成裸 UTF-8 字节（与浏览器/curl 线上行为一致）
+    raw = "; ".join(f"{k}={v}" for k, v in cookies.items())
+    return raw.encode("utf-8").decode("latin-1")
+
+
+# ---------- HTTP ----------
+
+
+def api_get(
+    path: str, params: dict, referer: str | None = None, cookies: dict[str, str] | None = None
+) -> dict:
+    url = f"{BASE}{path}?{urllib.parse.urlencode(params)}"
+    headers = {"User-Agent": UA, "Accept": "application/json, text/plain, */*"}
+    if referer:
+        headers["Referer"] = referer
+    if cookies:
+        headers["Cookie"] = cookie_header(cookies)
+    return _fetch(url, headers)
+
+
+def api_get_html(path: str, cookies: dict[str, str]) -> tuple[str, str]:
+    """请求 HTML 页面，返回 (html, 最终 URL)。"""
+    url = f"{BASE}{path}"
+    headers = {
+        "User-Agent": UA,
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Cookie": cookie_header(cookies),
+        "Referer": f"{BASE}/",
+    }
+    req = urllib.request.Request(url, headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=TIMEOUT) as resp:
+            return resp.read().decode("utf-8", errors="replace"), resp.geturl()
+    except urllib.error.HTTPError as exc:
+        raise DcdError(f"HTTP {exc.code}: {url}") from exc
+    except urllib.error.URLError as exc:
+        raise DcdError(f"网络错误: {exc.reason}") from exc
+
+
+def extract_next_data(html: str, final_url: str) -> dict:
+    """从页面 __NEXT_DATA__ 脚本块提取 pageProps。"""
+    if "/login-required" in final_url:
+        raise DcdError(
+            "登录态失效或未导入：运行 `dcd auth-import <playwright-state.json>`；"
+            "注意 Cookie 需来自已登录懂车帝的浏览器"
+        )
+    match = re.search(r'<script id="__NEXT_DATA__"[^>]*>(.*?)</script>', html, re.DOTALL)
+    if not match:
+        raise DcdError("页面结构异常：未找到 __NEXT_DATA__（可能被风控或页面改版）")
+    return (json.loads(match.group(1)).get("props") or {}).get("pageProps") or {}
+
+
+def api_post(path: str, data: dict) -> dict:
+    url = f"{BASE}{path}?{urllib.parse.urlencode(COMMON)}"
+    headers = {
+        "User-Agent": UA,
+        "Accept": "application/json, text/plain, */*",
+        "Content-Type": "application/x-www-form-urlencoded",
+    }
+    return _fetch(url, headers, urllib.parse.urlencode(data).encode())
+
+
+def _fetch(url: str, headers: dict, body: bytes | None = None) -> dict:
+    req = urllib.request.Request(url, data=body, headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=TIMEOUT) as resp:
+            payload = json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        raise DcdError(f"HTTP {exc.code}: {url}") from exc
+    except urllib.error.URLError as exc:
+        raise DcdError(f"网络错误: {exc.reason}") from exc
+    except json.JSONDecodeError as exc:
+        raise DcdError(f"响应不是 JSON（可能被风控拦截）: {url}") from exc
+    if payload.get("status"):
+        msg = payload.get("prompts") or payload.get("message") or ""
+        raise DcdError(f"接口错误 status={payload['status']} {msg}")
+    return payload
+
+
+# ---------- 输出 ----------
+
+
+def _width(text: str) -> int:
+    return sum(2 if unicodedata.east_asian_width(ch) in "WF" else 1 for ch in text)
+
+
+def _pad(text: str, width: int) -> str:
+    return text + " " * max(0, width - _width(text))
+
+
+def clip(text: str, limit: int) -> str:
+    if _width(text) <= limit:
+        return text
+    out, w = "", 0
+    for ch in text:
+        w += 2 if unicodedata.east_asian_width(ch) in "WF" else 1
+        if w > limit - 1:
+            break
+        out += ch
+    return out + "…"
+
+
+def render_table(headers: list[str], rows: list[list[str]]) -> str:
+    widths = [_width(h) for h in headers]
+    for row in rows:
+        for i, cell in enumerate(row[: len(headers)]):
+            widths[i] = max(widths[i], _width(str(cell)))
+    lines = ["  ".join(_pad(h, widths[i]) for i, h in enumerate(headers)).rstrip()]
+    lines.append("  ".join("-" * w for w in widths))
+    for row in rows:
+        lines.append(
+            "  ".join(
+                _pad(str(row[i]) if i < len(row) else "", widths[i])
+                for i in range(len(headers))
+            ).rstrip()
+        )
+    return "\n".join(lines)
+
+
+def dump_json(payload) -> None:
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+def price_span(low, high) -> str:
+    if low is None and high is None:
+        return "-"
+    if low == high or high is None:
+        return f"{low:g}万"
+    if low is None:
+        return f"{high:g}万"
+    return f"{low:g}-{high:g}万"
+
+
+# ---------- 子命令 ----------
+
+
+def cmd_rank(args) -> None:
+    # --local 城市榜：rank_data_type=64，销量=本地新车上牌量；全国无此榜
+    if args.local and args.city == "全国":
+        raise DcdError("城市榜需要指定城市，如: dcd rank --local -c 杭州")
+    payload = api_get(
+        "/motor/pc/car/rank_data",
+        {
+            **COMMON,
+            "city_name": args.city,
+            "count": args.count,
+            "offset": args.offset,
+            "rank_data_type": 64 if args.local else args.type,
+        },
+    )
+    if args.json:
+        dump_json(payload)
+        return
+    data = payload["data"]
+    total = (data.get("paging") or {}).get("total")
+    if args.local:
+        print(
+            f"{args.city} 城市榜（数据基于本地新车上牌量"
+            + (f"，共 {total} 款车系" if total else "")
+            + "）",
+            file=sys.stderr,
+        )
+    items = data["list"]
+    rows = [
+        [
+            str(it.get("rank") or ""),
+            it.get("series_name") or "",
+            it.get("brand_name") or "",
+            str(it.get("count") or ""),
+            price_span(it.get("min_price"), it.get("max_price")),
+            str(it.get("series_id") or ""),
+        ]
+        for it in items
+    ]
+    print(
+        render_table(
+            ["排名", "车系", "品牌", "本地销量" if args.local else "销量", "指导价", "车系ID"],
+            rows,
+        )
+    )
+
+
+def cmd_brands(args) -> None:
+    payload = api_get(
+        "/motor/brand/v4/brand/",
+        {
+            "hot_brand": 0,
+            "no_sales": 1,
+            "is_config": 0,
+            "version_code": 476,
+            "version_name": "4.7.6",
+            **COMMON,
+        },
+    )
+    if args.json:
+        dump_json(payload)
+        return
+    brands = []
+    for group in payload.get("data") or []:
+        info = group.get("info") or {}
+        if info.get("brand_id"):
+            brands.append(info)
+        brands.extend(info.get("brand") or [])
+    if args.filter:
+        needle = args.filter
+        brands = [
+            b
+            for b in brands
+            if needle in (b.get("brand_name") or "")
+            or needle.upper() == (b.get("pinyin") or "").upper()
+        ]
+    rows = [
+        [str(b.get("brand_id") or ""), b.get("brand_name") or "", b.get("pinyin") or ""]
+        for b in brands
+    ]
+    print(render_table(["品牌ID", "品牌", "首字母"], rows))
+
+
+def cmd_series(args) -> None:
+    # 参数名是 brand（不是 brand_id）：传 brand_id 会被服务端忽略，返回全站热门车系
+    payload = api_post(
+        "/motor/pc/car/brand/select_series_v2",
+        {"brand": args.brand_id, "sort_new": "hot_desc"},
+    )
+    if args.json:
+        dump_json(payload)
+        return
+    series = (payload.get("data") or {}).get("series") or []
+    rows = [
+        [
+            str(s.get("id") or ""),
+            s.get("outter_name") or "",
+            s.get("official_price") or "-",
+            s.get("dealer_price") or "-",
+            str(s.get("count") or ""),
+            f"{s['dcar_score']:.2f}" if s.get("dcar_score") else "-",
+            str(s.get("brand_name") or ""),
+        ]
+        for s in series
+    ]
+    print(
+        render_table(
+            ["车系ID", "车系", "指导价", "经销商价", "在售车型数", "评分", "品牌"], rows
+        )
+    )
+
+
+def cmd_cars(args) -> None:
+    payload = api_get(
+        "/motor/pc/car/series/car_list",
+        {**COMMON, "series_id": args.series_id},
+    )
+    if args.json:
+        dump_json(payload)
+        return
+    tabs = (payload.get("data") or {}).get("tab_list") or []
+    rows = []
+    for tab in tabs:
+        status = tab.get("tab_text") or ""
+        for entry in tab.get("data") or []:
+            info = entry.get("info") or {}
+            if entry.get("type") == "1068":
+                continue
+            if entry.get("type") == "1137":
+                rows.append([f"[{status}] {info.get('name') or ''}", "", "", "", "", ""])
+                continue
+            rows.append(
+                [
+                    info.get("car_name") or info.get("name") or "",
+                    str(info.get("year") or ""),
+                    info.get("official_price_str") or "",
+                    info.get("dealer_price") or "",
+                    info.get("owner_price") or "",
+                    str(info.get("car_id") or info.get("id") or ""),
+                ]
+            )
+    print(render_table(["车型", "年款", "官方指导价", "经销商价", "车主价", "车型ID"], rows))
+
+
+def _ptype(prop: dict) -> int:
+    # type 字段时而为 int 时而为 str（服务端 A/B），统一归一化
+    try:
+        return int(prop.get("type"))
+    except (TypeError, ValueError):
+        return -1
+
+
+def _spec_value(car: dict, prop: dict) -> str:
+    info = (car.get("info") or {})
+    subs = prop.get("sub_list") or []
+    if _ptype(prop) == 3 and subs:
+        labels = [
+            (s.get("text") or "")
+            for s in subs
+            if (info.get(s.get("key")) or {}).get("value")
+        ]
+        return "、".join(labels) if labels else "-"
+    cell = info.get(prop.get("key")) or {}
+    value = (cell.get("value") or "").strip()
+    if value:
+        return value
+    return {1: "标配", 2: "选装"}.get(cell.get("icon_type"), "-")
+
+
+def cmd_specs(args) -> None:
+    car_ids = [cid for raw in args.car_id for cid in raw.split(",") if cid]
+    payload = api_get(
+        "/motor/pc/car/get_full_config_info",
+        {"series_id": args.series_id, "car_ids": ",".join(car_ids)},
+    )
+    if args.json:
+        dump_json(payload)
+        return
+    data = payload["data"]
+    cars = data.get("car_info") or []
+    if not cars:
+        raise DcdError(f"未找到车型配置: {', '.join(car_ids)}")
+    # 实测该接口忽略 car_ids，总是返回整个车系，这里按请求过滤
+    by_id = {str(c.get("car_id")): c for c in cars}
+    missing = [cid for cid in car_ids if cid not in by_id]
+    if missing:
+        raise DcdError(f"车系 {args.series_id} 下不存在车型: {', '.join(missing)}")
+    cars = [by_id[cid] for cid in car_ids]
+    headers = ["参数"] + [c.get("car_name") or str(c.get("car_id")) for c in cars]
+    rows: list[list[str]] = []
+    section = ""
+    for prop in data.get("properties") or []:
+        ptype = _ptype(prop)
+        text = prop.get("text") or ""
+        if ptype == 0:
+            section = text
+            if args.section and args.section in section:
+                rows.append([f"◆ {text}", *[""] * len(cars)])
+            continue
+        if args.section and args.section not in section:
+            continue
+        if ptype == 2:
+            rows.append([f"◇ {text}", *[""] * len(cars)])
+            continue
+        if ptype == 6:
+            continue
+        rows.append([text, *[_spec_value(car, prop) for car in cars]])
+    if args.section and not rows:
+        names = [
+            p.get("text") or "" for p in data.get("properties") or [] if _ptype(p) == 0
+        ]
+        print(
+            f"提示: 没有章节匹配 {args.section!r}，可用章节: {'、'.join(names)}",
+            file=sys.stderr,
+        )
+    print(render_table(headers, rows))
+
+
+def cmd_reviews(args) -> None:
+    payload = api_get(
+        "/motor/pc/car/series/get_review_list",
+        {
+            "series_id": args.series_id,
+            "page": args.page,
+            "size": args.size,
+            "city_name": args.city,
+            "sort_by": args.sort,
+        },
+        referer=f"{BASE}/auto/series/score/{args.series_id}",
+    )
+    if args.json:
+        dump_json(payload)
+        return
+    data = payload.get("data") or {}
+    reviews = data.get("review_list") or []
+    print(
+        f"共 {data.get('total_count', '?')} 条评论，第 {args.page} 页 {len(reviews)} 条",
+        file=sys.stderr,
+    )
+    rows = []
+    for review in reviews:
+        buy = review.get("buy_car_info") or {}
+        score = ((review.get("score_info") or {}).get("score") or 0) / 100
+        ts = review.get("create_time")
+        rows.append(
+            [
+                time.strftime("%Y-%m-%d", time.localtime(ts)) if ts else "-",
+                (review.get("user_info") or {}).get("name") or "",
+                buy.get("car_name") or review.get("car_name") or "",
+                buy.get("price") or "",
+                f"{score:.2f}" if score else "-",
+                clip((review.get("content") or "").replace("\n", " "), 60),
+                str(review.get("digg_count_en") or "0"),
+            ]
+        )
+    print(render_table(["日期", "用户", "车型", "成交价", "评分", "内容", "赞"], rows))
+
+
+def cmd_search(args) -> None:
+    payload = api_get(
+        "/motor/searchapi/search_content",
+        {"keyword": args.keyword, "cur_tab": 2, "count": args.count, **COMMON},
+    )
+    if args.json:
+        dump_json(payload)
+        return
+    items = payload.get("data") or []
+    series = [it for it in items if it.get("cell_type") == 5002]
+    if series:
+        rows = [
+            [
+                str((it.get("display") or {}).get("series_id") or ""),
+                (it.get("display") or {}).get("series_name") or "",
+            ]
+            for it in series
+        ]
+        print(render_table(["车系ID", "车系"], rows))
+        return
+    print("未返回车系卡片（该词命中内容较多），以下为内容结果：", file=sys.stderr)
+    rows = [
+        [
+            (it.get("group_cell") or {}).get("title") or it.get("title") or "",
+            str(it.get("cell_type") or ""),
+        ]
+        for it in items
+    ]
+    print(render_table(["标题", "类型"], rows))
+
+
+def cmd_dealer(args) -> None:
+    car_ids = [cid for raw in args.car_id for cid in raw.split(",") if cid]
+    payload = api_get(
+        "/motor/pc/car/series/car_dealer_price",
+        {**COMMON, "car_ids": ",".join(car_ids), "city_name": args.city},
+    )
+    if args.json:
+        dump_json(payload)
+        return
+    data = payload.get("data") or {}
+    order = [cid for cid in car_ids if cid in data] + [
+        cid for cid in data if cid not in car_ids
+    ]
+    rows = []
+    for cid in order:
+        it = data[cid]
+        rows.append(
+            [
+                it.get("car_name") or "",
+                str(it.get("year") or ""),
+                it.get("official_price") or "-",
+                it.get("dealer_price") if it.get("has_dealer_price") else "暂无报价",
+                it.get("cut_price") if it.get("has_cut_price") else "-",
+                it.get("series_name") or "",
+                cid,
+            ]
+        )
+    print(f"{args.city} 经销商报价：", file=sys.stderr)
+    print(render_table(["车型", "年款", "指导价", "经销商价", "优惠", "车系", "车型ID"], rows))
+
+
+def cmd_series_info(args) -> None:
+    cookies = load_cookies(args.cookie_file)
+    if args.city:
+        # 该 Cookie 按百分号编码存储（浏览器即为 %E6%9D%AD%E5%B7%9E 形式）
+        cookies["city_name"] = urllib.parse.quote(args.city)
+    # 该 HTML 路由有无视 Cookie 的 CDN 缓存（会串城市），加随机参数强制回源
+    path = f"/auto/series/{args.series_id}?_r={int(time.time() * 1000)}"
+    html, final_url = api_get_html(path, cookies)
+    pp = extract_next_data(html, final_url)
+
+    head = pp.get("seriesHomeHead") or {}
+    scores = pp.get("scoreSimpleInfo") or {}
+    card = pp.get("carPriceCard") or {}
+    dealers = pp.get("allDealerList") or []
+
+    def score_name(v) -> str:
+        return f"{v / 100:.2f}" if isinstance(v, (int, float)) and v else "-"
+
+    overview = [
+        ["品牌", f"{head.get('brand_name') or '-'} ({head.get('brand_id') or '?'})"],
+        ["车系", f"{head.get('series_name') or pp.get('seriesName') or '-'} ({pp.get('seriesId') or args.series_id})"],
+        ["厂商指导价", head.get("official_price") or "-"],
+        ["经销商价", head.get("dealer_price") or "-"],
+        ["懂车分", score_name(head.get("total_score"))],
+        ["口碑数", str(head.get("total_review_count") or "-")],
+    ]
+    score_rows = [
+        [label, score_name(scores.get(key))]
+        for label, key in [
+            ("总分", "score"),
+            ("外观", "appearance_score"),
+            ("内饰", "interiors_score"),
+            ("空间", "space_score"),
+            ("舒适", "comfort_score"),
+            ("配置", "configuration_score"),
+            ("动力", "power_score"),
+            ("操控", "control_score"),
+        ]
+        if key in scores
+    ]
+    price_rows = [
+        ["车款", f"{card.get('car_name') or '-'}（{card.get('year') or '?'} 款）"],
+        ["官方指导价", card.get("official_price") or "-"],
+        ["裸车均价", card.get("naked_price_avg") or "-"],
+        ["全款均价", card.get("full_price_avg") or "-"],
+        ["最新车主价", f"{card.get('latest_owner_price') or '-'}（{card.get('latest_owner_city_name') or '?'}）" if card.get("has_latest_owner_price") else "-"],
+        ["价格样本数", str(card.get("price_num") or "-")],
+        ["累计询价", f"{card.get('query_price_count_en')}人" if card.get("query_price_count_en") else "-"],
+    ]
+    dealer_rows = [
+        [
+            (d.get("dealer_name") or "").strip(),
+            d.get("dealer_price") or "-",
+            "/".join((l.get("text") or "").strip() for l in d.get("label_list") or []),
+            "、".join((p.get("text") or "").strip() for p in d.get("promotion_list") or []),
+            clip((d.get("address") or "").strip(), 42),
+        ]
+        for d in dealers
+    ]
+
+    if args.json:
+        dump_json(
+            {
+                "overview": dict(overview),
+                "scores": dict(score_rows),
+                "price_card": card,
+                "dealers": dealers,
+            }
+        )
+        return
+
+    sections = args.section or ["overview", "scores", "price", "dealers"]
+    if "overview" in sections:
+        print("【概览】")
+        print(render_table(["项目", "值"], overview))
+        print()
+    if "scores" in sections:
+        print("【懂车分】")
+        print(render_table(["维度", "得分"], score_rows) if score_rows else "（无数据）")
+        print()
+    if "price" in sections:
+        print("【价格卡】")
+        print(render_table(["项目", "值"], price_rows))
+        print()
+    if "dealers" in sections:
+        print(f"【经销商门店 {len(dealer_rows)} 家】")
+        print(render_table(["门店", "起价", "标签", "优惠", "地址"], dealer_rows))
+
+
+def cmd_me(args) -> None:
+    cookies = load_cookies(args.cookie_file)
+    payload = api_get("/passport/account/info/v2/", {}, cookies=cookies)
+    data = payload.get("data") or {}
+    if data.get("error_code"):
+        raise DcdError(
+            f"账号接口返回错误 {data['error_code']}: {data.get('description') or ''}"
+            "（登录态可能已过期，重新登录后 state-save + auth-import）"
+        )
+    if args.json:
+        dump_json(payload)
+        return
+    rows = [
+        ["用户名", data.get("screen_name") or data.get("name") or "-"],
+        ["用户ID", str(data.get("user_id_str") or data.get("user_id") or "-")],
+        ["手机号", data.get("mobile") or "-"],
+        ["头像", data.get("avatar_url") or "-"],
+    ]
+    print(render_table(["项目", "值"], rows))
+
+
+def cmd_auth_import(args) -> None:
+    src = Path(args.state_file).expanduser()
+    if not src.is_file():
+        raise DcdError(f"文件不存在: {src}")
+    try:
+        state = json.loads(src.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise DcdError(f"不是有效的存储状态 JSON: {src}") from exc
+    cookies = [
+        c
+        for c in state.get("cookies") or []
+        if any(x in (c.get("domain") or "") for x in ("dongchedi.com", "dcdapp.com"))
+    ]
+    if not cookies:
+        raise DcdError("该文件中没有懂车帝相关 Cookie（请先在已登录懂车帝的浏览器里 state-save）")
+    dest = Path(args.output).expanduser() if args.output else DEFAULT_COOKIE_FILE
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    lines = ["# Netscape HTTP Cookie File", f"# imported from {src} by dcd auth-import", ""]
+    for c in cookies:
+        domain = c.get("domain") or ""
+        expires = int(c.get("expires") or 0)
+        lines.append(
+            "\t".join(
+                [
+                    domain,
+                    "TRUE" if domain.startswith(".") else "FALSE",
+                    c.get("path") or "/",
+                    "TRUE" if c.get("secure") else "FALSE",
+                    str(expires if expires > 0 else 2147483647),
+                    c.get("name") or "",
+                    c.get("value") or "",
+                ]
+            )
+        )
+    dest.write_text("\n".join(lines) + "\n", encoding="utf-8")
+    print(f"已导入 {len(cookies)} 个 Cookie -> {dest}", file=sys.stderr)
+    try:
+        data = (api_get("/passport/account/info/v2/", {}, cookies=load_cookies(str(dest))).get("data")) or {}
+        if data.get("error_code"):
+            print(f"警告: 登录态未通过验证（{data.get('description') or data['error_code']}）", file=sys.stderr)
+        else:
+            print(f"登录态有效: {data.get('name')}（{data.get('mobile') or '手机号未知'}）", file=sys.stderr)
+    except DcdError as exc:
+        print(f"警告: 登录态校验请求失败（{exc}）", file=sys.stderr)
+
+
+# ---------- 入口 ----------
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="dcd",
+        description="懂车帝数据查询 CLI（rank/brands/series/cars/specs/reviews/search/dealer 免登录；series-info/me 需登录态）",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p = sub.add_parser("rank", help="销量榜（默认全国零售量；--local 切换城市榜）")
+    p.add_argument(
+        "-t", "--type", type=int, default=11, help="榜单类型，默认 11（零售量总榜；--local 时忽略）"
+    )
+    p.add_argument("-n", "--count", type=int, default=20, help="条数，默认 20")
+    p.add_argument("-o", "--offset", type=int, default=0, help="起始偏移，默认 0")
+    p.add_argument("-c", "--city", default="全国", help="城市，默认 全国；--local 时必须指定")
+    p.add_argument("--local", action="store_true", help="城市榜：本地新车上牌量（如 --local -c 杭州）")
+    p.add_argument("-j", "--json", action="store_true", help="输出原始 JSON")
+    p.set_defaults(func=cmd_rank)
+
+    p = sub.add_parser("brands", help="品牌列表")
+    p.add_argument("-f", "--filter", help="按品牌名或首字母过滤")
+    p.add_argument("-j", "--json", action="store_true", help="输出原始 JSON")
+    p.set_defaults(func=cmd_brands)
+
+    p = sub.add_parser("series", help="品牌下的车系列表")
+    p.add_argument("brand_id", help="品牌ID（用 dcd brands 查）")
+    p.add_argument("-j", "--json", action="store_true", help="输出原始 JSON")
+    p.set_defaults(func=cmd_series)
+
+    p = sub.add_parser("cars", help="车系下的车型（年款/价格）")
+    p.add_argument("series_id", help="车系ID")
+    p.add_argument("-j", "--json", action="store_true", help="输出原始 JSON")
+    p.set_defaults(func=cmd_cars)
+
+    p = sub.add_parser("specs", help="车型参数配置表（可多车对比）")
+    p.add_argument("series_id", help="车系ID")
+    p.add_argument("car_id", nargs="+", help="车型ID，可多个（用 dcd cars 查）")
+    p.add_argument("-s", "--section", help="只看包含该文字的章节，如 电池")
+    p.add_argument("-j", "--json", action="store_true", help="输出原始 JSON")
+    p.set_defaults(func=cmd_specs)
+
+    p = sub.add_parser("reviews", help="车主评论")
+    p.add_argument("series_id", help="车系ID")
+    p.add_argument("-p", "--page", type=int, default=1, help="页码，默认 1")
+    p.add_argument("-n", "--size", type=int, default=20, help="每页条数，默认 20")
+    p.add_argument("-c", "--city", default="杭州", help="城市，默认 杭州")
+    p.add_argument("-s", "--sort", default="default", help="排序，默认 default")
+    p.add_argument("-j", "--json", action="store_true", help="输出原始 JSON")
+    p.set_defaults(func=cmd_reviews)
+
+    p = sub.add_parser("search", help="搜索车系")
+    p.add_argument("keyword", help="关键词")
+    p.add_argument("-n", "--count", type=int, default=20, help="条数，默认 20")
+    p.add_argument("-j", "--json", action="store_true", help="输出原始 JSON")
+    p.set_defaults(func=cmd_search)
+
+    p = sub.add_parser("dealer", help="经销商报价（免登录，分城市）")
+    p.add_argument("car_id", nargs="+", help="车型ID，可多个（用 dcd cars 查）")
+    p.add_argument("-c", "--city", default="杭州", help="城市，默认 杭州")
+    p.add_argument("-j", "--json", action="store_true", help="输出原始 JSON")
+    p.set_defaults(func=cmd_dealer)
+
+    p = sub.add_parser("series-info", help="车系综合信息：概览/懂车分/价格卡/门店（需登录态）")
+    p.add_argument("series_id", help="车系ID")
+    p.add_argument("-c", "--city", help="城市（默认取 Cookie 中的城市）")
+    p.add_argument(
+        "-s",
+        "--section",
+        action="append",
+        choices=["overview", "scores", "price", "dealers"],
+        help="只输出指定板块，可重复；默认全部",
+    )
+    p.add_argument("--cookie-file", help=f"Cookie 文件，默认 {DEFAULT_COOKIE_FILE}")
+    p.add_argument("-j", "--json", action="store_true", help="输出提取后的 JSON")
+    p.set_defaults(func=cmd_series_info)
+
+    p = sub.add_parser("me", help="账号信息，验证登录态（需登录态）")
+    p.add_argument("--cookie-file", help=f"Cookie 文件，默认 {DEFAULT_COOKIE_FILE}")
+    p.add_argument("-j", "--json", action="store_true", help="输出原始 JSON")
+    p.set_defaults(func=cmd_me)
+
+    p = sub.add_parser("auth-import", help="从 playwright state-save 的 JSON 导入懂车帝 Cookie")
+    p.add_argument("state_file", help="state-save 产出的 storage state JSON")
+    p.add_argument("-o", "--output", help=f"输出文件，默认 {DEFAULT_COOKIE_FILE}")
+    p.set_defaults(func=cmd_auth_import)
+
+    return parser
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    try:
+        args.func(args)
+    except DcdError as exc:
+        print(f"错误: {exc}", file=sys.stderr)
+        raise SystemExit(1)
+    except KeyboardInterrupt:
+        raise SystemExit(130)
+
+
+if __name__ == "__main__":
+    main()

dongchedi_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.5
+Name: dongchedi-cli
+Version: 0.1.0
+Summary: 懂车帝（dongchedi.com）数据查询 CLI：销量榜 / 品牌 / 车系 / 车型 / 参数配置 / 车主评论 / 搜索
+Author: weisanju
+Keywords: automobile,car,cli,dongchedi,vehicle-data
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: Chinese (Simplified)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# dongchedi-cli
+
+懂车帝（www.dongchedi.com）数据查询 CLI。免登录命令走 PC 站公开 JSON 接口；登录命令读取浏览器登录态，走 HTML 页面的 SSR 数据。无第三方依赖（纯标准库）。
+
+## 安装
+
+```bash
+uv tool install dongchedi-cli    # 从 PyPI 安装；也可 pipx install dongchedi-cli 或 pip install dongchedi-cli
+
+# 从源码安装（开发）
+uv tool install --editable scripts/dongchedi-cli
+# 免安装临时运行
+PYTHONPATH=scripts/dongchedi-cli/src python3 -m dongchedi_cli.cli rank
+```
+
+## 用法
+
+```bash
+# ---- 免登录 ----
+dcd rank                          # 销量总榜（默认前 20，全国零售量）
+dcd rank -c 杭州 -n 50            # 指定城市与条数（注意：榜单仍是全国榜，仅指导价按城市变化）
+dcd rank --local -c 杭州          # 杭州城市榜：本地新车上牌量（共 317 款车系）
+dcd brands -f J                   # 品牌列表，按名称/首字母过滤
+dcd series 858                    # 吉利银河下的全部车系（含指导价/经销商价/评分）
+dcd cars 20154                    # 星愿的车型年款与价格（含停售/未上市）
+dcd specs 20154 259371            # 车型参数配置表
+dcd specs 20154 259371 259369 -s 电池   # 多车对比，只看"电池"章节
+dcd reviews 20154 -p 1 -n 20      # 车主评论（含成交价/评分）
+dcd search 秦plus                 # 搜车系
+dcd dealer 259371                 # 某车型的经销商报价与优惠（默认杭州）
+dcd dealer 259371 259369 -c 上海  # 多车型对比、指定城市
+
+# ---- 需登录态（见下方「登录态」）----
+dcd series-info 20154             # 车系主页 SSR：概览/评分/价格卡/经销商
+dcd series-info 20154 -s dealers  # 只看经销商（overview/scores/price/dealers）
+dcd series-info 20154 -c 北京     # 指定城市（覆盖登录态里的城市 Cookie）
+dcd me                            # 当前登录账号信息
+
+# 任意命令加 --json 输出原始数据
+```
+
+典型链条：`dcd brands -f 吉利` → `dcd series 858` → `dcd cars 20154` → `dcd specs 20154 <车型ID>`。
+
+表格结果输出到 stdout，进度/提示输出到 stderr，可安全重定向。
+
+## 登录态
+
+`series-info` / `me` 需要已登录懂车帝的 Cookie。获取流程（配合 playwright-cli）：
+
+```bash
+playwright-cli open https://www.dongchedi.com --persistent   # 登录（拼图滑块 + 短信验证码）
+playwright-cli state-save scripts/dongchedi-cli/.auth/state.json
+dcd auth-import scripts/dongchedi-cli/.auth/state.json       # 提取 Cookie 并当场校验
+# → 写入 ~/.config/dcd/cookies.txt（chmod 600），文件含 sessionid，勿提交
+```
+
+Cookie 文件解析优先级：`--cookie-file` 参数 → `DCD_COOKIE_FILE` 环境变量 → `~/.config/dcd/cookies.txt`。
+登录态过期后（报错提示会话过期）重新登录并重跑 `state-save` + `auth-import` 即可。
+
+## 已验证接口（2026-09 实测）
+
+| 命令 | 接口 | 备注 |
+| --- | --- | --- |
+| rank | `GET /motor/pc/car/rank_data` | `rank_data_type=11` 零售量总榜；`=64` 为城市榜（`--local`，需 city_name，销量=本地新车上牌量）；`=2` 批发量 |
+| brands | `GET /motor/brand/v4/brand/` | 品牌在 `data[].info`（其中 4 个热门品牌在 `info.brand`） |
+| series | `POST /motor/pc/car/brand/select_series_v2` | 表单参数是 `brand`（不是 `brand_id`，传错会静默返回全站热门车系） |
+| cars | `GET /motor/pc/car/series/car_list` | `data.tab_list[]`，type 1115=车型、1137=年款分组，1068 为占位需跳过 |
+| specs | `GET /motor/pc/car/get_full_config_info` | 需 `series_id` + `car_ids`；实测忽略 car_ids，总是返回全车系，CLI 已按请求过滤 |
+| reviews | `GET /motor/pc/car/series/get_review_list` | 需 `Referer: /auto/series/score/{series_id}` |
+| search | `GET /motor/searchapi/search_content` | `cur_tab=2`，车系卡片为 `cell_type=5002`（不一定出现，无则回退内容标题） |
+| dealer | `GET /motor/pc/car/series/car_dealer_price` | 匿名可用；依赖 `city_name`（全国 → 暂无报价），未覆盖城市会回落邻近城市 |
+| series-info | HTML `GET /auto/series/{id}` | 需登录态；数据在 `__NEXT_DATA__.props.pageProps`（经销商/价格卡/评分） |
+| me | `GET /passport/account/info/v2/` | 需登录态；匿名返回 `error_code=13` 会话过期 |
+
+公共参数 `aid=1839&app_name=auto_web_pc`；请求头用桌面 Chrome UA。
+
+## 注意事项
+
+- HTML 路由（`/auto/series/*`、`/auto/params-*`）无登录一律 302 到 `/login-required`；只有带完整登录 Cookie 才能拿到 SSR 数据（仅有 ttwid/tt_webid 不够）。
+- HTML 路由有 CDN 缓存且缓存键不含 Cookie，会串城市数据；CLI 已自动附加 `?_r=<毫秒时间戳>` 破缓存。
+- 城市由 `city_name` Cookie 控制且值为 **percent-encoded**（如 `%E6%9D%AD%E5%B7%9E`），URL 上的 `city_name` 参数会被页面逻辑忽略；CLI 的 `-c` 已按此处理。
+- 登录态 Cookie 含中文值，urllib 请求头默认 latin-1 编码，发送前已转 UTF-8 裸字节（与浏览器线上行为一致）。
+- 参数配置表字段：`data.properties[]` 为行定义（type 0/2 为章节标题，1 普通行，3 带子项，6 跳过），值在 `data.car_info[].info[<key>].value`；type 3 的值挂在 `sub_list[].key` 上。注意 `type` 字段时而为 int 时而为字符串，代码里已统一归一化。
+- 接口可能随版本变化（版本参数当前为 version_code=476），失效时优先用 `--json` 排查原始返回。
+
+## 开发与发布
+
+开发与发布由 `Makefile` 管理（`make help` 查看全部目标）：
+
+```bash
+make lint            # ruff 检查
+make smoke           # 走工作区源码对真实接口冒烟（覆盖全部免登录命令，需外网）
+make bump part=minor # 升版本号（同步 pyproject.toml 与 __init__.py）
+make check           # 离线校验：lint + 构建 + 版本一致性 + twine 元数据检查
+make publish-test    # 发布到 TestPyPI 预演（token 放 TESTPYPI_TOKEN）
+make publish         # 发布到 PyPI（token 放 UV_PUBLISH_TOKEN）
+make release         # 一键发布：check → smoke → bump → publish → tag
+```
+
+发布前在 pypi.org 生成 API token（scope 选本项目），`export UV_PUBLISH_TOKEN=pypi-xxx` 即可。

dongchedi_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+dongchedi_cli/__init__.py,sha256=3vgMEbIJzaaix4q6Rbf39-vkjzh0KPmgIE8c0FuSD_g,58
+dongchedi_cli/cli.py,sha256=eoo5JB3321QyjOH8CguKN5_vbTOI2oqSfJps1y3-6U4,29919
+dongchedi_cli-0.1.0.dist-info/METADATA,sha256=9KBBjg1qzedVykXQ4L8s4-4SdgN_ahBxBvM6Pql2RzQ,7196
+dongchedi_cli-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+dongchedi_cli-0.1.0.dist-info/entry_points.txt,sha256=l5AngDhZFc7NI9r8nm-iO-kDGwzlMMX_6Z2bkQvVc3s,47
+dongchedi_cli-0.1.0.dist-info/RECORD,,

dongchedi_cli-0.1.0.dist-info/WHEEL

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

dongchedi_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dcd = dongchedi_cli.cli:main