plotagon-director 0.6.0__py3-none-any.whl

plotagon_director/core/decompiler.py

@@ -0,0 +1,120 @@
+"""Decompilation d'un .plotdoc vers le format project.yaml.
+
+Chemin inverse du generateur : permet d'editer au texte un film cree dans
+l'appli, puis de le regenerer. Les types d'instructions inconnus sont
+conserves bruts dans `unknown_instructions` (rien n'est perdu).
+"""
+
+import re
+
+
+def _slug(text):
+    s = re.sub(r"[^a-z0-9]+", "", str(text).lower())
+    return s or "actor"
+
+
+def _ref_for(character_id, display_name, cast):
+    """Retourne un ref stable pour un personnage (meme id -> meme ref)."""
+    for ref, member in cast.items():
+        if member["character"] == character_id:
+            return ref
+    base = _slug(display_name or character_id.split(".")[-1])
+    ref = base
+    n = 2
+    while ref in cast:
+        ref = "%s%d" % (base, n)
+        n += 1
+    cast[ref] = {
+        "ref": ref,
+        "character": character_id,
+        "name": display_name or character_id.split(".")[-1].capitalize(),
+    }
+    return ref
+
+
+def plotdoc_to_project(plotdoc):
+    """Transforme un dict .plotdoc en dict project.yaml.
+
+    Retourne (project, unknown_count).
+    """
+    cast = {}
+    scenes = []
+    unknown = []
+    current = None
+
+    for instr in plotdoc.get("contents", {}).get("instructions", []):
+        itype = instr.get("type")
+        p = instr.get("parameters", {})
+
+        if itype == "scene":
+            current = {"scene": p.get("scene", {}).get("id", "")}
+            name = p.get("scene", {}).get("text")
+            if name:
+                current["scene_name"] = name
+            current["actors"] = []
+            current["dialogue"] = []
+            i = 1
+            while ("actor%d" % i) in p:
+                actor = p["actor%d" % i]
+                ref = _ref_for(actor.get("id", ""), actor.get("text"), cast)
+                entry = {"ref": ref}
+                position = p.get("location%d" % i, {}).get("id")
+                if position:
+                    entry["position"] = position
+                current["actors"].append(entry)
+                i += 1
+            scenes.append(current)
+
+        elif itype == "dialogue":
+            if current is None:
+                current = {"scene": "", "actors": [], "dialogue": []}
+                scenes.append(current)
+            character = p.get("character", {})
+            ref = _ref_for(character.get("id", ""), character.get("text"), cast)
+            line = {
+                "actor": ref,
+                "expression": p.get("expression", {}).get("id", "neutral"),
+                "text": p.get("text", {}).get("text", ""),
+            }
+            if p.get("isRecorded"):
+                # replique avec audio embarque dans le .plot d'origine ;
+                # ajouter `voice:` au cast pour la re-synthetiser au build
+                line["recorded"] = True
+            camera = p.get("camera")
+            if camera:
+                line["camera"] = camera.get("type", {}).get("name", "")
+                if camera.get("position"):
+                    line["camera_position"] = camera["position"].get("id", "")
+                if camera.get("target"):
+                    line["camera_target"] = camera["target"].get("id", "")
+            current["dialogue"].append(line)
+
+        elif itype == "music":
+            if current is not None:
+                current["music"] = p.get("music", {}).get("id", "")
+
+        elif itype == "action":
+            if current is None:
+                current = {"scene": "", "actors": [], "dialogue": []}
+                scenes.append(current)
+            character = p.get("character", {})
+            ref = _ref_for(character.get("id", ""), character.get("text"), cast)
+            line = {"actor": ref, "action": p.get("action", {}).get("id", "")}
+            target = p.get("target")
+            if target:
+                line["target"] = _ref_for(
+                    target.get("id", ""), target.get("text"), cast
+                )
+            current["dialogue"].append(line)
+
+        else:
+            unknown.append(instr)
+
+    project = {
+        "project": {"title": plotdoc.get("name", "untitled")},
+        "cast": list(cast.values()),
+        "scenes": scenes,
+    }
+    if unknown:
+        project["unknown_instructions"] = unknown
+    return project, len(unknown)

