Update pipeline/postprocess.py

pipeline/postprocess.py

@@ -1,61 +1,60 @@
-# ─── Post-Processing Engine v3 ─────────────────────────────────────────────────
+# ─── Post-Processing Engine v4 ─────────────────────────────────────────────────
+
+MIN_DISPLAY = 1.5   # حداقل زمان نمایش هر subtitle (ثانیه)
+MAX_DISPLAY = 7.0   # حداکثر زمان نمایش
+MAX_CHARS   = 80    # حداکثر کاراکتر برای merge
+MAX_GAP     = 1.5   # حداکثر فاصله بین دو segment برای merge
+
 
 def format_timestamp(seconds: float) -> str:
     ms = round((seconds % 1) * 1000)
-    s = int(seconds) % 60
-    m = int(seconds // 60) % 60
-    h = int(seconds // 3600)
+    s  = int(seconds) % 60
+    m  = int(seconds // 60) % 60
+    h  = int(seconds // 3600)
     return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
 
 
 def merge_segments(segments: list) -> list:
-    """
-    ادغام segment‌های کوتاه و تک‌کلمه‌ای به جملات کامل.
-    هر جمله حداکثر ۸۰ کاراکتر و حداکثر ۷ ثانیه.
-    """
+    """ادغام segment‌های کوتاه به جملات کامل"""
     if not segments:
         return []
 
-    MAX_CHARS = 80
-    MAX_DURATION = 7.0
-    MAX_GAP = 1.5  # اگه gap بین دو segment بیشتر از این بود، جدا بمون
-
-    merged = []
+    merged  = []
     current = None
 
     for seg in segments:
         if current is None:
             current = {
-                "text": seg["text"].strip(),
+                "text":  seg["text"].strip(),
                 "start": seg["start"],
-                "end": seg["end"],
-                "words": seg.get("words", []),
+                "end":   seg["end"],
+                "words": list(seg.get("words", [])),
             }
             continue
 
-        gap = seg["start"] - current["end"]
-        combined_text = current["text"] + " " + seg["text"].strip()
+        gap              = seg["start"] - current["end"]
+        combined_text    = current["text"] + " " + seg["text"].strip()
         combined_duration = seg["end"] - current["start"]
-        ends_sentence = current["text"].rstrip().endswith((".", "!", "?"))
+        ends_sentence    = current["text"].rstrip().endswith((".", "!", "?"))
 
         should_merge = (
             len(combined_text.replace(" ", "")) <= MAX_CHARS
-            and combined_duration <= MAX_DURATION
+            and combined_duration <= MAX_DISPLAY
             and gap <= MAX_GAP
             and not ends_sentence
         )
 
         if should_merge:
-            current["text"] = combined_text
-            current["end"] = seg["end"]
-            current["words"] = current["words"] + seg.get("words", [])
+            current["text"]  = combined_text
+            current["end"]   = seg["end"]
+            current["words"] += list(seg.get("words", []))
         else:
             merged.append(current)
             current = {
-                "text": seg["text"].strip(),
+                "text":  seg["text"].strip(),
                 "start": seg["start"],
-                "end": seg["end"],
-                "words": seg.get("words", []),
+                "end":   seg["end"],
+                "words": list(seg.get("words", [])),
             }
 
     if current:
@@ -64,40 +63,69 @@ def merge_segments(segments: list) -> list:
     return merged
 
 
+def remove_duplicates(segments: list) -> list:
+    """حذف subtitle‌های تکراری متوالی"""
+    if not segments:
+        return []
+    result = [segments[0]]
+    for seg in segments[1:]:
+        if seg["text"].strip() != result[-1]["text"].strip():
+            result.append(seg)
+    return result
+
+
 def fix_overlaps(segments: list) -> list:
-    """
-    رفع timestamp‌های overlapping.
-    هیچ subtitle نباید قبل از شروع subtitle قبلی تموم بشه.
-    """
+    """رفع timestamp‌های overlapping"""
     fixed = []
-    for i, seg in enumerate(segments):
+    for seg in segments:
+        seg = dict(seg)
         if fixed and seg["start"] < fixed[-1]["end"]:
-            # overlap داریم — start رو تنظیم کن
-            seg = dict(seg)
             seg["start"] = fixed[-1]["end"] + 0.001
-            if seg["start"] >= seg["end"]:
-                seg["end"] = seg["start"] + 0.5
+        if seg["start"] >= seg["end"]:
+            seg["end"] = seg["start"] + MIN_DISPLAY
         fixed.append(seg)
     return fixed
 
 
-def split_long_segment(seg: dict, max_chars: int = 80) -> list:
+def apply_min_display(segments: list) -> list:
     """
-    شکستن segment‌های خیلی طولانی به دو بخش.
+    اعمال حداقل زمان نمایش.
+    اگه فاصله تا subtitle بعدی کافی باشه، end رو افزایش میدیم.
+    اگه subtitle بعدی نزدیکه، حداکثر تا ۸۰ms قبلش امتداد میدیم.
     """
+    result = []
+    for i, seg in enumerate(segments):
+        seg = dict(seg)
+        duration = seg["end"] - seg["start"]
+
+        if duration < MIN_DISPLAY:
+            # حداکثر تا کجا میتونیم end رو ببریم؟
+            if i + 1 < len(segments):
+                next_start  = segments[i + 1]["start"]
+                max_end     = next_start - 0.080   # ۸۰ms قبل از subtitle بعدی
+            else:
+                max_end     = seg["end"] + MAX_DISPLAY
+
+            new_end = seg["start"] + MIN_DISPLAY
+            seg["end"] = min(new_end, max(max_end, seg["end"]))
+
+        result.append(seg)
+    return result
+
+
+def split_long_segment(seg: dict) -> list:
+    """شکستن segment‌های خیلی طولانی"""
     words = seg.get("words", [])
-    text = seg["text"].strip()
+    text  = seg["text"].strip()
 
-    if len(text.replace(" ", "")) <= max_chars or len(words) < 4:
+    if len(text.replace(" ", "")) <= MAX_CHARS or len(words) < 4:
         return [seg]
 
-    mid = len(words) // 2
-
-    # پیدا کردن بهترین نقطه split
-    best_idx = mid
+    # پیدا کردن بهترین نقطه split (بزرگ‌ترین gap)
+    best_idx = len(words) // 2
     best_gap = -1
     for i in range(1, len(words)):
-        gap = words[i]["start"] - words[i-1]["end"]
+        gap = words[i]["start"] - words[i - 1]["end"]
         if gap > best_gap:
             best_gap = gap
             best_idx = i
@@ -109,22 +137,22 @@ def split_long_segment(seg: dict, max_chars: int = 80) -> list:
         return [seg]
 
     start2 = words2[0]["start"]
-    end1 = max(start2 - 0.08, words1[-1]["end"])
+    end1   = max(start2 - 0.080, words1[-1]["end"])
 
     seg1 = {
-        "text": " ".join(w["word"].strip() for w in words1),
+        "text":  " ".join(w["word"].strip() for w in words1),
         "start": words1[0]["start"],
-        "end": end1,
+        "end":   end1,
         "words": words1,
     }
     seg2 = {
-        "text": " ".join(w["word"].strip() for w in words2),
+        "text":  " ".join(w["word"].strip() for w in words2),
         "start": start2,
-        "end": words2[-1]["end"],
+        "end":   words2[-1]["end"],
         "words": words2,
     }
 
-    return split_long_segment(seg1, max_chars) + split_long_segment(seg2, max_chars)
+    return split_long_segment(seg1) + split_long_segment(seg2)
 
 
 def build_srt(segments: list) -> str:
@@ -135,7 +163,7 @@ def build_srt(segments: list) -> str:
         if not text:
             continue
         start_tc = format_timestamp(seg["start"])
-        end_tc = format_timestamp(seg["end"])
+        end_tc   = format_timestamp(seg["end"])
         lines.append(f"{index}\n{start_tc} --> {end_tc}\n{text}")
         index += 1
     return "\n\n".join(lines) + "\n"
@@ -145,18 +173,24 @@ def process(segments: list) -> str:
     if not segments:
         return ""
 
-    # مرحله ۱ — ادغام segment‌های کوتاه
+    # ۱ — ادغام segment‌های کوتاه
     merged = merge_segments(segments)
 
-    # مرحله ۲ — رفع overlap
+    # ۲ — حذف duplicate
+    merged = remove_duplicates(merged)
+
+    # ۳ — رفع overlap
     fixed = fix_overlaps(merged)
 
-    # مرحله ۳ — شکستن segment‌های خیلی طولانی
-    final = []
+    # ۴ — شکستن segment‌های خیلی طولانی
+    split = []
     for seg in fixed:
-        final.extend(split_long_segment(seg))
+        split.extend(split_long_segment(seg))
+
+    # ۵ — رفع overlap بعد از split
+    split = fix_overlaps(split)
 
-    # مرحله ۴ — رفع overlap بعد از split
-    final = fix_overlaps(final)
+    # ۶ — اعمال حداقل زمان نمایش
+    final = apply_min_display(split)
 
     return build_srt(final)