@yujp_vc/ppt-assistant 0.0.0-stage → 1.5.2

package/grasp_evidence.py

@@ -0,0 +1,150 @@
+"""Read numeric grasp evidence and project it without running workspace code."""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+from PIL import Image
+
+# Shared sequential palette for raw and completed depth, including the legend.
+DEPTH_COLORS = np.array([[68, 1, 84], [59, 82, 139], [33, 145, 140],
+                         [94, 201, 98], [253, 231, 37]], dtype=float)
+
+
+def depth_colors(values):
+    """Map normalized values in [0, 1] to the same RGB palette."""
+    values = np.clip(values, 0, 1)
+    stops = np.linspace(0, 1, len(DEPTH_COLORS))
+    return np.stack([np.interp(values, stops, DEPTH_COLORS[:, i])
+                     for i in range(3)], axis=-1).astype(np.uint8)
+
+
+def depth_pair(before: Path, after: Path, crop: list[int], limits: list[float]):
+    """Return two atomic depth images using identical pixel ROI and meter limits."""
+    arrays = [np.load(path, allow_pickle=False) for path in (before, after)]
+    if arrays[0].ndim != 2 or arrays[0].shape != arrays[1].shape:
+        raise ValueError("depth pair requires matching two-dimensional arrays")
+    left, top, right, bottom = crop
+    height, width = arrays[0].shape
+    if not (0 <= left < right <= width and 0 <= top < bottom <= height):
+        raise ValueError("depth crop exceeds source dimensions")
+    low, high = limits
+    if not np.isfinite([low, high]).all() or not 0 < low < high:
+        raise ValueError("depth pair requires increasing positive meter limits")
+    pictures = []
+    for array in arrays:
+        roi = array[top:bottom, left:right]
+        valid = np.isfinite(roi) & (roi > 0)
+        normalized = np.zeros(roi.shape, dtype=float)
+        normalized[valid] = (roi[valid] - low) / (high - low)
+        rgb = depth_colors(normalized)
+        rgb[~valid] = [190, 190, 190]
+        pictures.append(Image.fromarray(rgb))
+    return pictures
+
+
+def gripper_projection(execution: Path, calibration: Path, tip_z_m=.1034, finger_length_m=.04,
+                       finger_width_m=.02, finger_thickness_m=.01):
+    """Project a selected pose and predicted jaw opening into source RGB pixels.
+
+    The wireframe follows the recorded camera transform. Finger length and
+    tip offset describe the display geometry, not a collision or safety test.
+    """
+    record = json.loads(execution.read_text(encoding="utf-8"))
+    camera = json.loads(calibration.read_text(encoding="utf-8"))
+    return project_gripper(record, camera, tip_z_m, finger_length_m,
+                           finger_width_m, finger_thickness_m)
+
+
+def candidate_projections(response: Path, calibration: Path, count=None):
+    """Project the highest-score saved candidates with the selected-pose geometry."""
+    record = json.loads(response.read_text(encoding="utf-8"))
+    camera = json.loads(calibration.read_text(encoding="utf-8"))
+    grasps = record["grasps"]
+    candidates = []
+    if count is not None and (type(count) is not int or not 1 <= count <= len(grasps.get("scores", {}).get(next(iter(grasps["scores"]), ""), []))):
+        raise ValueError("candidate display count is outside the recorded candidates")
+    for group, poses in grasps["pred_grasps_cam"].items():
+        scores, openings = grasps["scores"][group], grasps["gripper_openings"][group]
+        if len(poses) != len(scores) or len(poses) != len(openings):
+            raise ValueError("candidate poses, scores and openings must have matching lengths")
+        for index, (pose, score, opening) in enumerate(zip(poses, scores, openings)):
+            if type(score) not in {int, float} or not np.isfinite(score):
+                raise ValueError("candidate scores must be finite numbers")
+            candidates.append((score, group, index, pose, opening))
+    if len(candidates) != grasps["total_grasps"] or not candidates:
+        raise ValueError("candidate arrays must match the recorded nonzero total")
+    projections = []
+    ranked = sorted(candidates, key=lambda c: -c[0])
+    for score, group, index, pose, opening in ranked if count is None else ranked[:count]:
+        projection = project_gripper({"T_camera_cgn_gripper": pose,
+                                      "gripper_opening_m": opening}, camera)
+        projection.update(score=score, group=group, index=index)
+        projections.append(projection)
+    return {"total": len(candidates), "projections": projections}
+
+
+def gated_candidate_projections(execution: Path, calibration: Path):
+    """Project every saved candidate and retain its accepted/rejected status."""
+    record = json.loads(execution.read_text(encoding="utf-8"))
+    camera = json.loads(calibration.read_text(encoding="utf-8"))
+    accepted = record.get("candidate_acceptances", [])
+    rejected = record.get("candidate_rejections", [])
+    candidates = [(item, "accepted") for item in accepted] + [(item, "rejected") for item in rejected]
+    expected = record.get("candidates_evaluated")
+    if type(expected) is not int or expected <= 0 or len(candidates) != expected:
+        raise ValueError("candidate gate record must contain every evaluated candidate")
+    projections = []
+    for item, status in candidates:
+        pose = item.get("T_camera_cgn_gripper")
+        opening = item.get("gripper_opening_m")
+        if pose is None or opening is None:
+            raise ValueError("candidate gate record is missing pose or opening")
+        projection = project_gripper({"T_camera_cgn_gripper": pose,
+                                      "gripper_opening_m": opening}, camera)
+        projection.update(status=status, index=item.get("candidate_index"),
+                          score=item.get("candidate_score"))
+        projections.append(projection)
+    return {"total": expected, "accepted": len(accepted),
+            "rejected": len(rejected), "projections": projections}
+
+
+def project_gripper(record, camera, tip_z_m=.1034, finger_length_m=.04,
+                    finger_width_m=.02, finger_thickness_m=.01):
+    """Project one recorded pose with common display geometry for every layout."""
+    transform = np.asarray(record["T_camera_cgn_gripper"], dtype=float)
+    intrinsic = np.asarray(camera["color_k"], dtype=float)
+    opening = float(record["gripper_opening_m"])
+    if (transform.shape != (4, 4) or intrinsic.shape != (3, 3)
+            or not np.isfinite(transform).all() or not np.isfinite(intrinsic).all()
+            or not np.isfinite(opening) or not 0 <= opening <= .2
+            or not 0 < finger_length_m < tip_z_m
+            or not 0 < finger_width_m < .1 or not 0 < finger_thickness_m < .1):
+        raise ValueError("invalid recorded gripper pose or display geometry")
+    base_z = tip_z_m - finger_length_m
+    local = np.array([[-opening / 2, 0, base_z], [-opening / 2, 0, tip_z_m],
+                      [opening / 2, 0, base_z], [opening / 2, 0, tip_z_m],
+                      [0, 0, tip_z_m]])
+    edges = [(0, 1), (0, 2), (2, 3)]
+    # Draw each finger as a wireframe volume so an oblique camera view does
+    # not reduce the grasp display to three nearly coincident center lines.
+    for low_x, high_x in [(-opening / 2 - finger_thickness_m, -opening / 2),
+                          (opening / 2, opening / 2 + finger_thickness_m)]:
+        start = len(local)
+        corners = [[x, y, z] for x in (low_x, high_x)
+                   for y in (-finger_width_m / 2, finger_width_m / 2)
+                   for z in (base_z, tip_z_m)]
+        local = np.concatenate([local, np.array(corners)])
+        for a in range(8):
+            for axis_bit in (1, 2, 4):
+                b = a ^ axis_bit
+                if a < b:
+                    edges.append((start + a, start + b))
+    points = local @ transform[:3, :3].T + transform[:3, 3]
+    if (points[:, 2] <= 0).any():
+        raise ValueError("gripper projection requires positive camera depth")
+    pixels = points @ intrinsic.T
+    pixels = pixels[:, :2] / pixels[:, 2:3]
+    segments = [(pixels[a].tolist(), pixels[b].tolist()) for a, b in edges]
+    return {"segments": segments, "center_uv": pixels[4].tolist(), "opening_mm": opening * 1000}

