| import fcntl |
| import json |
| import os |
| import time |
| import zipfile |
| from pathlib import Path |
| from typing import Dict, Iterable, Sequence |
|
|
| import numpy as np |
|
|
|
|
| STATUS_FIELDS = [ |
| "sign_language", |
| "title", |
| "duration_sec", |
| "start_sec", |
| "end_sec", |
| "subtitle_languages", |
| "subtitle_dir_path", |
| "subtitle_en_source", |
| "raw_video_path", |
| "raw_metadata_path", |
| "metadata_status", |
| "subtitle_status", |
| "download_status", |
| "process_status", |
| "upload_status", |
| "local_cleanup_status", |
| "archive_name", |
| "last_error", |
| "updated_at", |
| ] |
|
|
|
|
| def _lock_path(stats_path: Path) -> Path: |
| return stats_path.with_suffix(stats_path.suffix + ".lock") |
|
|
|
|
| def processed_complete_counter_path(stats_path: Path) -> Path: |
| return stats_path.parent / "processed_complete.count" |
|
|
|
|
| def _counter_lock_path(counter_path: Path) -> Path: |
| return counter_path.with_suffix(counter_path.suffix + ".lock") |
|
|
|
|
| def read_processed_complete_counter(counter_path: Path) -> int: |
| if not counter_path.exists(): |
| return 0 |
| try: |
| return int(counter_path.read_text(encoding="utf-8").strip() or "0") |
| except Exception: |
| return 0 |
|
|
|
|
| def write_processed_complete_counter(counter_path: Path, value: int) -> int: |
| counter_path.parent.mkdir(parents=True, exist_ok=True) |
| normalized = max(0, int(value)) |
| tmp_path = counter_path.parent / f".{counter_path.name}.{os.getpid()}.tmp" |
| try: |
| tmp_path.write_text(f"{normalized}\n", encoding="utf-8") |
| os.replace(tmp_path, counter_path) |
| finally: |
| if tmp_path.exists(): |
| tmp_path.unlink(missing_ok=True) |
| return normalized |
|
|
|
|
| def adjust_processed_complete_counter(counter_path: Path, delta: int) -> int: |
| lock_path = _counter_lock_path(counter_path) |
| lock_path.parent.mkdir(parents=True, exist_ok=True) |
| with lock_path.open("a+", encoding="utf-8") as handle: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_EX) |
| try: |
| current = read_processed_complete_counter(counter_path) |
| return write_processed_complete_counter(counter_path, current + int(delta)) |
| finally: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_UN) |
|
|
|
|
| def _load_stats_unlocked(stats_path: Path) -> Dict[str, Dict[str, str]]: |
| if not stats_path.exists() or stats_path.stat().st_size == 0: |
| return {} |
|
|
| stats: Dict[str, Dict[str, str]] = {} |
| with np.load(stats_path, allow_pickle=True) as data: |
| video_ids = [str(item) for item in data.get("video_ids", np.asarray([], dtype=object)).tolist()] |
| for index, video_id in enumerate(video_ids): |
| record = {} |
| for field in STATUS_FIELDS: |
| values = data.get(field) |
| record[field] = str(values[index]) if values is not None and index < len(values) else "" |
| stats[video_id] = record |
| return stats |
|
|
|
|
| def load_stats(stats_path: Path, retries: int = 8, retry_delay: float = 0.2) -> Dict[str, Dict[str, str]]: |
| if not stats_path.exists(): |
| return {} |
|
|
| lock_path = _lock_path(stats_path) |
| lock_path.parent.mkdir(parents=True, exist_ok=True) |
| last_error: Exception | None = None |
| for _ in range(retries): |
| with lock_path.open("a+", encoding="utf-8") as handle: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_SH) |
| try: |
| return _load_stats_unlocked(stats_path) |
| except (EOFError, ValueError, OSError, zipfile.BadZipFile) as exc: |
| last_error = exc |
| finally: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_UN) |
| time.sleep(retry_delay) |
| if last_error is not None: |
| raise last_error |
| return {} |
|
|
|
|
| def save_stats(stats_path: Path, stats: Dict[str, Dict[str, str]]) -> None: |
| stats_path.parent.mkdir(parents=True, exist_ok=True) |
| video_ids = sorted(stats) |
| payload = {"video_ids": np.asarray(video_ids, dtype=object)} |
| for field in STATUS_FIELDS: |
| payload[field] = np.asarray([stats[video_id].get(field, "") for video_id in video_ids], dtype=object) |
| tmp_path = stats_path.parent / f".{stats_path.stem}.{os.getpid()}.tmp.npz" |
| try: |
| np.savez(tmp_path, **payload) |
| os.replace(tmp_path, stats_path) |
| finally: |
| if tmp_path.exists(): |
| tmp_path.unlink(missing_ok=True) |
|
|
|
|
| def ensure_record(stats: Dict[str, Dict[str, str]], video_id: str) -> Dict[str, str]: |
| if video_id not in stats: |
| stats[video_id] = {field: "" for field in STATUS_FIELDS} |
| return stats[video_id] |
|
|
|
|
| def update_video_stats(stats_path: Path, video_id: str, **updates: str) -> Dict[str, str]: |
| lock_path = _lock_path(stats_path) |
| lock_path.parent.mkdir(parents=True, exist_ok=True) |
| with lock_path.open("a+", encoding="utf-8") as handle: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_EX) |
| stats = _load_stats_unlocked(stats_path) |
| record = ensure_record(stats, video_id) |
| for key, value in updates.items(): |
| if key in STATUS_FIELDS: |
| record[key] = "" if value is None else str(value) |
| save_stats(stats_path, stats) |
| fcntl.flock(handle.fileno(), fcntl.LOCK_UN) |
| return dict(record) |
|
|
|
|
| def update_many_video_stats(stats_path: Path, video_ids: Iterable[str], **updates: str) -> None: |
| lock_path = _lock_path(stats_path) |
| lock_path.parent.mkdir(parents=True, exist_ok=True) |
| with lock_path.open("a+", encoding="utf-8") as handle: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_EX) |
| stats = _load_stats_unlocked(stats_path) |
| for video_id in video_ids: |
| record = ensure_record(stats, video_id) |
| for key, value in updates.items(): |
| if key in STATUS_FIELDS: |
| record[key] = "" if value is None else str(value) |
| save_stats(stats_path, stats) |
| fcntl.flock(handle.fileno(), fcntl.LOCK_UN) |
|
|
|
|
| def update_many_video_stats_with_retry(stats_path: Path, video_ids: Iterable[str], retries: int = 8, retry_delay: float = 0.2, **updates: str) -> None: |
| last_error: Exception | None = None |
| for _ in range(retries): |
| try: |
| update_many_video_stats(stats_path, video_ids, **updates) |
| return |
| except (EOFError, ValueError, OSError, zipfile.BadZipFile) as exc: |
| last_error = exc |
| time.sleep(retry_delay) |
| if last_error is not None: |
| raise last_error |
|
|
|
|
|
|
| def journal_lock_path(journal_path: Path) -> Path: |
| return journal_path.with_suffix(journal_path.suffix + ".lock") |
|
|
|
|
| def sidecar_status_dir(stats_path: Path) -> Path: |
| return stats_path.parent / "video_status" |
|
|
|
|
| def sidecar_status_path(stats_path: Path, video_id: str) -> Path: |
| return sidecar_status_dir(stats_path) / f"{video_id}.jsonl" |
|
|
|
|
| def append_status_journal(journal_path: Path, video_ids: Sequence[str], **updates: str) -> None: |
| journal_path.parent.mkdir(parents=True, exist_ok=True) |
| payload = { |
| "video_ids": list(video_ids), |
| "updates": {key: ("" if value is None else str(value)) for key, value in updates.items()}, |
| "recorded_at": time.strftime("%Y-%m-%d %H:%M:%S"), |
| } |
| lock_path = journal_lock_path(journal_path) |
| with lock_path.open("a+", encoding="utf-8") as handle: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_EX) |
| try: |
| with journal_path.open("a", encoding="utf-8") as journal_handle: |
| journal_handle.write(json.dumps(payload, ensure_ascii=False) + "\n") |
| finally: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_UN) |
|
|
|
|
| def append_status_sidecar(stats_path: Path, video_id: str, **updates: str) -> None: |
| payload = { |
| "video_ids": [video_id], |
| "updates": {key: ("" if value is None else str(value)) for key, value in updates.items()}, |
| "recorded_at": time.strftime("%Y-%m-%d %H:%M:%S"), |
| } |
| sidecar_path = sidecar_status_path(stats_path, video_id) |
| sidecar_path.parent.mkdir(parents=True, exist_ok=True) |
| lock_path = journal_lock_path(sidecar_path) |
| with lock_path.open("a+", encoding="utf-8") as handle: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_EX) |
| try: |
| with sidecar_path.open("a", encoding="utf-8") as sidecar_handle: |
| sidecar_handle.write(json.dumps(payload, ensure_ascii=False) + "\n") |
| finally: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_UN) |
|
|
|
|
| def update_video_stats_best_effort(stats_path: Path, journal_path: Path, video_id: str, **updates: str) -> Dict[str, str]: |
| append_status_sidecar(stats_path, video_id, **updates) |
| return {key: ("" if value is None else str(value)) for key, value in updates.items() if key in STATUS_FIELDS} |
|
|
|
|
| def update_many_video_stats_best_effort(stats_path: Path, journal_path: Path, video_ids: Sequence[str], **updates: str) -> None: |
| try: |
| update_many_video_stats_with_retry(stats_path, video_ids, **updates) |
| except Exception: |
| append_status_journal(journal_path, video_ids, **updates) |
|
|
|
|
| def _apply_payloads_to_stats(stats_path: Path, payloads: Sequence[dict]) -> int: |
| if not payloads: |
| return 0 |
| update_count = 0 |
| stats_lock_path = _lock_path(stats_path) |
| stats_lock_path.parent.mkdir(parents=True, exist_ok=True) |
| with stats_lock_path.open("a+", encoding="utf-8") as stats_handle: |
| fcntl.flock(stats_handle.fileno(), fcntl.LOCK_EX) |
| try: |
| stats = _load_stats_unlocked(stats_path) |
| for payload in payloads: |
| video_ids = [str(item) for item in payload.get("video_ids", []) if str(item)] |
| updates = payload.get("updates", {}) |
| if not video_ids or not isinstance(updates, dict): |
| continue |
| for video_id in video_ids: |
| record = ensure_record(stats, video_id) |
| for key, value in updates.items(): |
| if key in STATUS_FIELDS: |
| record[key] = "" if value is None else str(value) |
| update_count += 1 |
| if update_count: |
| save_stats(stats_path, stats) |
| finally: |
| fcntl.flock(stats_handle.fileno(), fcntl.LOCK_UN) |
| return update_count |
|
|
|
|
| def apply_status_journal_to_stats(stats_path: Path, journal_path: Path, remove_applied: bool = True) -> int: |
| payloads = [] |
|
|
| if journal_path.exists() and journal_path.stat().st_size > 0: |
| lock_path = journal_lock_path(journal_path) |
| with lock_path.open("a+", encoding="utf-8") as handle: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_EX) |
| try: |
| if journal_path.exists() and journal_path.stat().st_size > 0: |
| for line in journal_path.read_text(encoding="utf-8").splitlines(): |
| if line.strip(): |
| payloads.append(json.loads(line)) |
| if remove_applied: |
| journal_path.unlink(missing_ok=True) |
| finally: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_UN) |
|
|
| sidecar_dir = sidecar_status_dir(stats_path) |
| if sidecar_dir.exists(): |
| for sidecar_path in sorted(sidecar_dir.glob("*.jsonl")): |
| lock_path = journal_lock_path(sidecar_path) |
| with lock_path.open("a+", encoding="utf-8") as handle: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_EX) |
| try: |
| if sidecar_path.exists() and sidecar_path.stat().st_size > 0: |
| for line in sidecar_path.read_text(encoding="utf-8").splitlines(): |
| if line.strip(): |
| payloads.append(json.loads(line)) |
| if remove_applied: |
| sidecar_path.unlink(missing_ok=True) |
| finally: |
| fcntl.flock(handle.fileno(), fcntl.LOCK_UN) |
| if remove_applied: |
| lock_path.unlink(missing_ok=True) |
|
|
| return _apply_payloads_to_stats(stats_path, payloads) |
|
|
