"""后台轮询目录中的 .svo2，逐段跑 FishMeasure，齐套后聚合 final（与 ingest 共用 SQLite）。""" from __future__ import annotations import asyncio import hashlib from pathlib import Path from typing import Dict, List, Set, Tuple from loguru import logger from app.compat import to_thread from app.db import ( add_watch_processed, load_watch_processed, measure_snapshot_deliverable, save_measure_snapshot, ) from app.services import measure as measure_svc from app.settings import Settings from app.state import app_state from app.watch_idle import IdleWatchWarnState, idle_warn_interval_sec, maybe_warn_idle_watch _MEASURE_IDLE_WARN_INTERVAL_SEC = idle_warn_interval_sec( "FISH_MEASURE_WATCH_IDLE_WARN_INTERVAL_SEC" ) def _state_path(settings: Settings) -> Path: """返回旧版 JSON 状态文件路径（仅用于兼容导入 SQLite）。""" assert settings.measure_watch_dir is not None return settings.measure_watch_dir / ".fishmeasure_watch_processed.json" def iter_svo2_folders(watch_dir: Path) -> List[Tuple[List[Path], str]]: """扫描子文件夹，返回 (svo文件路径列表, fish_id) 列表。 文件夹命名格式为 fish{N}。每个子文件夹内多个 .svo2 先逐段测量，齐套后再聚合 final。 """ result = [] # type: List[Tuple[List[Path], str]] if not watch_dir.is_dir(): return result for entry in sorted(watch_dir.iterdir()): if not entry.is_dir(): continue folder_name = entry.name if not folder_name.startswith("fish"): continue try: fish_id = folder_name[4:] if not fish_id.isdigit(): continue except (IndexError, ValueError): continue svo_files = sorted([ p for p in entry.iterdir() if p.is_file() and p.suffix.lower() == ".svo2" ]) if svo_files: result.append((svo_files, fish_id)) return result def _final_processed_key(fish_id: str, svo_list: List[Path]) -> str: sig = "|".join(sorted(str(p.resolve()) for p in svo_list)) h = hashlib.sha256(sig.encode("utf-8")).hexdigest()[:24] return f"__measure_final__fish{fish_id}:{h}" def _folder_size_tuple(svo_list: List[Path]) -> Tuple[Tuple[str, int], ...]: out: List[Tuple[str, int]] = [] for p in sorted(svo_list, key=lambda x: str(x.resolve())): try: st = p.stat() out.append((str(p.resolve()), int(st.st_size))) except OSError: return tuple() return tuple(out) async def _run_single_svo_measure( svo: Path, fish_id: str, settings: Settings, processed: Set[str], state_file: Path, ) -> None: key = str(svo.resolve()) fish_folder = svo.parent.resolve() fish_output_root = settings.measure_output_root / f"fish{fish_id}" fish_output_root.mkdir(parents=True, exist_ok=True) logger.info( "[measure-watch] segment inference fish_id={} svo={}", fish_id, svo.name, ) async with app_state.measure_lock: app_state.measure_status = "running" try: def _run(): with app_state.measure_thread_lock: return measure_svc.run_full_measure( svo, settings, output_root=fish_output_root ) snap = await to_thread(_run) snap = measure_svc.tag_measure_snapshot_meta( snap, measurement_phase="segment", fish_folder=str(fish_folder), segment_source=str(svo.resolve()), ) if measure_snapshot_deliverable(snap): save_measure_snapshot( settings, snap, source_path=str(svo.resolve()), client_id=None, ) else: logger.warning( "[measure-watch] no deliverable measure rows for fish_id={} svo={}, skip SQLite", fish_id, svo.name, ) app_state.measure_status = "idle" processed.add(key) if settings.measure_watch_use_state_file: add_watch_processed(settings, key, "measure") r0 = snap.result[0] if snap.result else {} logger.info( "[measure-watch] segment done: fish_id={} svo={} weight={!r}", fish_id, svo.name, r0.get("weight", ""), ) except (RuntimeError, FileNotFoundError) as e: logger.warning( "[measure-watch] measure failed fish_id={} svo={}: {}", fish_id, svo.name, e, ) app_state.measure_status = "idle" processed.add(key) if settings.measure_watch_use_state_file: add_watch_processed(settings, key, "measure") except Exception as e: logger.exception( "[measure-watch] error fish_id={} svo={}: {}", fish_id, svo.name, e, ) app_state.measure_status = "idle" processed.add(key) if settings.measure_watch_use_state_file: add_watch_processed(settings, key, "measure") async def _run_final_aggregate( svo_list: List[Path], fish_id: str, settings: Settings, processed: Set[str], state_file: Path, final_key: str, ) -> None: fish_folder = svo_list[0].parent.resolve() logger.info( "[measure-watch] final aggregate fish_id={} {} segment(s)", fish_id, len(svo_list), ) async with app_state.measure_lock: app_state.measure_status = "running" try: def _reload(): return measure_svc.reload_segment_snapshots_for_aggregate( svo_list, fish_id, settings ) pairs = await to_thread(_reload) contributing_svos = [p[0] for p in pairs] segments = [p[1] for p in pairs] paths_joined = "|".join(sorted(str(p.resolve()) for p in contributing_svos)) snap = measure_svc.build_measure_snapshot_aggregate( segments, fish_id, settings, contributing_svos=contributing_svos, fish_folder=str(fish_folder), segment_source_paths=paths_joined, ) if measure_snapshot_deliverable(snap): try: v_left, v_right = await to_thread( measure_svc.generate_aggregate_preview_media, contributing_svos, snap, fish_id, settings, final_key=final_key, ) snap.video_left = v_left snap.video_right = v_right except Exception as e: logger.warning( "[measure-watch] final preview generate failed fish_id={}: {}", fish_id, e, ) save_measure_snapshot( settings, snap, source_path=f"aggregate:{final_key}", client_id=None, ) else: logger.warning( "[measure-watch] final not deliverable for fish_id={}, skip SQLite", fish_id, ) app_state.measure_status = "idle" processed.add(final_key) if settings.measure_watch_use_state_file: add_watch_processed(settings, final_key, "measure") r0 = snap.result[0] if snap.result else {} logger.info( "[measure-watch] final done: fish_id={} weight={!r}", fish_id, r0.get("weight", ""), ) except Exception as e: logger.exception( "[measure-watch] final aggregate failed fish_id={}: {}", fish_id, e, ) app_state.measure_status = "idle" processed.add(final_key) if settings.measure_watch_use_state_file: add_watch_processed(settings, final_key, "measure") async def watch_tick( settings: Settings, processed: Set[str], stability: Dict[str, Tuple[int, int]], final_stability: Dict[str, Tuple[Tuple[Tuple[str, int], ...], int]], state_file: Path, ) -> bool: """逐段稳定即测量；同一 fish 目录全部段已处理且整体稳定后写 final。""" assert settings.measure_watch_dir is not None watch_dir = settings.measure_watch_dir did = False seen_keys: Set[str] = set() for svo_list, fish_id in iter_svo2_folders(watch_dir): if not svo_list: continue fish_folder = svo_list[0].parent folder_key = str(fish_folder.resolve()) for svo in svo_list: key = str(svo.resolve()) seen_keys.add(key) if key in processed: continue try: st = svo.stat() except OSError: continue size = int(st.st_size) if size <= 0: stability.pop(key, None) continue last = stability.get(key) if last is None or last[0] != size: stability[key] = (size, 1) else: _, cnt = last cnt += 1 stability[key] = (size, cnt) if cnt >= settings.measure_watch_stable_polls: await _run_single_svo_measure( svo, fish_id, settings, processed, state_file ) stability.pop(key, None) did = True fk = _final_processed_key(fish_id, svo_list) if fk in processed: continue if not all(str(p.resolve()) in processed for p in svo_list): final_stability.pop(folder_key, None) continue tup = _folder_size_tuple(svo_list) if not tup: continue prev = final_stability.get(folder_key) if prev is None or prev[0] != tup: final_stability[folder_key] = (tup, 1) else: _, c = prev c += 1 final_stability[folder_key] = (tup, c) if c >= settings.measure_watch_stable_polls: await _run_final_aggregate( svo_list, fish_id, settings, processed, state_file, fk ) final_stability.pop(folder_key, None) did = True for k in list(stability.keys()): if k not in seen_keys: del stability[k] return did async def run_measure_watch_loop(settings: Settings) -> None: assert settings.measure_watch_dir is not None wd = settings.measure_watch_dir if not wd.is_dir(): logger.warning("[measure-watch] skip: not a directory: {}", wd) return state_file = _state_path(settings) processed: Set[str] = ( load_watch_processed(settings, state_file, "measure") if settings.measure_watch_use_state_file else set() ) stability = {} # type: Dict[str, Tuple[int, int]] final_stability = {} # type: Dict[str, Tuple[Tuple[Tuple[str, int], ...], int]] logger.info( "[measure-watch] watching {} (poll={}s, stable_polls={}, aggregate={}, state={} {})", wd, settings.measure_watch_poll_interval, settings.measure_watch_stable_polls, settings.measure_final_aggregate_mode, "on" if settings.measure_watch_use_state_file else "off", state_file if settings.measure_watch_use_state_file else "", ) idle_warn_state = IdleWatchWarnState() while True: did = await watch_tick( settings, processed, stability, final_stability, state_file ) maybe_warn_idle_watch( did_work=did, log_tag="measure-watch", algo_name="FishMeasure", idle_hint="目录内无 fish{N} 子文件夹、已全部处理完毕，或文件尚未达到稳定轮询次数", watch_dir=wd, state=idle_warn_state, interval_sec=_MEASURE_IDLE_WARN_INTERVAL_SEC, ) await asyncio.sleep(max(settings.measure_watch_poll_interval, 0.1))