Update app.py

app.py

@@ -1,4 +1,4 @@
-""" SRT Generator (Belarusian Edition)
+""" SRT Generator (Belarusian Edition) – fixed version
 
 """
 from __future__ import annotations
@@ -7,6 +7,7 @@ import json
 import logging
 import mimetypes
 import os
+import re
 import threading
 import uuid
 from datetime import datetime
@@ -62,6 +63,13 @@ ALLOWED_VIDEO_PREFIX = ("video/",)
 HISTORY = Path("transcripts"); HISTORY.mkdir(exist_ok=True)
 TEXT_KEYS = ("text", "text_raw")  # accepted keys for transcript text
 
+# ---------------------------------------------------------------------------
+# REGEXES FOR TIME PARSING
+# ---------------------------------------------------------------------------
+_RE_HMS_MS = re.compile(r"^(?:(\d{1,2}):)?(\d{1,2}):(\d{1,2})[.,](\d{1,3})$")  # HH:MM:SS,ms
+_RE_MS_MS = re.compile(r"^(\d{1,2}):(\d{1,2})[.,](\d{1,3})$")                  #   MM:SS,ms
+_RE_SECONDS = re.compile(r"^\d+(?:[.,]\d+)?$")                                 #    SS[.ms]
+
 # ---------------------------------------------------------------------------
 # HELPERS
 # ---------------------------------------------------------------------------
@@ -74,50 +82,30 @@ def _validate(path: str, mime_prefixes: tuple[str, ...]) -> None:
         raise ValueError("Файл занадта вялікі.")
     mime, _ = mimetypes.guess_type(path)
     if not mime or not mime.startswith(mime_prefixes):
-        raise ValueError(f"Непадтрыманы тып файла: {mime or 'невядомы'}.")
+        raise ValueError(f"Непадтрыманы тып файла: {mime or 'невядомы' }.")
 
 
 def _parse_raw_time(raw: float | int | str) -> float:
-    """Convert various time formats → seconds (float)."""
+    """Convert supported time formats → seconds (float)."""
     if isinstance(raw, (int, float)):
         return float(raw)
 
     s = str(raw).strip()
-    if "," in s and ":" in s:
-        s = s.replace(",", ":", 1)  # HH:MM:SS,mmm → HH:MM:SS:mmm
-    else:
-        s = s.replace(",", ".", 1)  # decimal comma
-
-    parts = s.split(":")
+    if not s:
+        return 0.0
 
-    # Just seconds
-    if len(parts) == 1:
-        try:
-            return float(parts[0])
-        except ValueError:
-            return 0.0
+    if (m := _RE_HMS_MS.match(s)):
+        h, m_, sec, ms = (int(x or 0) for x in m.groups())
+        return h * 3600 + m_ * 60 + sec + ms / 1_000
 
-    try:
-        nums = [float(p) for p in parts]
-    except ValueError:
-        return 0.0
+    if (m := _RE_MS_MS.match(s)):
+        m_, sec, ms = (int(x) for x in m.groups())
+        return m_ * 60 + sec + ms / 1_000
 
-    if len(nums) == 4:  # HH:MM:SS:MS
-        h, m, sec, ms = nums
-    elif len(nums) == 3:
-        a, b, c = nums
-        if c > 59:  # treat as MS
-            h = 0
-            m, sec, ms = a, b, c
-        else:  # HH:MM:SS
-            h, m, sec, ms = a, b, c, 0
-    elif len(nums) == 2:  # SS:MS
-        h = m = 0
-        sec, ms = nums
-    else:
-        return 0.0
+    if _RE_SECONDS.match(s):
+        return float(s.replace(",", "."))
 
-    return h * 3600 + m * 60 + sec + ms / 1000.0
+    raise ValueError(f"Невядомы фармат часу: {raw!r}")
 
 
 def _sec_to_ts(raw: float | int | str) -> str:
@@ -128,6 +116,39 @@ def _sec_to_ts(raw: float | int | str) -> str:
     ms_int = int(round((rem - s_int) * 1000))
     return f"{int(h):02d}:{int(m):02d}:{s_int:02d},{ms_int:03d}"
 
+
+# ---------------------------------------------------------------------------
+# SANITISATION
+# ---------------------------------------------------------------------------
+
+def _sanitize_segments(raw_segments: list[dict]) -> list[dict]:
+    """Ensure segments are consistent: start < end, non‑overlapping."""
+    fixed: list[dict] = []
+    prev_end = 0.0
+
+    for idx, seg in enumerate(raw_segments, 1):
+        start = _parse_raw_time(seg["start"])
+        end = _parse_raw_time(seg["end"])
+        text = seg["text"]
+
+        # Swap if necessary
+        if end < start:
+            logger.warning("Segment %s: end < start – swapping", idx)
+            start, end = end, start
+
+        # Shift if overlap
+        if start < prev_end:
+            logger.warning("Segment %s: overlap – shifting", idx)
+            start = prev_end + 0.001
+            if end <= start:
+                end = start + 1.0
+
+        fixed.append({"start": start, "end": end, "text": text})
+        prev_end = end
+
+    return fixed
+
+
 # ---------------------------------------------------------------------------
 # GEMINI TRANSCRIPTION
 # ---------------------------------------------------------------------------
@@ -147,6 +168,7 @@ def _transcribe(path: str, status: Callable[[str], None]) -> str:
     logger.info("Gemini raw response (first 5k): %s", text[:5000])
     return text
 
+
 # ---------------------------------------------------------------------------
 # PIPELINE
 # ---------------------------------------------------------------------------
@@ -185,12 +207,12 @@ def transcribe_audio(path: str, status: Callable[[str], None]):
     status("📥 Апрацоўка транскрыпцыі …")
 
     try:
-        segments = json.loads(raw)
+        segments_json = json.loads(raw)
     except json.JSONDecodeError as exc:
         raise ValueError("Gemini response is not valid JSON – see logs.") from exc
 
-    valid: list[dict] = []
-    for idx, seg in enumerate(segments, 1):
+    raw_segments: list[dict] = []
+    for idx, seg in enumerate(segments_json, 1):
         if not {"start", "end"}.issubset(seg):
             logger.warning("Segment #%s missing timing – skipped", idx)
             continue
@@ -198,12 +220,13 @@ def transcribe_audio(path: str, status: Callable[[str], None]):
         if not txt:
             logger.warning("Segment #%s empty text – skipped", idx)
             continue
-        valid.append({"start": seg["start"], "end": seg["end"], "text": txt})
+        raw_segments.append({"start": seg["start"], "end": seg["end"], "text": txt})
 
-    if not valid:
+    if not raw_segments:
         raise ValueError("Gemini returned no usable segments – cannot build SRT.")
 
-    return valid
+    # --- NEW: sanitise timings ---
+    return _sanitize_segments(raw_segments)
 
 
 def transcripts_to_srt(segments: List[dict]) -> Tuple[str, str]:
@@ -218,6 +241,7 @@ def transcripts_to_srt(segments: List[dict]) -> Tuple[str, str]:
     out_path.write_text(content, "utf-8")
     return content, str(out_path)
 
+
 # ---------------------------------------------------------------------------
 # AUDIO / VIDEO HELPERS
 # ---------------------------------------------------------------------------
@@ -250,6 +274,7 @@ def handle_file(audio: str | None, video: str | None, status: Callable[[str], No
         return process_video(video, status)
     raise ValueError("Ні адзін файл не загружаны.")
 
+
 # ---------------------------------------------------------------------------
 # GRADIO UI
 # ---------------------------------------------------------------------------