# HG changeset patch
# User yating-l
# Date 1508275685 14400
# Node ID bc00f5c4c59e51cd7d2869d7e0332f5232f1a9ff
planemo upload for repository https://github.com/Yating-L/jbrowse-archive-creator.git
diff -r 000000000000 -r bc00f5c4c59e apollo/ApolloInstance.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/apollo/ApolloInstance.py Tue Oct 17 17:28:05 2017 -0400
@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+import os
+import json
+import shutil
+import tempfile
+import logging
+from util import subtools
+from mako.lookup import TemplateLookup
+
+
+class ApolloInstance(object):
+ def __init__(self, apollo_host, tool_directory, user_email):
+ self.apollo_host = apollo_host
+ self.tool_directory = tool_directory
+ self.default_user = user_email
+ self.logger = logging.getLogger(__name__)
+ self.apolloTemplate = self._getApolloTemplate()
+ self._arrow_init()
+
+ #TODO: Encode password
+ def _arrow_init(self):
+ arrow_config = tempfile.NamedTemporaryFile(bufsize=0)
+ with open(arrow_config.name, 'w') as conf:
+ htmlMakoRendered = self.apolloTemplate.render(
+ apollo_host = self.apollo_host,
+ admin_user = self.default_user,
+ admin_pw = '1234'
+ )
+ conf.write(htmlMakoRendered)
+
+ home_dir = os.path.expanduser('~')
+ arrow_config_dir = os.path.join(home_dir, '.apollo-arrow.yml')
+ shutil.copyfile(arrow_config.name, arrow_config_dir)
+ self.logger.debug("Initated arrow: apollo-arrow.yml= %s", arrow_config_dir)
+
+
+ def _getApolloTemplate(self):
+ mylookup = TemplateLookup(directories=[os.path.join(self.tool_directory, 'templates')],
+ output_encoding='utf-8', encoding_errors='replace')
+ apolloTemplate = mylookup.get_template("apollo-arrow.yml")
+ return apolloTemplate
+
+ def getHost(self):
+ return self.apollo_host
+
+ def createApolloUser(self, apollo_user, admin=None):
+ p = subtools.arrow_create_user(apollo_user.user_email, apollo_user.firstname, apollo_user.lastname, apollo_user.password, admin)
+ user_info = json.loads(p)
+ user_id = user_info.get('userId')
+ if not user_id:
+ self.logger.debug("Cannot create new user: %s; The user may already exist", apollo_user.user_email)
+ user_id = subtools.arrow_get_users(apollo_user.user_email)
+ self.logger.debug("Got user_id for new or existing user: user_id = %s", str(user_id))
+ return user_id
+
+ def grantPermission(self, user_id, organism_id, **user_permissions):
+ subtools.arrow_update_organism_permissions(user_id, organism_id, **user_permissions)
+ self.logger.debug("Grant user %s permissions to organism %s, permissions = %s", str(user_id), str(organism_id), ','.join(user_permissions))
+
+ def addOrganism(self, organism_name, organism_dir):
+ p = subtools.arrow_add_organism(organism_name, organism_dir)
+ organism = json.loads(p)
+ organism_id = organism['id']
+ self.logger.debug("Added new organism to Apollo instance, %s", p)
+ return organism_id
+
+ def loadHubToApollo(self, apollo_user, organism_name, organism_dir, admin_user=False, **user_permissions):
+ user_id = self.createApolloUser(apollo_user, admin_user)
+ organism_id = self.addOrganism(organism_name, organism_dir)
+ self.grantPermission(user_id, organism_id, **user_permissions)
+ self.logger.debug("Successfully load the hub to Apollo")
\ No newline at end of file
diff -r 000000000000 -r bc00f5c4c59e apollo/ApolloInstance.pyc
Binary file apollo/ApolloInstance.pyc has changed
diff -r 000000000000 -r bc00f5c4c59e apollo/ApolloUser.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/apollo/ApolloUser.py Tue Oct 17 17:28:05 2017 -0400
@@ -0,0 +1,10 @@
+#!/usr/bin/python
+
+import os
+
+class ApolloUser(object):
+ def __init__(self, user_email, firstname, lastname, password):
+ self.user_email = user_email
+ self.firstname = firstname
+ self.lastname = lastname
+ self.password = password
diff -r 000000000000 -r bc00f5c4c59e apollo/ApolloUser.pyc
Binary file apollo/ApolloUser.pyc has changed
diff -r 000000000000 -r bc00f5c4c59e apollo/__init__.py
diff -r 000000000000 -r bc00f5c4c59e apollo/__init__.pyc
Binary file apollo/__init__.pyc has changed
diff -r 000000000000 -r bc00f5c4c59e jbrowsehubToApollo.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jbrowsehubToApollo.py Tue Oct 17 17:28:05 2017 -0400
@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+import os
+import sys
+import argparse
+import json
+import logging
+import collections
+from apollo.ApolloInstance import ApolloInstance
+from util.Reader import Reader
+
+
+def main(argv):
+ parser = argparse.ArgumentParser(description='Upload a hub to display on Apollo.')
+ parser.add_argument('-j', '--data_json', help='JSON file containing the metadata of the inputs')
+ parser.add_argument('-o', '--output', help='HTML output')
+
+ #parser.add_argument('-e', '--extra_file_path', help='Extra file path for generated jbrowse hub')
+ #parser.add_argument('-d', '--jbrowsehub', help='Name of the HTML summarizing the content of the JBrowse Hub Archive')
+
+ # Get the args passed in parameter
+ args = parser.parse_args()
+ json_inputs_data = args.data_json
+ outputFile = args.output
+ #outputFile = args.jbrowsehub
+
+
+ ##Parse JSON file with Reader
+ reader = Reader(json_inputs_data)
+
+ # Begin init variables
+ extra_files_path = reader.getExtFilesPath()
+ user_email = reader.getUserEmail()
+ genome_name = reader.getGenomeName()
+ species_name = reader.getSpeciesName()
+ apollo_host = reader.getApolloHost()
+ apollo_user = reader.getApolloUser()
+ toolDirectory = reader.getToolDir()
+ jbrowse_hub = reader.getJBrowseHubDir()
+
+ logging.info("#### JBrowseArchiveCreator: Start to upload JBrowse Hub to Apollo instance: %s #### ", apollo_host)
+
+ # Set up apollo
+ apollo = ApolloInstance(apollo_host, toolDirectory, user_email)
+ jbrowse_hub_dir = _getHubDir(jbrowse_hub, extra_files_path, genome_name)
+ apollo.loadHubToApollo(apollo_user, species_name, jbrowse_hub_dir, admin=True)
+ outHtml(outputFile, apollo_host, species_name)
+
+ logging.info('#### JBrowseArchiveCreator: Congratulation! JBrowse Hub is uploaded! ####\n')
+
+def _getHubDir(outputFile, extra_files_path, genome_name):
+ file_dir = os.path.abspath(outputFile)
+ source_dir = os.path.dirname(file_dir)
+ output_folder_name = os.path.basename(extra_files_path)
+ jbrowse_hub_dir = os.path.join(source_dir, output_folder_name, 'myHub', genome_name)
+ return jbrowse_hub_dir
+
+def outHtml(outputFile, host_name, species_name):
+ with open(outputFile, 'w') as htmlfile:
+ htmlstr = 'The new Organism "%s" is created on Apollo:
' % species_name
+ jbrowse_hub = 'View JBrowse Hub on Apollo' % host_name
+ htmlstr += jbrowse_hub
+ htmlfile.write(htmlstr)
+
+if __name__ == "__main__":
+ main(sys.argv)
\ No newline at end of file
diff -r 000000000000 -r bc00f5c4c59e jbrowsehubToApollo.xml
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jbrowsehubToApollo.xml Tue Oct 17 17:28:05 2017 -0400
@@ -0,0 +1,93 @@
+
+
+ This Galaxy tool is used to prepare your files to be ready for displaying on JBrowse with Apollo plugin
+
+
+
+ apollo_api
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This Galaxy tool will load a jbrowse hub to Apollo instance for visualization and interactive annotation.
+
+
+
+
\ No newline at end of file
diff -r 000000000000 -r bc00f5c4c59e templates/__init__.py
diff -r 000000000000 -r bc00f5c4c59e templates/apollo-arrow.yml
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/templates/apollo-arrow.yml Tue Oct 17 17:28:05 2017 -0400
@@ -0,0 +1,10 @@
+## Apollo's Arrow: Global Configuration File.
+# Each stanza should contian a single galaxy server to control.
+#
+# You can set the key __default to the name of a default instance
+__default: local
+
+local:
+ url: ${apollo_host}
+ username: ${admin_user}
+ password: ${admin_pw}
diff -r 000000000000 -r bc00f5c4c59e templates/custom_track_styles.css
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/templates/custom_track_styles.css Tue Oct 17 17:28:05 2017 -0400
@@ -0,0 +1,9 @@
+.${label},
+.plus-${label},
+.minus-${label}
+{
+ background-color: ${color};
+ height: 90%;
+ top: 5%;
+}
+
diff -r 000000000000 -r bc00f5c4c59e tool_dependencies.xml
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tool_dependencies.xml Tue Oct 17 17:28:05 2017 -0400
@@ -0,0 +1,23 @@
+
+
+
+
+
+
+ https://github.com/galaxy-genome-annotation/python-apollo/archive/3.0.3.tar.gz
+ $INSTALL_DIR/apollo
+
+ export PYTHONPATH=$PYTHONPATH:$INSTALL_DIR/apollo &&
+ python setup.py install --install-lib $INSTALL_DIR/apollo
+
+
+ $INSTALL_DIR/apollo
+ $INSTALL_DIR/apollo
+
+
+
+
+
+
+
+
diff -r 000000000000 -r bc00f5c4c59e util/Reader.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/util/Reader.py Tue Oct 17 17:28:05 2017 -0400
@@ -0,0 +1,95 @@
+import json
+import re
+import logging
+import codecs
+from apollo.ApolloUser import ApolloUser
+from util import santitizer
+
+class Reader(object):
+
+ def __init__(self, input_json_file):
+ self.inputFile = input_json_file
+ self.args = self.loadJson()
+
+
+ def loadJson(self):
+ try:
+ data_file = codecs.open(self.inputFile, 'r', 'utf-8')
+ return json.load(data_file)
+ except IOError:
+ print "Cannot find JSON file\n"
+ exit(1)
+
+ def getJBrowseHubDir(self):
+ try:
+ return self.args["jbrowse_hub"]
+ except KeyError:
+ print ("jbrowse_hub is not defined in the input file!")
+ exit(1)
+
+ def getToolDir(self):
+ try:
+ return self.args["tool_directory"]
+ except KeyError:
+ print ("tool_directory is not defined in the input file!")
+ exit(1)
+
+ def getExtFilesPath(self):
+ try:
+ return self.args["extra_files_path"]
+ except KeyError:
+ print ("extra_files_path is not defined in the input file!")
+ exit(1)
+
+ def getUserEmail(self):
+ try:
+ return self.args["user_email"]
+ except KeyError:
+ print ("user_email is not defined in the input file!")
+ exit(1)
+
+ def getDebugMode(self):
+ try:
+ return self.args["debug_mode"]
+ except KeyError:
+ print ("debug_mode is not defined in the input file!")
+ exit(1)
+
+ def getApolloHost(self):
+ apollo_host = self.args.get("apollo_host")
+ return apollo_host
+
+
+ def getSpeciesName(self):
+ species_name = santitizer.sanitize_name_input(self.args["species_name"])
+ return species_name
+
+ def getGenomeName(self):
+ jbrowse_hub = self.getJBrowseHubDir()
+ with open(jbrowse_hub, 'r') as f:
+ html = f.read()
+ m = re.search('The new Organism "(.+?)" is created on Apollo', html)
+ if m:
+ genome_name = m.group(1)
+ else:
+ print("Cannot find genome name in the jbrowse hub file!")
+ exit(1)
+ return genome_name
+
+
+ def getApolloUser(self):
+ user_info = self.args.get("apollo_user")
+ if not user_info:
+ firstname = "demo"
+ lastname = "user"
+ password = "gonramp"
+ user_email = self.getUserEmail()
+ else:
+ firstname = user_info['firstname']
+ lastname = user_info['lastname']
+ user_email = user_info['user_email']
+ password = user_info['password']
+ apollo_user = ApolloUser(user_email, firstname, lastname, password)
+ return apollo_user
+
+
\ No newline at end of file
diff -r 000000000000 -r bc00f5c4c59e util/Reader.pyc
Binary file util/Reader.pyc has changed
diff -r 000000000000 -r bc00f5c4c59e util/__init__.py
diff -r 000000000000 -r bc00f5c4c59e util/__init__.pyc
Binary file util/__init__.pyc has changed
diff -r 000000000000 -r bc00f5c4c59e util/santitizer.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/util/santitizer.py Tue Oct 17 17:28:05 2017 -0400
@@ -0,0 +1,70 @@
+#!/usr/bin/python
+# -*- coding: utf8 -*-
+
+"""
+This class handles the subprocess calls of the different tools used
+in HubArchiveCreator
+"""
+
+import logging
+import os
+import subprocess
+import sys
+import string
+import tempfile
+
+
+def prefixTrackName(filename):
+ """
+ santitize trackName. Because track name must begin with a letter and
+ contain only the following chars: [a-zA-Z0-9_].
+ See the "track" Common settings at:
+ https://genome.ucsc.edu/goldenpath/help/trackDb/trackDbHub.html#bigPsl_-_Pairwise_Alignments
+ skip the santitization for cytoBandIdeo track
+ """
+ if filename == 'cytoBandIdeo':
+ return filename
+ valid_chars = "_%s%s" % (string.ascii_letters, string.digits)
+ sanitize_name = ''.join([c if c in valid_chars else '_' for c in filename])
+ sanitize_name = "gonramp_" + sanitize_name
+ return sanitize_name
+
+def sanitize_name_input(string_to_sanitize):
+ """
+ Sanitize the string passed in parameter by replacing '/' and ' ' by '_'
+
+ :param string_to_sanitize:
+ :return :
+
+ :Example:
+
+ >>> sanitize_name_input('this/is an//example')
+ this_is_an__example
+ """
+ return string_to_sanitize \
+ .replace("/", "_") \
+ .replace(" ", "_")
+
+def sanitize_name_inputs(inputs_data):
+ """
+ Sanitize value of the keys "name" of the dictionary passed in parameter.
+
+ Because sometimes output from Galaxy, or even just file name, from user inputs, have spaces.
+ Also, it can contain '/' character and could break the use of os.path function.
+
+ :param inputs_data: dict[string, dict[string, string]]
+ """
+ for key in inputs_data:
+ inputs_data[key]["name"] = sanitize_name_input(inputs_data[key]["name"])
+
+def sanitize_group_name(group_name):
+ return group_name.lower().replace(' ', '_')
+
+def sanitize_name(input_name):
+ """
+ Galaxy will name all the files and dirs as *.dat,
+ the function can replace '.' to '_' for the dirs
+ """
+ validChars = "_-%s%s" % (string.ascii_letters, string.digits)
+ sanitized_name = ''.join([c if c in validChars else '_' for c in input_name])
+ return "gonramp_" + sanitized_name
diff -r 000000000000 -r bc00f5c4c59e util/santitizer.pyc
Binary file util/santitizer.pyc has changed
diff -r 000000000000 -r bc00f5c4c59e util/subtools.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/util/subtools.py Tue Oct 17 17:28:05 2017 -0400
@@ -0,0 +1,379 @@
+#!/usr/bin/env python
+
+"""
+This file include common used functions for converting file format to gff3
+"""
+from collections import OrderedDict
+import json
+import subprocess
+import os
+import sys
+import tempfile
+import string
+import logging
+
+class PopenError(Exception):
+ def __init__(self, cmd, error, return_code):
+ self.cmd = cmd
+ self.error = error
+ self.return_code = return_code
+
+ def __str__(self):
+ message = "The subprocess {0} has returned the error: {1}.".format(
+ self.cmd, self.return_code)
+ message = ','.join(
+ (message, "Its error message is: {0}".format(self.error)))
+ return repr(message)
+
+
+def _handleExceptionAndCheckCall(array_call, **kwargs):
+ """
+ This class handle exceptions and call the tool.
+ It maps the signature of subprocess.check_call:
+ See https://docs.python.org/2/library/subprocess.html#subprocess.check_call
+ """
+ stdout = kwargs.get('stdout', subprocess.PIPE)
+ stderr = kwargs.get('stderr', subprocess.PIPE)
+ shell = kwargs.get('shell', False)
+ stdin = kwargs.get('stdin', None)
+
+ cmd = array_call[0]
+
+ output = None
+ error = None
+
+ # TODO: Check the value of array_call and <=[0]
+ logging.debug("Calling {0}:".format(cmd))
+ logging.debug("%s", array_call)
+ logging.debug("---------")
+
+ # TODO: Use universal_newlines option from Popen?
+ try:
+ p = subprocess.Popen(array_call, stdout=stdout,
+ stderr=stderr, shell=shell, stdin=stdin)
+
+ # TODO: Change this because of possible memory issues => https://docs.python.org/2/library/subprocess.html#subprocess.Popen.communicate
+
+ output, error = p.communicate()
+
+ if stdout == subprocess.PIPE:
+ logging.debug("\t{0}".format(output))
+ else:
+ logging.debug("\tOutput in file {0}".format(stdout.name))
+ # If we detect an error from the subprocess, then we raise an exception
+ # TODO: Manage if we raise an exception for everything, or use CRITICAL etc... but not stop process
+ # TODO: The responsability of returning a sys.exit() should not be there, but up in the app.
+ if p.returncode:
+ if stderr == subprocess.PIPE:
+ raise PopenError(cmd, error, p.returncode)
+ else:
+ # TODO: To Handle properly with a design behind, if we received a option as a file for the error
+ raise Exception("Error when calling {0}. Error as been logged in your file {1}. Error code: {2}"
+ .format(cmd, stderr.name, p.returncode))
+
+ except OSError as e:
+ message = "The subprocess {0} has encountered an OSError: {1}".format(
+ cmd, e.strerror)
+ if e.filename:
+ message = '\n'.join(
+ (message, ", against this file: {0}".format(e.filename)))
+ logging.error(message)
+ sys.exit(-1)
+ except PopenError as p:
+ message = "The subprocess {0} has returned the error: {1}.".format(
+ p.cmd, p.return_code)
+ message = '\n'.join(
+ (message, "Its error message is: {0}".format(p.error)))
+
+ logging.exception(message)
+
+ sys.exit(p.return_code)
+ except Exception as e:
+ message = "The subprocess {0} has encountered an unknown error: {1}".format(
+ cmd, e)
+ logging.exception(message)
+
+ sys.exit(-1)
+ return p
+
+
+def write_features(field, attribute, gff3):
+ """
+ The function write the features to gff3 format (defined in https://github.com/The-Sequence-Ontology/Specifications/blob/master/gff3.md)
+ field, attribute are ordered dictionary
+ gff3 is the file handler
+ """
+ attr = []
+ for v in field.values():
+ gff3.write(str(v) + '\t')
+ for k, v in attribute.items():
+ s = str(k) + '=' + str(v)
+ attr.append(s)
+ gff3.write(';'.join(attr))
+ gff3.write('\n')
+
+def twoBitInfo(two_bit_file_name, two_bit_info_file):
+ """
+ Call twoBitInfo and write the result into twoBit_info_file
+ :param two_bit_file_name:
+ :param two_bit_info_file:
+ :return the subprocess.check_call return object:
+ """
+ array_call = ['twoBitInfo', two_bit_file_name, two_bit_info_file]
+ p = _handleExceptionAndCheckCall(array_call)
+ return p
+
+
+def faToTwoBit(fasta_file_name, twoBitFile):
+ """
+ This function call faToTwoBit UCSC tool, and return the twoBitFile
+ :param fasta_file_name:
+ :param mySpecieFolder:
+ :return:
+ """
+
+ array_call = ['faToTwoBit', fasta_file_name, twoBitFile]
+ _handleExceptionAndCheckCall(array_call)
+
+ return twoBitFile
+
+def sortChromSizes(two_bit_info_file_name, chrom_sizes_file_name):
+ """
+ Call sort with -k2rn on two_bit_info_file_name and write the result into chrom_sizes_file_name
+ :param two_bit_info_file_name:
+ :param chrom_sizes_file_name:
+ :return:
+ """
+ array_call = ['sort', '-k2rn', two_bit_info_file_name,
+ '-o', chrom_sizes_file_name]
+ p = _handleExceptionAndCheckCall(array_call)
+ return p
+
+def getChromSizes(reference, tool_dir):
+ #TODO: find a better way instead of shipping the two exec files with the tool
+ faToTwoBit = os.path.join(tool_dir, 'faToTwoBit')
+ twoBitInfo = os.path.join(tool_dir, 'twoBitInfo')
+ try:
+ twoBitFile = tempfile.NamedTemporaryFile(bufsize=0)
+ chrom_sizes = tempfile.NamedTemporaryFile(bufsize=0, suffix='.chrom.sizes', delete=False)
+ except IOError as err:
+ print "Cannot create tempfile err({0}): {1}".format(err.errno, err.strerror)
+ try:
+ subprocess.call(['faToTwoBit', reference, twoBitFile.name])
+ except OSError as err:
+ print "Cannot generate twoBitFile from faToTwoBit err({0}): {1}".format(err.errno, err.strerror)
+ try:
+ subprocess.call(['twoBitInfo', twoBitFile.name, chrom_sizes.name])
+ except OSError as err:
+ print "Cannot generate chrom_sizes from twoBitInfo err({0}): {1}".format(err.errno, err.strerror)
+ return chrom_sizes
+
+def sequence_region(chrom_sizes):
+ """
+ This function read from a chromatin size file generated by twoBitInfo and write the information to dict
+ return a dict
+ """
+ f = open(chrom_sizes, 'r')
+ sizes = f.readlines()
+ sizes_dict = {}
+ for line in sizes:
+ chrom_info = line.rstrip().split('\t')
+ sizes_dict[chrom_info[0]] = chrom_info[1]
+ return sizes_dict
+
+def child_blocks(parent_field, parent_attr, gff3, child_type):
+ num = 0
+ blockcount = int(parent_attr['blockcount'])
+ chromstart = parent_attr['chromstarts'].split(',')
+ blocksize = parent_attr['blocksizes'].split(',')
+ parent_start = parent_field['start']
+ while num < blockcount:
+ child_attr = OrderedDict()
+ child_field = parent_field
+ child_field['type'] = child_type
+ child_field['start'] = int(chromstart[num]) + int(parent_start)
+ child_field['end'] = int(child_field['start']) + int(blocksize[num]) - 1
+ child_attr['ID'] = parent_attr['ID'] + '_part_' + str(num+1)
+ child_attr['Parent'] = parent_attr['ID']
+ write_features(child_field, child_attr, gff3)
+ num = num + 1
+
+def add_tracks_to_json(trackList_json, new_tracks, modify_type):
+ """
+ Add to track configuration (trackList.json)
+ # modify_type = 'add_tracks': add a new track like bam or bigwig, new_track = dict()
+ # modify_type = 'add_attr': add configuration to the existing track, new_track = dict(track_name: dict())
+ """
+ with open(trackList_json, 'r+') as f:
+ data = json.load(f)
+ if modify_type == 'add_tracks':
+ data['tracks'].append(new_tracks)
+ elif modify_type == 'add_attr':
+ for k in new_tracks:
+ for track in data['tracks']:
+ if k.lower() in track['urlTemplate'].lower():
+ attr = new_tracks[k]
+ for k, v in attr.items():
+ track[k] = v
+ f.seek(0, 0)
+ f.write(json.dumps(data, separators=(',' , ':'), indent=4))
+ f.truncate()
+ f.close()
+
+
+def createBamIndex(bamfile):
+ subprocess.call(['samtools', 'index', bamfile])
+ filename = bamfile + '.bai'
+ if os.path.exists(filename):
+ return filename
+ else:
+ raise ValueError('Did not find bai file')
+
+def flatfile_to_json(inputFile, dataType, trackType, trackLabel, outputFolder, options=None, compress=False):
+ if "bed" in dataType:
+ fileType = "--bed"
+ elif "gff" in dataType:
+ fileType = "--gff"
+ else:
+ raise ValueError("%s is not a valid filetype for flatfile_to_json" % dataType)
+
+
+ array_call = ['flatfile-to-json.pl',
+ fileType, inputFile,
+ '--trackType', trackType,
+ '--trackLabel', trackLabel,
+ '--out', outputFolder]
+ if compress:
+ array_call.append('--compress')
+ if options:
+ config = options.get("config")
+ clientConfig = options.get("clientConfig")
+ renderClassName = options.get('renderClassName')
+ subfeatureClasses = options.get('subfeatureClasses')
+ load_type = options.get("type")
+ if clientConfig:
+ array_call.append('--clientConfig')
+ array_call.append(clientConfig)
+ if config:
+ array_call.append('--config')
+ array_call.append(config)
+ if load_type:
+ array_call.append('--type')
+ array_call.append(load_type)
+ if renderClassName:
+ array_call.append('--renderClassName')
+ array_call.append(renderClassName)
+ if subfeatureClasses:
+ array_call.append('--subfeatureClasses')
+ array_call.append(json.dumps(subfeatureClasses))
+
+ p = _handleExceptionAndCheckCall(array_call)
+ return p
+
+def bam_to_json(inputFile, trackLabel, outputFolder, options=None, compress=False):
+
+ array_call = ['bam-to-json.pl',
+ '--bam', inputFile,
+ '--trackLabel', trackLabel,
+ '--out', outputFolder]
+ if compress:
+ array_call.append('--compress')
+ if options:
+ config = options.get('config')
+ clientConfig = options.get('clientConfig')
+ if clientConfig:
+ array_call.append('--clientConfig')
+ array_call.append(clientConfig)
+ if config:
+ array_call.append('--config')
+ array_call.append(config)
+
+ p = _handleExceptionAndCheckCall(array_call)
+ return p
+
+def add_track_json(trackList, track_json):
+ track_json = json.dumps(track_json)
+ new_track = subprocess.Popen(['echo', track_json], stdout=subprocess.PIPE)
+ p = subprocess.call(['add-track-json.pl', trackList], stdin=new_track.stdout)
+ return p
+
+def prepare_refseqs(fasta_file_name, outputFolder):
+ array_call = ['prepare-refseqs.pl', '--fasta', fasta_file_name, '--out', outputFolder]
+ p = _handleExceptionAndCheckCall(array_call)
+ return p
+
+def generate_names(outputFolder):
+ array_call = ['generate-names.pl', '-v', '--out', outputFolder]
+ p = _handleExceptionAndCheckCall(array_call)
+ return p
+
+def validateFiles(input_file, chrom_sizes_file_name, file_type, options=None):
+ """
+ Call validateFiles on input_file, using chrom_sizes_file_name and file_type
+ :param input_file:
+ :param chrom_sizes_file_name:
+ :param file_type:
+ :return:
+ """
+
+ array_call = ['validateFiles', '-chromInfo=' + chrom_sizes_file_name, '-type='+ file_type, input_file]
+ if options:
+ tab = options.get("tab")
+ autoSql = options.get("autoSql")
+ logging.debug("tab: {0}".format(tab))
+ logging.debug("autoSql: {0}".format(autoSql))
+ if autoSql:
+ autoSql = ''.join(['-as=', autoSql])
+ array_call.append(autoSql)
+ if tab:
+ array_call.append('-tab')
+ p = _handleExceptionAndCheckCall(array_call)
+ return p
+
+def arrow_add_organism(organism_name, organism_dir, public=False):
+ array_call = ['arrow', 'organisms', 'add_organism', organism_name, organism_dir]
+ if public:
+ array_call.append('--public')
+ print array_call
+ p = subprocess.check_output(array_call)
+ return p
+
+def arrow_create_user(user_email, firstname, lastname, password, admin=False):
+ """ Create a new user of Apollo, the default user_role is "user" """
+ array_call = ['arrow', 'users', 'create_user', user_email, firstname, lastname, password]
+ if admin:
+ array_call += ['--role', 'admin']
+ logging.debug("%s", array_call)
+ print array_call
+ p = subprocess.check_output(array_call)
+ print ("p = %s", p)
+ return p
+
+def arrow_update_organism_permissions(user_id, organism, **user_permissions):
+ array_call = ['arrow', 'users', 'update_organism_permissions', str(user_id), str(organism)]
+ admin = user_permissions.get("admin", False)
+ write = user_permissions.get("write", False)
+ read = user_permissions.get("read", False)
+ export = user_permissions.get("export", False)
+ if admin:
+ array_call.append('--administrate')
+ if write:
+ array_call.append('--write')
+ if read:
+ array_call.append('--read')
+ if export:
+ array_call.append('--export')
+ p = subprocess.check_output(array_call)
+ return p
+
+def arrow_get_users(user_email):
+ array_call = ['arrow', 'users', 'get_users']
+ logging.debug("%s", array_call)
+ print array_call
+ p = subprocess.check_output(array_call)
+ all_users = json.loads(p)
+ for d in all_users:
+ if d['username'] == user_email:
+ return d['userId']
+ logging.error("Cannot find user %s", user_email)
+
diff -r 000000000000 -r bc00f5c4c59e util/subtools.pyc
Binary file util/subtools.pyc has changed