Source code for cgl.plugins.otio.tools.aaf.aaf_extract_publish_shots


import opentimelineio as otio

from cgl.core.path.object import PathObject

from cgl.plugins.otio.tools.aaf import aaf_media_linker
from cgl.plugins.otio.tools.aaf.aaf_extract_shots import flatten_item
from cgl.plugins.otio.tools.aaf import otio_duration_fix



[docs]
def get_path_object_from_metadata(item):
    metadata = dict(item.metadata.get("cgl", {}))
    required_keys = [
        'entity_type',
        'company',
        'project',
        'sequence',
        'shot',
        'task',
        'variant',
        'user',
        'major_version',
        'minor_version',
    ]

    major_version = None
    minor_version = None

    for key in required_keys:
        if key not in metadata:
            return None
        if metadata[key] is None:
            return None

        if key in ('major_version', 'minor_version'):
            metadata[key] = f"{metadata[key]:03d}"
            if key == 'major_version':
                major_version = metadata[key]
            else:
                minor_version = metadata[key]

    metadata['version'] = f"{major_version}.{minor_version}"
    metadata['tree'] = 'render'

    po = PathObject.from_dict(metadata)
    return po





[docs]
def is_shot(item):
    if get_path_object_from_metadata(item):
        return True
    return False





[docs]
def simplify_timeline(aaf_path):
    aaf_media_linker.register_media_linker()
    otio_duration_fix.otio_file_fixups(aaf_path)
    timeline = otio.adapters.read_from_file(aaf_path, media_linker_name="aaf_media_linker")

    new_timeline = otio.schema.Timeline()
    new_timeline.global_start_time = timeline.global_start_time

    for track in timeline.video_tracks():
        new_track = otio.schema.Track(kind=track.kind)
        new_timeline.tracks.append(new_track)

        for item in track:

            flat = None
            if isinstance(item, (otio.schema.Transition, otio.schema.Gap, otio.schema.Clip)):
                flat = [item]
            else:
                flat = flatten_item(item)
                if flat.source_range:
                    flat = otio.algorithms.track_trimmed_to_range(flat, flat.source_range)

            for thing in flat:
                if isinstance(thing, (otio.schema.Transition, otio.schema.Gap)):
                    new_track.append(thing.deepcopy())
                    continue

                po = get_path_object_from_metadata(thing)
                if po:
                    new_item = thing.deepcopy()
                    new_track.append(new_item)
                else:
                    gap = otio.schema.Gap(name=thing.name,
                                          source_range=thing.source_range,
                                          metadata=thing.metadata)
                    new_track.append(gap)

    return new_timeline





[docs]
def convert_timeline(aaf_path, otio_path):
    aaf_media_linker.register_media_linker()
    timeline = otio.adapters.read_from_file(aaf_path, media_linker_name="aaf_media_linker")

    otio.adapters.write_to_file(timeline, otio_path)



if __name__ == "__main__":
    # src = sys.argv[1]
    # dst = sys.argv[2]
    # convert_timeline(src, dst)
    src = "Z:/prod/premise/render/ASJ/shots/280/0000/amc/default/publish/003.000/high/280_For_Testing_turnover_asj.aaf"
    src = "Z:/prod/premise/render/AlchemyTestB/shots/280/0000/amc/default/publish/004.000/high/280_For_Testing_turnover.aaf"
    otio_path = "Z:/EDITORIAL/simple.otio"
    timeline = simplify_timeline(src)
    otio.adapters.write_to_file(timeline, otio_path)