pipeline

def before_save(event):
    """Check and set up project before saving workfile
    """
    max_filename_before: str = rt.maxFileName
    max_filename_after: str = event.get("filename")

    if not max_filename_before:
        # Saving from a new unsaved file, no need to check for changes.
        return

    if not max_filename_after:
        # The event carries no filename, nothing to compare against.
        return

    if max_filename_before != max_filename_after:
        print(f"Detected scene name change from {max_filename_before} to "
              f"{max_filename_after}")
    max_filename_before = os.path.splitext(max_filename_before)[0]
    max_filename_after = os.path.splitext(max_filename_after)[0]
    lib.reset_render_outputs(max_filename_before, max_filename_after)

def containerise_texture(name: str, context: dict,
                         view_node, sme_view_number,
                         namespace=None, loader=None,
                         suffix="_CON"):
    """Containerise texture nodes

    Args:
        name (str): name of the container
        context (dict): context
        view_node: texture node
        sme_view: target view of slate material editor
        namespace (str, optional): namespace. Defaults to None.
        loader (str, optional): loader. Defaults to None.
        suffix (str, optional): suffix. Defaults to "_CON".

    Returns:
        container: The container object holding the texture node metadata.
    """
    data = {
        "schema": "ayon:container-3.0",
        "id": AYON_CONTAINER_ID,
        "name": name,
        "namespace": namespace or "",
        "loader": loader,
        "representation": context["representation"]["id"],
        "project_name": context["project"]["name"],
        "view_node": view_node,
        "sme_view_number": sme_view_number,
    }
    if namespace:
        container_name = f"{namespace}:{name}{suffix}"
    else:
        container_name = f"{name}{suffix}"
    container = rt.container(name=container_name)
    if not lib.imprint(container_name, data):
        raise RuntimeError(f"imprinting of {container_name} failed.")
    return container

def get_containers() -> List:
    """Get all container nodes in the scene.

    Returns:
        list : list of container nodes in the scene
    """
    return [
        obj for obj in rt.objects
        if rt.getUserProp(obj, "id") in {
            AYON_CONTAINER_ID, AVALON_CONTAINER_ID
        }
    ]

def get_previous_loaded_object(container: str):
    """Get previous loaded_object through the AYON Data

    Args:
        container (str): the container which stores the AYON Data

    Returns:
        node_list(list): list of nodes which are previously loaded
    """
    node_list = []
    container_modifier = container.modifiers[0]
    ayon_data = lib.get_ayon_data(container_modifier)
    node_transform_monitor_list = rt.getProperty(ayon_data, "all_handles")
    for node_transform_monitor in node_transform_monitor_list:
        node_list.append(node_transform_monitor.node)
    return node_list

def import_custom_attribute_data(container: str, selections: list):
    """Importing the AYON custom parameter built by the creator

    Args:
        container (str): target container which adds custom attributes
        selections (list): nodes to be added into
        group in custom attributes
    """
    attrs = load_custom_attribute_data()
    modifier = rt.EmptyModifier()
    rt.addModifier(container, modifier)
    container.modifiers[0].name = "AYON Data"
    rt.custAttributes.add(container.modifiers[0], attrs)
    node_list = []
    sel_list = []
    for i in selections:
        node_ref = rt.NodeTransformMonitor(node=i)
        node_list.append(node_ref)
        sel_list.append(str(i))

    # Setting the property
    rt.setProperty(
        container.modifiers[0].AYONData,
        "all_handles", node_list)
    rt.setProperty(
        container.modifiers[0].AYONData,
        "sel_list", sel_list)

def load_custom_attribute_data():
    """Re-loading the AYON custom parameter built by the creator

    Returns:
        attribute: re-loading the custom OP attributes set in Maxscript
    """
    return rt.Execute(MS_CUSTOM_ATTRIB)

def ls() -> Generator[dict, None, None]:
    """Get all AYON containers."""
    containers = get_containers()
    for container in sorted(containers, key=attrgetter("name")):
        yield parse_container(container)

def on_after_open():
    """Check and set up unit scale after opening workfile if user enabled.
    """
    lib.validate_unit_scale()

def on_before_open():
    """Check and set up project before opening workfile
    """
    _set_project()

def on_init() -> None:
    """Callback for initialization event."""
    if lib.is_headless():
        return

    if not os.path.exists(rt.ColorPipelineMgr.OCIOConfigPath):
        lib.reset_colorspace()
    last_workfile = os.getenv("AYON_LAST_WORKFILE")
    if (
        os.getenv("AVALON_OPEN_LAST_WORKFILE") != "1"
        or not last_workfile
        or not os.path.exists(last_workfile)
    ):
        from .workfile_template_builder import trigger_on_app_launch
        trigger_on_app_launch()

        lib.set_context_settings()

def on_new() -> None:
    """Callback for new scene event."""
    if lib.is_headless():
        return
    from .workfile_template_builder import trigger_on_new_file
    trigger_on_new_file()
    lib.set_context_settings()

def parse_container(container):
    """Return the container node's full container data.

    Args:
        container (str): A container node name.

    Returns:
        dict: The container schema data for this container node.

    """
    data = lib.read(container)

    # Backwards compatibility pre-schemas for containers
    data["schema"] = data.get("schema", "ayon:container-3.0")

    # Append transient data
    data["objectName"] = container.Name
    return data

def remove_container_data(container_node: str):
    """Function to remove container data after updating, switching or deleting it.

    Args:
        container_node (str): container node
    """
    if not rt.isProperty(container_node, "modifiers"):
        rt.Delete(container_node)
        rt.redrawViews()
        return

    container_node_modifier = container_node.modifiers[0]
    if container_node_modifier.name in {"OP Data", "AYON Data"}:
        ayon_data = lib.get_ayon_data(container_node_modifier)
        all_set_members_names = [
            member.node for member in ayon_data.all_handles
        ]
        if not all_set_members_names:
            rt.deleteModifier(container_node, container_node.modifiers[0])
            rt.Delete(container_node)
            rt.redrawViews()
            return
        # clean up the children of alembic dummy objects
        for current_set_member in all_set_members_names:
            shape_list = [
                members for members in current_set_member
                if rt.ClassOf(members) == rt.AlembicObject
                or rt.isValidNode(members)
            ]
            if shape_list:  # noqa
                rt.Delete(shape_list)
            rt.Delete(current_set_member)
        rt.deleteModifier(container_node, container_node.modifiers[0])

    rt.Delete(container_node)
    rt.redrawViews()

def update_custom_attribute_data(container: str, selections: list):
    """Updating the AYON custom parameter built by the creator

    Args:
        container (str): target container which adds custom attributes
        selections (list): nodes to be added into
        group in custom attributes
    """
    if container.modifiers[0].name in {"OP Data", "AYON Data"}:
        rt.deleteModifier(container, container.modifiers[0])
    import_custom_attribute_data(container, selections)