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

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

import utilities
import speciesData

""" 
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

    """

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

        :return:
        """
        try:
            histories = self.instance.histories.get_histories(name=str(self.genus_species))
            self.history_id = histories[0]["id"]
            logging.debug("History ID set 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.genus_species))
            self.history_id = histories[0]["id"]
            logging.debug("History ID set 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:
        """

        self.set_get_history()

        logging.debug("History ID: %s" % 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: %s" % self.library_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"]

        # Minimum datasets to populate tripal views --> will not work if these files are not assigned in the input file
        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

        """

        logging.debug("Connecting to the galaxy instance (%s)" % self.instance_url)
        self.instance = galaxy.GalaxyInstance(url=self.instance_url,
                                              email=self.config["galaxy_default_admin_email"],
                                              password=self.config["galaxy_default_admin_password"]
                                              )
        self.instance.histories.get_histories()

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



    def return_instance(self):


        return self.instance
        


    def install_changesets_revisions_for_individual_tools(self):
        """
        This function is used to verify that installed tools called outside workflows have the correct versions and changesets
        If it finds versions don't match, will install the correct version + changeset in the instance
        Doesn't do anything if versions match
        
        :return:
        """

        self.connect_to_instance()

        logging.info("Validating installed individual tools versions and changesets")

        # Verify that the add_organism and add_analysis versions are correct in the toolshed
        add_organism_tool = self.instance.tools.show_tool("toolshed.g2.bx.psu.edu/repos/gga/chado_organism_add_organism/organism_add_organism/2.3.4+galaxy0")
        add_analysis_tool = self.instance.tools.show_tool("toolshed.g2.bx.psu.edu/repos/gga/chado_analysis_add_analysis/analysis_add_analysis/2.3.4+galaxy0")
        get_organism_tool = self.instance.tools.show_tool("toolshed.g2.bx.psu.edu/repos/gga/chado_organism_get_organisms/organism_get_organisms/2.3.4+galaxy0")
        get_analysis_tool = self.instance.tools.show_tool("toolshed.g2.bx.psu.edu/repos/gga/chado_analysis_get_analyses/analysis_get_analyses/2.3.4+galaxy0")

        # changeset for 2.3.4+galaxy0 has to be manually found because there is no way to get the wanted changeset of a non installed tool via bioblend 
        # except for workflows (.ga) that already contain the changeset revisions inside the steps ids
        
        if get_organism_tool["version"] != "2.3.4+galaxy0":
            toolshed_dict = get_organism_tool["tool_shed_repository"]
            logging.warning("Changeset for %s is not installed" % toolshed_dict["name"])
            changeset_revision = "831229e6cda2"
            name = toolshed_dict["name"]
            owner = toolshed_dict["owner"]
            toolshed = "https://" + toolshed_dict["tool_shed"]
            logging.warning("Installing changeset revision {0} for {1}".format(changeset_revision, name))

            self.instance.toolshed.install_repository_revision(tool_shed_url=toolshed, name=name, owner=owner, 
                                                               changeset_revision=changeset_revision,
                                                               install_tool_dependencies=True,
                                                               install_repository_dependencies=False,
                                                               install_resolver_dependencies=True)

        if get_analysis_tool["version"] != "2.3.4+galaxy0":
            toolshed_dict = changeset_revision["tool_shed_repository"]
            logging.warning("Changeset for %s is not installed" % toolshed_dict["name"])
            changeset_revision = "a867923f555e"
            name = toolshed_dict["name"]
            owner = toolshed_dict["owner"]
            toolshed = "https://" + toolshed_dict["tool_shed"]
            logging.warning("Installing changeset revision {0} for {1}".format(changeset_revision, name))

            self.instance.toolshed.install_repository_revision(tool_shed_url=toolshed, name=name, owner=owner, 
                                                               changeset_revision=changeset_revision,
                                                               install_tool_dependencies=True,
                                                               install_repository_dependencies=False,
                                                               install_resolver_dependencies=True)

        if add_organism_tool["version"] != "2.3.4+galaxy0":
            toolshed_dict = add_organism_tool["tool_shed_repository"]
            logging.warning("Changeset for %s is not installed" % toolshed_dict["name"])
            changeset_revision = "1f12b9650028"
            name = toolshed_dict["name"]
            owner = toolshed_dict["owner"]