pipeline

def containerise(
        name: str, namespace: str,
        context: dict, loader: object,
        options: dict | None = None) -> None:
    """Imprint a loaded container with metadata.

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

    Arguments:
        name (str): Name of resulting assembly
        namespace (str): Namespace under which to host container
        context (dict): Asset information
        loader (load.LoaderPlugin): loader instance used to produce container.
        options (dict): options

    """
    data = {
        "schema": "ayon:container-3.0",
        "id": AYON_CONTAINER_ID,
        "name": str(name),
        "namespace": str(namespace) if namespace else None,
        "loader": str(loader.__class__.__name__),
        "representation": context["representation"]["id"],
        "project_name": context["project"]["name"],
        "objectName": name,
    }
    if options:
        fabric_index = options.get("fabricIndex")
        data["fabricIndex"] = fabric_index
        data["objectName"] = f"{name}_fabric_{fabric_index}"
    else:
        data["objectName"] = name
    # save the main_data in a temp folder
    container_data = ls() or []
    container_data.append(data)
    set_metadata(AYON_CONTAINERS, container_data)

def get_ayon_metadata() -> dict:
    """Get AYON relevant metadata from current file.

    Returns:
        dict: AYON metadata as a dictionary.
    """
    # need to convert string to dict
    metadata_str = utility_api.GetMetaDataForCurrentGarment()
    return json.loads(metadata_str)

def get_current_workfile() -> str:
    """Get the current file path from the host.

    Returns:
        str: The current workfile path.
    """
    host = registered_host()
    return host.get_current_workfile()

def get_instances() -> dict:
    """Retrieve all stored instances from the project settings.

    Returns:
        dict: Dictionary of stored instances from the project settings.
    """
    ayon_metadata = get_ayon_metadata()
    return ayon_metadata.get(AYON_INSTANCES, {})

def get_instances_values() -> list:
    """Retrieve all stored instances from the project settings.

    Returns:
        list: List of all instance values from the project settings.
    """
    ayon_instances = get_instances()
    return list(ayon_instances.values())

def imprint(object_name: str, data: dict) -> None:
    """Imprint metadata onto an object in the scene.

    Args:
        object_name (str): Name of the object to imprint metadata on.
        data (dict): Metadata to imprint.
    """
    # Retrieve existing containers
    container_data = ls()
    # Find the container for the specified object
    for container in container_data:
        if container.get("objectName") == object_name:
            container.update(data)
            break
    else:
        log.warning(
            "No container found for object %s to imprint data.", object_name
        )
        return
    # Update the metadata
    set_metadata(AYON_CONTAINERS, container_data)

def ls() -> list:
    """List all AYON containers in the current file metadata.

    Returns:
        list: List of AYON container metadata dictionaries.
    """
    ayon_metadata = get_ayon_metadata() or {}
    return ayon_metadata.get(AYON_CONTAINERS, [])

def open_workfile(filepath: str) -> None:
    """Open a workfile from the specified file path."""
    import_options = ApiTypes.ImportZPRJOption()
    import_api.ImportZprj(filepath, import_options)

def remove_container_data(object_name: str) -> None:
    """Remove container data for a specific object in the scene.

    Args:
        object_name (str): Name of the object whose container data is to
            be removed.
    """
    container_data = ls()
    # Filter out the container for the specified object
    updated_containers = [
        container for container in container_data
        if container.get("objectName") != object_name
    ]
    # Update the metadata
    set_metadata(AYON_CONTAINERS, updated_containers)

def remove_instance(instance_id: str) -> None:
    """Helper method to remove the data for a specific container."""
    instances = get_instances()
    instances.pop(instance_id, None)
    set_metadata(AYON_INSTANCES, instances)

def save_workfile(filepath: str) -> None:
    """Save the current workfile to the specified file path."""
    export_api.ExportZPrj(filepath)
    open_workfile(filepath)

def set_instance(
    instance_id: str, instance_data: dict, *, update: bool = False) -> None:
    """Set a single instance into the current file metadata."""
    set_instances({instance_id: instance_data}, update=update)

def set_instances(instance_data_by_id: dict, *, update: bool = False) -> None:
    """Set multiple instances into the current file metadata.

    Args:
        instance_data_by_id (dict): instance data mapped by their IDs
        update (bool, optional): Whether to update existing instances.
        Defaults to False.
    """
    instances = get_instances()
    for instance_id, instance_data in instance_data_by_id.items():
        if update:
            existing_data = instances.get(instance_id, {})
            existing_data.update(instance_data)
        else:
            instances[instance_id] = instance_data

    set_metadata(AYON_INSTANCES, instances)

def set_metadata(data_type: str, data: Union[dict, list]) -> None:
    """Set instance data into the current file metadata."""
    ayon_metadata = get_ayon_metadata()
    ayon_metadata[data_type] = data
    # Serialize with optional formatting
    json_to_str_data = f"{json.dumps(ayon_metadata)}"
    utility_api.SetMetaDataForCurrentGarment(json_to_str_data)