plotagon_director/core/diffplot.py

@@ -0,0 +1,89 @@
+"""Comparaison structurelle de deux .plot — outil de retro-ingenierie.
+
+Usage type : exporter un projet avant/apres l'ajout d'une fonctionnalite
+inconnue (musique, camera, 2e acteur...) dans l'appli officielle, puis
+comparer pour isoler les nouveaux types d'instructions, cles JSON et
+fichiers embarques.
+"""
+
+import zipfile
+from collections import Counter
+
+from .archive import read_plot
+
+
+def _entry_kinds(path):
+    kinds = Counter()
+    names = []
+    with zipfile.ZipFile(path) as zf:
+        for name in zf.namelist():
+            suffix = "." + name.rsplit(".", 1)[-1] if "." in name else "(sans ext)"
+            kinds[suffix] += 1
+            names.append(name)
+    return kinds, names
+
+
+def _param_keys_by_type(plotdoc):
+    keys = {}
+    for instr in plotdoc.get("contents", {}).get("instructions", []):
+        keys.setdefault(instr.get("type"), set()).update(
+            instr.get("parameters", {}).keys()
+        )
+    return keys
+
+
+def diff_plots(path_a, path_b):
+    """Retourne un rapport texte des differences structurelles A -> B."""
+    lines = []
+    doc_a, doc_b = read_plot(path_a), read_plot(path_b)
+    kinds_a, _ = _entry_kinds(path_a)
+    kinds_b, _ = _entry_kinds(path_b)
+
+    lines.append("FICHIERS EMBARQUES (extension: A -> B)")
+    for suffix in sorted(set(kinds_a) | set(kinds_b)):
+        a, b = kinds_a.get(suffix, 0), kinds_b.get(suffix, 0)
+        marker = "  " if a == b else "->"
+        lines.append("  %s %-12s %d -> %d" % (marker, suffix, a, b))
+
+    lines.append("")
+    lines.append("CLES RACINE DU .plotdoc")
+    root_a, root_b = set(doc_a), set(doc_b)
+    for key in sorted(root_b - root_a):
+        lines.append("  + %s (nouveau dans B)" % key)
+    for key in sorted(root_a - root_b):
+        lines.append("  - %s (absent de B)" % key)
+    if root_a == root_b:
+        lines.append("  identiques")
+
+    lines.append("")
+    lines.append("TYPES D'INSTRUCTIONS ET PARAMETRES")
+    keys_a = _param_keys_by_type(doc_a)
+    keys_b = _param_keys_by_type(doc_b)
+    for itype in sorted(set(keys_a) | set(keys_b)):
+        in_a, in_b = keys_a.get(itype), keys_b.get(itype)
+        if in_a is None:
+            lines.append("  + type '%s' NOUVEAU dans B, parametres: %s"
+                         % (itype, ", ".join(sorted(in_b))))
+        elif in_b is None:
+            lines.append("  - type '%s' absent de B" % itype)
+        else:
+            new = in_b - in_a
+            gone = in_a - in_b
+            if new:
+                lines.append("  ~ type '%s': nouveaux parametres dans B: %s"
+                             % (itype, ", ".join(sorted(new))))
+            if gone:
+                lines.append("  ~ type '%s': parametres absents de B: %s"
+                             % (itype, ", ".join(sorted(gone))))
+            if not new and not gone:
+                lines.append("    type '%s': parametres identiques" % itype)
+
+    counts_a = Counter(i["type"] for i in doc_a["contents"]["instructions"])
+    counts_b = Counter(i["type"] for i in doc_b["contents"]["instructions"])
+    lines.append("")
+    lines.append("NOMBRE D'INSTRUCTIONS PAR TYPE (A -> B)")
+    for itype in sorted(set(counts_a) | set(counts_b)):
+        lines.append("  %-12s %d -> %d"
+                     % (itype, counts_a.get(itype, 0), counts_b.get(itype, 0)))
+
+    return "\n".join(lines)

