Delete tts_ad.py

tts_ad.py

@@ -1,121 +0,0 @@
-import os, re, tempfile, subprocess
-from dataclasses import dataclass
-from typing import List, Optional, Tuple
-import numpy as np
-import soundfile as sf
-
-from ovos_tts_plugin_matxa_multispeaker_cat import MatxaCatalanTTSPlugin
-from pydub import AudioSegment
-
-@dataclass
-class Segment:
-    idx: int
-    start_s: float
-    end_s: float
-    text: str
-
-SRT_TS = re.compile(
-    r"(?P<h1>\d{2}):(?P<m1>\d{2}):(?P<s1>\d{2}),(?P<ms1>\d{3})\s*-->\s*"
-    r"(?P<h2>\d{2}):(?P<m2>\d{2}):(?P<s2>\d{2}),(?P<ms2>\d{3})"
-)
-
-def _ts_to_seconds(h: str, m: str, s: str, ms: str) -> float:
-    return int(h)*3600 + int(m)*60 + int(s) + int(ms)/1000.0
-
-def _is_empty_ad_text(t: str) -> bool:
-    cleaned = re.sub(r"[^\wÀ-ÿ]", "", t, flags=re.UNICODE)
-    return len(cleaned.strip()) == 0
-
-def parse_srt_ad_only(srt_text: str) -> List[Segment]:
-    content = srt_text.replace("\r\n","\n").replace("\r","\n")
-    blocks = [b.strip() for b in re.split(r"\n\s*\n", content) if b.strip()]
-    segs: List[Segment] = []
-    for block in blocks:
-        lines = block.split("\n")
-        if len(lines) < 2: continue
-        try:
-            idx = int(lines[0].strip())
-            m = SRT_TS.match(lines[1].strip())
-            if not m: continue
-            start_s = _ts_to_seconds(m["h1"],m["m1"],m["s1"],m["ms1"])
-            end_s   = _ts_to_seconds(m["h2"],m["m2"],m["s2"],m["ms2"])
-            ad_texts=[]
-            for t in lines[2:]:
-                t=t.strip()
-                if t.startswith("(AD):"):
-                    t=t[len("(AD):"):].lstrip()
-                    if t and not _is_empty_ad_text(t):
-                        ad_texts.append(t)
-            if not ad_texts: continue
-            segs.append(Segment(idx=idx, start_s=start_s, end_s=end_s, text=" ".join(ad_texts)))
-        except: 
-            continue
-    segs.sort(key=lambda s:(s.start_s, s.idx))
-    return segs
-
-def _resample_np(x: np.ndarray, sr_from: int, sr_to: int) -> np.ndarray:
-    if sr_from == sr_to: return x
-    ratio = sr_to / sr_from
-    new_len = int(round(len(x)*ratio))
-    xp = np.linspace(0,1,num=len(x),endpoint=False)
-    xq = np.linspace(0,1,num=new_len,endpoint=False)
-    return np.interp(xq, xp, x).astype(np.float32)
-
-def trim_or_pad(data: np.ndarray, sr: int, target_sec: float) -> np.ndarray:
-    target_len = int(round(target_sec * sr))
-    if len(data) > target_len: return data[:target_len]
-    if len(data) < target_len:
-        pad = np.zeros(target_len-len(data), dtype=data.dtype)
-        return np.concatenate([data,pad])
-    return data
-
-def synth_text_to_wav(text: str, out_path: str, voice="central/grau", tts=None) -> Tuple[int, np.ndarray]:
-    created = False
-    if tts is None:
-        tts = MatxaCatalanTTSPlugin()
-        created = True
-    # asegura carpeta
-    os.makedirs(os.path.dirname(out_path) or ".", exist_ok=True)
-    tts.get_tts(text, out_path, voice=voice)
-    data, sr = sf.read(out_path, dtype="float32", always_2d=False)
-    if data.ndim == 2: data = data.mean(axis=1)
-    if created: del tts
-    return sr, data
-
-def build_ad_track_from_srt_text(srt_text: str, out_audio_path: str, voice="central/grau") -> str:
-    segs = parse_srt_ad_only(srt_text)
-    if not segs:
-        raise ValueError("No se encontraron bloques (AD) con contenido en el SRT.")
-    # generar cada clip y montar timeline
-    tts = MatxaCatalanTTSPlugin()
-    tmpdir = tempfile.mkdtemp(prefix="matxa_ad_")
-    clips=[]
-    for seg in segs:
-        seg_wav = os.path.join(tmpdir, f"ad_{seg.idx}.wav")
-        sr, data = synth_text_to_wav(seg.text, seg_wav, voice=voice, tts=tts)
-        data = trim_or_pad(data, sr, seg.end_s - seg.start_s)
-        clips.append((sr, data, seg.start_s, seg.end_s))
-    master_sr = clips[0][0]
-    total_dur = max(s.end_s for s in segs)
-    master = np.zeros(int(round(total_dur*master_sr)), dtype=np.float32)
-    for sr, data, start_s, _ in clips:
-        d = _resample_np(data, sr, master_sr)
-        i = int(round(start_s*master_sr))
-        j = min(i+len(d), len(master))
-        master[i:j] += d[:j-i]
-    # normalización suave
-    peak = float(np.max(np.abs(master))) if master.size else 0.0
-    if peak > 0.999: master = (master/peak*0.98).astype(np.float32)
-    # escribe mp3 o wav
-    base, ext = os.path.splitext(out_audio_path)
-    os.makedirs(os.path.dirname(out_audio_path) or ".", exist_ok=True)
-    if ext.lower()==".mp3":
-        tmp_wav = base + ".__tmp__.wav"
-        sf.write(tmp_wav, master, master_sr, subtype="PCM_16")
-        AudioSegment.from_wav(tmp_wav).export(out_audio_path, format="mp3")
-        os.remove(tmp_wav)
-    else:
-        if ext.lower()!=".wav":
-            out_audio_path = base + ".wav"
-        sf.write(out_audio_path, master, master_sr, subtype="PCM_16")
-    return out_audio_path