How to use the translators.assethandlers.AssetType.SHADER_ASSET function in translators

def process_path(self, filename, asset_type, sub_texture=False):
        archive_asset = bpy.path.abspath(filename)

        if '%' in archive_asset:
            archive_asset = self._convert_frame_number(archive_asset)

        if asset_type == AssetType.SHADER_ASSET:
            dir_name, file_name = os.path.split(archive_asset)
            self._searchpaths.append(dir_name)
            archive_asset = os.path.splitext(file_name)[0]

        if asset_type == AssetType.TEXTURE_ASSET and sub_texture:
            base_filename = os.path.splitext(archive_asset)[0]
            archive_asset = f"{base_filename}.tx"

        if asset_type == AssetType.ARCHIVE_ASSET:
            archive_dir, archive = os.path.split(archive_asset)
            self._searchpaths.append(archive_dir)
            archive_asset = archive

        return archive_asset

def _set_shadergroup(self):
        as_lamp_data = self.bl_lamp.data.appleseed

        self.__as_area_lamp_shadergroup.clear()

        shader_dir_path = self.__find_shader_dir()
        shader_path = self._asset_handler.process_path(
            os.path.join(shader_dir_path, "as_blender_areaLight.oso"),
            AssetType.SHADER_ASSET)

        surface_path = self._asset_handler.process_path(
            os.path.join(shader_dir_path, "as_closure2surface.oso"),
            AssetType.SHADER_ASSET)

        lamp_color = " ".join(map(str, as_lamp_data.area_color))

        lamp_params = {'in_color': f"color {lamp_color}",
                       'in_intensity': f"float {as_lamp_data.area_intensity}",
                       'in_intensity_scale': f"float {as_lamp_data.area_intensity_scale}",
                       'in_exposure': f"float {as_lamp_data.area_exposure}",
                       'in_normalize': f"int {as_lamp_data.area_normalize}"}

        self.__as_area_lamp_shadergroup.add_shader("shader", shader_path, "asAreaLight", lamp_params)
        self.__as_area_lamp_shadergroup.add_shader("surface", surface_path, "asClosure2Surface", {})
        self.__as_area_lamp_shadergroup.add_connection("asAreaLight", "out_output", "asClosure2Surface", "in_input")

def _set_shadergroup(self):
        as_lamp_data = self.bl_lamp.data.appleseed

        self.__as_area_lamp_shadergroup.clear()

        shader_dir_path = self.__find_shader_dir()
        shader_path = self._asset_handler.process_path(
            os.path.join(shader_dir_path, "as_blender_areaLight.oso"),
            AssetType.SHADER_ASSET)

        surface_path = self._asset_handler.process_path(
            os.path.join(shader_dir_path, "as_closure2surface.oso"),
            AssetType.SHADER_ASSET)

        lamp_color = " ".join(map(str, as_lamp_data.area_color))

        lamp_params = {'in_color': f"color {lamp_color}",
                       'in_intensity': f"float {as_lamp_data.area_intensity}",
                       'in_intensity_scale': f"float {as_lamp_data.area_intensity_scale}",
                       'in_exposure': f"float {as_lamp_data.area_exposure}",
                       'in_normalize': f"int {as_lamp_data.area_normalize}"}

        self.__as_area_lamp_shadergroup.add_shader("shader", shader_path, "asAreaLight", lamp_params)
        self.__as_area_lamp_shadergroup.add_shader("surface", surface_path, "asClosure2Surface", {})
        self.__as_area_lamp_shadergroup.add_connection("asAreaLight", "out_output", "asClosure2Surface", "in_input")

break

        if surface_shader is None:
            logger.debug("No surface shader for %s", self.__shader_group.get_name())
            return

        self.__shader_group.clear()

        for shader in self.__shader_list:
            parameters = {}
            parameter_types = shader.parameter_types
            shader_keys = dir(shader)

            self.__parse_parameters(parameter_types, parameters, scene, shader, shader_keys)

            shader_file_name = self.asset_handler.process_path(shader.file_name, AssetType.SHADER_ASSET)
            self.__shader_group.add_shader("shader", shader_file_name, shader.name, parameters)

            self.__create_shader_connections(shader)

        surface_shader_file = self.asset_handler.process_path(surface_shader.file_name, AssetType.SHADER_ASSET)

        self.__shader_group.add_shader("surface", surface_shader_file, surface_shader.name, {})

def _set_shadergroup(self):
        as_lamp_data = self.bl_lamp.data.appleseed

        shader_name = f"{self.appleseed_name}_tree"

        shader_group = asr.ShaderGroup(shader_name)

        shader_dir_path = self._find_shader_dir()
        shader_path = self.asset_handler.process_path(os.path.join(shader_dir_path, "as_blender_areaLight.oso"), AssetType.SHADER_ASSET)
        surface_path = self.asset_handler.process_path(os.path.join(shader_dir_path, "as_closure2surface.oso"), AssetType.SHADER_ASSET)

        lamp_color = " ".join(map(str, as_lamp_data.area_color))

        lamp_params = {'in_color': f"color {lamp_color}",
                       'in_intensity': f"float {as_lamp_data.area_intensity}",
                       'in_intensity_scale': f"float {as_lamp_data.area_intensity_scale}",
                       'in_exposure': f"float {as_lamp_data.area_exposure}",
                       'in_normalize': f"int {as_lamp_data.area_normalize}"}

        shader_group.add_shader("shader", shader_path, "asAreaLight", lamp_params)
        shader_group.add_shader("surface", surface_path, "asClosure2Surface", {})
        shader_group.add_connection("asAreaLight", "out_output", "asClosure2Surface", "in_input")

        self._as_area_lamp_shadergroup = shader_group