plotagon_director/core/doctor.py

@@ -0,0 +1,67 @@
+"""Diagnostic d'environnement : dependances, bibliotheque, installation, TLS."""
+
+import importlib
+import sys
+
+from ..library import DATA_PATH, load_library
+
+
+def run_doctor(check_network=True):
+    """Retourne (rapport_texte, ok_global)."""
+    lines = []
+    ok = True
+
+    def check(label, passed, detail=""):
+        nonlocal ok
+        ok = ok and passed
+        lines.append("%s %-38s %s" % ("OK  " if passed else "FAIL", label, detail))
+
+    check("Python >= 3.10", sys.version_info >= (3, 10),
+          "%d.%d" % sys.version_info[:2])
+
+    for module in ("yaml", "edge_tts", "soundfile", "numpy", "truststore"):
+        try:
+            importlib.import_module(module)
+            check("module %s" % module, True)
+        except ImportError as exc:
+            check("module %s" % module, False, str(exc))
+
+    library = load_library()
+    if library:
+        check("bibliotheque (library.json)", True,
+              "%d scenes, %d personnages, %d expressions" % (
+                  len(library["scenes"]), len(library["characters"]),
+                  len(library["expressions"])))
+    else:
+        check("bibliotheque (library.json)", False,
+              "lancer: python -m plotagon_director.library.builder (%s)" % DATA_PATH)
+
+    # optionnelle: necessaire uniquement pour RECONSTRUIRE la bibliotheque
+    from ..library.builder import DEFAULT_MANIFEST
+    check("installation Plotagon (optionnelle)", True,
+          str(DEFAULT_MANIFEST) if DEFAULT_MANIFEST.exists()
+          else "non trouvee — le generateur fonctionne sans (bibliotheque embarquee)")
+
+    if check_network:
+        try:
+            import ssl
+            import socket
+            try:
+                import truststore
+                truststore.inject_into_ssl()
+            except ImportError:
+                pass
+            ctx = ssl.create_default_context()
+            with socket.create_connection(("speech.platform.bing.com", 443), timeout=6) as s:
+                with ctx.wrap_socket(s, server_hostname="speech.platform.bing.com"):
+                    pass
+            check("TLS vers Edge TTS", True)
+        except ssl.SSLCertVerificationError as exc:
+            check("TLS vers Edge TTS", False,
+                  "certificat rejete (antivirus qui intercepte ? verifier truststore): %s" % exc)
+        except OSError as exc:
+            check("TLS vers Edge TTS", False, "reseau indisponible: %s" % exc)
+
+    lines.append("")
+    lines.append("RESULT   %s" % ("PASS" if ok else "FAIL"))
+    return "\n".join(lines), ok

plotagon_director/core/plotdoc.py

