utils/stats_npz.py

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)