def METHOD_NAME(
    script_attributes_context: ScriptAttributesContext,
) -> dict[str, Callable]:
    """This makes a dictionary of lambda functions that are closed over the class instance that they represent.
    This is passed into PythonScriptParser as a list of helper functions that are
    available for running.  In general, they maintain the do_task call structure that they had, but
    they always return a value rather than updating the task data.
    We may be able to remove the task for each of these calls if we are not using it other than potentially
    updating the task data.
    """
    def make_closure(
        subclass: type[Script],
        script_attributes_context: ScriptAttributesContext,
    ) -> Callable:
        """Yes - this is black magic.
        Essentially, we want to build a list of all of the submodules (i.e. email, user_data_get, etc)
        and a function that is assocated with them.
        This basically creates an Instance of the class and returns a function that calls do_task
        on the instance of that class.
        the next for x in range, then grabs the name of the module and associates it with the function
        that we created.
        """
        instance = subclass()
        def check_script_permission() -> None:
            if subclass.requires_privileged_permissions():
                script_function_name = get_script_function_name(subclass)
                uri = f"/can-run-privileged-script/{script_function_name}"
                process_instance = ProcessInstanceModel.query.filter_by(
                    id=script_attributes_context.process_instance_id
                ).first()
                if process_instance is None:
                    raise ProcessInstanceNotFoundError(
                        "Could not find a process instance with id"
                        f" '{script_attributes_context.process_instance_id}' when"
                        f" running script '{script_function_name}'"
                    )
                user = process_instance.process_initiator
                has_permission = AuthorizationService.user_has_permission(
                    user=user, permission="create", target_uri=uri
                )
                if not has_permission:
                    raise ScriptUnauthorizedForUserError(
                        f"User {user.username} does not have access to run"
                        f" privileged script '{script_function_name}'"
                    )
        def run_script_if_allowed(*ar: Any, **kw: Any) -> Any:
            check_script_permission()
            return subclass.run(
                instance,
                script_attributes_context,
                *ar,
                **kw,
            )
        return run_script_if_allowed
    def get_script_function_name(subclass: type[Script]) -> str:
        return subclass.__module__.split(".")[-1]
    execlist = {}
    subclasses = Script.get_all_subclasses()
    for x in range(len(subclasses)):
        subclass = subclasses[x]
        execlist[get_script_function_name(subclass)] = make_closure(
            subclass, script_attributes_context=script_attributes_context
        )
    return execlist