run_workflow_phaeoexplorer.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import bioblend
import bioblend.galaxy.objects
import argparse
import os
import logging
import sys
import json
import time
import utilities
import speciesData

from bioblend.galaxy.objects import GalaxyInstance
from bioblend import galaxy

""" 
gga_init.py

Usage: $ python3 gga_init.py -i input_example.yml --config [config file] [OPTIONS]
"""


class RunWorkflow(speciesData.SpeciesData):
    """
    Run a workflow into the galaxy instance's history of a given species


    This script is made to work for a Phaeoexplorer-specific workflow, but can be adapted to run any workflow,
    provided the user creates their own workflow in a .ga format, and change the set_parameters function
    to have the correct parameters for their workflow (TODO: use a mapping file for parameters and the .ga file)

    """


    def set_get_history(self):
        """
        Create or set the working history to the current species one

        TODO move to utilities

        :return:
        """
        try:
            histories = self.instance.histories.get_histories(name=str(self.full_name))
            self.history_id = histories[0]["id"]
            logging.info("History for {0}: {1}".format(self.full_name, self.history_id))
        except IndexError:
            logging.info("Creating history for %s" % self.full_name)
            self.instance.histories.create_history(name=str(self.full_name))
            histories = self.instance.histories.get_histories(name=str(self.full_name))
            self.history_id = histories[0]["id"]
            logging.info("History for {0}: {1}".format(self.full_name, self.history_id))

        return self.history_id

    def get_instance_attributes(self):
        """
        retrieves instance attributes:
        - working history ID
        - libraries ID (there should only be one library!)
        - datasets IDs

        :return:
        """

        histories = self.instance.histories.get_histories(name=str(self.full_name))
        self.history_id = histories[0]["id"]

        logging.debug("History ID: " + self.history_id)
        libraries = self.instance.libraries.get_libraries()  # normally only one library

        library_id = self.instance.libraries.get_libraries()[0]["id"]  # project data folder/library
        logging.debug("Library ID: " + self.history_id)
        instance_source_data_folders = self.instance.libraries.get_folders(library_id=library_id)

        # Access folders via their absolute path
        genome_folder = self.instance.libraries.get_folders(library_id=library_id, name="/genome/" + str(self.species_folder_name) + "/v" + str(self.genome_version))
        annotation_folder = self.instance.libraries.get_folders(library_id=library_id, name="/annotation/" + str(self.species_folder_name) + "/OGS" + str(self.ogs_version))
        
        # Get their IDs
        genome_folder_id = genome_folder[0]["id"]
        annotation_folder_id = annotation_folder[0]["id"]

        # Get the content of the folders
        genome_folder_content = self.instance.folders.show_folder(folder_id=genome_folder_id, contents=True)
        annotation_folder_content = self.instance.folders.show_folder(folder_id=annotation_folder_id, contents=True)

        # Find genome folder datasets
        genome_fasta_ldda_id = genome_folder_content["folder_contents"][0]["ldda_id"]

        annotation_gff_ldda_id, annotation_proteins_ldda_id, annotation_transcripts_ldda_id = None, None, None

        # Several dicts in the annotation folder content (one dict = one file)
        for k, v in annotation_folder_content.items():
            if k == "folder_contents":
                for d in v:
                    if "proteins" in d["name"]:
                        annotation_proteins_ldda_id = d["ldda_id"]
                    if "transcripts" in d["name"]:
                        annotation_transcripts_ldda_id = d["ldda_id"]
                    if ".gff" in d["name"]:
                        annotation_gff_ldda_id = d["ldda_id"]

        self.datasets["genome_file"] = genome_fasta_ldda_id
        self.datasets["gff_file"] = annotation_gff_ldda_id
        self.datasets["proteins_file"] = annotation_proteins_ldda_id
        self.datasets["transcripts_file"] = annotation_transcripts_ldda_id

        return {"history_id": self.history_id, "library_id": library_id, "datasets": self.datasets}


    def connect_to_instance(self):
        """
        Test the connection to the galaxy instance for the current organism
        Exit if we cannot connect to the instance

        """
        self.instance = galaxy.GalaxyInstance(url=self.instance_url,
                                              email=self.config["galaxy_default_admin_email"],
                                              password=self.config["galaxy_default_admin_password"]
                                              )

        logging.info("Connecting to the galaxy instance %s" % self.instance_url)
        try:
            self.instance.histories.get_histories()
        except bioblend.ConnectionError:
            logging.critical("Cannot connect to galaxy instance %s" % self.instance_url)
            sys.exit()
        else:
            logging.info("Successfully connected to galaxy instance %s" % self.instance_url)
            return 1


    def prepare_history(self):
        """
        Galaxy instance startup in preparation for importing datasets and running a workflow
        - Add organism and analyses into the chado database
        - Get any other existing organisms IDs before updating the galaxy instance --> separate

        Calling this function is mandatory to have a working galaxy instance history

        :return:
        """

        self.connect_to_instance()
        histories = self.instance.histories.get_histories(name=str(self.full_name))

        # Add organism (species) to chado
        
        logging.info("Adding organism to the instance's chado database")
        if self.common == "" or self.common is None:
            self.instance.tools.run_tool(
                tool_id="toolshed.g2.bx.psu.edu/repos/gga/chado_organism_add_organism/organism_add_organism/2.3.3",
                history_id=self.history_id,
                tool_inputs={"abbr": self.abbreviation,
                             "genus": self.genus_uppercase,
                             "species": self.chado_species_name,
                             "common": self.abbreviation})
        else:
            self.instance.tools.run_tool(
                tool_id="toolshed.g2.bx.psu.edu/repos/gga/chado_organism_add_organism/organism_add_organism/2.3.3",
                history_id=self.history_id,
                tool_inputs={"abbr": self.abbreviation,
                             "genus": self.genus_uppercase,
                             "species": self.chado_species_name,
                             "common": self.common})

        # Add OGS analysis to chado
        logging.info("Adding OGS analysis to the instance's chado database")
        self.instance.tools.run_tool(
            tool_id="toolshed.g2.bx.psu.edu/repos/gga/chado_analysis_add_analysis/analysis_add_analysis/2.3.3",
            history_id=self.history_id,
            tool_inputs={"name": self.full_name_lowercase + " OGS" + self.ogs_version,
                         "program": "Performed by Genoscope",
                         "programversion": str(self.sex + " OGS" + self.ogs_version),
                         "sourcename": "Genoscope",
                         "date_executed": self.date})

        # Add genome analysis to chado
        logging.info("Adding genome analysis to the instance's chado database")
        self.instance.tools.run_tool(
            tool_id="toolshed.g2.bx.psu.edu/repos/gga/chado_analysis_add_analysis/analysis_add_analysis/2.3.2",
            history_id=self.history_id,
            tool_inputs={"name": self.full_name_lowercase + " genome v" + self.genome_version,
                         "program": "Performed by Genoscope",
                         "programversion": str(self.sex + "genome v" + self.genome_version),
                         "sourcename": "Genoscope",
                         "date_executed": self.date})

        # Also get the organism and analyses IDs
        self.get_organism_and_analyses_ids()

        logging.info("Finished initializing instance")


    def run_workflow(self, workflow_path, workflow_parameters, workflow_name, datamap):
        """
        Run a workflow in galaxy
        Requires the .ga file to be loaded as a dictionary (optionally could be uploaded as a raw file)

        :param workflow_name:
        :param workflow_parameters:
        :param datamap:
        :return:
        """

        logging.info("Importing workflow %s" % str(workflow_path))
        workflow_ga_file = workflow_path

        with open(workflow_ga_file, 'r') as ga_in_file:
            # Store the decoded json dictionary
            workflow_dict = json.load(ga_in_file)

            self.instance.workflows.import_workflow_dict(workflow_dict=workflow_dict)
            workflow_attributes = self.instance.workflows.get_workflows(name=workflow_name)
            workflow_id = workflow_attributes[0]["id"]  # Most recently imported workflow
            show_workflow = self.instance.workflows.show_workflow(workflow_id=workflow_id)
            try:
                logging.debug("Workflow ID: %s" % workflow_id)
                # logging.debug("Workflow information:\n%s" % str(show_workflow))
            except Exception:
                logging.warning("Error retrieving workflow attributes for workflow %s" % workflow_name)

            self.instance.workflows.invoke_workflow(workflow_id=workflow_id,
                                                    history_id=self.history_id,
                                                    params=workflow_parameters,
                                                    inputs=datamap,
                                                    inputs_by="",
                                                    allow_tool_state_corrections=True)

            logging.info("Successfully imported and invoked workflow {0}, check your galaxy instance ({1}) for the jobs state".format(workflow_name, self.instance_url))


    def get_invocation_report(self, workflow_name):
        """
        Debugging method for workflows

        Get report of a workflow invocation (execution of a workflow in the instance via the API

        :param workflow_name:
        :return:
        """

        workflow_attributes = self.instance.workflows.get_workflows(name=workflow_name)
        workflow_id = workflow_attributes[1]["id"] # Most recently imported workflow
        print("Workflow ID: %s" % workflow_id)
        invocations = self.instance.workflows.get_invocations(workflow_id=workflow_id)
        print(invocations)
        invocation_id = invocations[0]["id"]
        invocation_report = self.instance.invocations.get_invocation_report(invocation_id=invocation_id)

        logging.debug(invocation_report)


    def import_datasets_into_history(self):
        """
        Find datasets in a library, get their ID and import them into the current history if they are not already

        :return:
        """

        # Instanciate the instance 
        gio = GalaxyInstance(url=self.instance_url,
                             email=self.config["galaxy_default_admin_email"],
                             password=self.config["galaxy_default_admin_password"])

        prj_lib = gio.libraries.get_previews(name="Project Data")
        library_id = prj_lib[0].id

        instance_source_data_folders = self.instance.libraries.get_folders(library_id=str(library_id))

        folders_ids = {}
        current_folder_name = ""
        # Loop over the folders in the library and map folders names to their IDs
        for i in instance_source_data_folders:
            for k, v in i.items():
                if k == "name":
                    folders_ids[v] = 0
                    current_folder_name = v
                if k == "id":
                    folders_ids[current_folder_name] = v

        # Iterating over the folders to find datasets and map datasets to their IDs
        logging.info("Datasets IDs: ")
        for k, v in folders_ids.items():
            if k == "/genome":
                sub_folder_content = self.instance.folders.show_folder(folder_id=v, contents=True)
                final_sub_folder_content = self.instance.folders.show_folder(folder_id=sub_folder_content["folder_contents"][0]["id"], contents=True)
                for k2, v2 in final_sub_folder_content.items():
                    for e in v2:
                        if type(e) == dict:
                            if e["name"].endswith(".fa"):
                                self.datasets["genome_file"] = e["ldda_id"]
                                logging.info("\t" + e["name"] + ": " + e["ldda_id"])
            if k == "/annotation":
                sub_folder_content = self.instance.folders.show_folder(folder_id=v, contents=True)
                final_sub_folder_content = self.instance.folders.show_folder(folder_id=sub_folder_content["folder_contents"][0]["id"], contents=True)
                for k2, v2 in final_sub_folder_content.items():
                    for e in v2:
                        if type(e) == dict:
                            # TODO: manage versions? (differentiate between the correct folders using self.config)
                            if "transcripts" in e["name"]:
                                self.datasets["transcripts_file"] = e["ldda_id"]
                                logging.info("\t" + e["name"] + ": " + e["ldda_id"])
                            elif "proteins" in e["name"]:
                                self.datasets["proteins_file"] = e["ldda_id"]
                                logging.info("\t" + e["name"] + ": " + e["ldda_id"])
                            elif "gff" in e["name"]:
                                self.datasets["gff_file"] = e["ldda_id"]
                                logging.info("\t" + e["name"] + ": " + e["ldda_id"])

        logging.info("Uploading datasets into history %s" % self.history_id)
        self.instance.histories.upload_dataset_from_library(history_id=self.history_id, lib_dataset_id=self.datasets["genome_file"])
        self.instance.histories.upload_dataset_from_library(history_id=self.history_id, lib_dataset_id=self.datasets["gff_file"])
        self.instance.histories.upload_dataset_from_library(history_id=self.history_id, lib_dataset_id=self.datasets["transcripts_file"])
        self.instance.histories.upload_dataset_from_library(history_id=self.history_id, lib_dataset_id=self.datasets["proteins_file"])

        _datasets = self.instance.datasets.get_datasets()
        with open(os.path.join(self.main_dir, "datasets_ids.json"), "w") as datasets_ids_outfile:
            datasets_ids_outfile.write(str(_datasets))

        return {"history_id": self.history_id, "library_id": library_id, "datasets": self.datasets}


    def get_datasets_hda_ids(self):
        """
        Get the hda IDs of the datasets imported into an history
        The most "recent" imports will be prioritized


        As some tools will not work using the input datasets ldda IDs
        To bypass this issue, we need to retrieve the datasets imported into an history using this method


        TODO: call every tool of workflows with hda datasets ids (clearer and more robust)

        :return:
        """

        # List of all datasets in the instance (including outputs from jobs)
        # "limit" and "offset" options *may* be used to restrict search to specific datasets but since
        # there is no way to know which imported datasets are the correct ones depending on history content
        # it's not currently used
        history_datasets_li = self.instance.datasets.get_datasets()

        genome_dataset_hda_id, gff_dataset_hda_id, transcripts_dataset_hda_id, proteins_datasets_hda_id = None, None, None, None

        genome_dataset_hda_id = history_datasets_li[3]["id"]
        gff_dataset_hda_id = history_datasets_li[2]["id"]
        transcripts_dataset_hda_id = history_datasets_li[1]["id"]
        proteins_datasets_hda_id = history_datasets_li[0]["id"]

        for dataset_dict in history_datasets_li[0:3]:
            # Datasets imports should be the last jobs in history if the function calls are in correct order
            # If not, add the function call "get_datasets_hda_ids()" just after "import_datasets_into_history()"
            if dataset_dict["name"].endswith("proteins.fa"):
                proteins_datasets_hda_id = dataset_dict["id"]
                logging.debug("Proteins dataset hda ID: %s" % proteins_datasets_hda_id)
            elif dataset_dict["name"].endswith("transcripts-gff.fa"):
                transcripts_dataset_hda_id = dataset_dict["id"]
                logging.debug("Transcripts dataset hda ID: %s" % transcripts_dataset_hda_id)
            elif dataset_dict["name"].endswith(".gff"):
                gff_dataset_hda_id = dataset_dict["id"]
                logging.debug("gff dataset hda ID: %s" % gff_dataset_hda_id)
            else:
                genome_dataset_hda_id = dataset_dict["id"]
                logging.debug("Genome dataset hda id: %s" % genome_dataset_hda_id)

        # Return a dict made of the hda ids
        return{"genome_hda_id": genome_dataset_hda_id, "transcripts_hda_id": transcripts_dataset_hda_id,
               "proteins_hda_id": proteins_datasets_hda_id, "gff_hda_id": gff_dataset_hda_id}



    def get_organism_and_analyses_ids(self):
        """
        Retrieve current organism ID and OGS and genome chado analyses IDs (needed to run some tools as Tripal/Chado
        doesn't accept organism/analyses names as valid inputs

        WARNING: It is mandatory to call this function before invoking a workflow

        :return:
        """
        # Get the ID for the current organism in chado
        org = self.instance.tools.run_tool(
            tool_id="toolshed.g2.bx.psu.edu/repos/gga/chado_organism_get_organisms/organism_get_organisms/2.3.3",
            history_id=self.history_id,
            tool_inputs={"abbr": self.abbreviation,
                         "genus": self.genus_uppercase,
                         "species": self.chado_species_name,
                         "common": self.common})
        time.sleep(3)
        # Run tool again (sometimes the tool doesn't return anything despite the organism already being in the db)
        org = self.instance.tools.run_tool(
            tool_id="toolshed.g2.bx.psu.edu/repos/gga/chado_organism_get_organisms/organism_get_organisms/2.3.3",
            history_id=self.history_id,
            tool_inputs={"abbr": self.abbreviation,
                         "genus": self.genus_uppercase,
                         "species": self.chado_species_name,
                         "common": self.common})
        time.sleep(10)
        org_job_out = org["outputs"][0]["id"]
        org_json_output = self.instance.datasets.download_dataset(dataset_id=org_job_out)
        try:
            org_output = json.loads(org_json_output)[0]
            self.org_id = str(org_output["organism_id"])  # id needs to be a str to be recognized by chado tools
        except IndexError:
            logging.debug("No organism matching " + self.full_name + " exists in the instance's chado database")

        # Get the ID for the OGS analysis in chado
        ogs_analysis = self.instance.tools.run_tool(
            tool_id="toolshed.g2.bx.psu.edu/repos/gga/chado_analysis_get_analyses/analysis_get_analyses/2.3.3",
            history_id=self.history_id,
            tool_inputs={"name": self.full_name_lowercase + " OGS" + self.ogs_version})
        ogs_analysis_job_out = ogs_analysis["outputs"][0]["id"]
        ogs_analysis_json_output = self.instance.datasets.download_dataset(dataset_id=ogs_analysis_job_out)
        try:
            ogs_analysis_output = json.loads(ogs_analysis_json_output)[0]
            self.ogs_analysis_id = str(ogs_analysis_output["analysis_id"])
        except IndexError:
            logging.debug("no matching OGS analysis exists in the instance's chado database")

        # Get the ID for the genome analysis in chado
        genome_analysis = self.instance.tools.run_tool(
            tool_id="toolshed.g2.bx.psu.edu/repos/gga/chado_analysis_get_analyses/analysis_get_analyses/2.3.3",
            history_id=self.history_id,
            tool_inputs={"name": self.full_name_lowercase + " genome v" + self.genome_version})
        genome_analysis_job_out = genome_analysis["outputs"][0]["id"]
        genome_analysis_json_output = self.instance.datasets.download_dataset(dataset_id=genome_analysis_job_out)
        try:
            genome_analysis_output = json.loads(genome_analysis_json_output)[0]
            self.genome_analysis_id = str(genome_analysis_output["analysis_id"])
        except IndexError:
            logging.debug("no matching genome analysis exists in the instance's chado database")



