plotagon-director 0.6.0__py3-none-any.whl

plotagon_director/__init__.py

@@ -0,0 +1,3 @@
+"""plotagon_director — generation de films Plotagon Studio Desktop (.plot)."""
+
+__version__ = "0.6.0"

plotagon_director/audio/phonemes.py

@@ -0,0 +1,70 @@
+"""Fichiers .phonemes (synchro labiale) au format de Plotagon Studio.
+
+Format CONFIRME par decodage d'un export officiel : messages protobuf
+concatenes, un par trame de 2048 echantillons (~46.4 ms a 44100 Hz) :
+
+    champ 1 (tag 0x0d, float32 LE) : debut en secondes (omis si 0)
+    champ 2 (tag 0x15, float32 LE) : fin en secondes
+    champ 3 (tag 0x1a, string)     : phoneme
+
+Phonemes observes : sil, ae, d, eh, l, m, n, ow, uu, uw.
+"""
+
+import io
+import struct
+import wave
+
+FRAME_SAMPLES = 2048
+
+# Cycle de voyelles pour la synchro labiale approximative (amplitude-based).
+_MOUTH_CYCLE = ["eh", "ae", "ow", "eh", "uw", "ae"]
+
+
+def phonemes_from_wav(wav_bytes):
+    """Synchro labiale approximative par enveloppe d'amplitude.
+
+    L'appli genere les phonemes par analyse du signal ; ici on approxime :
+    trames silencieuses -> "sil", trames parlees -> cycle de voyelles.
+    """
+    import numpy as np
+
+    with wave.open(io.BytesIO(wav_bytes)) as w:
+        rate = w.getframerate()
+        pcm = np.frombuffer(w.readframes(w.getnframes()), dtype="<i2")
+
+    records = []
+    n_frames = max(1, (len(pcm) + FRAME_SAMPLES - 1) // FRAME_SAMPLES)
+    rms = np.array([
+        np.sqrt(np.mean(
+            pcm[i * FRAME_SAMPLES:(i + 1) * FRAME_SAMPLES].astype("f8") ** 2
+        )) if len(pcm[i * FRAME_SAMPLES:(i + 1) * FRAME_SAMPLES]) else 0.0
+        for i in range(n_frames)
+    ])
+    threshold = max(300.0, float(rms.max()) * 0.08)
+
+    mouth = 0
+    for i in range(n_frames):
+        start = i * FRAME_SAMPLES / rate
+        end = min((i + 1) * FRAME_SAMPLES, len(pcm)) / rate
+        if rms[i] >= threshold:
+            label = _MOUTH_CYCLE[(mouth // 2) % len(_MOUTH_CYCLE)]
+            mouth += 1
+        else:
+            label = "sil"
+            mouth = 0
+        records.append((start, end, label))
+    return records
+
+
+def encode_phonemes(records):
+    """Encode les enregistrements au format protobuf observe."""
+    out = bytearray()
+    for start, end, label in records:
+        body = bytearray()
+        if start > 0.0:
+            body += b"\x0d" + struct.pack("<f", start)
+        body += b"\x15" + struct.pack("<f", end)
+        raw = label.encode()
+        body += b"\x1a" + bytes([len(raw)]) + raw
+        out += b"\x0a" + bytes([len(body)]) + body
+    return bytes(out)

plotagon_director/audio/tts.py

@@ -0,0 +1,163 @@
+"""Synthese vocale Edge TTS au format audio de Plotagon Studio.
+
+Format CONFIRME (export officiel 1.11.0) : WAV PCM mono 44100 Hz 16 bits.
+
+Deux optimisations pour l'iteration rapide :
+- cache disque (%LOCALAPPDATA%/plotagon-director/tts-cache) par hash de
+  (texte, voix, rate, pitch) — un rebuild sans changement ne touche pas
+  au reseau ;
+- synthese parallele (asyncio) pour les films a nombreuses repliques.
+"""
+
+import asyncio
+import hashlib
+import io
+import os
+import wave
+from pathlib import Path
+
+TARGET_RATE = 44100
+CONCURRENCY = 4
+
+CACHE_DIR = (
+    Path(os.environ.get("LOCALAPPDATA", str(Path.home())))
+    / "plotagon-director" / "tts-cache"
+)
+
+
+def _inject_truststore():
+    """Fait utiliser a Python le magasin de certificats Windows.
+
+    Indispensable derriere un antivirus qui intercepte le TLS (ex. Norton).
+    """
+    try:
+        import truststore
+        truststore.inject_into_ssl()
+    except ImportError:
+        pass
+
+
+def _cache_path(text, voice, rate, pitch):
+    key = "%s|%s|%s|%s" % (text, voice, rate or "", pitch or "")
+    return CACHE_DIR / (hashlib.sha256(key.encode("utf-8")).hexdigest() + ".wav")
+
+
+async def _fetch_mp3(text, voice, rate=None, pitch=None):
+    import edge_tts
+
+    kwargs = {}
+    if rate:
+        kwargs["rate"] = rate
+    if pitch:
+        kwargs["pitch"] = pitch
+    communicate = edge_tts.Communicate(text, voice, **kwargs)
+    buf = io.BytesIO()
+    async for chunk in communicate.stream():
+        if chunk["type"] == "audio":
+            buf.write(chunk["data"])
+    return buf.getvalue()
+
+
+def _mp3_to_wav(mp3_bytes):
+    import numpy as np
+    import soundfile as sf
+
+    data, sr = sf.read(io.BytesIO(mp3_bytes), dtype="float32")
+    if data.ndim > 1:
+        data = data.mean(axis=1)
+    if sr != TARGET_RATE:
+        n_out = int(round(len(data) * TARGET_RATE / sr))
+        x_old = np.linspace(0.0, 1.0, num=len(data), endpoint=False)
+        x_new = np.linspace(0.0, 1.0, num=n_out, endpoint=False)
+        data = np.interp(x_new, x_old, data).astype("float32")
+
+    pcm = (np.clip(data, -1.0, 1.0) * 32767).astype("<i2")
+    out = io.BytesIO()
+    with wave.open(out, "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(TARGET_RATE)
+        w.writeframes(pcm.tobytes())
+    return out.getvalue()
+
+
+def synthesize_wav(text, voice, rate=None, pitch=None, use_cache=True):
+    """Synthetise une replique et retourne des octets WAV 44.1k mono 16b."""
+    if use_cache:
+        cached = _cache_path(text, voice, rate, pitch)
+        if cached.exists():
+            return cached.read_bytes()
+
+    _inject_truststore()
+    wav = _mp3_to_wav(asyncio.run(_fetch_mp3(text, voice, rate, pitch)))
+
+    if use_cache:
+        CACHE_DIR.mkdir(parents=True, exist_ok=True)
+        cached.write_bytes(wav)
+    return wav
+
+
+def synthesize_many(jobs, use_cache=True, progress=None):
+    """Synthetise plusieurs repliques en parallele.
+
+    jobs : liste de dicts {"guid", "text", "voice", "rate", "pitch"}.
+    progress : callback(job, from_cache) appele apres chaque replique.
+    Retourne {guid: wav_bytes}.
+    """
+    results = {}
+    to_fetch = []
+    for job in jobs:
+        cached = _cache_path(job["text"], job["voice"], job.get("rate"), job.get("pitch"))
+        if use_cache and cached.exists():
+            results[job["guid"]] = cached.read_bytes()
+            if progress:
+                progress(job, True)
+        else:
+            to_fetch.append(job)
+
+    if to_fetch:
+        _inject_truststore()
+
+        async def _run_all():
+            sem = asyncio.Semaphore(CONCURRENCY)
+
+            async def _one(job):
+                async with sem:
+                    mp3 = await _fetch_mp3(
+                        job["text"], job["voice"], job.get("rate"), job.get("pitch")
+                    )
+                return job, mp3
+
+            return await asyncio.gather(*(_one(j) for j in to_fetch))
+
+        for job, mp3 in asyncio.run(_run_all()):
+            wav = _mp3_to_wav(mp3)
+            results[job["guid"]] = wav
+            if use_cache:
+                CACHE_DIR.mkdir(parents=True, exist_ok=True)
+                _cache_path(
+                    job["text"], job["voice"], job.get("rate"), job.get("pitch")
+                ).write_bytes(wav)
+            if progress:
+                progress(job, False)
+
+    return results
+
+
+def list_voices(locale_prefix=None):
+    """Liste les voix Edge TTS, filtrees par prefixe de locale (ex. 'fr')."""
+    _inject_truststore()
+    import edge_tts
+
+    voices = asyncio.run(edge_tts.list_voices())
+    if locale_prefix:
+        voices = [
+            v for v in voices
+            if v["Locale"].lower().startswith(locale_prefix.lower())
+        ]
+    return sorted(voices, key=lambda v: v["ShortName"])
+
+
+def wav_duration_ms(wav_bytes):
+    with wave.open(io.BytesIO(wav_bytes)) as w:
+        return int(round(1000.0 * w.getnframes() / w.getframerate()))

plotagon_director/cli.py

@@ -0,0 +1,308 @@
+"""CLI plotagon-director.
+
+Commandes : validate | build | batch | parse | decompile | diff | list |
+positions | voices | say | new | doctor
+"""
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+import yaml
+
+from .core.archive import read_plot, write_plot
+from .core.plotdoc import MS_PER_CHAR, build_plotdoc
+from .core.validator import load_project, validate_project
+from .library import load_library
+
+NEW_TEMPLATE = """\
+# Scenario Plotagon — IDs valides: `plotagon-director list scenes|characters|expressions|actions|music`
+project:
+  title: "%s"
+  language: "fr-FR"
+
+# cast_file: cast-commun.yaml   # optionnel: cast partage entre films
+
+cast:
+  - ref: paul
+    character: news.paul
+    name: "Paul"
+    voice: fr-FR-HenriNeural    # optionnel: voix Edge TTS (`plotagon-director voices fr`)
+    # rate: "+10%%"             # optionnel
+    # pitch: "-5Hz"             # optionnel
+
+scenes:
+  - scene: spaces.greenscreen
+    # music: music.corny        # optionnel (music.stopmusic pour arreter)
+    actors:
+      - ref: paul
+        position: Left          # slots: `plotagon-director positions <scene>`
+    dialogue:
+      - actor: paul
+        expression: happy       # 88 expressions: `plotagon-director list expressions`
+        text: "Bonjour !"
+        # camera: wide shot     # optionnel: 10 types (docs/PLOT_FORMAT.md)
+      # - actor: paul           # interaction a 2 personnages
+      #   action: handshake
+      #   target: autre_ref
+"""
+
+
+def print_report(errors, warnings, strict=False):
+    print("PLOTAGON VALIDATOR")
+    print("=" * 20)
+    for w in warnings:
+        print(f"WARNING  {w}")
+    for e in errors:
+        print(f"ERROR    {e}")
+    if errors or (strict and warnings):
+        print("RESULT   FAIL")
+        sys.exit(1)
+    print("RESULT   PASS" if not warnings else "RESULT   PASS WITH WARNINGS")
+
+
+def _format_srt_time(ms):
+    h, rem = divmod(ms, 3600000)
+    m, rem = divmod(rem, 60000)
+    s, ms = divmod(rem, 1000)
+    return "%02d:%02d:%02d,%03d" % (h, m, s, ms)
+
+
+def _write_srt(path, entries):
+    """entries: liste de (debut_ms, fin_ms, texte)."""
+    blocks = []
+    for i, (start, end, text) in enumerate(entries, start=1):
+        blocks.append("%d\n%s --> %s\n%s\n" % (
+            i, _format_srt_time(start), _format_srt_time(end), text
+        ))
+    Path(path).write_text("\n".join(blocks), encoding="utf-8")
+
+
+SRT_GAP_MS = 400  # estimation des transitions entre repliques dans l'appli
+
+
+def do_build(project_path, output, no_voices=False, strict=False, srt=None,
+             no_cache=False):
+    errors, warnings = validate_project(project_path)
+    if errors or (strict and warnings):
+        print_report(errors, warnings, strict)
+    plotdoc, voice_jobs = build_plotdoc(load_project(project_path), load_library())
+
+    media = {}
+    durations = {}
+    if voice_jobs and not no_voices:
+        from .audio.phonemes import encode_phonemes, phonemes_from_wav
+        from .audio.tts import synthesize_many, wav_duration_ms
+
+        def progress(job, from_cache):
+            print("TTS  %s [%s] %s" % (
+                "(cache)" if from_cache else "       ",
+                job["voice"], job["text"][:50],
+            ))
+
+        wavs = synthesize_many(voice_jobs, use_cache=not no_cache,
+                               progress=progress)
+        for guid, wav in wavs.items():
+            media[guid] = {
+                "wav": wav,
+                "phonemes": encode_phonemes(phonemes_from_wav(wav)),
+            }
+            durations[guid] = wav_duration_ms(wav)
+        plotdoc["lengthSeconds"] = str(max(1000, sum(durations.values())))
+    elif voice_jobs:
+        plotdoc["voicerecordings"] = []
+        for instr in plotdoc["contents"]["instructions"]:
+            instr["parameters"]["isRecorded"] = False
+            instr["parameters"]["playRecording"] = False
+
+    write_plot(plotdoc, output, media)
+    print("OK  %s (%d instructions, %d voix)" % (
+        output, len(plotdoc["contents"]["instructions"]), len(media)
+    ))
+
+    if srt:
+        entries = []
+        t = 0
+        for instr in plotdoc["contents"]["instructions"]:
+            if instr["type"] != "dialogue":
+                continue
+            params = instr["parameters"]
+            text = params.get("text", {}).get("text", "")
+            duration = durations.get(
+                params["GUID"], max(1500, len(text) * MS_PER_CHAR)
+            )
+            entries.append((t, t + duration, text))
+            t += duration + SRT_GAP_MS
+        _write_srt(srt, entries)
+        print("OK  %s (%d sous-titres)" % (srt, len(entries)))
+
+
+def do_list(category, filter_term=None):
+    library = load_library()
+    if library is None:
+        sys.exit("library.json absent — lancer: python -m plotagon_director.library.builder")
+    if category not in library or category == "source":
+        sys.exit("Categories: %s" % ", ".join(k for k in library if k != "source"))
+    items = library[category]
+    if category == "actions":
+        rows = [(k, v.get("phrase", "")) for k, v in items.items()]
+        if filter_term:
+            rows = [r for r in rows if filter_term.lower() in r[0].lower()]
+        for k, phrase in rows:
+            print("%-22s %s" % (k, phrase))
+        print("-- %d actions" % len(rows))
+        return
+    if filter_term:
+        items = [i for i in items if filter_term.lower() in i.lower()]
+    for item in items:
+        print(item)
+    print("-- %d %s" % (len(items), category))
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="plotagon-director")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    pval = sub.add_parser("validate", help="valide un project.yaml")
+    pval.add_argument("project")
+    pval.add_argument("--strict", action="store_true",
+                      help="les warnings deviennent des erreurs")
+
+    pbuild = sub.add_parser("build", help="genere un .plot depuis un project.yaml")
+    pbuild.add_argument("project")
+    pbuild.add_argument("output")
+    pbuild.add_argument("--no-voices", action="store_true",
+                        help="ignore les champs voice (pas de reseau)")
+    pbuild.add_argument("--no-cache", action="store_true",
+                        help="resynthetise tout (ignore le cache TTS)")
+    pbuild.add_argument("--strict", action="store_true")
+    pbuild.add_argument("--srt", metavar="FICHIER",
+                        help="ecrit aussi les sous-titres SRT (temps estimes)")
+
+    pbatch = sub.add_parser("batch", help="build tous les .yaml d'un dossier")
+    pbatch.add_argument("directory")
+    pbatch.add_argument("outdir", nargs="?", default=None)
+    pbatch.add_argument("--no-voices", action="store_true")
+
+    pparse = sub.add_parser("parse", help="lit un .plot et affiche son JSON")
+    pparse.add_argument("plot")
+
+    pdec = sub.add_parser("decompile", help="convertit un .plot en project.yaml")
+    pdec.add_argument("plot")
+    pdec.add_argument("output", nargs="?", default=None,
+                      help="fichier yaml de sortie (defaut: stdout)")
+
+    pdiff = sub.add_parser("diff", help="compare la structure de deux .plot")
+    pdiff.add_argument("plot_a")
+    pdiff.add_argument("plot_b")
+
+    plist = sub.add_parser("list", help="liste la bibliotheque (scenes, characters...)")
+    plist.add_argument("category")
+    plist.add_argument("--filter", dest="filter_term", default=None)
+
+    ppos = sub.add_parser("positions", help="liste les positions d'acteurs d'une scene")
+    ppos.add_argument("scene")
+
+    pvoi = sub.add_parser("voices", help="liste les voix Edge TTS")
+    pvoi.add_argument("locale", nargs="?", default=None,
+                      help="prefixe de locale, ex. fr ou fr-CA")
+
+    psay = sub.add_parser("say", help="synthetise une phrase pour ecouter une voix")
+    psay.add_argument("text")
+    psay.add_argument("voice")
+    psay.add_argument("output", nargs="?", default="voix-test.wav")
+
+    pnew = sub.add_parser("new", help="cree un squelette de project.yaml")
+    pnew.add_argument("title")
+    pnew.add_argument("output", nargs="?", default=None)
+
+    pdoc = sub.add_parser("doctor", help="diagnostic d'environnement")
+    pdoc.add_argument("--offline", action="store_true",
+                      help="saute le test reseau/TLS")
+
+    args = parser.parse_args()
+
+    if args.command == "validate":
+        errors, warnings = validate_project(args.project)
+        print_report(errors, warnings, args.strict)
+
+    elif args.command == "build":
+        do_build(args.project, args.output, args.no_voices, args.strict,
+                 args.srt, args.no_cache)
+
+    elif args.command == "batch":
+        directory = Path(args.directory)
+        outdir = Path(args.outdir) if args.outdir else directory
+        outdir.mkdir(parents=True, exist_ok=True)
+        files = sorted(directory.glob("*.yaml")) + sorted(directory.glob("*.yml"))
+        if not files:
+            sys.exit("Aucun .yaml dans %s" % directory)
+        for f in files:
+            print("== %s" % f.name)
+            do_build(str(f), str(outdir / (f.stem + ".plot")), args.no_voices)
+
+    elif args.command == "parse":
+        print(json.dumps(read_plot(args.plot), ensure_ascii=False, indent=2))
+
+    elif args.command == "decompile":
+        from .core.decompiler import plotdoc_to_project
+        project, unknown = plotdoc_to_project(read_plot(args.plot))
+        text = yaml.safe_dump(project, allow_unicode=True, sort_keys=False,
+                              default_flow_style=False)
+        if args.output:
+            Path(args.output).write_text(text, encoding="utf-8")
+            print("OK  %s" % args.output)
+        else:
+            print(text)
+        if unknown:
+            print("ATTENTION: %d instruction(s) de type inconnu conservees "
+                  "dans `unknown_instructions` (a analyser)." % unknown,
+                  file=sys.stderr)
+
+    elif args.command == "diff":
+        from .core.diffplot import diff_plots
+        print(diff_plots(args.plot_a, args.plot_b))
+
+    elif args.command == "list":
+        do_list(args.category, args.filter_term)
+
+    elif args.command == "positions":
+        library = load_library() or {}
+        slots = library.get("scene_positions", {}).get(args.scene)
+        if slots is None:
+            sys.exit("Scene inconnue ou positions non extraites: %s "
+                     "(relancer library.builder ?)" % args.scene)
+        for s in slots:
+            print("%-24s %s" % (s["id"], s["text"]))
+        print("-- %d positions" % len(slots))
+
+    elif args.command == "voices":
+        from .audio.tts import list_voices
+        voices = list_voices(args.locale)
+        for v in voices:
+            print("%-28s %-8s %s" % (v["ShortName"], v["Gender"], v["Locale"]))
+        print("-- %d voix" % len(voices))
+
+    elif args.command == "say":
+        from .audio.tts import synthesize_wav
+        wav = synthesize_wav(args.text, args.voice)
+        Path(args.output).write_bytes(wav)
+        print("OK  %s" % args.output)
+
+    elif args.command == "new":
+        out = args.output or (args.title.lower().replace(" ", "-") + ".yaml")
+        if Path(out).exists():
+            sys.exit("%s existe deja." % out)
+        Path(out).write_text(NEW_TEMPLATE % args.title, encoding="utf-8")
+        print("OK  %s" % out)
+
+    elif args.command == "doctor":
+        from .core.doctor import run_doctor
+        report, ok = run_doctor(check_network=not args.offline)
+        print(report)
+        sys.exit(0 if ok else 1)
+
+
+if __name__ == "__main__":
+    main()

plotagon_director/core/archive.py

@@ -0,0 +1,35 @@
+"""Lecture/ecriture du conteneur .plot.
+
+.plot = archive ZIP contenant "<guid-projet>.plotdoc" (JSON UTF-8) et,
+pour chaque replique avec voix, "<guid-projet>/<guid-instruction>.wav"
+et ".phonemes".
+"""
+
+import json
+import zipfile
+
+
+def write_plot(plotdoc, out_path, media=None):
+    """Ecrit un .plot.
+
+    media : dict {guid_instruction: {"wav": bytes, "phonemes": bytes}}.
+    """
+    inner_name = "%s.plotdoc" % plotdoc["id"]
+    payload = json.dumps(plotdoc, ensure_ascii=False, indent=2)
+    with zipfile.ZipFile(out_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr(inner_name, payload)
+        for guid, files in (media or {}).items():
+            base = "%s/%s" % (plotdoc["id"], guid)
+            zf.writestr(base + ".wav", files["wav"])
+            if files.get("phonemes"):
+                zf.writestr(base + ".phonemes", files["phonemes"])
+
+
+def read_plot(path):
+    """Lit un .plot et retourne le dict .plotdoc."""
+    with zipfile.ZipFile(path) as zf:
+        names = [n for n in zf.namelist() if n.endswith(".plotdoc")]
+        if not names:
+            raise ValueError("Aucun .plotdoc dans l'archive: %s" % path)
+        with zf.open(names[0]) as f:
+            return json.load(f)