def _set_shadergroup(self):
        as_lamp_data = self.bl_lamp.data.appleseed

        shader_name = f"{self.appleseed_name}_tree"

        shader_group = asr.ShaderGroup(shader_name)

        shader_dir_path = self._find_shader_dir()
        shader_path = self.asset_handler.process_path(os.path.join(shader_dir_path, "as_blender_areaLight.oso"), AssetType.SHADER_ASSET)
        surface_path = self.asset_handler.process_path(os.path.join(shader_dir_path, "as_closure2surface.oso"), AssetType.SHADER_ASSET)

        lamp_color = " ".join(map(str, as_lamp_data.area_color))

        lamp_params = {'in_color': f"color {lamp_color}",
                       'in_intensity': f"float {as_lamp_data.area_intensity}",
                       'in_intensity_scale': f"float {as_lamp_data.area_intensity_scale}",
                       'in_exposure': f"float {as_lamp_data.area_exposure}",
                       'in_normalize': f"int {as_lamp_data.area_normalize}"}

        shader_group.add_shader("shader", shader_path, "asAreaLight", lamp_params)
        shader_group.add_shader("surface", surface_path, "asClosure2Surface", {})
        shader_group.add_connection("asAreaLight", "out_output", "asClosure2Surface", "in_input")

        self._as_area_lamp_shadergroup = shader_group

parameter_value = self._asset_handler.process_path(
                                parameter_value.filepath,
                                AssetType.TEXTURE_ASSET, sub_texture)

                        if parameter_type == "int checkbox":
                            parameter_type = "int"
                            parameter_value = int(parameter_value)
                        elif parameter_type in ('color', 'vector', 'normal', 'point', 'float[2]'):
                            parameter_value = " ".join(map(str, parameter_value))
                            if parameter_type == 'float[2]':
                                parameter_type = 'float[]'

                        parameters[key] = parameter_type + " " + str(parameter_value)
                
                if node.node_type == 'osl':
                    shader_file_name = self._asset_handler.process_path(node.file_name, AssetType.SHADER_ASSET)
                    logger.debug(f"appleseed: Adding {node.name} shader to {self.__mat_name} node tree")
                    self.__as_shader_group.add_shader("shader", shader_file_name, node.name, parameters)
                elif node.node_type == 'osl_script':
                    script = node.script
                    osl_path = bpy.path.abspath(script.filepath, library=script.library)
                    if script.is_in_memory or script.is_dirty or script.is_modified or not os.path.exists(osl_path):
                        source_code = script.as_string()
                    else:
                        code = open(osl_path, 'r')
                        source_code = code.read()
                        code.close()
                    logger.debug(f"appleseed: Adding {node.name} source shader to {self.__mat_name} node tree")
                    self.__as_shader_group.add_source_shader("shader", node.bl_idname, node.name, source_code, parameters)
                
                for output in node.outputs:
                    if output.is_linked:

def __create_material(self, as_lamp_data, lamp_data):
        shader_name = self.bl_lamp.name + "_tree"
        if self.__lamp_shader_group is None:
            self.__lamp_shader_group = asr.ShaderGroup(shader_name)
        lamp_params = {'in_color': "color {0}".format(" ".join(map(str, as_lamp_data.area_color))),
                       'in_intensity': "float {0}".format(as_lamp_data.area_intensity),
                       'in_intensity_scale': "float {0}".format(as_lamp_data.area_intensity_scale),
                       'in_exposure': "float {0}".format(as_lamp_data.area_exposure),
                       'in_normalize': "int {0}".format(as_lamp_data.area_normalize)}
        self.__lamp_shader_group.clear()

        shader_dir_path = self.__find_shader_dir()
        shader_path = self.asset_handler.process_path(os.path.join(shader_dir_path, "as_blender_areaLight.oso"), AssetType.SHADER_ASSET)
        surface_path = self.asset_handler.process_path(os.path.join(shader_dir_path, "as_closure2surface.oso"), AssetType.SHADER_ASSET)

        self.__lamp_shader_group.add_shader("shader", shader_path, "asAreaLight", lamp_params)
        self.__lamp_shader_group.add_shader("surface", surface_path, "asClosure2Surface", {})
        self.__lamp_shader_group.add_connection("asAreaLight", "out_output", "asClosure2Surface", "in_input")
        # Emit are lamp material and surface shader.
        self.__edf_mat = asr.Material('osl_material', lamp_data.name + "_mat", {'osl_surface': shader_name})

self.__shader_group.clear()

        for shader in self.__shader_list:
            parameters = {}
            parameter_types = shader.parameter_types
            shader_keys = dir(shader)

            self.__parse_parameters(parameter_types, parameters, scene, shader, shader_keys)

            shader_file_name = self.asset_handler.process_path(shader.file_name, AssetType.SHADER_ASSET)
            self.__shader_group.add_shader("shader", shader_file_name, shader.name, parameters)

            self.__create_shader_connections(shader)

        surface_shader_file = self.asset_handler.process_path(surface_shader.file_name, AssetType.SHADER_ASSET)

        self.__shader_group.add_shader("surface", surface_shader_file, surface_shader.name, {})