if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Automatic data loading in containers and interaction "
                                                 "with galaxy instances for GGA"
                                                 ", following the protocol @ "
                                                 "http://gitlab.sb-roscoff.fr/abims/e-infra/gga")

    parser.add_argument("input",
                        type=str,
                        help="Input file (yml)")

    parser.add_argument("-v", "--verbose",
                        help="Increase output verbosity",
                        action="store_true")

    parser.add_argument("--config",
                        type=str,
                        help="Config path, default to the 'config' file inside the script repository")

    parser.add_argument("--main-directory",
                        type=str,
                        help="Where the stack containers will be located, defaults to working directory")

    parser.add_argument("--workflow", "-w",
                        type=str,
                        help="Worfklow to run")

    args = parser.parse_args()

    if args.verbose:
        logging.basicConfig(level=logging.DEBUG)
    else:
        logging.basicConfig(level=logging.INFO)
    logging.getLogger("urllib3").setLevel(logging.INFO)
    logging.getLogger("bioblend").setLevel(logging.INFO)

    # Parsing the config file if provided, using the default config otherwise
    if not args.config:
        args.config = os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])), "config")
    else:
        args.config = os.path.abspath(args.config)

    if not args.main_directory:
        args.main_directory = os.getcwd()
    else:
        args.main_directory = os.path.abspath(args.main_directory)

    sp_dict_list = utilities.parse_input(args.input)

    for sp_dict in sp_dict_list:

        # Creating an instance of the RunWorkflow object for the current organism
        run_workflow_for_current_organism = RunWorkflow(parameters_dictionary=sp_dict)

        #  Checking if user specified a workflow to run
        if not args.workflow:
            logging.critical("No workflow specified, exiting")
            sys.exit()
        else:
            workflow = os.path.abspath(args.workflow)

        # Verifying the galaxy container is running
        if utilities.check_galaxy_state(genus_lowercase=run_workflow_for_current_organism.genus_lowercase,
                                        species=run_workflow_for_current_organism.species,
                                        script_dir=run_workflow_for_current_organism.script_dir):

            # Starting
            logging.info("run_workflow.py called for %s" % run_workflow_for_current_organism.full_name)

            # Setting some of the instance attributes
            run_workflow_for_current_organism.main_dir = args.main_directory
            run_workflow_for_current_organism.species_dir = os.path.join(run_workflow_for_current_organism.main_dir,
                                                                         run_workflow_for_current_organism.genus_species +
                                                                         "/")

            # Parse the config yaml file
            run_workflow_for_current_organism.config = utilities.parse_config(args.config)
            # Set the instance url attribute
            for env_variable, value in run_workflow_for_current_organism.config.items():
                if env_variable == "hostname":
                    run_workflow_for_current_organism.instance_url = "http://{0}:8888/sp/{1}/galaxy/".format(
                        value, run_workflow_for_current_organism.genus_species)
                    break
                else:
                    run_workflow_for_current_organism.instance_url = "http://localhost:8888/sp/{0}_{1}/galaxy/".format(
                        run_workflow_for_current_organism.genus_lowercase,
                        run_workflow_for_current_organism.species)

            # TODO: Create distinct methods to call different pre-set workflows using CL arguments/config options (i.e load-chado, jbrowse, functional-annotation, orthology, ...)

            # If input workflow is Chado_load_Tripal_synchronize.ga
            if "Chado_load_Tripal_synchronize" in str(workflow):

                logging.info("Executing workflow 'Chado_load_Tripal_synchronize'")

                run_workflow_for_current_organism.connect_to_instance()
                run_workflow_for_current_organism.set_get_history()
                # run_workflow_for_current_organism.get_species_history_id()

                # Prepare the instance+history for the current organism (add organism and analyses in Chado) TODO: add argument "setup"
                # (although it should pose no problem as the "Chado add" refuses to duplicate an analysis/organism anyway)
                # run_workflow_for_current_organism.prepare_history()

                # Get the attributes of the instance and project data files
                run_workflow_for_current_organism.get_instance_attributes()
                run_workflow_for_current_organism.get_organism_and_analyses_ids()

                # Import datasets into history
                # TODO: it seems it is not required anymore since using "ldda" option for datasets in the workflow datamap doesn't need files from history
                run_workflow_for_current_organism.import_datasets_into_history()
                run_workflow_for_current_organism.get_datasets_hda_ids()

                # Explicit workflow parameter names
                GENOME_FASTA_FILE = "0"
                GFF_FILE = "1"
                PROTEINS_FASTA_FILE = "2"
                TRANSCRIPTS_FASTA_FILE = "3"

                LOAD_FASTA_IN_CHADO = "4"
                LOAD_GFF_IN_CHADO = "5"
                SYNC_ORGANISM_INTO_TRIPAL = "6"
                SYNC_GENOME_ANALYSIS_INTO_TRIPAL = "7"
                SYNC_OGS_ANALYSIS_INTO_TRIPAL = "8"
                SYNC_FEATURES_INTO_TRIPAL = "9"

                workflow_parameters = {}

                workflow_parameters[GENOME_FASTA_FILE] = {}
                workflow_parameters[GFF_FILE] = {}
                workflow_parameters[PROTEINS_FASTA_FILE] = {}
                workflow_parameters[TRANSCRIPTS_FASTA_FILE] = {}
                workflow_parameters[LOAD_FASTA_IN_CHADO] = {"organism": run_workflow_for_current_organism.org_id,
                                                            "analysis_id": run_workflow_for_current_organism.genome_analysis_id,
                                                            "do_update": "true"}
                # Change "do_update": "true" to "do_update": "false" in above parameters to prevent appending/updates to the fasta file in chado
                # WARNING: It is safer to never update it and just change the genome/ogs versions in the config
                workflow_parameters[LOAD_GFF_IN_CHADO] = {"organism": run_workflow_for_current_organism.org_id,
                                                          "analysis_id": run_workflow_for_current_organism.ogs_analysis_id}
                workflow_parameters[SYNC_ORGANISM_INTO_TRIPAL] = {"organism_id": run_workflow_for_current_organism.org_id}
                workflow_parameters[SYNC_GENOME_ANALYSIS_INTO_TRIPAL] = {"analysis_id": run_workflow_for_current_organism.ogs_analysis_id}
                workflow_parameters[SYNC_OGS_ANALYSIS_INTO_TRIPAL] = {"analysis_id": run_workflow_for_current_organism.genome_analysis_id}
                workflow_parameters[SYNC_FEATURES_INTO_TRIPAL] = {"organism_id": run_workflow_for_current_organism.org_id}

                # Datamap for input datasets - dataset source (type): ldda (LibraryDatasetDatasetAssociation)
                run_workflow_for_current_organism.datamap = {}
                run_workflow_for_current_organism.datamap[GENOME_FASTA_FILE] = {"src": "ldda", "id": run_workflow_for_current_organism.datasets["genome_file"]}
                run_workflow_for_current_organism.datamap[GFF_FILE] = {"src": "ldda", "id": run_workflow_for_current_organism.datasets["gff_file"]}
                run_workflow_for_current_organism.datamap[PROTEINS_FASTA_FILE] = {"src": "ldda", "id": run_workflow_for_current_organism.datasets["proteins_file"]}
                run_workflow_for_current_organism.datamap[TRANSCRIPTS_FASTA_FILE] = {"src": "ldda", "id": run_workflow_for_current_organism.datasets["transcripts_file"]}

                run_workflow_for_current_organism.datamap = {}
                run_workflow_for_current_organism.datamap[GENOME_FASTA_FILE] = {"src": "ldda", "id":
                    run_workflow_for_current_organism.datasets["genome_file"]}
                run_workflow_for_current_organism.datamap[GFF_FILE] = {"src": "ldda",
                                                                       "id": run_workflow_for_current_organism.datasets[
                                                                           "gff_file"]}

                # Run the Chado load Tripal sync workflow with the parameters set above
                run_workflow_for_current_organism.run_workflow(workflow_path=workflow,
                                                               workflow_parameters=workflow_parameters,
                                                               datamap=run_workflow_for_current_organism.datamap,
                                                               workflow_name="Chado load Tripal synchronize")


            # Jbrowse creation workflow
            elif "Jbrowse" in str(workflow):

                logging.info("Executing workflow 'Jbrowse'")

                run_workflow_for_current_organism.connect_to_instance()
                run_workflow_for_current_organism.set_get_history()
                run_workflow_for_current_organism.get_instance_attributes()
                run_workflow_for_current_organism.get_organism_and_analyses_ids()
                run_workflow_for_current_organism.import_datasets_into_history()
                hda_ids = run_workflow_for_current_organism.get_datasets_hda_ids()  # Note: always call this function AFTER calling "import_datasets_into_history()"

                # Debugging
                # run_workflow_for_current_organism.get_invocation_report(workflow_name="Jbrowse")

                GENOME_FASTA_FILE = "0"
                GFF_FILE = "1"
                ADD_JBROWSE = "2"
                ADD_ORGANISM_TO_JBROWSE = "3"

                workflow_parameters = {}

                workflow_parameters[GENOME_FASTA_FILE] = {}
                workflow_parameters[GFF_FILE] = {}
                # Jbrowse custom feature url
                workflow_parameters[ADD_JBROWSE] = {"jb_menu": {"menu_url": "http://{hostname}:{port}/sp/{genus_sp}/feature/{Genus}/{species}/{id}".format(hostname=run_workflow_for_current_organism.config["hostname"],
                                                                                                                                                           port=run_workflow_for_current_organism.config["http_port"],
                                                                                                                                                           genus_sp=run_workflow_for_current_organism.genus_species,
                                                                                                                                                           Genus=run_workflow_for_current_organism.genus_uppercase,
                                                                                                                                                           species=run_workflow_for_current_organism.species,
                                                                                                                                                           id="id")}}
                # Organism to add to the Jbrowse "container" (consists of a name and an id, not tied to the galaxy instance or chado/tripal names and ids)
                workflow_parameters[ADD_ORGANISM_TO_JBROWSE] = {"name": [{"name": run_workflow_for_current_organism.full_name,
                                                               "unique_id": run_workflow_for_current_organism.abbreviation}]}

                run_workflow_for_current_organism.datamap = {}
                run_workflow_for_current_organism.datamap[GENOME_FASTA_FILE] = {"src": "hda", "id": hda_ids["genome_hda_id"]}
                run_workflow_for_current_organism.datamap[GFF_FILE] = {"src": "hda", "id": hda_ids["gff_hda_id"]}



                # Run the jbrowse creation workflow
                run_workflow_for_current_organism.run_workflow(workflow_path=workflow,
                                                               workflow_parameters=workflow_parameters,
                                                               datamap=run_workflow_for_current_organism.datamap,
                                                               workflow_name="Jbrowse")




        else:
            logging.critical("The galaxy container for %s is not ready yet!" % run_workflow_for_current_organism.full_name)
            sys.exit()