Update app.py

app.py

@@ -1,130 +1,507 @@
 import os
+import math
+import json
+import tempfile
+from dataclasses import dataclass
+from typing import Dict, List, Tuple, Optional
+
 import cv2
 import numpy as np
 import pandas as pd
 import gradio as gr
-
 import mediapipe as mp
 
 
-mp_pose = mp.solutions.pose
-mp_drawing = mp.solutions.drawing_utils
+# -------------------------
+# Utils: geometry
+# -------------------------
+def _dist(a: np.ndarray, b: np.ndarray) -> float:
+    return float(np.linalg.norm(a - b))
 
+def _safe_div(a: float, b: float, eps: float = 1e-8) -> float:
+    return a / (b + eps)
 
-def _ensure_rgb(img: np.ndarray) -> np.ndarray:
-    # Gradio Image returns RGB np.uint8
-    if img is None:
+def eye_aspect_ratio(pts: Dict[int, np.ndarray], idx: List[int]) -> Optional[float]:
+    """
+    EAR = (||p2-p6|| + ||p3-p5||) / (2*||p1-p4||)
+    idx: [p1, p2, p3, p4, p5, p6]
+    """
+    try:
+        p1, p2, p3, p4, p5, p6 = [pts[i] for i in idx]
+    except KeyError:
         return None
-    if img.dtype != np.uint8:
-        img = np.clip(img, 0, 255).astype(np.uint8)
-    if img.ndim == 2:
-        img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
-    return img
+    A = _dist(p2, p6)
+    B = _dist(p3, p5)
+    C = _dist(p1, p4)
+    return _safe_div((A + B), (2.0 * C))
 
-
-def estimate_pose(image: np.ndarray, model_complexity: int, min_det: float, min_track: float):
+def angle_3pts(a: np.ndarray, b: np.ndarray, c: np.ndarray) -> Optional[float]:
     """
-    Returns:
-      - annotated_image (RGB)
-      - keypoints dataframe
+    angle at point b in degrees formed by a-b-c
     """
-    image = _ensure_rgb(image)
-    if image is None:
-        return None, pd.DataFrame()
+    ba = a - b
+    bc = c - b
+    nba = np.linalg.norm(ba)
+    nbc = np.linalg.norm(bc)
+    if nba < 1e-8 or nbc < 1e-8:
+        return None
+    cosang = float(np.dot(ba, bc) / (nba * nbc))
+    cosang = max(-1.0, min(1.0, cosang))
+    return float(np.degrees(np.arccos(cosang)))
 
-    # MediaPipe expects RGB, but drawing is easier in BGR sometimes; we'll keep RGB and convert when needed.
-    rgb = image.copy()
 
-    with mp_pose.Pose(
-        static_image_mode=True,
-        model_complexity=model_complexity,
-        enable_segmentation=False,
-        min_detection_confidence=float(min_det),
-        min_tracking_confidence=float(min_track),
-    ) as pose:
-        results = pose.process(rgb)
+# -------------------------
+# MediaPipe indices
+# -------------------------
+# FaceMesh landmarks for EAR (common set)
+LEFT_EYE_EAR_IDX  = [33, 160, 158, 133, 153, 144]
+RIGHT_EYE_EAR_IDX = [362, 385, 387, 263, 373, 380]
+
+# Pose landmark enum mapping (MediaPipe Pose)
+POSE = mp.solutions.pose
+POSE_LM = POSE.PoseLandmark
 
