captionwave 0.1.0__py3-none-any.whl

captionwave/__init__.py

@@ -0,0 +1,22 @@
+"""
+captionwave — genera audio + subtítulos animados sincronizados a partir de texto.
+
+Salidas: .ass (animado), .srt (respaldo), audio (.mp3) y emojis con tiempos.
+Tú montas el video con FFmpeg/MoviePy usando esos archivos.
+"""
+
+from .core import CaptionGenerator, chunk_words
+from .styles import Style, PRESETS, get_style, list_styles, hex_to_ass
+from .emojis import EmojiPicker
+
+__version__ = "0.1.0"
+__all__ = [
+    "CaptionGenerator",
+    "chunk_words",
+    "Style",
+    "PRESETS",
+    "get_style",
+    "list_styles",
+    "hex_to_ass",
+    "EmojiPicker",
+]

captionwave/ass_writer.py

@@ -0,0 +1,209 @@
+"""
+Escritura del archivo .ass (Advanced SubStation Alpha).
+
+Genera subtítulos animados que libass/ffmpeg renderiza de forma nativa. La
+sincronización viene de los tiempos por palabra del TTS.
+
+Técnica de resaltado: para los estilos de "palabra activa" se emite UN evento
+por palabra, dibujando la línea completa con solo la palabra en curso resaltada.
+Así nunca hay dos palabras activas, la posición no se mueve y se evita una
+limitación de libass al encadenar varias transiciones \\t con huecos.
+"""
+
+from __future__ import annotations
+from .styles import Style, hex_to_ass
+
+
+# ---- utilidades de tiempo ----
+def _fmt_time(seconds: float) -> str:
+    if seconds < 0:
+        seconds = 0
+    cs = int(round(seconds * 100))
+    h, cs = divmod(cs, 360000)
+    m, cs = divmod(cs, 6000)
+    s, cs = divmod(cs, 100)
+    return f"{h:d}:{m:02d}:{s:02d}.{cs:02d}"
+
+
+def _alignment(position: str) -> int:
+    return {"center": 5, "lower": 2, "upper": 8}.get(position, 5)
+
+
+def _txt(word: str, upper: bool) -> str:
+    return word.upper() if upper else word
+
+
+def _word_windows(words, line_start, line_end):
+    """Ventana [inicio, fin) de cada palabra, continua (sin huecos)."""
+    n = len(words)
+    wins = []
+    for i, w in enumerate(words):
+        s = w["start"]
+        e = words[i + 1]["start"] if i + 1 < n else line_end
+        if e <= s:
+            e = s + 0.12
+        wins.append((i, s, e))
+    return wins
+
+
+# ---- karaoke (usa \k nativo de libass) ----
+def _line_karaoke(style: Style, words, line_start):
+    al = _alignment(style.position)
+    parts = ["{\\an%d}" % al]
+    cursor = 0
+    for w in words:
+        s = max(0, int(round((w["start"] - line_start) * 100)))
+        e = max(s + 1, int(round((w["start"] + w["dur"] - line_start) * 100)))
+        gap = s - cursor
+        if gap > 0:
+            parts.append("{\\k%d} " % gap)
+        parts.append("{\\kf%d}%s " % (max(1, e - s), _txt(w["word"], style.uppercase)))
+        cursor = e
+    return "".join(parts).rstrip()
+
+
+# ---- línea completa con UNA palabra resaltada (estática + pop opcional) ----
+def _render_active(words, active_idx, style, fad=(0, 0)):
+    al = _alignment(style.position)
+    base = hex_to_ass(style.base_color)
+    act = hex_to_ass(style.active_color)
+    anim = style.animation
+
+    head = "{\\an%d" % al
+    if fad != (0, 0):
+        head += "\\fad(%d,%d)" % fad
+    head += "}"
+    parts = [head]
+
+    for k, w in enumerate(words):
+        word = _txt(w["word"], style.uppercase)
+        activa = (k == active_idx)
+        if anim == "active_sticker":
+            if activa:
+                on = hex_to_ass(style.sticker_text_color)
+                stick = hex_to_ass(style.sticker_color)
+                blk = "{\\1c%s\\3c%s\\bord%d\\fscx70\\fscy70\\t(0,9,\\fscx100\\fscy100)}" % (
+                    on, stick, style.sticker_bord)
+            else:
+                outline = hex_to_ass(style.outline_color)
+                blk = "{\\1c%s\\3c%s\\bord%d}" % (base, outline, style.outline_w)
+        elif anim == "active_pop":
+            if activa:
+                p = style.pop_scale
+                blk = "{\\1c%s\\fscx80\\fscy80\\t(0,9,\\fscx%d\\fscy%d)}" % (act, p, p)
+            else:
+                blk = "{\\1c%s\\fscx100\\fscy100}" % base
+        else:  # active_color / fade
+            blk = "{\\1c%s}" % (act if activa else base)
+        parts.append(blk + word + " ")
+
+    return "".join(parts).rstrip()
+
+
+def _line_events(ln, style):
+    """Devuelve lista de (start, end, text) para una línea según su animación."""
+    words = ln["words"]
+    ls, le = ln["start"], ln["end"]
+    anim = style.animation
+
+    if anim == "karaoke":
+        return [(ls, le, _line_karaoke(style, words, ls))]
+
+    wins = _word_windows(words, ls, le)
+    n = len(wins)
+    evs = []
+    for (i, s, e) in wins:
+        fad = (0, 0)
+        if anim == "fade":
+            fad = (120 if i == 0 else 0, 120 if i == n - 1 else 0)
+        evs.append((s, e, _render_active(words, i, style, fad=fad)))
+    return evs
+
+
+# ---- single_word: una palabra a la vez, grande y centrada ----
+def _single_word_events(style: Style, words, total):
+    act = hex_to_ass(style.active_color)
+    rows = []
+    n = len(words)
+    for i, w in enumerate(words):
+        s = w["start"]
+        e = words[i + 1]["start"] if i + 1 < n else total
+        if e <= s + 0.05:
+            e = s + 0.2
+        txt = ("{\\an5\\1c%s\\fscx70\\fscy70\\t(0,140,\\fscx100\\fscy100)\\fad(50,50)}%s"
+               % (act, _txt(w["word"], style.uppercase)))
+        rows.append((s, e, txt))
+    return rows
+
+
+# ---- cabecera y estilos ----
+def _header(style: Style, W: int, H: int) -> str:
+    primary = (hex_to_ass(style.active_color)
+               if style.animation == "karaoke" else hex_to_ass(style.base_color))
+    secondary = hex_to_ass(style.base_color)
+    outline = hex_to_ass(style.outline_color)
+    back = hex_to_ass("#000000")
+    bold = -1 if style.bold else 0
+    align = _alignment(style.position)
+    margin_v = 0 if style.position == "center" else style.margin_v
+
+    return (
+        "[Script Info]\n"
+        "ScriptType: v4.00+\n"
+        "WrapStyle: 2\n"
+        "ScaledBorderAndShadow: yes\n"
+        f"PlayResX: {W}\n"
+        f"PlayResY: {H}\n"
+        "YCbCr Matrix: TV.709\n"
+        "\n"
+        "[V4+ Styles]\n"
+        "Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, "
+        "OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, "
+        "ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, "
+        "Alignment, MarginL, MarginR, MarginV, Encoding\n"
+        f"Style: Main,{style.font},{style.font_size},{primary},{secondary},"
+        f"{outline},{back},{bold},0,0,0,100,100,0,0,1,{style.outline_w},"
+        f"{style.shadow},{align},60,60,{margin_v},1\n"
+        f"Style: Emoji,{style.font},96,&H00FFFFFF,&H00FFFFFF,&H00000000,"
+        f"&H00000000,0,0,0,0,100,100,0,0,1,0,0,5,0,0,0,1\n"
+        "\n"
+        "[Events]\n"
+        "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n"
+    )
+
+
+def _dialogue(start, end, text, style_name="Main", layer=0):
+    return f"Dialogue: {layer},{_fmt_time(start)},{_fmt_time(end)},{style_name},,0,0,0,,{text}\n"
+
+
+def build_ass(lines, style: Style, resolution=(1080, 1920),
+              emojis=None, emoji_in_ass=True) -> str:
+    """Construye el contenido completo del .ass.
+
+    lines: lista de dicts {words:[{word,start,dur}], start, end, emoji?}
+    """
+    W, H = resolution
+    chunks = [_header(style, W, H)]
+
+    if style.animation == "single_word":
+        flat = [w for ln in lines for w in ln["words"]]
+        total = lines[-1]["end"] if lines else 0.0
+        for (s, e, t) in _single_word_events(style, flat, total):
+            chunks.append(_dialogue(s, e, t))
+    else:
+        for ln in lines:
+            for (s, e, t) in _line_events(ln, style):
+                chunks.append(_dialogue(s, e, t))
+
+    # Emoji por línea (capa superior). Ojo: libass no garantiza emoji a color
+    # (ver nota en emojis.py); usa emojis.json para superponer tu propio arte.
+    if emoji_in_ass:
+        cx, cy = W // 2, int(H * 0.34)
+        for ln in lines:
+            em = ln.get("emoji")
+            if not em:
+                continue
+            txt = "{\\an5\\pos(%d,%d)\\fad(120,120)}%s" % (cx, cy, em)
+            chunks.append(_dialogue(ln["start"], ln["end"], txt, style_name="Emoji", layer=2))
+
+    return "".join(chunks)

