pipeline

def containerise(track_item,
                 name,
                 namespace,
                 context,
                 loader=None,
                 data=None):
    """Bundle Hiero's object into an assembly and imprint it with metadata

    Containerisation enables a tracking of version, author and origin
    for loaded assets.

    Arguments:
        track_item (hiero.core.TrackItem): object to imprint as container
        name (str): Name of resulting assembly
        namespace (str): Namespace under which to host container
        context (dict): Asset information
        loader (str, optional): Name of node used to produce this container.

    Returns:
        track_item (hiero.core.TrackItem): containerised object

    """

    data_imprint = OrderedDict({
        "schema": "ayon:container-3.0",
        "id": AYON_CONTAINER_ID,
        "name": str(name),
        "namespace": str(namespace),
        "loader": str(loader),
        "representation": context["representation"]["id"],
    })

    if data:
        for k, v in data.items():
            data_imprint.update({k: v})

    log.debug("_ data_imprint: {}".format(data_imprint))
    lib.set_trackitem_ayon_tag(track_item, data_imprint)

    return track_item

def launch_workfiles_app(*args):
    ''' Wrapping function for workfiles launcher '''
    from .lib import get_main_window

    main_window = get_main_window()
    # show workfile gui
    host_tools.show_workfiles(parent=main_window)

def ls():
    """List available containers.

    This function is used by the Container Manager in Nuke. You'll
    need to implement a for-loop that then *yields* one Container at
    a time.

    See the `container.json` schema for details on how it should look,
    and the Maya equivalent, which is in `avalon.maya.pipeline`
    """

    # get all track items from current timeline
    all_items = lib.get_track_items()

    # append all video tracks
    for track in (lib.get_current_sequence() or []):
        if type(track) is not hiero.core.VideoTrack:
            continue
        all_items.append(track)

    for item in all_items:
        container_data = parse_container(item)

        if isinstance(container_data, list):
            for _c in container_data:
                yield _c
        elif container_data:
            yield container_data

@contextlib.contextmanager
def maintained_selection():
    """Maintain selection during context

    Example:
        >>> with maintained_selection():
        ...     for track_item in track_items:
        ...         < do some stuff >
    """
    from .lib import (
        set_selected_track_items,
        get_selected_track_items
    )
    previous_selection = get_selected_track_items()
    reset_selection()
    try:
        # do the operation
        yield
    finally:
        reset_selection()
        set_selected_track_items(previous_selection)

def parse_container(item, validate=True):
    """Return container data from track_item's pype tag.

    Args:
        item (hiero.core.TrackItem or hiero.core.VideoTrack):
            A containerised track item.
        validate (bool)[optional]: validating with avalon scheme

    Returns:
        dict: The container schema data for input containerized track item.

    """
    def data_to_container(item, data):
        if (
            not data
            or data.get("id") not in {
                AYON_CONTAINER_ID, AVALON_CONTAINER_ID
            }
        ):
            return

        if validate and data and data.get("schema"):
            schema.validate(data)

        if not isinstance(data, dict):
            return

        # If not all required data return the empty container
        required = ['schema', 'id', 'name',
                    'namespace', 'loader', 'representation']

        if any(key not in data for key in required):
            return

        container = {key: data[key] for key in required}

        container["objectName"] = item.name()

        # Store reference to the node object
        container["_item"] = item

        return container

    # convert tag metadata to normal keys names
    if type(item) is hiero.core.VideoTrack:
        return_list = []
        _data = lib.get_track_ayon_data(item)

        if not _data:
            return
        # convert the data to list and validate them
        for _, obj_data in _data.items():
            container = data_to_container(item, obj_data)
            return_list.append(container)
        return return_list
    else:
        _data = lib.get_trackitem_ayon_data(item)
        return data_to_container(item, _data)

def publish(parent):
    """Shorthand to publish from within host"""
    return host_tools.show_publish(parent)

def reload_config():
    """Attempt to reload pipeline at run-time.

    CAUTION: This is primarily for development and debugging purposes.

    """
    import importlib

    for module in (
        "ayon_hiero.lib",
        "ayon_hiero.menu",
        "ayon_hiero.tags"
    ):
        log.info("Reloading module: {}...".format(module))
        try:
            module = importlib.import_module(module)
            import imp
            imp.reload(module)
        except Exception as e:
            log.warning("Cannot reload module: {}".format(e))
            importlib.reload(module)

def reset_selection():
    """Deselect all selected nodes
    """
    from .lib import set_selected_track_items
    set_selected_track_items([])

def update_container(item, data=None):
    """Update container data to input track_item or track's
    AYON tag.

    Args:
        item (hiero.core.TrackItem or hiero.core.VideoTrack):
            A containerised track item.
        data (dict)[optional]: dictionery with data to be updated

    Returns:
        bool: True if container was updated correctly

    """

    data = data or {}
    data = deepcopy(data)

    if type(item) is hiero.core.VideoTrack:
        # form object data for test
        object_name = data["objectName"]

        # get all available containers
        containers = lib.get_track_ayon_data(item)
        container = lib.get_track_ayon_data(item, object_name)

        containers = deepcopy(containers)
        container = deepcopy(container)

        # update data in container
        updated_container = _update_container_data(container, data)
        # merge updated container back to containers
        containers.update({object_name: updated_container})

        return bool(lib.set_track_ayon_tag(item, containers))
    else:
        container = lib.get_trackitem_ayon_data(item)
        updated_container = _update_container_data(container, data)

        log.info("Updating container: `{}`".format(item.name()))
        return bool(lib.set_trackitem_ayon_tag(item, updated_container))