-    annotated = rgb.copy()
+# Key joints for limb movement/angles
+JOINTS = {
+    "left_wrist": POSE_LM.LEFT_WRIST.value,
+    "right_wrist": POSE_LM.RIGHT_WRIST.value,
+    "left_ankle": POSE_LM.LEFT_ANKLE.value,
+    "right_ankle": POSE_LM.RIGHT_ANKLE.value,
 
-    rows = []
-    if results.pose_landmarks:
-        # Draw landmarks
-        annotated_bgr = cv2.cvtColor(annotated, cv2.COLOR_RGB2BGR)
+    "left_shoulder": POSE_LM.LEFT_SHOULDER.value,
+    "right_shoulder": POSE_LM.RIGHT_SHOULDER.value,
+    "left_elbow": POSE_LM.LEFT_ELBOW.value,
+    "right_elbow": POSE_LM.RIGHT_ELBOW.value,
+
+    "left_hip": POSE_LM.LEFT_HIP.value,
+    "right_hip": POSE_LM.RIGHT_HIP.value,
+    "left_knee": POSE_LM.LEFT_KNEE.value,
+    "right_knee": POSE_LM.RIGHT_KNEE.value,
+}
+
+
+# -------------------------
+# Drawing
+# -------------------------
+mp_drawing = mp.solutions.drawing_utils
+mp_drawing_styles = mp.solutions.drawing_styles
+mp_face_mesh = mp.solutions.face_mesh
+
+def draw_pose(image_bgr, pose_results):
+    if pose_results.pose_landmarks:
         mp_drawing.draw_landmarks(
-            annotated_bgr,
-            results.pose_landmarks,
-            mp_pose.POSE_CONNECTIONS,
-            landmark_drawing_spec=mp_drawing.DrawingSpec(thickness=2, circle_radius=2),
-            connection_drawing_spec=mp_drawing.DrawingSpec(thickness=2),
+            image_bgr,
+            pose_results.pose_landmarks,
+            POSE.POSE_CONNECTIONS,
+            landmark_drawing_spec=mp_drawing_styles.get_default_pose_landmarks_style(),
         )