captionwave/core.py

@@ -0,0 +1,182 @@
+"""
+API principal de captionwave.
+
+Ejemplo mínimo:
+
+    from captionwave import CaptionGenerator
+
+    gen = CaptionGenerator(voice="es-MX-DaliaNeural", rate="+18%", style="hormozi")
+    r = gen.generate(
+        "El Sol es una estrella que contiene el 99% de la masa del sistema solar.",
+        out_audio="voz.mp3",
+        out_ass="subs.ass",
+        out_srt="subs.srt",
+    )
+    print(r["duration"], "segundos")
+
+Devuelve un dict con: audio, ass, srt, duration, words, lines, emojis.
+Los archivos quedan listos para que tú montes el video (FFmpeg, MoviePy, etc.).
+"""
+
+from __future__ import annotations
+import json
+from typing import Optional, Union
+
+from .styles import Style, get_style, list_styles  # re-export
+from .emojis import EmojiPicker
+from . import tts as _tts
+from . import ass_writer as _ass
+from . import srt_writer as _srt
+
+
+def chunk_words(words, max_words=3, max_chars=18, total=None):
+    """Agrupa palabras en líneas. Devuelve lista de dicts con start/end/words/text."""
+    lines = []
+    cur = []
+    for w in words:
+        cur.append(w)
+        txt = " ".join(x["word"] for x in cur)
+        if len(cur) >= max_words or len(txt) >= max_chars:
+            lines.append(cur)
+            cur = []
+    if cur:
+        lines.append(cur)
+
+    salida = []
+    for grupo in lines:
+        salida.append({
+            "words": grupo,
+            "start": grupo[0]["start"],
+            "end": grupo[-1]["start"] + grupo[-1]["dur"],
+            "text": " ".join(x["word"] for x in grupo),
+        })
+    # El fin de cada línea = inicio de la siguiente (subtítulos continuos)
+    for i in range(len(salida) - 1):
+        salida[i]["end"] = salida[i + 1]["start"]
+    if salida:
+        fin = total if total else (salida[-1]["end"] + 0.4)
+        salida[-1]["end"] = max(salida[-1]["end"], fin)
+    return salida
+
+
+class CaptionGenerator:
+    def __init__(
+        self,
+        voice: str = "es-MX-DaliaNeural",
+        rate: str = "+0%",
+        style: Union[str, Style] = "hormozi",
+        emoji: bool = True,
+        emoji_max_version: float = 15.0,
+        emoji_in_ass: bool = True,
+        resolution=(1080, 1920),
+    ):
+        self.voice = voice
+        self.rate = rate
+        self.style = get_style(style)
+        self.use_emoji = emoji
+        self.emoji_in_ass = emoji_in_ass
+        self.resolution = resolution
+        self._picker = EmojiPicker(emoji_max_version) if emoji else None
+
+    # -- API principal --
+    def generate(
+        self,
+        text: str,
+        out_audio: str = "audio.mp3",
+        out_ass: Optional[str] = "subs.ass",
+        out_srt: Optional[str] = None,
+        out_emojis: Optional[str] = None,
+        intro: Optional[str] = None,
+        intro_rate: Optional[str] = None,
+    ) -> dict:
+        """Genera audio + subtítulos sincronizados a partir de `text`.
+
+        intro: texto opcional que se dice ANTES (p. ej. un gancho), con su propio
+               ritmo `intro_rate`. Sus tiempos se integran automáticamente.
+        """
+        # 1) Voz + tiempos por palabra
+        if intro:
+            parts = [(intro.strip(), intro_rate or self.rate), (text.strip(), self.rate)]
+            words, dur = _tts.synthesize_segments(parts, voice=self.voice, out_path=out_audio)
+        else:
+            words, dur = _tts.synthesize(text, voice=self.voice, rate=self.rate, out_path=out_audio)
+
+        if not words:
+            raise RuntimeError("El TTS no devolvió palabras. ¿Conexión a internet / voz válida?")
+
+        # 2) Construir subtítulos a partir de los tiempos por palabra del TTS
+        resultado = self.build_from_words(
+            words, dur, out_ass=out_ass, out_srt=out_srt, out_emojis=out_emojis,
+        )
+        resultado["audio"] = out_audio
+        return resultado
+
+    # -- API sin TTS (offline) --
+    def build_from_words(
+        self,
+        words,
+        duration: float,
+        out_ass: Optional[str] = "subs.ass",
+        out_srt: Optional[str] = None,
+        out_emojis: Optional[str] = None,
+    ) -> dict:
+        """Construye los subtítulos a partir de tiempos por palabra ya calculados.
+
+        No usa TTS ni internet: tú aportas
+        ``words = [{"word", "start", "dur"}, ...]`` (en segundos) y la duración
+        total. Útil para pruebas, pipelines offline o cuando ya tienes los
+        tiempos de otra fuente.
+
+        Devuelve el mismo dict que ``generate`` (con ``audio=None``).
+        """
+        if not words:
+            raise ValueError("`words` está vacío: no hay nada que subtitular.")
+
+        # 1) Agrupar en líneas
+        lines = chunk_words(words, self.style.max_words, self.style.max_chars, total=duration)
+
+        # 2) Emojis: por línea (para el .ass) y por palabra (para overlay propio)
+        emojis_palabra = []
+        if self.use_emoji and self._picker:
+            for i, ln in enumerate(lines):
+                ln["emoji"] = self._picker.for_phrase(ln["text"], i)
+            for w in words:
+                emojis_palabra.append({
+                    "word": w["word"],
+                    "emoji": self._picker.for_word(w["word"]),
+                    "start": round(w["start"], 3),
+                    "dur": round(w["dur"], 3),
+                })
+
+        # 3) Escribir .ass
+        if out_ass:
+            ass_text = _ass.build_ass(
+                lines, self.style, resolution=self.resolution,
+                emoji_in_ass=(self.emoji_in_ass and self.use_emoji),
+            )
+            with open(out_ass, "w", encoding="utf-8") as f:
+                f.write(ass_text)
+
+        # 4) Escribir .srt (opcional)
+        if out_srt:
+            with open(out_srt, "w", encoding="utf-8") as f:
+                f.write(_srt.build_srt(lines, uppercase=self.style.uppercase))
+
+        # 5) Escribir emojis.json (opcional, para superponer arte propio)
+        if out_emojis and self.use_emoji:
+            with open(out_emojis, "w", encoding="utf-8") as f:
+                json.dump(emojis_palabra, f, ensure_ascii=False, indent=2)
+
+        return {
+            "audio": None,
+            "ass": out_ass,
+            "srt": out_srt,
+            "duration": duration,
+            "words": words,
+            "lines": [
+                {"text": ln["text"], "start": ln["start"], "end": ln["end"],
+                 "emoji": ln.get("emoji")}
+                for ln in lines
+            ],
+            "emojis": emojis_palabra,
+        }

