This started as a class assignment, but it ended up being much more fun than a normal homework.

The original task was to build a short promotional video in Premiere Pro, use MOGRT templates for animated text, and then create a localized version through automation instead of manually rebuilding every text layer. On paper, that sounds fairly straightforward. In practice, it opened up a much more interesting question: how much of a Premiere project can we treat as structured, localizable content rather than just a closed visual asset?

For my version, I created a promotional video for a "Fingerstyle Guitar Night" event and used a small Python tool to extract translatable text from the .prproj file, edit it externally, and apply the updated content back into a new project file. I used several Motion Graphics templates, including a main title, a subtitle card, two lower-third style text overlays, an information screen, and a closing subscription screen. I chose these templates because they provided clean animated text treatments, fit the tone of a music promo, and were much easier to edit and localize than more decorative designs.

One of the main challenges in the process was making sure the text displayed correctly inside the templates. Some text treatments were clearly designed with English in mind, so I had to adjust font choice, sizing, and spacing to make the Chinese text fit naturally on screen. That also made one limitation of the workflow very clear: automation can handle text extraction and replacement, but it cannot automatically solve font compatibility, text overflow, or layout balance. Human review is still necessary before final delivery.

Even so, compared with manually recreating every animated text layer for another language, this workflow is much more efficient. It saves time, reduces repetitive work, and makes it much easier to scale the same video across multiple locales. I can easily see the real-world value of this kind of automation in multilingual event promos, social media campaigns, and marketing videos that need to be adapted quickly without rebuilding everything from scratch.

"""    
Supports decompressing/recompressing project files and extracting,
replacing, and translating text content within them.
"""

import sys
import os

from lib.compression import decompress_prproj, compress_prproj, verify_prproj
from lib.text import list_texts, replace_text, extract_for_translation, apply_translation


def cmd_decompress(args):
    input_file = args[0]
    output_file = args[1] if len(args) > 1 else input_file.replace('.prproj', '.xml')

    xml_bytes = decompress_prproj(input_file, output_file)
    print(f"Decompressed: {input_file} -> {output_file}")
    print(f"XML size: {len(xml_bytes):,} bytes")


def cmd_compress(args):
    input_file = args[0]
    output_file = args[1] if len(args) > 1 else input_file.replace('.xml', '.prproj')

    with open(input_file, 'rb') as f:
        xml_content = f.read()

    compress_prproj(xml_content, output_file)
    print(f"Compressed: {input_file} -> {output_file}")
    print(f"Original size: {len(xml_content):,} bytes")
    print(f"Compressed size: {os.path.getsize(output_file):,} bytes")


def cmd_verify(args):
    info = verify_prproj(args[0])

    print(f"File: {info['file']}")
    valid_str = 'valid' if info['magic_valid'] else 'INVALID'
    print(f"  Magic: {info['magic'].hex()} ({valid_str})")
    print(f"  Method: {info['method']} ({info['method_name']})")
    print(f"  Flags: {info['flags']}")
    print(f"  OS byte: {info['os_byte']} (0x{info['os_byte']:02x})")

    if info['success']:
        print(f"  Decompression: SUCCESS ({info['decompressed_size']:,} bytes)")
        xml_str = 'Valid' if info['has_xml_declaration'] else 'Missing XML declaration'
        print(f"  XML structure: {xml_str}")
    else:
        print(f"  Decompression: FAILED - {info['error']}")


def cmd_list(args):
    list_texts(args[0])


def cmd_extract(args):
    extract_for_translation(args[0], args[1])


def cmd_apply(args):
    apply_translation(args[0], args[1], args[2])


def cmd_replace(args):
    prproj = args[0]
    output = args[1]
    old_text = args[2]
    new_text = args[3]
    replace_text(prproj, output, {old_text: new_text})


COMMANDS = {
    'decompress': (cmd_decompress, 1, 'decompress input.prproj [output.xml]'),
    'compress':   (cmd_compress,   1, 'compress input.xml [output.prproj]'),
    'verify':     (cmd_verify,     1, 'verify file.prproj'),
    'list':       (cmd_list,       1, 'list input.prproj'),
    'extract':    (cmd_extract,    2, 'extract input.prproj texts.json'),
    'apply':      (cmd_apply,      3, 'apply input.prproj texts.json output.prproj'),
    'replace':    (cmd_replace,    4, "replace input.prproj output.prproj 'old text' 'new text'"),
}


if __name__ == '__main__':
    if len(sys.argv) < 2 or sys.argv[1] not in COMMANDS:
        print("PyPremiere_L10n - Adobe Premiere Pro .prproj tool\n")
        print("Usage:")
        for name, (_, _, usage) in COMMANDS.items():
            print(f"  python pypremiere_tool.py {usage}")
        sys.exit(1)

    command = sys.argv[1]
    handler, min_args, usage = COMMANDS[command]
    args = sys.argv[2:]

    if len(args) < min_args:
        print(f"Usage: python pypremiere_tool.py {usage}")
        sys.exit(1)

    handler(args)