@@ -0,0 +1,178 @@
+"""Construction du document .plotdoc depuis un projet YAML.
+
+Format CONFIRME le 2026-08-31 sur Plotagon Studio 1.11.0 (exports officiels).
+Voir docs/PLOT_FORMAT.md pour la specification complete.
+"""
+
+import uuid
+from datetime import datetime
+
+# Duree estimee par caractere de dialogue non synthetise, calibree sur
+# l'echantillon officiel (63 caracteres -> lengthSeconds "6755").
+MS_PER_CHAR = 107
+
+_POSITION_TEXTS = {"Left": "on screen", "Right": "on screen"}
+
+# Enum des types de camera — ordre releve dans Assembly-CSharp.dll et
+# CONFIRME par un export officiel (4="moving right", 8="wide shot").
+CAMERA_TYPES = [
+    "default",              # 0
+    "establishing shot",    # 1
+    "in dialogue mode",     # 2
+    "in interaction mode",  # 3
+    "moving right",         # 4
+    "moving left",          # 5
+    "moving forward",       # 6
+    "moving backward",      # 7
+    "wide shot",            # 8
+    "still",                # 9
+]
+
+_CAMERA_POSITION_NAMES = {"EstablishingLocation": "Establishing Spot"}
+
+
+def _camera_params(line, slot_texts):
+    """Construit le parametre camera d'une instruction dialogue."""
+    name = line["camera"]
+    camera = {"type": {"id": CAMERA_TYPES.index(name), "name": name}}
+    position = line.get("camera_position")
+    if position:
+        camera["position"] = {
+            "id": position,
+            "name": _CAMERA_POSITION_NAMES.get(position, position),
+            "useLocations": True,
+        }
+    target = line.get("camera_target")
+    if target:
+        camera["target"] = {
+            "id": target,
+            "name": slot_texts.get(target, target),
+        }
+    return camera
+
+
+def _display(asset_id):
+    return str(asset_id).split(".")[-1].capitalize()
+
+
+def _entry(asset_id, text=None):
+    return {"id": asset_id, "text": text if text is not None else _display(asset_id)}
+
+
+def _base_params():
+    return {
+        "GUID": str(uuid.uuid4()),
+        "extensiondata": True,
+        "isRecorded": False,
+        "playRecording": False,
+        "extrasEnabled": False,
+    }
+
+
+def build_plotdoc(data, library=None):
+    """Transforme un projet (dict issu de project.yaml) en dict .plotdoc.
+
+    Retourne (plotdoc, voice_jobs). voice_jobs liste les repliques a
+    synthetiser : {"guid", "text", "voice", "rate", "pitch"} — remplie quand
+    le membre du cast a un champ `voice` (id de voix Edge TTS).
+
+    library : bibliotheque (load_library()) — sert a choisir des positions
+    valides par defaut et leurs libelles, propres a chaque scene.
+    """
+    project = data.get("project", {})
+    cast = {c["ref"]: c for c in data.get("cast", [])}
+    all_positions = (library or {}).get("scene_positions", {})
+
+    instructions = []
+    voice_jobs = []
+    total_chars = 0
+
+    for scene in data.get("scenes", []):
+        params = _base_params()
+        params["scene"] = _entry(scene["scene"], scene.get("scene_name"))
+        slots = all_positions.get(scene["scene"], [])
+        slot_texts = {s["id"]: s["text"] for s in slots}
+        for i, actor in enumerate(scene.get("actors", []), start=1):
+            member = cast[actor["ref"]]
+            position = actor.get("position")
+            if not position:
+                # par defaut: i-eme slot reel de la scene, sinon Left/Right
+                if len(slots) >= i:
+                    position = slots[i - 1]["id"]
+                else:
+                    position = "Left" if i == 1 else "Right"
+            text = slot_texts.get(position) or _POSITION_TEXTS.get(
+                position, "on screen"
+            )
+            params["location%d" % i] = _entry(position, text)
+            params["actor%d" % i] = _entry(
+                member["character"], member.get("name")
+            )
+        instructions.append({"type": "scene", "parameters": params})
+
+        # musique de scene — structure relevee dans app.js (PROBABLE)
+        if scene.get("music"):
+            params = _base_params()
+            params["music"] = _entry(scene["music"], scene.get("music_name"))
+            instructions.append({"type": "music", "parameters": params})
+
+        for line in scene.get("dialogue", []):
+            member = cast[line["actor"]]
+            params = _base_params()
+
+            if line.get("action"):
+                # instruction action — CONFIRMEE par export officiel:
+                # {character, target, action} ; le texte est la phrase
+                # verbale de la bibliotheque (ex. "force chokes")
+                known = (library or {}).get("actions", {}).get(line["action"], {})
+                params["action"] = _entry(
+                    line["action"],
+                    line.get("action_name") or known.get("phrase"),
+                )
+                params["character"] = _entry(
+                    member["character"], member.get("name")
+                )
+                target_ref = line.get("target")
+                if target_ref:
+                    target = cast[target_ref]
+                    params["target"] = _entry(
+                        target["character"], target.get("name")
+                    )
+                instructions.append({"type": "action", "parameters": params})
+                continue
+
+            expression = line.get("expression", "neutral")
+            params["expression"] = _entry(expression, expression.capitalize())
+            params["text"] = {"id": "", "text": line["text"]}
+            params["character"] = _entry(member["character"], member.get("name"))
+            if line.get("camera"):
+                params["camera"] = _camera_params(line, slot_texts)
+            voice = line.get("voice") or member.get("voice")
+            if voice:
+                params["isRecorded"] = True
+                params["playRecording"] = True
+                voice_jobs.append({
+                    "guid": params["GUID"],
+                    "text": line["text"],
+                    "voice": voice,
+                    "rate": line.get("rate") or member.get("rate"),
+                    "pitch": line.get("pitch") or member.get("pitch"),
+                })
+            instructions.append({"type": "dialogue", "parameters": params})
+            total_chars += len(line["text"])
+
+    now = datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
+    plotdoc = {
+        "id": str(uuid.uuid4()),
+        "name": project.get("title", "untitled"),
+        "dateCreated": now,
+        "dateUpdated": now,
+        "thumbnail": "",
+        "lengthSeconds": str(max(1000, total_chars * MS_PER_CHAR)),
+        "voicerecordings": [j["guid"] for j in voice_jobs],
+        "contents": {
+            "selectedIndex": max(0, len(instructions) - 1),
+            "instructions": instructions,
+        },
+    }
+    return plotdoc, voice_jobs