captionwave/emojis.py

@@ -0,0 +1,161 @@
+"""
+Asignación palabra -> emoji.
+
+Importante: solo se usan emojis cuya **versión de Unicode** es lo bastante
+antigua como para estar presente en iOS. Esto evita "tofus" (cuadritos) en
+iPhone. El umbral se controla con `max_version` (por defecto 15.0, que cubre
+ampliamente las versiones recientes de iOS).
+
+Nota sobre la APARIENCIA "estilo Apple": este módulo entrega el CARÁCTER de
+emoji correcto (un punto de código Unicode), no la imagen de Apple. La imagen
+con la que se ve un emoji la pone el sistema/fuente donde se renderice:
+  - En un iPhone/Mac se verá con el diseño de Apple automáticamente.
+  - En Linux (p. ej. un servidor) se verá con Noto/Twemoji.
+La librería NO incluye ni descarga el arte propietario de Apple. Si necesitas
+el diseño exacto de Apple en el video, superpón tus propias imágenes usando los
+tiempos del emoji que entrega `generate(...)` (campo `emojis`).
+"""
+
+from __future__ import annotations
+import unicodedata
+import functools
+
+import emoji as _emoji_lib
+
+
+# Palabras que NO deben disparar la búsqueda de emoji.
+_STOP = {
+    "de", "del", "la", "el", "los", "las", "con", "y", "o", "un", "una", "para",
+    "por", "en", "a", "al", "que", "se", "su", "sus", "sin", "sobre", "tipo",
+    "como", "este", "esta", "ese", "esa", "es", "son", "tiene", "tienen", "fue",
+    "ser", "han", "hay", "muy", "mas", "menos", "todo", "toda", "todos", "mismo",
+    "cada", "entre", "hasta", "cuando", "donde", "porque", "mucho", "mucha",
+    "uno", "dos", "tres", "cuatro", "cinco", "seis", "siete", "ocho", "nueve",
+    "diez", "cien", "mil", "veces", "vez", "casi", "tan", "tanto", "cerca",
+}
+
+# Diccionario curado: control fino para palabras clave frecuentes.
+CURADOS = {
+    "estrella": "⭐", "estrellas": "⭐", "estelar": "⭐",
+    "galaxia": "🌌", "galaxias": "🌌", "universo": "🌌", "cosmos": "🌌",
+    "tierra": "🌍", "mundo": "🌍", "planeta": "🪐", "planetas": "🪐",
+    "agua": "💧", "liquido": "💧", "oceano": "🌊", "mar": "🌊", "ola": "🌊",
+    "arbol": "🌳", "arboles": "🌳", "bosque": "🌳", "selva": "🌳", "planta": "🌱",
+    "cometa": "☄️", "meteorito": "☄️", "asteroide": "☄️",
+    "luz": "💡", "brillo": "💡", "ilumina": "💡",
+    "energia": "⚡", "electricidad": "⚡", "rayo": "⚡", "rayos": "⚡",
+    "explosion": "💥", "estalla": "💥", "impacto": "💥", "choque": "💥",
+    "molecula": "⚛️", "atomo": "⚛️", "particula": "⚛️", "neutron": "⚛️",
+    "proton": "⚛️", "electron": "⚛️",
+    "quimica": "🧪", "reaccion": "🧪", "experimento": "🔬", "ciencia": "🔬",
+    "cientifico": "🔬", "microscopio": "🔬",
+    "celula": "🦠", "celulas": "🦠", "virus": "🦠", "bacteria": "🦠", "microbio": "🦠",
+    "dinosaurio": "🦕", "dinosaurios": "🦕", "fosil": "🦴",
+    "terremoto": "🌋", "sismo": "🌋", "volcan": "🌋",
+    "numero": "🔢", "numeros": "🔢", "millones": "🔢", "miles": "🔢",
+    "diamante": "💎", "cristal": "💎", "oro": "🪙",
+    "velocidad": "⚡", "veloz": "⚡", "rapido": "⚡",
+    "calor": "🔥", "caliente": "🔥", "fuego": "🔥",
+    "temperatura": "🌡️", "frio": "❄️", "congelado": "❄️", "hielo": "🧊",
+    "aire": "💨", "viento": "💨", "gas": "💨",
+    "oxigeno": "🫁", "pulmon": "🫁", "pulmones": "🫁",
+    "sonido": "🔊", "oido": "👂", "musica": "🎵",
+    "computadora": "💻", "ordenador": "💻", "datos": "💻",
+    "tiempo": "⏳", "reloj": "⏰", "año": "📅", "años": "📅", "siglo": "📅",
+    "cerebro": "🧠", "corazon": "❤️", "sangre": "🩸", "hueso": "🦴",
+    "sol": "☀️", "luna": "🌙", "noche": "🌙", "dia": "🌞",
+    "dinero": "💰", "ojo": "👀", "ojos": "👀", "mente": "🧠",
+}
+
+# Emojis de respaldo cuando no se encuentra nada relevante.
+DEFAULTS = ["✨", "🤯", "💫", "👀", "🔥"]
+
+
+def _norm(w: str) -> str:
+    """minúsculas, sin acentos (conservando ñ), solo letras."""
+    w = w.lower().replace("ñ", "\x00")
+    w = "".join(c for c in unicodedata.normalize("NFKD", w) if not unicodedata.combining(c))
+    w = w.replace("\x00", "ñ")
+    return "".join(c for c in w if c.isalpha())
+
+
+def _es_bandera(ch: str) -> bool:
+    return any(0x1F1E6 <= ord(c) <= 0x1F1FF or c == "\U0001F3F4" for c in ch)
+
+
+@functools.lru_cache(maxsize=8)
+def _build_index(max_version: float):
+    """Construye {palabra_norm: emoji} desde la librería emoji.
+
+    Filtra por versión (compatibilidad iOS), descarta banderas y se queda con
+    el nombre más específico para cada palabra.
+    """
+    idx: dict[str, tuple[str, int]] = {}
+    try:
+        _emoji_lib.config.load_language("es")
+    except Exception:
+        pass
+    for ch, d in _emoji_lib.EMOJI_DATA.items():
+        if d.get("status") != _emoji_lib.STATUS["fully_qualified"]:
+            continue
+        ver = d.get("E")
+        if not isinstance(ver, (int, float)) or ver > max_version:
+            continue
+        if _es_bandera(ch):
+            continue
+        nombre = d.get("es") or d.get("en")
+        if not nombre:
+            continue
+        tokens = nombre.strip(":").split("_")
+        ntok = len(tokens)
+        for t in tokens:
+            k = _norm(t)
+            if len(k) < 3 or k in _STOP:
+                continue
+            if k not in idx or ntok < idx[k][1]:
+                idx[k] = (ch, ntok)
+    return idx
+
+
+class EmojiPicker:
+    """Selecciona emojis para palabras y frases, limitado a iOS."""
+
+    def __init__(self, max_version: float = 15.0):
+        self.max_version = max_version
+        self._idx = _build_index(max_version)
+
+    def for_word(self, palabra: str):
+        """Devuelve un emoji para una sola palabra, o None si no aplica."""
+        k = _norm(palabra)
+        if not k or k in _STOP:
+            return None
+        if k in CURADOS:
+            return CURADOS[k]
+        # plurales sencillos
+        for suf in ("es", "s"):
+            base = k[:-len(suf)]
+            if k.endswith(suf) and len(base) >= 3 and base in CURADOS:
+                return CURADOS[base]
+        if k in self._idx:
+            return self._idx[k][0]
+        for suf in ("es", "s"):
+            base = k[:-len(suf)]
+            if k.endswith(suf) and len(base) >= 3 and base in self._idx:
+                return self._idx[base][0]
+        return None
+
+    def for_phrase(self, frase: str, fallback_idx: int = 0):
+        """Mejor emoji para una frase (busca en sus palabras, de larga a corta)."""
+        for w in sorted(frase.split(), key=len, reverse=True):
+            e = self.for_word(w)
+            if e:
+                return e
+        return DEFAULTS[fallback_idx % len(DEFAULTS)]
+
+    def is_ios_safe(self, ch: str) -> bool:
+        """True si el emoji está dentro de la versión permitida (iOS)."""
+        d = _emoji_lib.EMOJI_DATA.get(ch)
+        if not d:
+            return False
+        ver = d.get("E")
+        return isinstance(ver, (int, float)) and ver <= self.max_version