package/image_check.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""Vision QC for a generated image before it enters a deck.
+
+Checks the things a prompt cannot guarantee: does the subject match the brief,
+is there accidental text or a watermark, is the background clean, and which
+side is quiet enough for copy. Returns JSON and exits 2 when the asset fails.
+
+    python3 image_check.py assets/hero.png --intent "robot arm and amber bottle,
+        negative space on the left" --min-score 7
+"""
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import os
+import sys
+import urllib.request
+from pathlib import Path
+
+BASE = "https://api.deepseek.com"
+MODEL = "deepseek-v4-flash-vision-exp"
+PROMPT = """You are a strict image QA for presentation assets. Judge the image against the intent.
+Return ONLY a JSON object with this shape:
+{"subject_match": 0-10, "has_text": true/false, "has_watermark": true/false,
+ "background_clean": 0-10, "negative_space": "left|right|top|bottom|none",
+ "issues": ["short concrete issue"], "score": 0-10}
+Rules: score reflects fitness as a full-bleed slide image; accidental text, logos,
+watermarks, malformed hands or collages are automatic failures; "negative_space"
+is the quietest side for overlaying copy. Intent: %s"""
+
+
+def _key() -> str:
+    key = os.environ.get("DEEPSEEK_API_KEY", "").strip()
+    if key:
+        return key
+    homes = [os.environ.get("DSH_HOME", "").strip(),
+             os.path.expanduser("~/.dsh-linux"), os.path.expanduser("~/.dsh")]
+    for home in homes:
+        if not home:
+            continue
+        path = os.path.join(home, ".credentials.yaml")
+        if not os.path.isfile(path):
+            continue
+        try:
+            for line in open(path, encoding="utf-8"):
+                stripped = line.strip()
+                if stripped.startswith("DEEPSEEK_API_KEY:"):
+                    value = stripped.split(":", 1)[1].strip().strip("'\"")
+                    if value:
+                        return value
+        except OSError:
+            continue
+    return ""
+
+
+def _mime(path: Path) -> str:
+    return {".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
+            ".webp": "image/webp"}.get(path.suffix.lower(), "image/png")
+
+
+def _parse(text: str) -> dict:
+    start, end = text.find("{"), text.rfind("}")
+    if start < 0 or end <= start:
+        raise ValueError(f"模型没有返回 JSON：{text[:200]}")
+    data = json.loads(text[start:end + 1])
+    for field in ("subject_match", "has_text", "has_watermark",
+                  "background_clean", "negative_space", "issues", "score"):
+        if field not in data:
+            raise ValueError(f"模型 JSON 缺少 {field}")
+    return data
+
+
+def check(image: Path, intent: str, min_score: float, timeout: int = 120) -> dict:
+    key = _key()
+    if not key:
+        raise RuntimeError("未找到 DEEPSEEK_API_KEY（env、$DSH_HOME、~/.dsh-linux、~/.dsh）")
+    payload = {
+        "model": MODEL,
+        "messages": [{"role": "user", "content": [
+            {"type": "text", "text": PROMPT % intent},
+            {"type": "image_url", "image_url": {
+                "url": f"data:{_mime(image)};base64," +
+                       base64.b64encode(image.read_bytes()).decode()}},
+        ]}],
+        "temperature": 0,
+    }
+    data = json.dumps(payload).encode("utf-8")
+    headers = {"Authorization": f"Bearer {key}", "Content-Type": "application/json"}
+    try:
+        import requests
+    except ImportError:
+        requests = None
+    if requests is not None:
+        proxy = (os.environ.get("PPT_IMAGE_PROXY") or os.environ.get("HTTPS_PROXY")
+                 or os.environ.get("https_proxy"))
+        proxies = {"http": proxy, "https": proxy} if proxy else None
+        response = requests.post(BASE + "/chat/completions", data=data, headers=headers,
+                                 timeout=timeout, proxies=proxies)
+        if response.status_code >= 400:
+            raise RuntimeError(f"视觉接口 {response.status_code}: {response.text[:300]}")
+        body = response.json()
+    else:
+        request = urllib.request.Request(BASE + "/chat/completions", data=data,
+                                         headers=headers, method="POST")
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            body = json.loads(response.read().decode("utf-8"))
+    text = body["choices"][0]["message"]["content"]
+    report = _parse(text)
+    report["pass"] = (float(report["score"]) >= min_score
+                      and not report["has_text"] and not report["has_watermark"])
+    return report
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("image", type=Path)
+    parser.add_argument("--intent", required=True, help="what the image must show and leave room for")
+    parser.add_argument("--min-score", type=float, default=7.0)
+    parser.add_argument("--timeout", type=int, default=120)
+    parser.add_argument("--json", action="store_true", help="print the raw report only")
+    parser.add_argument("--transparent", action="store_true",
+                        help="asset is a transparent cutout; ignore the flattened white preview")
+    args = parser.parse_args()
+    intent = args.intent
+    if args.transparent:
+        intent += (" The asset is a transparent-background cutout; transparency is flattened "
+                   "to white in this preview, so do not treat the white background as an error.")
+    try:
+        report = check(args.image, intent, args.min_score, args.timeout)
+    except Exception as error:
+        print(f"image_check: {error}", file=sys.stderr)
+        return 2
+    if args.json:
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+    else:
+        print(f"score={report['score']} pass={report['pass']} "
+              f"subject={report['subject_match']} clean={report['background_clean']} "
+              f"text={report['has_text']} watermark={report['has_watermark']} "
+              f"quiet={report['negative_space']}")
+        for issue in report.get("issues") or []:
+            print(f"- {issue}")
+    return 0 if report["pass"] else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/image_fetch.py

@@ -0,0 +1,253 @@
+#!/usr/bin/env python3
+"""
+图片获取 —— 关键词联网取图，用于 PPT 配图「插入/填充」。
+默认走国内（必应国内图片搜索 cn.bing.com，直连、无需 key、国内站点优先）；
+国内找不到 → Pexels（走代理，外网）→ loremflickr/picsum 兜底。
+
+代理：读环境变量 PPT_PROXY，默认 http://127.0.0.1:7897（仅用于国外站点 Pexels/loremflickr/picsum）。
+国内站点（cn.bing.com + 中文图床）强制直连，不受 shell 代理影响。
+
+用法：
+    python3 image_fetch.py <keyword> <out.jpg> [width] [height]
+也可作为模块： from image_fetch import fetch
+"""
+import sys, os, json, re, urllib.request, urllib.parse
+
+CONFIG_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'config.json')
+PROXY = os.environ.get('PPT_PROXY', 'http://127.0.0.1:7897')
+
+# 强制直连（绕过 shell 的 http_proxy，用于国内站点）
+_NO_PROXY_OPENER = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+# 走代理（用于国外站点 Pexels/loremflickr/picsum）
+_PROXY_OPENER = urllib.request.build_opener(urllib.request.ProxyHandler({'http': PROXY, 'https': PROXY}))
+
+
+def _open(url, timeout=25, headers=None, via_proxy=False):
+    req = urllib.request.Request(url, headers=headers or {})
+    opener = _PROXY_OPENER if via_proxy else _NO_PROXY_OPENER
+    return opener.open(req, timeout=timeout)
+
+
+def _pexels_key():
+    k = os.environ.get('PEXELS_API_KEY', '').strip()
+    if k:
+        return k
+    if os.path.exists(CONFIG_PATH):
+        try:
+            return json.load(open(CONFIG_PATH, encoding='utf-8')).get('pexels_key', '').strip()
+        except Exception:
+            return ''
+    return ''
+
+
+def _has_cjk(s):
+    return any('\u4e00' <= c <= '\u9fff' for c in s)
+
+
+def _is_domestic_host(url):
+    """粗略判断图片 URL 是否来自国内站点，用于中文题材优先。"""
+    try:
+        host = urllib.parse.urlsplit(url).netloc.lower()
+    except Exception:
+        return False
+    if host.endswith(('.cn', '.com.cn', '.net.cn', '.org.cn')):
+        return True
+    return any(k in host for k in (
+        'zhimg.com', 'byteimg.com', 'sinaimg.cn', 'gtimg.cn', 'bjd.com.cn',
+        'suning.cn', 'zdmimg.com', 'bbtnews.com.cn', 'sohu.com', '163.com',
+        'baidu.com', 'bdimg.com', 'alicdn.com', 'taobao.com', 'jd.com',
+    ))
+
+
+def search_pexels(keyword, key=None, per_page=1, orientation='landscape'):
+    """Pexels 语义搜图（外网，走代理）。返回最匹配照片 dict，无结果返回 None。"""
+    key = key or _pexels_key()
+    if not key:
+        return None
+    q = urllib.parse.quote(keyword)
+    url = f"https://api.pexels.com/v1/search?query={q}&per_page={per_page}&orientation={orientation}"
+    with _open(url, timeout=25, headers={'Authorization': key, 'User-Agent': 'Mozilla/5.0'}, via_proxy=True) as r:
+        data = json.loads(r.read().decode('utf-8'))
+    photos = data.get('photos', [])
+    return photos[0] if photos else None
+
+
+def search_bing_cn(keyword, count=20):
+    """必应国内图片搜索（直连、无需 key）。返回完整图 URL 列表，国内站点优先。"""
+    q = urllib.parse.quote(keyword)
+    url = f"https://cn.bing.com/images/async?q={q}&first=0&count={count}&mmasync=1"
+    with _open(url, timeout=25, headers={
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        'Referer': 'https://cn.bing.com/images/search',
+    }, via_proxy=False) as r:
+        t = r.read().decode('utf-8', 'ignore')
+    urls = re.findall(r'murl&quot;:&quot;(.*?)&quot;', t)
+    urls.sort(key=lambda u: 0 if _is_domestic_host(u) else 1)
+    return urls
+
+
+def _save(data, out_path):
+    os.makedirs(os.path.dirname(os.path.abspath(out_path)), exist_ok=True)
+    with open(out_path, 'wb') as f:
+        f.write(data)
+    return out_path
+
+
+def _download(url, out_path, timeout=30, via_proxy=False):
+    with _open(url, timeout=timeout, headers={'User-Agent': 'Mozilla/5.0'}, via_proxy=via_proxy) as r:
+        data = r.read()
+    if len(data) < 1000:
+        raise RuntimeError('下载内容过小')
+    return _save(data, out_path)
+
+
+def fetch_bing_cn(keyword, out_path, count=20):
+    """从必应国内图片搜索下载第一张能成功下载的图（国内站点优先、直连）。返回 (path, src_url)。"""
+    urls = search_bing_cn(keyword, count)
+    for u in urls:
+        if u.startswith('//'):
+            u = 'https:' + u
+        try:
+            with _open(u, timeout=20, headers={
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
+                'Referer': 'https://cn.bing.com/images/search',
+            }, via_proxy=False) as r:
+                data = r.read()
+            if len(data) < 1000:
+                continue
+            _save(data, out_path)
+            return out_path, u
+        except Exception:
+            continue
+    raise RuntimeError(f"必应图片搜索下载失败(关键词='{keyword}')")
+
+
+def search_taobao(keyword, count=15):
+    """淘宝商品图搜索（直连）：返回 alicdn 商品图 URL 列表（商品图通常是白底实拍，适合商品题材）。"""
+    q = urllib.parse.quote(keyword)
+    url = f"https://s.taobao.com/search?q={q}"
+    with _open(url, timeout=25, headers={
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        'Referer': 'https://www.taobao.com/',
+    }, via_proxy=False) as r:
+        t = r.read().decode('utf-8', 'ignore')
+    urls = re.findall(r'//img\.alicdn\.com/[^"\s\\]+', t)
+    seen = []
+    for u in urls:
+        u = 'https:' + u
+        if u not in seen:
+            seen.append(u)
+    return seen[:count]
+
+
+def fetch_taobao(keyword, out_path, count=15):
+    """从淘宝搜索下载第一张能成功下载的商品图。返回 (path, src_url)。"""
+    urls = search_taobao(keyword, count)
+    for u in urls:
+        try:
+            with _open(u, timeout=20, headers={
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
+                'Referer': 'https://s.taobao.com/',
+            }, via_proxy=False) as r:
+                data = r.read()
+            if len(data) < 1000:
+                continue
+            _save(data, out_path)
+            return out_path, u
+        except Exception:
+            continue
+    raise RuntimeError(f"淘宝商品图搜索下载失败(关键词='{keyword}')")
+
+
+_TRANSLATE_DICT = {
+    '电动自行车': 'electric bicycle', '电瓶车': 'electric scooter moped',
+    '电动车': 'electric scooter', '电动摩托车': 'electric motorcycle',
+    '充电桩': 'ev charging station', '充电站': 'charging station',
+    '外卖': 'food delivery rider', '头盔': 'helmet', '电池': 'battery',
+    '骑行': 'cycling', '城市': 'city street', '交通': 'traffic',
+}
+
+
+def _deepseek_key():
+    k = os.environ.get('DEEPSEEK_API_KEY', '').strip()
+    if k:
+        return k
+    cred = os.path.expanduser('~/.dsh/.credentials.yaml')
+    if os.path.exists(cred):
+        try:
+            for line in open(cred, encoding='utf-8'):
+                if line.startswith('DEEPSEEK_API_KEY'):
+                    return line.split(':', 1)[1].strip()
+        except Exception:
+            pass
+    return ''
+
+
+def _translate_en(keyword):
+    """中文关键词 → 英文（先查内置词表，再走 DeepSeek 翻译），供 Pexels 兜底用。"""
+    if not _has_cjk(keyword):
+        return keyword
+    if keyword in _TRANSLATE_DICT:
+        return _TRANSLATE_DICT[keyword]
+    dk = _deepseek_key()
+    if not dk:
+        return keyword
+    try:
+        payload = {
+            'model': 'deepseek-v4-flash',
+            'messages': [{'role': 'user', 'content': f'把下面中文关键词翻译成英文，只输出英文（3 个单词以内，不要解释）：{keyword}'}],
+        }
+        with _open('https://api.deepseek.com/chat/completions', timeout=20,
+                   headers={'Authorization': 'Bearer ' + dk, 'Content-Type': 'application/json'},
+                   via_proxy=True) as r:
+            d = json.loads(r.read().decode('utf-8'))
+        en = d['choices'][0]['message']['content'].strip().strip('"')
+        return en if en else keyword
+    except Exception:
+        return keyword
+
+
+def fetch(keyword, out_path, w=1600, h=900, key=None):
+    """下载配图，返回 (path, attribution)。默认走国内（必应国内），找不到再走 Pexels（英文关键词）。"""
+    key = key or _pexels_key()
+    # 1) 默认：必应国内搜索（直连、国内站点优先，国内题材不违和）
+    try:
+        path, _ = fetch_bing_cn(keyword, out_path)
+        return path, ""
+    except Exception:
+        pass
+    # 2) 淘宝商品图（商品题材更贴切：白底实拍；图片偏小，作补充源）
+    try:
+        path, _ = fetch_taobao(keyword, out_path)
+        return path, ""
+    except Exception:
+        pass
+    # 3) 国内都找不到 → Pexels（外网、走代理；中文关键词先翻成英文，命中更准）
+    try:
+        en = _translate_en(keyword)
+        ph = search_pexels(en, key=key)
+        if ph:
+            src = ph['src'].get('large2x') or ph['src'].get('large') or ph['src'].get('original')
+            _download(src, out_path, via_proxy=True)
+            return out_path, ""
+    except Exception:
+        pass
+    # 3) 都不行就报错（不再走 loremflickr/picsum：中文关键词只会拿到随机图）
+    raise RuntimeError(f"图片获取失败(关键词='{keyword}')，请换关键词或人工指定图片")
+
+
+if __name__ == '__main__':
+    if len(sys.argv) < 3:
+        print("用法: python3 image_fetch.py <keyword> <out.jpg> [width] [height]")
+        sys.exit(1)
+    kw = sys.argv[1]; out = sys.argv[2]
+    w = int(sys.argv[3]) if len(sys.argv) > 3 else 1600
+    h = int(sys.argv[4]) if len(sys.argv) > 4 else 900
+    try:
+        path, attr = fetch(kw, out, w, h)
+        print(f"已保存: {path}")
+        if attr:
+            print(f"署名: {attr}")
+    except Exception as e:
+        print(f"失败: {e}")
+        sys.exit(2)

package/ingest.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+文件摄取工具 —— 让 PPT 助手「接受」现有 PPT / PDF / 图片文件：
+读取 .pptx / .pdf 的内容与结构，输出可读文本供助手分析、重排、转写。
+扫描版 PDF（无文字层）自动走 OCR（pdftoppm + tesseract）。
+
+用法：
+    python3 ingest.py <file.pptx|file.pdf|file.png|file.jpg>
+"""
+import sys, os, subprocess, glob, tempfile
+
+def ingest_pptx(path):
+    from pptx import Presentation
+    from pptx.enum.shapes import MSO_SHAPE_TYPE
+    prs = Presentation(path)
+    out = []
+    out.append(f"# PPT 摄取: {os.path.basename(path)}")
+    out.append(f"页数: {len(prs.slides)}  尺寸: {prs.slide_width/914400:.2f}x{prs.slide_height/914400:.2f} in")
+    for i, s in enumerate(prs.slides, 1):
+        layout = s.slide_layout.name if s.slide_layout else '?'
+        out.append(f"\n--- 第{i}页 (layout: {layout}) ---")
+        for sh in s.shapes:
+            if sh.has_text_frame and sh.text_frame.text.strip():
+                out.append(f"  [文本] {sh.text_frame.text.strip()}")
+            elif sh.has_table:
+                tbl = sh.table
+                out.append(f"  [表格] {len(tbl.rows)}行 x {len(tbl.columns)}列")
+                for r in tbl.rows:
+                    out.append("     | " + " | ".join(c.text.strip() for c in r.cells))
+            elif hasattr(sh, 'has_chart') and sh.has_chart:
+                out.append(f"  [图表] {sh.name}")
+            elif sh.shape_type == MSO_SHAPE_TYPE.PICTURE:
+                out.append(f"  [图片] {sh.name}")
+        if s.has_notes_slide:
+            note = s.notes_slide.notes_text_frame.text.strip()
+            if note:
+                out.append(f"  [备注] {note}")
+    return "\n".join(out)
+
+def _tesseract_ocr(image_path):
+    """对单张图片 OCR（中英混合）。"""
+    r = subprocess.run(
+        ["tesseract", image_path, "stdout", "-l", "chi_sim+eng", "--psm", "3"],
+        capture_output=True, text=True)
+    return (r.stdout or "").strip()
+
+def ingest_image(path):
+    txt = _tesseract_ocr(path)
+    return f"# 图片 OCR: {os.path.basename(path)}\n{txt}"
+
+def _ocr_scanned_pdf(path):
+    """扫描版 PDF：逐页渲染为 PNG 再 OCR。"""
+    out = [f"# PDF 摄取(扫描版, 经 OCR): {os.path.basename(path)}"]
+    with tempfile.TemporaryDirectory() as td:
+        subprocess.run(
+            ["pdftoppm", "-png", "-r", "200", path, os.path.join(td, "page")],
+            check=True, capture_output=True)
+        imgs = sorted(glob.glob(os.path.join(td, "page-*.png")))
+        out.append(f"总页数: {len(imgs)}")
+        for i, img in enumerate(imgs, 1):
+            txt = _tesseract_ocr(img)
+            out.append(f"\n--- 第{i}页(OCR) ---\n{txt}")
+    return "\n".join(out)
+
+def ingest_pdf(path):
+    from pypdf import PdfReader
+    r = PdfReader(path)
+    pages = []
+    total_text = ""
+    for i, page in enumerate(r.pages, 1):
+        t = page.extract_text() or ""
+        total_text += t
+        pages.append(f"\n--- 第{i}页 ---\n{t}")
+    if total_text.strip():
+        return f"# PDF 摄取: {os.path.basename(path)}\n总页数: {len(pages)}" + "".join(pages)
+    # 无文字层 → 扫描版，走 OCR
+    return _ocr_scanned_pdf(path)
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print("用法: python3 ingest.py <file.pptx|file.pdf|file.png|file.jpg>")
+        sys.exit(1)
+    path = sys.argv[1]
+    ext = os.path.splitext(path)[1].lower()
+    if ext == '.pptx':
+        print(ingest_pptx(path))
+    elif ext == '.pdf':
+        print(ingest_pdf(path))
+    elif ext in ('.png', '.jpg', '.jpeg', '.tif', '.tiff', '.bmp'):
+        print(ingest_image(path))
+    else:
+        print(f"不支持的类型: {ext}（仅支持 .pptx / .pdf / 图片）")
+        sys.exit(2)