plotagon_director/core/validator.py

@@ -0,0 +1,165 @@
+"""Validation d'un project.yaml contre la bibliotheque de ressources."""
+
+from pathlib import Path
+
+import yaml
+
+from ..library import load_library
+
+
+def load_yaml(path):
+    with open(path, "r", encoding="utf-8") as f:
+        return yaml.safe_load(f)
+
+
+def load_project(path):
+    """Charge un project.yaml, en fusionnant un eventuel `cast_file`.
+
+    `cast_file` (chemin relatif au project.yaml) permet de partager un cast
+    recurrent entre plusieurs films ; le cast local complete/precede.
+    """
+    data = load_yaml(path)
+    if isinstance(data, dict) and data.get("cast_file"):
+        extra = load_yaml(Path(path).parent / data["cast_file"]) or []
+        if isinstance(extra, dict):
+            extra = extra.get("cast", [])
+        data["cast"] = list(extra) + list(data.get("cast", []))
+    return data
+
+
+def validate_project(path):
+    data = load_project(path)
+    errors, warnings = [], []
+
+    if not isinstance(data, dict):
+        errors.append("Project root must be a mapping.")
+        return errors, warnings
+
+    library = load_library()
+    if library is None:
+        warnings.append(
+            "library.json absent: lance `python -m plotagon_director.library.builder` "
+            "pour valider contre les vraies ressources."
+        )
+
+    project = data.get("project", {})
+    cast = data.get("cast", [])
+    scenes = data.get("scenes", [])
+
+    if not project.get("title"):
+        warnings.append("Project title is missing.")
+    if not scenes:
+        errors.append("No scenes defined.")
+
+    refs = {}
+    for member in cast:
+        if not isinstance(member, dict) or not member.get("ref"):
+            errors.append("Cast member without ref.")
+            continue
+        if member["ref"] in refs:
+            errors.append("Duplicate cast ref '%s'." % member["ref"])
+        refs[member["ref"]] = member
+        character = member.get("character")
+        if not character:
+            errors.append("Cast '%s': missing character id." % member["ref"])
+        elif library and character not in library["characters"]:
+            errors.append(
+                "Cast '%s': character '%s' absent de la bibliotheque."
+                % (member["ref"], character)
+            )
+
+    for index, scene in enumerate(scenes, start=1):
+        sid = scene.get("scene", "?")
+        label = "Scene %d (%s)" % (index, sid)
+
+        if not scene.get("scene"):
+            errors.append("Scene %d: missing scene id." % index)
+        elif library and sid not in library["scenes"]:
+            errors.append("%s: scene absente de la bibliotheque." % label)
+
+        actors = scene.get("actors", [])
+        if not actors:
+            warnings.append("%s: no actors." % label)
+        if len(actors) > 2:
+            warnings.append(
+                "%s: %d acteurs — seuls 2 slots (actor1/actor2) sont CONFIRMES."
+                % (label, len(actors))
+            )
+        slots = (library or {}).get("scene_positions", {}).get(sid, [])
+        slot_ids = {s["id"] for s in slots}
+        if slots and len(actors) > len(slots):
+            warnings.append(
+                "%s: %d acteurs pour %d position(s) disponible(s)."
+                % (label, len(actors), len(slots))
+            )
+        for actor in actors:
+            if actor.get("ref") not in refs:
+                errors.append("%s: unknown actor ref '%s'." % (label, actor.get("ref")))
+            position = actor.get("position")
+            if position and slot_ids and position not in slot_ids:
+                errors.append(
+                    "%s: position '%s' inexistante (disponibles: %s)."
+                    % (label, position, ", ".join(sorted(slot_ids)))
+                )
+
+        music = scene.get("music")
+        if music and music != "music.stopmusic":
+            if library and music not in library["music"]:
+                errors.append(
+                    "%s: musique '%s' absente de la bibliotheque." % (label, music)
+                )
+
+        for line in scene.get("dialogue", []):
+            if line.get("actor") not in refs:
+                errors.append(
+                    "%s: dialogue actor '%s' is unknown." % (label, line.get("actor"))
+                )
+
+            if line.get("action"):
+                action_id = line["action"]
+                known_actions = (library or {}).get("actions", {})
+                if known_actions and action_id not in known_actions:
+                    errors.append(
+                        "%s: action '%s' absente de la bibliotheque "
+                        "(valides: %s)."
+                        % (label, action_id, ", ".join(sorted(known_actions)))
+                    )
+                target = line.get("target")
+                if target and target not in refs:
+                    errors.append(
+                        "%s: action target '%s' is unknown." % (label, target)
+                    )
+                if not target:
+                    warnings.append(
+                        "%s: action '%s' sans target — les actions sont des "
+                        "interactions a 2 personnages (observees avec target)."
+                        % (label, action_id)
+                    )
+                continue
+
+            if not line.get("text"):
+                # valide dans l'appli (mime sans parole), observe dans les
+                # exports officiels — simple avertissement
+                warnings.append("%s: dialogue sans texte (mime)." % label)
+            expression = line.get("expression", "neutral")
+            if library and expression not in library["expressions"]:
+                errors.append(
+                    "%s: expression '%s' absente de la bibliotheque."
+                    % (label, expression)
+                )
+            camera = line.get("camera")
+            if camera:
+                from .plotdoc import CAMERA_TYPES
+                if camera not in CAMERA_TYPES:
+                    errors.append(
+                        "%s: camera '%s' inconnue (valides: %s)."
+                        % (label, camera, ", ".join(CAMERA_TYPES))
+                    )
+                target = line.get("camera_target")
+                if target and slot_ids and target not in slot_ids:
+                    warnings.append(
+                        "%s: camera_target '%s' n'est pas un slot de la scene."
+                        % (label, target)
+                    )
+
+    return errors, warnings

plotagon_director/library/__init__.py

@@ -0,0 +1,14 @@
+"""Bibliotheque des ressources Plotagon (scenes, personnages, expressions...)."""
+
+import json
+from pathlib import Path
+
+DATA_PATH = Path(__file__).parent / "data" / "library.json"
+
+
+def load_library():
+    """Retourne la bibliotheque, ou None si elle n'a pas ete construite."""
+    if DATA_PATH.exists():
+        with open(DATA_PATH, encoding="utf-8") as f:
+            return json.load(f)
+    return None