utils

def bake_gizmos_recursively(in_group=None):
    """Converting a gizmo to group

    Arguments:
        in_group (Optional[nuke.Node]): group node or all nodes
    """
    from .lib import maintained_selection
    if in_group is None:
        in_group = nuke.Root()
    # preserve selection after all is done
    with maintained_selection():
        # jump to the group
        with in_group:
            for node in nuke.allNodes():
                if is_node_gizmo(node) and not gizmo_is_nuke_default(node):
                    with node:
                        outputs = get_node_outputs(node)
                        group = node.makeGroup()
                        # Reconnect inputs and outputs if any
                        if outputs:
                            for n, pipes in outputs.items():
                                for i in pipes:
                                    n.setInput(i, group)
                        for i in range(node.inputs()):
                            group.setInput(i, node.input(i))
                        # set node position and name
                        group.setXYpos(node.xpos(), node.ypos())
                        name = node.name()
                        nuke.delete(node)
                        group.setName(name)
                        node = group

                if node.Class() == "Group":
                    bake_gizmos_recursively(node)

def get_node_outputs(node):
    """
    Return a dictionary of the nodes and pipes that are connected to node
    """
    dep_dict = {}
    dependencies = node.dependent(nuke.INPUTS | nuke.HIDDEN_INPUTS)
    for d in dependencies:
        dep_dict[d] = []
        for i in range(d.inputs()):
            if d.input(i) == node:
                dep_dict[d].append(i)
    return dep_dict

def gizmo_is_nuke_default(gizmo) -> bool:
    """Check if gizmo is in default install path"""
    plug_dir = os.path.join(os.path.dirname(
        nuke.env['ExecutablePath']), 'plugins')
    return gizmo.filename().startswith(plug_dir)

def is_node_gizmo(node) -> bool:
    """Return True if the node is a gizmo."""
    return 'gizmo_file' in node.knobs()

def render_single_frame(group_node: nuke.Node) -> None:
    """Render a single frame for the given group node.

    Args:
        group_node (nuke.Node): The group node containing the write
        node to render.
    """
    write_node = nuke.allNodes("Write", group=group_node)[0]
    frame = int(write_node["first"].value())
    nuke.execute(write_node.fullName(), frame, frame)

def set_context_favorites(favorites=None):
    """Adding favorite folders to nuke's browser

    Arguments:
        favorites (dict): couples of {name:path}
    """
    favorites = favorites or {}
    icon_path = resources.get_resource("icons", "folder-favorite.png")
    for name, path in favorites.items():
        nuke.addFavoriteDir(
            name,
            path,
            nuke.IMAGE | nuke.SCRIPT | nuke.GEO,
            icon=icon_path)