-        annotated = cv2.cvtColor(annotated_bgr, cv2.COLOR_BGR2RGB)
-
-        # Collect keypoints
-        for i, lm in enumerate(results.pose_landmarks.landmark):
-            rows.append(
-                {
-                    "id": i,
-                    "name": mp_pose.PoseLandmark(i).name,
-                    "x": float(lm.x),
-                    "y": float(lm.y),
-                    "z": float(lm.z),
-                    "visibility": float(lm.visibility),
-                }
+
+def draw_face(image_bgr, face_results, draw_full_mesh: bool = False):
+    if not face_results.multi_face_landmarks:
+        return
+    for face_landmarks in face_results.multi_face_landmarks:
+        if draw_full_mesh:
+            # full mesh (dense) - heavier visually
+            mp_drawing.draw_landmarks(
+                image_bgr,
+                face_landmarks,
+                mp_face_mesh.FACEMESH_TESSELATION,
+                landmark_drawing_spec=None,
+                connection_drawing_spec=mp_drawing_styles.get_default_face_mesh_tesselation_style(),
             )
+        # contours are enough for most
+        mp_drawing.draw_landmarks(
+            image_bgr,
+            face_landmarks,
+            mp_face_mesh.FACEMESH_CONTOURS,
+            landmark_drawing_spec=None,
+            connection_drawing_spec=mp_drawing_styles.get_default_face_mesh_contours_style(),
+        )
+
+
+# -------------------------
+# Blink detection
+# -------------------------
+@dataclass
+class BlinkState:
+    in_blink: bool = False
+    blink_count: int = 0
+    consec_below: int = 0
+
+def update_blink(state: BlinkState, ear: Optional[float], thr: float, min_consec: int) -> BlinkState:
+    """
+    Basic blink logic:
+    - ear below threshold for >= min_consec frames => blink start
+    - when ear goes back above => blink end (count once)
+    """
+    if ear is None:
+        # treat missing as no-update
+        return state
+
+    if ear < thr:
+        state.consec_below += 1
+        if (not state.in_blink) and state.consec_below >= min_consec:
+            state.in_blink = True
+    else:
+        if state.in_blink:
+            state.blink_count += 1
+        state.in_blink = False
+        state.consec_below = 0
+    return state
+
+
+# -------------------------
+# Core processing
+# -------------------------
+def process_video(
+    video_path: str,
+    pose_model_complexity: int = 1,
+    min_pose_det_conf: float = 0.5,
+    min_pose_track_conf: float = 0.5,
+    min_face_det_conf: float = 0.5,
+    ear_threshold: float = 0.21,
+    blink_min_consec: int = 2,
+    draw_full_face_mesh: bool = False,
+    max_frames: int = 0,  # 0 => all
+) -> Tuple[str, str, str, str]:
+    """
+    Returns:
+      annotated_video_path, csv_path, json_path, report_md
+    """
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise RuntimeError("Cannot open video. Please upload a valid video file.")
+
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    if fps <= 1e-6:
+        fps = 30.0
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    # output paths
+    tmpdir = tempfile.mkdtemp(prefix="mp_analysis_")
+    out_video = os.path.join(tmpdir, "annotated.mp4")
+    out_csv = os.path.join(tmpdir, "per_frame_metrics.csv")
+    out_json = os.path.join(tmpdir, "summary.json")
+    out_report = os.path.join(tmpdir, "report.md")
+
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter(out_video, fourcc, fps, (width, height))
+
+    # MediaPipe init
+    with mp.solutions.pose.Pose(
+        static_image_mode=False,
+        model_complexity=pose_model_complexity,
+        enable_segmentation=False,
+        min_detection_confidence=min_pose_det_conf,
+        min_tracking_confidence=min_pose_track_conf,
+    ) as pose, mp_face_mesh.FaceMesh(
+        static_image_mode=False,
+        max_num_faces=1,
+        refine_landmarks=True,  # improves eye landmarks
+        min_detection_confidence=min_face_det_conf,
+        min_tracking_confidence=min_face_det_conf,
+    ) as face_mesh:
+
+        rows = []
+        prev_pts = {}  # for movement delta (normalized coordinates)
+        left_blink = BlinkState()
+        right_blink = BlinkState()
+
+        frame_idx = 0
+        while True:
+            ok, frame_bgr = cap.read()
+            if not ok:
+                break
+            frame_idx += 1
+            if max_frames and frame_idx > max_frames:
+                break
+
+            frame_rgb = cv2.cvtColor(frame_bgr, cv2.COLOR_BGR2RGB)
+
+            pose_res = pose.process(frame_rgb)
+            face_res = face_mesh.process(frame_rgb)
+
+            # Extract face landmarks (pixel coords)
+            face_pts: Dict[int, np.ndarray] = {}
+            if face_res.multi_face_landmarks:
+                lm = face_res.multi_face_landmarks[0].landmark
+                for i in range(len(lm)):
+                    face_pts[i] = np.array([lm[i].x * width, lm[i].y * height], dtype=np.float32)
+
+            # EAR
+            left_ear = eye_aspect_ratio(face_pts, LEFT_EYE_EAR_IDX)
+            right_ear = eye_aspect_ratio(face_pts, RIGHT_EYE_EAR_IDX)
+
+            left_blink = update_blink(left_blink, left_ear, ear_threshold, blink_min_consec)
+            right_blink = update_blink(right_blink, right_ear, ear_threshold, blink_min_consec)
+
+            # Extract pose landmarks (normalized coords + pixel)
+            pose_norm: Dict[str, Optional[np.ndarray]] = {}
+            pose_px: Dict[str, Optional[np.ndarray]] = {}
+            if pose_res.pose_landmarks:
+                lms = pose_res.pose_landmarks.landmark
+                for name, idx in JOINTS.items():
+                    if idx < len(lms):
+                        pose_norm[name] = np.array([lms[idx].x, lms[idx].y], dtype=np.float32)
+                        pose_px[name] = np.array([lms[idx].x * width, lms[idx].y * height], dtype=np.float32)
+                    else:
+                        pose_norm[name] = None
+                        pose_px[name] = None
+            else:
+                for name in JOINTS:
+                    pose_norm[name] = None
+                    pose_px[name] = None
+
+            # Limb movement: per-frame displacement & speed (in normalized units)
+            def movement_metrics(key: str):
+                cur = pose_norm.get(key)
+                if cur is None:
+                    return None, None
+                prev = prev_pts.get(key)
+                if prev is None:
+                    d = 0.0
+                else:
+                    d = float(np.linalg.norm(cur - prev))
+                v = d * fps
+                prev_pts[key] = cur
+                return d, v
+
+            lw_d, lw_v = movement_metrics("left_wrist")
+            rw_d, rw_v = movement_metrics("right_wrist")
+            la_d, la_v = movement_metrics("left_ankle")
+            ra_d, ra_v = movement_metrics("right_ankle")
+
+            # Joint angles (pixel coords for stability)
+            def get_angle(a, b, c):
+                if a is None or b is None or c is None:
+                    return None
+                return angle_3pts(a, b, c)
+
+            left_elbow_ang = get_angle(pose_px["left_shoulder"], pose_px["left_elbow"], pose_px["left_wrist"])
+            right_elbow_ang = get_angle(pose_px["right_shoulder"], pose_px["right_elbow"], pose_px["right_wrist"])
+            left_knee_ang = get_angle(pose_px["left_hip"], pose_px["left_knee"], pose_px["left_ankle"])
+            right_knee_ang = get_angle(pose_px["right_hip"], pose_px["right_knee"], pose_px["right_ankle"])
+
+            # Draw overlays
+            draw_pose(frame_bgr, pose_res)
+            draw_face(frame_bgr, face_res, draw_full_mesh=draw_full_face_mesh)
+
+            # HUD text
+            hud_lines = [
+                f"frame: {frame_idx}/{total_frames if total_frames>0 else '?'}  fps:{fps:.1f}",
+                f"EAR L:{left_ear:.3f}" if left_ear is not None else "EAR L:None",
+                f"EAR R:{right_ear:.3f}" if right_ear is not None else "EAR R:None",
+                f"Blink L:{left_blink.blink_count}  R:{right_blink.blink_count}",
+            ]
+            y0 = 24
+            for line in hud_lines:
+                cv2.putText(frame_bgr, line, (12, y0), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 2)
+                y0 += 22
+
+            writer.write(frame_bgr)
+
+            rows.append({
+                "frame": frame_idx,
+                "time_s": (frame_idx - 1) / fps,
+
+                "left_ear": left_ear,
+                "right_ear": right_ear,
+
+                "lw_disp": lw_d,
+                "rw_disp": rw_d,
+                "la_disp": la_d,
+                "ra_disp": ra_d,
+
+                "lw_speed": lw_v,
+                "rw_speed": rw_v,
+                "la_speed": la_v,
+                "ra_speed": ra_v,
+
+                "left_elbow_angle": left_elbow_ang,
+                "right_elbow_angle": right_elbow_ang,
+                "left_knee_angle": left_knee_ang,
+                "right_knee_angle": right_knee_ang,
+            })
+
+    cap.release()
+    writer.release()
 
     df = pd.DataFrame(rows)
-    return annotated, df
 
+    # Summaries
+    def _sum_series(s: pd.Series):
+        s2 = s.dropna()
+        if len(s2) == 0:
+            return {"mean": None, "min": None, "max": None}
+        return {"mean": float(s2.mean()), "min": float(s2.min()), "max": float(s2.max())}
 
-def build_demo():
-    with gr.Blocks(title="Pose Estimation") as demo:
-        gr.Markdown(
-            "## 🕺 Pose Estimation (MediaPipe)\n"
-            "上传一张图片 → 输出骨架标注图 + 关键点表格。\n\n"
-            "如果你之前遇到 `TypeError: argument of type 'bool' is not iterable`，这是 Gradio 4.x 的一个坑，"
-            "本 Space 已升级到 Gradio 5.x 来避免。"
-        )
+    # movement totals in normalized units (roughly proportional)
+    summary = {
+        "video": {
+            "fps": float(fps),
+            "width": width,
+            "height": height,
+            "frames_processed": int(len(df)),
+            "duration_s": float(len(df) / fps),
+        },
+        "blink": {
+            "ear_threshold": float(ear_threshold),
+            "min_consecutive_frames": int(blink_min_consec),
+            "left_blinks": int(left_blink.blink_count),
+            "right_blinks": int(right_blink.blink_count),
+            "left_blinks_per_min": float(_safe_div(left_blink.blink_count, (len(df)/fps)/60.0)) if len(df) else 0.0,
+            "right_blinks_per_min": float(_safe_div(right_blink.blink_count, (len(df)/fps)/60.0)) if len(df) else 0.0,
+            "left_ear_stats": _sum_series(df["left_ear"]),
+            "right_ear_stats": _sum_series(df["right_ear"]),
+        },
+        "limb_movement": {
+            "total_disp": {
+                "left_wrist": float(df["lw_disp"].fillna(0).sum()),
+                "right_wrist": float(df["rw_disp"].fillna(0).sum()),
+                "left_ankle": float(df["la_disp"].fillna(0).sum()),
+                "right_ankle": float(df["ra_disp"].fillna(0).sum()),
+            },
+            "speed_stats": {
+                "left_wrist": _sum_series(df["lw_speed"]),
+                "right_wrist": _sum_series(df["rw_speed"]),
+                "left_ankle": _sum_series(df["la_speed"]),
+                "right_ankle": _sum_series(df["ra_speed"]),
+            },
+            "angle_stats_deg": {
+                "left_elbow": _sum_series(df["left_elbow_angle"]),
+                "right_elbow": _sum_series(df["right_elbow_angle"]),
+                "left_knee": _sum_series(df["left_knee_angle"]),
+                "right_knee": _sum_series(df["right_knee_angle"]),
+            }
+        }
+    }
 
-        with gr.Row():
-            inp = gr.Image(label="Input Image", type="numpy")
-            out_img = gr.Image(label="Annotated Output", type="numpy")
+    # Save outputs
+    df.to_csv(out_csv, index=False)
+    with open(out_json, "w", encoding="utf-8") as f:
+        json.dump(summary, f, ensure_ascii=False, indent=2)
 
-        with gr.Row():
-            model_complexity = gr.Radio(
-                choices=[0, 1, 2],
-                value=1,
-                label="Model Complexity (0=light, 2=accurate)",
-            )
-            min_det = gr.Slider(0.1, 0.99, value=0.5, step=0.01, label="Min Detection Confidence")
-            min_track = gr.Slider(0.1, 0.99, value=0.5, step=0.01, label="Min Tracking Confidence")
-
-        out_df = gr.Dataframe(
-            label="Keypoints (normalized coords)",
-            headers=["id", "name", "x", "y", "z", "visibility"],
-            interactive=False,
-            wrap=True,
-        )
+    report_md = f"""# MediaPipe Pose + FaceLandmarks 分析报告
 
-        run_btn = gr.Button("Run Pose Estimation", variant="primary")
-        run_btn.click(
-            fn=estimate_pose,
-            inputs=[inp, model_complexity, min_det, min_track],
-            outputs=[out_img, out_df],
-        )
+## 视频信息
+- 分辨率: {width} x {height}
+- FPS: {fps:.2f}
+- 处理帧数: {len(df)}
+- 时长(秒): {summary["video"]["duration_s"]:.2f}
 
-        gr.Markdown(
-            "### Notes\n"
-            "- `x/y/z` 是相对坐标（0~1），相对于输入图像宽高。\n"
-            "- 这是 CPU 友好版本，适合 Hugging Face Spaces。"
-        )
+## 眨眼分析（EAR）
+- 阈值: {ear_threshold}
+- 最小连续帧数: {blink_min_consec}
+- 左眼眨眼次数: {summary["blink"]["left_blinks"]}（{summary["blink"]["left_blinks_per_min"]:.2f} 次/分钟）
+- 右眼眨眼次数: {summary["blink"]["right_blinks"]}（{summary["blink"]["right_blinks_per_min"]:.2f} 次/分钟）
+- 左眼 EAR: mean={summary["blink"]["left_ear_stats"]["mean"]}  min={summary["blink"]["left_ear_stats"]["min"]}  max={summary["blink"]["left_ear_stats"]["max"]}
+- 右眼 EAR: mean={summary["blink"]["right_ear_stats"]["mean"]} min={summary["blink"]["right_ear_stats"]["min"]} max={summary["blink"]["right_ear_stats"]["max"]}
+
+## 肢体运动量（normalized units）
+> 这里的位移/速度是基于归一化坐标(0~1)计算，适合“相对比较”和趋势分析。
+- 累计位移（越大代表越动）:
+  - 左手腕: {summary["limb_movement"]["total_disp"]["left_wrist"]:.6f}
+  - 右手腕: {summary["limb_movement"]["total_disp"]["right_wrist"]:.6f}
+  - 左脚踝: {summary["limb_movement"]["total_disp"]["left_ankle"]:.6f}
+  - 右脚踝: {summary["limb_movement"]["total_disp"]["right_ankle"]:.6f}
+
+## 输出文件
+- annotated.mp4：叠加了 Pose 和 FaceMesh 的视频
+- per_frame_metrics.csv：逐帧指标（EAR / 位移 / 速度 / 关节角）
+- summary.json：汇总统计
+"""
+    with open(out_report, "w", encoding="utf-8") as f:
+        f.write(report_md)
+
+    return out_video, out_csv, out_json, out_report
+
+
+# -------------------------
+# Gradio UI
+# -------------------------
+def ui_process(
+    video,
+    pose_model_complexity,
+    min_pose_det_conf,
+    min_pose_track_conf,
+    min_face_det_conf,
+    ear_threshold,
+    blink_min_consec,
+    draw_full_face_mesh,
+    max_frames
+):
+    # video may be dict in some gradio versions
+    if isinstance(video, dict) and "path" in video:
+        video_path = video["path"]
+    else:
+        video_path = video
+
+    out_video, out_csv, out_json, out_report = process_video(
+        video_path=str(video_path),
+        pose_model_complexity=int(pose_model_complexity),
+        min_pose_det_conf=float(min_pose_det_conf),
+        min_pose_track_conf=float(min_pose_track_conf),
+        min_face_det_conf=float(min_face_det_conf),
+        ear_threshold=float(ear_threshold),
+        blink_min_consec=int(blink_min_consec),
+        draw_full_face_mesh=bool(draw_full_face_mesh),
+        max_frames=int(max_frames),
+    )
+
+    # Show report text + return files
+    with open(out_report, "r", encoding="utf-8") as f:
+        report_text = f.read()
+
+    return out_video, out_csv, out_json, report_text
+
+
+demo = gr.Blocks(title="Video Pose + FaceLandmarks + Blink/Limb Analytics")
+
+with demo:
+    gr.Markdown("## 上传视频 → MediaPipe Pose + FaceMesh → 肢体运动量 & 眨眼量化（EAR）")
+
+    with gr.Row():
+        video_in = gr.Video(label="上传视频", sources=["upload"])
+
+    with gr.Accordion("参数（一般默认就够用）", open=False):
+        pose_model_complexity = gr.Radio([0, 1, 2], value=1, label="Pose model_complexity (0快/2准)")
+        min_pose_det_conf = gr.Slider(0.1, 0.9, value=0.5, step=0.05, label="Pose min_detection_confidence")
+        min_pose_track_conf = gr.Slider(0.1, 0.9, value=0.5, step=0.05, label="Pose min_tracking_confidence")
+        min_face_det_conf = gr.Slider(0.1, 0.9, value=0.5, step=0.05, label="Face min_detection_confidence")
+
+        ear_threshold = gr.Slider(0.10, 0.35, value=0.21, step=0.01, label="眨眼阈值 EAR（越小越严格）")
+        blink_min_consec = gr.Slider(1, 6, value=2, step=1, label="眨眼最小连续帧数（抗抖动）")
+
+        draw_full_face_mesh = gr.Checkbox(value=False, label="叠加完整 FaceMesh（更密/更慢）")
+        max_frames = gr.Number(value=0, precision=0, label="最多处理帧数（0=全处理，调试可设 300）")
 
-    return demo
+    run_btn = gr.Button("开始分析")
 
+    with gr.Row():
+        video_out = gr.Video(label="输出：叠加标注视频")
+    with gr.Row():
+        csv_out = gr.File(label="逐帧指标 CSV（per_frame_metrics.csv）")
+        json_out = gr.File(label="汇总 JSON（summary.json）")
+    report_out = gr.Markdown()
 
-demo = build_demo()
+    run_btn.click(
+        fn=ui_process,
+        inputs=[
+            video_in,
+            pose_model_complexity,
+            min_pose_det_conf,
+            min_pose_track_conf,
+            min_face_det_conf,
+            ear_threshold,
+            blink_min_consec,
+            draw_full_face_mesh,
+            max_frames,
+        ],
+        outputs=[video_out, csv_out, json_out, report_out],
+    )
 
 if __name__ == "__main__":
-    # Hugging Face Spaces 通常不需要 share=True
-    # 如果你环境仍然报 localhost 不可访问，可把 share=True 打开兜底
-    share = os.getenv("GRADIO_SHARE", "0") == "1"
-    demo.launch(server_name="0.0.0.0", server_port=7860, share=share)
+    # HF Spaces 不需要 share=True；也别开 share，省事
+    demo.launch(server_name="0.0.0.0", server_port=7860)