captionwave/srt_writer.py

@@ -0,0 +1,32 @@
+"""
+Escritura de .srt (respaldo de compatibilidad).
+
+SRT no admite animaciones ni karaoke: son bloques de texto con tiempo. Sirve
+para reproductores/plataformas que no aceptan .ass. La sincronización por línea
+se mantiene.
+"""
+
+from __future__ import annotations
+
+
+def _fmt(seconds: float) -> str:
+    if seconds < 0:
+        seconds = 0
+    ms = int(round(seconds * 1000))
+    h, ms = divmod(ms, 3600000)
+    m, ms = divmod(ms, 60000)
+    s, ms = divmod(ms, 1000)
+    return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
+
+
+def build_srt(lines, uppercase: bool = True) -> str:
+    out = []
+    for i, ln in enumerate(lines, 1):
+        text = ln["text"]
+        if uppercase:
+            text = text.upper()
+        out.append(str(i))
+        out.append(f"{_fmt(ln['start'])} --> {_fmt(ln['end'])}")
+        out.append(text)
+        out.append("")
+    return "\n".join(out) + "\n"

captionwave/styles.py

@@ -0,0 +1,153 @@
+"""
+Estilos de subtítulos.
+
+Cada estilo combina:
+  - una `animation` (cómo se mueve/resalta la palabra activa)
+  - colores, fuente, tamaño, posición
+
+Los colores se escriben en HEX normal ("#RRGGBB") y se convierten al
+formato de ASS internamente. Puedes usar un preset tal cual o copiarlo y
+cambiarle cualquier campo.
+
+Animaciones disponibles:
+  - "karaoke"        -> barrido tipo karaoke (color tenue -> color activo)
+  - "active_color"   -> solo la palabra que se está diciendo cambia de color
+  - "active_pop"     -> la palabra activa crece (rebote) y cambia de color
+  - "active_sticker" -> la palabra activa recibe un "sticker" de fondo (estilo Hormozi)
+  - "single_word"    -> una palabra a la vez, grande y centrada
+  - "fade"           -> la frase aparece con fade + palabra activa en color
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, replace
+from typing import Optional
+
+
+def hex_to_ass(color: str, alpha: int = 0) -> str:
+    """Convierte '#RRGGBB' al formato de color de ASS '&HAABBGGRR'.
+
+    alpha: 0 = opaco, 255 = totalmente transparente.
+    """
+    c = color.lstrip("#")
+    if len(c) == 3:
+        c = "".join(ch * 2 for ch in c)
+    r = int(c[0:2], 16)
+    g = int(c[2:4], 16)
+    b = int(c[4:6], 16)
+    return f"&H{alpha:02X}{b:02X}{g:02X}{r:02X}"
+
+
+@dataclass
+class Style:
+    name: str = "custom"
+    animation: str = "active_color"   # ver lista arriba
+
+    # Tipografía
+    font: str = "DejaVu Sans"         # nombre de la fuente (debe existir en el sistema que renderiza)
+    font_file: Optional[str] = None   # ruta opcional al .ttf (útil para fijar la fuente al render)
+    font_size: int = 84
+    bold: bool = True
+
+    # Colores
+    base_color: str = "#FFFFFF"       # color normal del texto
+    active_color: str = "#FFD23F"     # color de la palabra activa
+    outline_color: str = "#000000"    # contorno
+    outline_w: int = 5
+    shadow: int = 0
+
+    # Solo para animation="active_sticker"
+    sticker_color: str = "#FFD23F"        # color del "sticker" de fondo
+    sticker_text_color: str = "#000000"   # color del texto cuando está sobre el sticker
+    sticker_bord: int = 18                # grosor del sticker
+
+    # Solo para animation="active_pop" / "single_word"
+    pop_scale: int = 130              # % de escala al hacer "pop"
+
+    # Texto
+    uppercase: bool = True
+    max_words: int = 3                # máximo de palabras por línea
+    max_chars: int = 18              # corte adicional por longitud
+
+    # Posición: "center" (medio de la pantalla), "lower" (abajo), "upper" (arriba)
+    position: str = "center"
+    margin_v: int = 260               # margen vertical cuando position != center
+
+    def copy(self, **cambios) -> "Style":
+        """Devuelve una copia del estilo con los campos indicados modificados."""
+        return replace(self, **cambios)
+
+
+# --------------------------------------------------------------------------
+#   PRESETS  (inspirados en las opciones de revid.ai)
+# --------------------------------------------------------------------------
+PRESETS = {
+    # Clásico de Shorts/Reels: palabra activa con "sticker" amarillo.
+    "hormozi": Style(
+        name="hormozi", animation="active_sticker",
+        base_color="#FFFFFF", active_color="#FFD23F",
+        sticker_color="#FFD23F", sticker_text_color="#101010",
+        font_size=88, outline_w=6, uppercase=True, max_words=3,
+    ),
+    # Barrido karaoke: el texto se "llena" de color al ritmo de la voz.
+    "karaoke": Style(
+        name="karaoke", animation="karaoke",
+        base_color="#FFFFFF", active_color="#FFD23F",
+        font_size=82, outline_w=5, uppercase=True, max_words=4,
+    ),
+    # La palabra activa crece con un rebote.
+    "pop": Style(
+        name="pop", animation="active_pop",
+        base_color="#FFFFFF", active_color="#FFD23F",
+        pop_scale=134, font_size=84, outline_w=5, uppercase=True, max_words=3,
+    ),
+    # Una sola palabra a la vez, grande y centrada.
+    "single": Style(
+        name="single", animation="single_word",
+        base_color="#FFFFFF", active_color="#FFD23F",
+        pop_scale=118, font_size=120, outline_w=7, uppercase=True,
+    ),
+    # Neón: contorno de color y palabra activa cian.
+    "neon": Style(
+        name="neon", animation="active_color",
+        base_color="#FFFFFF", active_color="#27E1FF",
+        outline_color="#0066FF", outline_w=5, font_size=82, uppercase=True, max_words=3,
+    ),
+    # Sticker verde.
+    "green": Style(
+        name="green", animation="active_sticker",
+        base_color="#FFFFFF", active_color="#27E36B",
+        sticker_color="#27E36B", sticker_text_color="#08240F",
+        font_size=86, outline_w=6, uppercase=True, max_words=3,
+    ),
+    # "Fuego": palabra activa naranja con pop.
+    "fire": Style(
+        name="fire", animation="active_pop",
+        base_color="#FFFFFF", active_color="#FF5630",
+        pop_scale=132, font_size=84, outline_w=5, uppercase=True, max_words=3,
+    ),
+    # Limpio: parecido a unos subtítulos blancos con contorno (estilo simple).
+    "clean": Style(
+        name="clean", animation="active_color",
+        base_color="#FFFFFF", active_color="#FFE9A8",
+        outline_color="#000000", outline_w=5, font_size=78,
+        uppercase=True, max_words=3, position="lower",
+    ),
+}
+
+
+def get_style(estilo) -> Style:
+    """Acepta un nombre de preset (str) o un objeto Style y devuelve un Style."""
+    if isinstance(estilo, Style):
+        return estilo
+    if isinstance(estilo, str):
+        key = estilo.lower()
+        if key not in PRESETS:
+            disponibles = ", ".join(sorted(PRESETS))
+            raise ValueError(f"Estilo '{estilo}' no existe. Disponibles: {disponibles}")
+        return PRESETS[key].copy()
+    raise TypeError("estilo debe ser un nombre (str) o un objeto Style")
+
+
+def list_styles() -> list[str]:
+    """Lista los nombres de los presets disponibles."""
+    return sorted(PRESETS)

captionwave/tts.py

@@ -0,0 +1,157 @@
+"""
+Generación de voz (TTS) con tiempos por palabra.
+
+Usa edge-tts. La clave de la sincronización es que el motor devuelve eventos
+`WordBoundary` con el offset y duración EXACTOS de cada palabra dentro del audio
+que se está generando. Por eso los subtítulos quedan pegados al audio: ambos
+salen de la misma fuente.
+
+Requiere conexión a internet (endpoint de Microsoft Edge TTS).
+"""
+
+from __future__ import annotations
+import asyncio
+import os
+
+import edge_tts
+
+
+def _run_sync(coro):
+    """Ejecuta una corrutina de forma síncrona, también dentro de Jupyter/Colab.
+
+    En un script normal basta con ``asyncio.run``. Pero en notebooks (Google
+    Colab, Jupyter) ya hay un event loop corriendo y ``asyncio.run`` fallaría
+    con "cannot be called from a running event loop"; en ese caso la corrutina
+    se ejecuta en un hilo aparte con su propio loop.
+    """
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)  # no hay loop activo: caso normal (script)
+
+    import threading
+
+    box = {}
+
+    def _worker():
+        try:
+            box["value"] = asyncio.run(coro)
+        except BaseException as exc:  # se re-lanza en el hilo principal
+            box["error"] = exc
+
+    t = threading.Thread(target=_worker)
+    t.start()
+    t.join()
+    if "error" in box:
+        raise box["error"]
+    return box["value"]
+
+
+def _try_duration(path: str):
+    """Intenta leer la duración real del MP3 con mutagen, si está instalado."""
+    try:
+        from mutagen.mp3 import MP3  # opcional
+        return float(MP3(path).info.length)
+    except Exception:
+        return None
+
+
+def _make_communicate(text: str, voice: str, rate: str):
+    """Crea un Communicate pidiendo eventos por palabra (WordBoundary).
+
+    edge-tts >= 7 cambió el valor por defecto del parámetro ``boundary`` a
+    "SentenceBoundary"; sin "WordBoundary" no llegan los tiempos por palabra y
+    los subtítulos saldrían vacíos. En edge-tts < 7 ese parámetro no existe (y
+    el valor por defecto ya era WordBoundary), así que se omite.
+    """
+    try:
+        return edge_tts.Communicate(text, voice, rate=rate, boundary="WordBoundary")
+    except TypeError:
+        return edge_tts.Communicate(text, voice, rate=rate)
+
+
+async def _stream_one(text: str, voice: str, rate: str, fh):
+    """Escribe el audio de un segmento en el handle abierto `fh` y devuelve sus palabras."""
+    com = _make_communicate(text, voice, rate)
+    words = []
+    async for chunk in com.stream():
+        if chunk["type"] == "audio":
+            fh.write(chunk["data"])
+        elif chunk["type"] == "WordBoundary":
+            words.append({
+                "word": chunk["text"],
+                "start": chunk["offset"] / 1e7,
+                "dur": max(chunk["duration"] / 1e7, 0.02),
+            })
+    return words
+
+
+async def _run(parts, voice, out_path):
+    """parts = [(text, rate), ...]  -> audio concatenado + palabras con offset acumulado."""
+    todas = []
+    cursor = 0.0
+    with open(out_path, "wb") as fh:
+        for (text, rate) in parts:
+            ws = await _stream_one(text, voice, rate, fh)
+            for w in ws:
+                todas.append({"word": w["word"], "start": w["start"] + cursor, "dur": w["dur"]})
+            # avanzar el cursor por la duración de este segmento
+            if ws:
+                cursor = todas[-1]["start"] + todas[-1]["dur"]
+    return todas
+
+
+def synthesize(text: str, voice: str = "es-MX-DaliaNeural",
+               rate: str = "+0%", out_path: str = "audio.mp3"):
+    """Genera audio de un texto y devuelve (words, duration).
+
+    words: lista de dicts {word, start, dur} en segundos.
+    duration: duración total estimada del audio (s).
+    """
+    return synthesize_segments([(text, rate)], voice=voice, out_path=out_path)
+
+
+def synthesize_segments(parts, voice: str = "es-MX-DaliaNeural",
+                        out_path: str = "audio.mp3"):
+    """Igual que synthesize, pero une varios segmentos (p. ej. intro + cuerpo).
+
+    parts: lista de tuplas (texto, rate). Ej: [("¿Sabías que...?", "+25%"),
+           ("el sol es una estrella", "+18%")]
+    """
+    try:
+        words = _run_sync(_run(list(parts), voice, out_path))
+    except Exception as e:
+        # No dejes un .mp3 vacío/parcial tras un fallo.
+        try:
+            if os.path.exists(out_path) and os.path.getsize(out_path) == 0:
+                os.remove(out_path)
+        except OSError:
+            pass
+        raise RuntimeError(
+            "No se pudo generar la voz con edge-tts. Comprueba:\n"
+            "  • que tengas conexión a internet (edge-tts usa el servicio de "
+            "Microsoft Edge),\n"
+            "  • que ninguna red/proxy/firewall bloquee speech.platform.bing.com,\n"
+            f"  • que la voz exista (voz='{voice}'; lista: 'edge-tts --list-voices').\n"
+            f"Detalle técnico: {type(e).__name__}: {e}"
+        ) from e
+
+    if not words:
+        dur = _try_duration(out_path) or 0.0
+        return words, dur
+
+    last_end = words[-1]["start"] + words[-1]["dur"]
+    real = _try_duration(out_path)
+
+    if real and last_end > 0.3:
+        # Reescalar suavemente para alinear el último subtítulo con el fin real
+        factor = real / last_end
+        if 0.85 <= factor <= 1.15:
+            for w in words:
+                w["start"] *= factor
+                w["dur"] = max(w["dur"] * factor, 0.02)
+        dur = real
+    else:
+        dur = last_end + 0.4  # colchón final
+
+    return words, dur

captionwave-0.1.0.dist-info/METADATA

@@ -0,0 +1,269 @@
+Metadata-Version: 2.4
+Name: captionwave
+Version: 0.1.0
+Summary: Genera audio + subtítulos animados sincronizados (.ass/.srt) a partir de texto, con emojis compatibles con iOS.
+Author-email: Wilfredo Guillén <wilfredoguillensalazar@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Fortex-GT/Captionwave
+Project-URL: Repository, https://github.com/Fortex-GT/Captionwave
+Project-URL: Issues, https://github.com/Fortex-GT/Captionwave/issues
+Keywords: subtitles,captions,tts,ass,shorts,reels,tiktok,karaoke,emoji
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: edge-tts>=7.0
+Requires-Dist: emoji>=2.8
+Provides-Extra: duration
+Requires-Dist: mutagen>=1.45; extra == "duration"
+Provides-Extra: video
+Requires-Dist: moviepy>=2.0; extra == "video"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# captionwave
+
+Genera **audio (voz)** y **subtítulos animados sincronizados** (`.ass` + `.srt`) a partir de una variable de texto. Pensado para Shorts / Reels / TikTok estilo "¿Sabías que…?".
+
+La librería **no arma el video final**: te entrega los archivos (audio + subtítulos + emojis con tiempos) para que tú montes el video como prefieras (FFmpeg, tu editor, MoviePy…). Así tienes control total y no reprogramas los subtítulos en cada proyecto.
+
+- ✅ Voz con **edge-tts** y tiempos **por palabra** → el audio y los subtítulos quedan pegados *por construcción* (no se desfasan).
+- ✅ Subtítulos animados en **`.ass`** (karaoke, palabra activa, "pop", sticker estilo Hormozi, palabra-por-palabra…) que **FFmpeg/libass renderiza de forma nativa** (rápido).
+- ✅ `.srt` de respaldo para plataformas que no aceptan `.ass`.
+- ✅ **Emojis filtrados a los que existen en iOS** (sin "tofus"/cuadritos), con sus tiempos exportados para superponer tu propio arte.
+
+---
+
+## Instalación
+
+```bash
+pip install captionwave          # una vez publicado en PyPI
+```
+
+Mientras tanto —o en notebooks como Google Colab— instálalo desde GitHub:
+
+```bash
+pip install "git+https://github.com/Fortex-GT/Captionwave.git"
+```
+
+O desde el código fuente (este repositorio):
+
+```bash
+pip install .          # o, para desarrollo:  pip install -e .
+```
+
+Requisitos:
+- **Conexión a internet** para la voz (edge-tts usa el servicio de Microsoft Edge). Si solo quieres los subtítulos a partir de tiempos que ya tienes, puedes trabajar sin red con `build_from_words(...)` (ver más abajo y `examples/offline_sin_internet.py`).
+- **FFmpeg** instalado si vas a quemar los subtítulos en el video (`ffmpeg -version`).
+- Opcional, recomendado: `pip install captionwave[duration]` (usa *mutagen* para medir con exactitud la duración del audio y alinear el último subtítulo).
+
+---
+
+## Uso rápido
+
+```python
+from captionwave import CaptionGenerator
+
+gen = CaptionGenerator(
+    voice="es-MX-DaliaNeural",   # cualquier voz de edge-tts
+    rate="+18%",                 # más rápido = más dinámico
+    style="hormozi",             # ver estilos abajo
+)
+
+r = gen.generate(
+    "El Sol es una estrella que contiene el 99% de la masa del sistema solar.",
+    out_audio="voz.mp3",
+    out_ass="subs.ass",
+    out_srt="subs.srt",          # opcional
+    out_emojis="emojis.json",    # opcional (para superponer arte de emoji)
+)
+
+print(r["duration"], "segundos")
+```
+
+Esto crea `voz.mp3`, `subs.ass`, `subs.srt` y `emojis.json`, listos para montar.
+
+### Con un gancho/intro a otro ritmo
+
+```python
+r = gen.generate(
+    "el sol es una estrella enorme.",
+    intro="¿Sabías que...?",   # se dice antes
+    intro_rate="+5%",          # el gancho un poco más pausado
+    out_audio="voz.mp3", out_ass="subs.ass",
+)
+```
+
+### Sin internet (a partir de tiempos que ya tienes)
+
+Si ya tienes los tiempos por palabra (de otra fuente o para hacer pruebas),
+puedes generar los subtítulos **sin TTS ni conexión** con `build_from_words`:
+
+```python
+from captionwave import CaptionGenerator
+
+words = [
+    {"word": "El",       "start": 0.00, "dur": 0.18},
+    {"word": "Sol",      "start": 0.18, "dur": 0.34},
+    {"word": "es",       "start": 0.52, "dur": 0.16},
+    {"word": "una",      "start": 0.68, "dur": 0.18},
+    {"word": "estrella", "start": 0.86, "dur": 0.52},
+]
+
+gen = CaptionGenerator(style="hormozi")
+r = gen.build_from_words(words, duration=1.5, out_ass="subs.ass", out_srt="subs.srt")
+```
+
+Devuelve el mismo `dict` que `generate` (con `audio=None`). Ver `examples/offline_sin_internet.py`.
+
+---
+
+## Estilos disponibles
+
+![Muestra de estilos](estilos_muestra.png)
+
+*(Palabra activa "ESTRELLA" resaltada en 4 de los estilos. El resaltado avanza palabra por palabra al ritmo de la voz.)*
+
+```python
+from captionwave import list_styles
+print(list_styles())
+```
+
+| Estilo      | Animación        | Descripción |
+|-------------|------------------|-------------|
+| `hormozi`   | sticker amarillo | Palabra activa con fondo sólido (clásico de Shorts). |
+| `green`     | sticker verde    | Igual que hormozi pero en verde. |
+| `karaoke`   | barrido          | El texto se "llena" de color al ritmo de la voz. |
+| `pop`       | rebote           | La palabra activa crece y cambia de color. |
+| `fire`      | rebote naranja   | Variante de `pop` en tono fuego. |
+| `neon`      | color + glow     | Palabra activa cian con contorno azul. |
+| `single`    | palabra única    | Una sola palabra a la vez, grande y centrada. |
+| `clean`     | color suave      | Subtítulo abajo, sobrio (lower third). |
+
+### Personalizar cualquier estilo
+
+Cada estilo es un `Style` que puedes copiar y modificar:
+
+```python
+from captionwave import get_style, CaptionGenerator
+
+mi_estilo = get_style("hormozi").copy(
+    active_color="#FF3366",
+    sticker_color="#FF3366",
+    sticker_text_color="#FFFFFF",
+    font="Montserrat",     # debe estar instalada en el sistema que renderiza
+    font_size=96,
+    max_words=2,           # menos palabras por línea
+    position="lower",      # "center" | "lower" | "upper"
+)
+
+gen = CaptionGenerator(style=mi_estilo, rate="+20%")
+```
+
+Campos útiles de `Style`: `base_color`, `active_color`, `outline_color`, `outline_w`, `sticker_color`, `sticker_text_color`, `sticker_bord`, `pop_scale`, `font`, `font_size`, `uppercase`, `max_words`, `max_chars`, `position`.
+
+---
+
+## Montar el video con FFmpeg
+
+La librería te da `voz.mp3` + `subs.ass`. Para quemar los subtítulos sobre un fondo:
+
+**Sobre un video de fondo** (gameplay, b-roll, etc.):
+```bash
+ffmpeg -i fondo.mp4 -i voz.mp3 \
+  -vf "scale=1080:1920,ass=subs.ass" \
+  -map 0:v -map 1:a -shortest salida.mp4
+```
+
+**Sobre una imagen fija**:
+```bash
+ffmpeg -loop 1 -i fondo.jpg -i voz.mp3 \
+  -vf "scale=1080:1920,ass=subs.ass" \
+  -c:v libx264 -pix_fmt yuv420p -c:a aac -shortest salida.mp4
+```
+
+> El `.ass` ya trae la resolución (1080×1920 por defecto). Si cambias la resolución usa `resolution=(W, H)` en `CaptionGenerator`.
+
+---
+
+## ⚠️ Sobre los emojis (léelo)
+
+La librería elige, para cada palabra/frase, un **emoji que sí existe en iOS** (filtra por versión de Unicode; ajustable con `emoji_max_version`). Esto evita que en un iPhone aparezcan cuadritos.
+
+Dos cosas importantes sobre la **apariencia**:
+
+1. **No se incluye el arte de Apple.** Los emojis de Apple son propiedad de Apple y no se pueden empaquetar/redistribuir. La librería entrega el **carácter Unicode** correcto; el diseño con el que se ve lo pone el sistema donde se reproduce (en iPhone/Mac se verá con el estilo de Apple; en Linux con Noto/Twemoji).
+
+2. **libass no garantiza emojis a color.** Al quemar el `.ass` con FFmpeg, los emojis suelen salir **monocromos**. Por eso, si quieres el emoji a color (y con el look de Apple), la mejor ruta es **superponerlo como imagen** en tu editor o con FFmpeg, usando los tiempos que te da la librería:
+
+```python
+r = gen.generate("...", out_emojis="emojis.json")
+for e in r["emojis"]:
+    print(e)  # {"word": "estrella", "emoji": "⭐", "start": 1.38, "dur": 0.58}
+```
+
+Con eso colocas tu PNG de emoji (que tú aportas) en `start` durante `dur`. Así el carácter sale de la librería y el arte lo pones tú, sin problemas de copyright.
+
+Si prefieres incrustar el carácter directamente en el `.ass` de todas formas, está activado por defecto (`emoji_in_ass=True`); ponlo en `False` si vas a usar overlay.
+
+---
+
+## Qué devuelve `generate(...)`
+
+Un `dict` con:
+
+```python
+{
+  "audio": "voz.mp3",
+  "ass":   "subs.ass",
+  "srt":   "subs.srt" | None,
+  "duration": 6.37,                 # segundos
+  "words":  [{"word","start","dur"}, ...],
+  "lines":  [{"text","start","end","emoji"}, ...],
+  "emojis": [{"word","emoji","start","dur"}, ...],
+}
+```
+
+---
+
+## Desarrollo y tests
+
+```bash
+pip install -e ".[test]"
+pytest
+```
+
+Los tests **no necesitan internet** (no llaman al TTS): cubren los estilos, el
+troceado en líneas, la selección de emojis y la escritura de `.ass`/`.srt`.
+
+---
+
+## Publicar tu propia copia
+
+> **Antes de subir a PyPI, verifica que el nombre `captionwave` esté libre** en https://pypi.org. Si no lo está, renómbralo: cambia la carpeta `src/captionwave/` y el campo `name` de `pyproject.toml`.
+
+```bash
+pip install build twine
+python -m build
+twine upload dist/*
+```
+
+Para GitHub solo inicializa el repo y súbelo normal.
+
+---
+
+## Licencia
+
+MIT © 2026 Wilfredo Guillén — ver [LICENSE](LICENSE).

captionwave-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+captionwave/__init__.py,sha256=0ZqIVOn2XdUKWaG_lAkhC61yNHJD3IctIrQqdSYkR_w,565
+captionwave/ass_writer.py,sha256=Fuc8ACXrw8gkau6XzBbqhjvIMsCMcJPLC-oLIo31IRM,7441
+captionwave/core.py,sha256=w7gKhOkCGU2MsoqldhtN3tDW3e-w9KydT4mzcfSuPTM,6388
+captionwave/emojis.py,sha256=eEsSaQSG080dSGfGGx8A_fO3j5ve-Bq8doljo8bNZuE,6963
+captionwave/srt_writer.py,sha256=CrEnbrQ7MadyH2mKjyLdq87XIDHi26Mkb-K4TZsIlBE,873
+captionwave/styles.py,sha256=uIEP5_qaMSUUKx2fLFS5GXjhWcaoF6JkkhEpBhAT0Vg,5925
+captionwave/tts.py,sha256=uxQvWQot3SSDbXvWrxU5QJcQdBOvObVMqER_riYO2kM,5506
+captionwave-0.1.0.dist-info/licenses/LICENSE,sha256=ib_54mIkMoqZxNXDMHLVp3AnLTwnsbZjhSDQVNsDp7A,1074
+captionwave-0.1.0.dist-info/METADATA,sha256=kKtavIYW8ngCwbFa6S6MRh5Bx7LnAQvHvTu8mGn-31w,9921
+captionwave-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+captionwave-0.1.0.dist-info/top_level.txt,sha256=5E9diZeqVkzuSEt6eV_e-KgMwNFaUmI1eYJPKLht4ac,12
+captionwave-0.1.0.dist-info/RECORD,,

captionwave-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

captionwave-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Wilfredo Guillén
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

captionwave-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+captionwave