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 products.

    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): Context information
        loader (str, optional): Name of node used to produce this container.

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

    """

    data_imprint = OrderedDict({
        "schema": CONTAINER_SCHEMA,
        "id": AYON_CONTAINER_ID,
        "name": str(name),
        "namespace": str(namespace),
        "loader": str(loader),
        "representation": context["representation"]["id"],
        "project_name": context["project"]["name"]
    })

    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 Hiero. 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.
    """

    # 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

    # get container from tags
    tag_bin = tags.get_workfile_bin()
    if not tag_bin:
        return

    for tag_item in tag_bin.items():
        tag_data = tags.get_tag_data(tag_item)
        if tag_data.get("schema") == CONTAINER_SCHEMA:
            yield tag_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 AYON tag.

    Data of containers loaded with OpenPype are converted to AYON container
    data. The conversion is stored to the item on container update.

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

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

    """
    def data_to_container(item, data):
        data = _convert_legacy_container_data(data)
        if (
            not isinstance(data, dict)
            or data.get("id") != AYON_CONTAINER_ID
        ):
            return

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

        # 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}
        if "project_name" in data:
            container["project_name"] = data["project_name"]

        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.values():
            container = data_to_container(item, obj_data)
            if container:
                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.

    Containers loaded with OpenPype are stored as AYON containers.

    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 {}

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

        # get all available containers
        containers = {
            name: _convert_legacy_container_data(container)
            for name, container in (
                lib.get_track_ayon_data(item) or {}
            ).items()
        }

        # merge updated container back to containers
        containers[object_name] = _update_container_data(
            containers.get(object_name), data
        )

        return bool(lib.set_track_ayon_tag(item, containers))
    else:
        container = _convert_legacy_container_data(
            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))