PYQGIS Processing Script - Add custom action to output layer

Here is an example of setting multiple layer post processors to loaded output layers, adding custom actions to the layers which will load 2 different styles (one for point layers & one for line layers) to each layer.

By the way, it is not recommended to manually load layers to the project in the processAlgorithm() method of a processing algorithm. Instead, you should add them to the temporary layer store, then add them as layers to load on completion to the algorithms context object. The example below shows how to do that.

from qgis.PyQt.QtCore import QCoreApplication, QVariant

from qgis.PyQt.QtWidgets import QAction

from qgis.core import (QgsField, QgsProcessing, QgsProcessingAlgorithm,
                        QgsDataProvider, QgsProcessingParameterFileDestination,
                        QgsVectorLayer, QgsProcessingContext, QgsMapLayerType,
                        QgsProcessingLayerPostProcessorInterface,
                        Qgis)
                        
from qgis.utils import iface

import processing
                       
class AddLayerActions(QgsProcessingAlgorithm):
    OUTPUT = 'OUTPUT'
    
    # Empty dictionary to store the post processor class instances associated with each output layer id
    post_processors = {}
 
    def __init__(self):
        super().__init__()
 
    def name(self):
        return "addactions"
     
    def tr(self, text):
        return QCoreApplication.translate("addactions", text)
         
    def displayName(self):
        return self.tr("Add Actions")
 
    def group(self):
        return self.tr("Examples")
 
    def groupId(self):
        return "examples"
 
    def shortHelpString(self):
        return self.tr("Adds menu actions to a layer")
 
    def helpUrl(self):
        return "https://qgis.org"
         
    def createInstance(self):
        return type(self)()
   
    def initAlgorithm(self, config=None):
        self.addParameter(QgsProcessingParameterFileDestination(self.OUTPUT, 'Save Output Layer', fileFilter='GeoPackage (*.gpkg *GPKG)'))
 
    def processAlgorithm(self, parameters, context, feedback):
        layer_1 = QgsVectorLayer("Point?crs=epsg:4326", "Layer_1", "memory")
        layer_2 = QgsVectorLayer("Linestring?crs=epsg:4326", "Layer_2", "memory")
        layer_1.dataProvider().addAttributes([
            QgsField("Field_1", QVariant.String),
            QgsField("Field_2", QVariant.String)
            ])
        layer_1.updateFields()
        layer_2.dataProvider().addAttributes([
        QgsField("Field_1", QVariant.String),
        QgsField("Field_2", QVariant.String)
        ])
        layer_2.updateFields()

        params = {'LAYERS': [layer_1, layer_2],
            'OUTPUT': parameters[self.OUTPUT],
            'OVERWRITE': False,
            'SAVE_STYLES': False,
            'SAVE_METADATA': True,
            'SELECTED_FEATURES_ONLY': False}
        output_geopackage = processing.run("native:package", params, is_child_algorithm=True)
        
        fileName = output_geopackage['OUTPUT']
        layer = QgsVectorLayer(fileName, "test", "ogr")
        subLayers = layer.dataProvider().subLayers()

        for subLayer in subLayers:
            name = subLayer.split(QgsDataProvider.SUBLAYER_SEPARATOR)[1]
            uri = f"{fileName}|layername={name}"
            # Create layer
            sub_vlayer = QgsVectorLayer(uri, name, 'ogr')
            feedback.pushInfo(f'{sub_vlayer.isValid()}')
            if sub_vlayer.isValid():
                # Add output layers to temporary layer store and add
                # layer to load on completion to context object
                context.temporaryLayerStore().addMapLayer(sub_vlayer)
                context.addLayerToLoadOnCompletion(sub_vlayer.id(), QgsProcessingContext.LayerDetails(name,
                                                                                        context.project(),
                                                                                        name))
                # Create post processor class instance and add to dictionary
                pp = AddLayerAction.create()
                self.post_processors[sub_vlayer.id()] = pp
            # If layer will be loaded on completion, set its post processor
            if context.willLoadLayerOnCompletion(sub_vlayer.id()):
                context.layerToLoadOnCompletionDetails(sub_vlayer.id()).setPostProcessor(self.post_processors[sub_vlayer.id()])
 
        return {self.OUTPUT: layer.id()}
        

class AddLayerAction(QgsProcessingLayerPostProcessorInterface):

    instance = None
    
    def load_style_1(self, layer):
        if layer.geometryType() == Qgis.GeometryType.Point:
            layer.loadNamedStyle('path/to/point_style_1.qml')
        elif layer.geometryType() == Qgis.GeometryType.Line:
            layer.loadNamedStyle('path/to/line_style_1.qml')
        layer.triggerRepaint()
        
    def load_style_2(self, layer):
        if layer.geometryType() == Qgis.GeometryType.Point:
            layer.loadNamedStyle('path/to/point_style_2.qml')
        elif layer.geometryType() == Qgis.GeometryType.Line:
            layer.loadNamedStyle('path/to/line_style_2.qml')
        layer.triggerRepaint()

    def postProcessLayer(self, layer, context, feedback):
        # Reorder layers so that the point layer is always on top
        project = context.project()
        root_group = project.layerTreeRoot()
        if layer.geometryType() == Qgis.GeometryType.Point:
            lyr_node = root_group.findLayer(layer.id())
            if lyr_node:
                node_clone = lyr_node.clone()
                root_group.insertChildNode(0, node_clone)
                lyr_node.parent().removeChildNode(lyr_node)
        elif layer.geometryType() == Qgis.GeometryType.Line:
            lyr_node = root_group.findLayer(layer.id())
            if lyr_node:
                node_clone = lyr_node.clone()
                root_group.insertChildNode(1, node_clone)
                lyr_node.parent().removeChildNode(lyr_node)
        
        # Create & add the custom layer actions
        self.act1 = QAction("Load Style 1")
        self.act2 = QAction("Load Style 2")

        self.act1.triggered.connect(lambda: self.load_style_1(layer))
        self.act2.triggered.connect(lambda: self.load_style_2(layer))

        iface.addCustomActionForLayerType(self.act1, 'Load Style', QgsMapLayerType.VectorLayer, False)
        iface.addCustomActionForLayerType(self.act2, 'Load Style', QgsMapLayerType.VectorLayer, False)
        
        iface.addCustomActionForLayer(self.act1, layer)
        iface.addCustomActionForLayer(self.act2, layer)

    @staticmethod
    def create() -> 'AddLayerAction':
        AddLayerAction.instance = AddLayerAction()
        return AddLayerAction.instance

Screencast showing result:

Acknowledgements:

The section of code to read the sub-layers from the output geopackage is from the PyQGIS Cheat sheet.

The post processor stuff is based on an old example from Nyall Dawson, which I have been using and sharing for a while now. There are other ways to do it but this has worked well for me.