def getBogusAssembly(self):
# Create a fake assembly with lots of contigs
assembly_file_name = "bogus.fna" # "AP009048.fna"
assembly_temp_file = os.path.join("/kb/module/work/tmp",
assembly_file_name)
with open(assembly_temp_file, "w") as f:
for i in range(1, 30002):
f.write("> contig_%d\n" % i)
f.write(
"AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC\n"
)
assembly_name = "Assembly.2"
au = AssemblyUtil(os.environ["SDK_CALLBACK_URL"],
token=self.getContext()["token"])
assembly_ref = au.save_assembly_from_fasta({
"file": {
"path": assembly_temp_file
},
"workspace_name":
self.getWsName(),
"assembly_name":
assembly_name
})
self.assembly_ref = assembly_ref
print("Uploaded bogus assembly " + str(assembly_ref))
return assembly_ref
def _stage_assembly_files(self, object_list):
"""
_stage_assembly_files: download the fasta files to the scratch area
return list of file names
"""
log('Processing assembly object list: {}'.format(object_list))
# Sourmash uses the sequence filename as the default label for the signatures
# this includes the complete file path. So keeping the sequence file name as close
# to the desired label as possible is the reason not to place each file under
# a 'fasta' directory or inlude the '.fa' file extension
auc = AssemblyUtil(self.callbackURL)
staged_file_list = []
for assembly_upa in object_list:
try:
file_ = auc.get_assembly_as_fasta({'ref':
assembly_upa})['path']
except AssemblyUtilError as assembly_error:
print(str(assembly_error))
raise
filename = os.path.basename(file_).replace('.fa', '')
to_upper_command = "awk '{ if ($0 !~ />/) {print toupper($0)} else {print $0} }' " \
+ file_ + ' > tmp.fa ' + '&& mv tmp.fa ' + filename
self._run_command(to_upper_command)
staged_file_list.append(filename)
log('Created file list: {}'.format(staged_file_list))
return staged_file_list
def _build_index(self, assembly_info, validated_params):
# get the assembly as a fasta file using AssemblyUtil
au = AssemblyUtil(self.callback_url)
fasta_info = au.get_assembly_as_fasta({'ref': assembly_info['ref']})
# make the target destination folder (check again it wasn't created yet)
if os.path.exists(validated_params['output_dir']):
raise('Output directory name specified (' + validated_params['output_dir'] +
') already exists. Will not overwrite, so aborting.')
os.makedirs(validated_params['output_dir'])
# configure the command line args and run it
cli_params = self._build_cli_params(fasta_info['path'], fasta_info['assembly_name'], validated_params)
self.bowtie2.run('bowtie2-build', cli_params)
index_info = {'output_dir': validated_params['output_dir'],
'index_files_basename': fasta_info['assembly_name']}
# cache the result, mark if it worked or not
cache_success = self._put_cached_index(assembly_info,
fasta_info['assembly_name'],
validated_params['output_dir'],
validated_params['ws_for_cache'])
if cache_success:
index_info['pushed_to_cache'] = 1
else:
index_info['pushed_to_cache'] = 0
return index_info
def get_fasta_file(self, genome_ref):
ws = Workspace(self.ws_url)
# test if genome references an assembly type
# do get_objects2 without data. get list of refs
genome_obj_info = ws.get_objects2({
'objects': [{
'ref': genome_ref
}],
'no_data': 1
})
# get the list of genome refs from the returned info.
# if there are no refs (or something funky with the return), this will be an empty list.
# this WILL fail if data is an empty list. But it shouldn't be, and we know because
# we have a real genome reference, or get_objects2 would fail.
genome_obj_refs = genome_obj_info.get('data', [{}])[0].get('refs', [])
# see which of those are of an appropriate type (ContigSet or Assembly), if any.
assembly_ref = list()
ref_params = [{'ref': x} for x in genome_obj_refs]
ref_info = ws.get_object_info3({'objects': ref_params})
for idx, info in enumerate(ref_info.get('infos')):
if "KBaseGenomeAnnotations.Assembly" in info[
2] or "KBaseGenomes.ContigSet" in info[2]:
assembly_ref.append(";".join(ref_info.get('paths')[idx]))
# now just get the file.
au = AssemblyUtil(self.callback_url)
fasta_file = au.get_assembly_as_fasta({'ref': assembly_ref[0]})
return fasta_file["path"]
def __init__(self, config):
"""
:param config:
:param logger:
:param directory: Working directory
:param urls: Service urls
"""
# BEGIN_CONSTRUCTOR
self.ws_url = config["workspace-url"]
self.ws_url = config["workspace-url"]
self.callback_url = config['SDK_CALLBACK_URL']
self.srv_wiz_url = config['srv-wiz-url']
self.token = config['KB_AUTH_TOKEN']
self.shock_url = config['shock-url']
self.dfu = DataFileUtil(self.callback_url)
self.gfu = GenomeFileUtil(self.callback_url)
self.au = AssemblyUtil(self.callback_url)
self.rau = ReadsAlignmentUtils(self.callback_url)
self.set_api = SetAPI(self.srv_wiz_url, service_ver='dev')
self.eu = ExpressionUtils(self.callback_url)
self.ws = Workspace(self.ws_url, token=self.token)
self.scratch = os.path.join(config['scratch'], str(uuid.uuid4()))
self._mkdir_p(self.scratch)
self.tool_used = "Cufflinks"
self.tool_version = os.environ['VERSION']
# END_CONSTRUCTOR
pass
def test_annotate_contigs(self):
assembly_file_name = "small.fna" #"AP009048.fna"
assembly_test_file = os.path.join("/kb/module/test/data", assembly_file_name)
assembly_temp_file = os.path.join("/kb/module/work/tmp", assembly_file_name)
shutil.copy(assembly_test_file, assembly_temp_file)
assembly_name = 'Assembly.1'
au = AssemblyUtil(os.environ['SDK_CALLBACK_URL'], token=self.getContext()['token'])
assembly_ref = au.save_assembly_from_fasta({'file': {'path': assembly_temp_file},
'workspace_name': self.getWsName(),
'assembly_name': assembly_name})
genome_name = "Genome.1"
result = self.getImpl().annotate_contigs(self.getContext(),
{'assembly_ref': assembly_ref,
'output_workspace': self.getWsName(),
'output_genome_name': genome_name,
'evalue': None,
'fast': 0,
'gcode': None,
'genus': '',
'kingdom': 'Bacteria',
'metagenome': 0,
'mincontiglen': 1,
'norrna': 0,
'notrna': 0,
'rawproduct': 0,
'rfam': 1,
'scientific_name': 'Super : diper - name;'
})[0]
rep = self.getWsClient().get_objects([{'ref': result['report_ref']}])[0]['data']
self.assertTrue('text_message' in rep)
print("Report:\n" + str(rep['text_message']))
def __init__(self, config):
#BEGIN_CONSTRUCTOR
self.scratch = config['scratch']
self.callback_url = os.environ['SDK_CALLBACK_URL']
self.dfu = AssemblyUtil(self.callback_url)
#END_CONSTRUCTOR
pass
def load_test_genome_direct(self, filename, assembly_filename, obj_name):
au = AssemblyUtil(os.environ['SDK_CALLBACK_URL'])
assembly_ref = au.save_assembly_from_fasta({
'workspace_name':
self.getWsName(),
'assembly_name':
obj_name + '.assembly',
'file': {
'path': assembly_filename
}
})
pprint('created test assembly: ' + assembly_ref)
with open(filename, 'r') as file:
data_str = file.read()
data = json.loads(data_str)
data['assembly_ref'] = assembly_ref
# save to ws
save_info = {
'workspace':
self.getWsName(),
'objects': [{
'type': 'KBaseGenomes.Genome',
'data': data,
'name': obj_name + '.genome'
}]
}
result = self.ws.save_objects(save_info)
info = result[0]
ref = str(info[6]) + '/' + str(info[0]) + '/' + str(info[4])
print('created test genome: ' + ref + ' from file ' + filename)
return ref
def test_annotate_contigs(self):
assembly_file_name = "small.fna" #"AP009048.fna"
assembly_test_file = os.path.join("/kb/module/test/data", assembly_file_name)
assembly_temp_file = os.path.join("/kb/module/work/tmp", assembly_file_name)
shutil.copy(assembly_test_file, assembly_temp_file)
assembly_name = 'Assembly.1'
au = AssemblyUtil(os.environ['SDK_CALLBACK_URL'])
assembly_ref = au.save_assembly_from_fasta({'file': {'path': assembly_temp_file},
'workspace_name': self.getWsName(),
'assembly_name': assembly_name})
# Add a genome to the WS to test ref_paths
genome_name = "Genome.1"
genome = {'id': 'Unknown', 'features': [],
'scientific_name': "",
'domain': "", 'genetic_code': 0,
'assembly_ref': assembly_ref,
'cdss': [], 'mrnas': [],
'source': 'Magic!',
'gc_content': 0, 'dna_size': 0,
'reference_annotation': 0}
prov = self.getContext().provenance()
ga = GenomeAnnotationAPI(os.environ['SDK_CALLBACK_URL'])
info = ga.save_one_genome_v1(
{'workspace': self.getWsName(), 'name': genome_name,
'data': genome, 'provenance': prov})['info']
genome_ref = str(info[6]) + '/' + str(info[0]) + '/' + str(info[4])
result = self.getImpl().annotate_contigs(self.getContext(),
{'assembly_ref': "{};{}".format(genome_ref, assembly_ref),
'output_workspace': self.getWsName(),
'output_genome_name': genome_name,
'evalue': None,
'fast': 0,
'gcode': 0,
'genus': 'genus',
'kingdom': 'Bacteria',
'metagenome': 0,
'mincontiglen': 1,
'norrna': 0,
'notrna': 0,
'rawproduct': 0,
'rfam': 1,
'scientific_name': 'Super : diper - name;'
})[0]
rep = self.getWsClient().get_objects([{'ref': result['report_ref']}])[0]['data']
self.assertTrue('text_message' in rep)
print("Report:\n" + str(rep['text_message']))
genome_ref = self.getWsName() + "/" + genome_name
genome = self.getWsClient().get_objects([{'ref': genome_ref}])[0]['data']
features_to_work = {}
for feature in genome['features']:
features_to_work[feature['id']] = feature['location']
aseq = AssemblySequenceAPI(os.environ['SDK_CALLBACK_URL'], token=self.getContext()['token'])
dna_sequences = aseq.get_dna_sequences({'requested_features': features_to_work,
'assembly_ref': genome['assembly_ref']})['dna_sequences']
bad_dnas = 0
for feature in genome['features']:
if feature['dna_sequence'] != dna_sequences[feature['id']]:
bad_dnas += 1
self.assertEqual(bad_dnas, 0)
def __init__(self, config):
self.callback_url = config['SDK_CALLBACK_URL']
self.scratch = config['scratch']
self.shock_url = config['shock-url']
self.dfu = DataFileUtil(self.callback_url)
self.au = AssemblyUtil(self.callback_url)
self.setapi = SetAPI(self.callback_url)
self.wss = workspaceService(config['workspace-url'])
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
# WARNING: don't call any logging methods on the context object,
# it'll result in a NoneType error
cls.ctx = MethodContext(None)
cls.ctx.update({'token': token,
'provenance': [
{'service': 'AssemblyAPI',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated': 1})
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('AssemblyAPI'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = AssemblyAPI(cls.cfg)
cls.scratch = cls.cfg['scratch']
cls.callback_url = os.environ['SDK_CALLBACK_URL']
suffix = int(time.time() * 1000)
cls.wsName = "test_kb_maxbin_" + str(suffix)
cls.ws_info = cls.wsClient.create_workspace({'workspace': cls.wsName})
cls.obj_name = "7989/489/2"
cls.contigs = [u'NZ_ALQT01000016']
# create an example Assembly
cls.au = AssemblyUtil(cls.callback_url)
assembly_filename = 'test.fa'
cls.assembly_fasta_file_path = os.path.join(cls.scratch, assembly_filename)
shutil.copy(os.path.join("data", assembly_filename), cls.assembly_fasta_file_path)
assembly_params = {
'file': {'path': cls.assembly_fasta_file_path},
'workspace_name': cls.wsName,
'assembly_name': 'MyAssembly'
}
cls.assembly_ref_1 = cls.au.save_assembly_from_fasta(assembly_params)
print('Assembly1:' + cls.assembly_ref_1)
# create a test legacy contigset
with open('data/contigset1.json') as file:
contigset_data = json.load(file)
pprint(contigset_data)
saveData = {
'type': 'KBaseGenomes.ContigSet',
'data': contigset_data,
'name': 'contigset'
}
cls.contig_set_info = cls.wsClient.save_objects({'workspace': cls.wsName, 'objects': [saveData]})[0]
pprint(cls.contig_set_info)
cls.contig_set_ref = str(cls.contig_set_info[6]) + '/' + str(cls.contig_set_info[0]) + '/' + str(cls.contig_set_info[4])
print('ContigSet1:' + cls.contig_set_ref)
def __init__(self, config):
self.callback_url = config['SDK_CALLBACK_URL']
self.scratch = os.path.join(config['scratch'],
'import_assembly_' + str(uuid.uuid4()))
handler_utils._mkdir_p(self.scratch)
self.token = config['KB_AUTH_TOKEN']
self.dfu = DataFileUtil(self.callback_url)
self.au = AssemblyUtil(self.callback_url)
self.uploader_utils = UploaderUtil(config)
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('kb_Msuite'):
cls.cfg[nameval[0]] = nameval[1]
# Getting username from Auth profile for token
authServiceUrl = cls.cfg['auth-service-url']
auth_client = _KBaseAuth(authServiceUrl)
user_id = auth_client.get_user(token)
# WARNING: don't call any logging methods on the context object,
# it'll result in a NoneType error
cls.ctx = MethodContext(None)
cls.ctx.update({
'token':
token,
'user_id':
user_id,
'provenance': [{
'service': 'kb_Msuite',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated':
1
})
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL)
cls.serviceImpl = kb_Msuite(cls.cfg)
cls.scratch = cls.cfg['scratch']
cls.callback_url = os.environ['SDK_CALLBACK_URL']
cls.checkm_runner = CheckMUtil(cls.cfg, cls.ctx)
suffix = int(time.time() * 1000)
cls.wsName = "test_kb_Msuite_" + str(suffix)
cls.ws_info = cls.wsClient.create_workspace({'workspace': cls.wsName})
cls.au = AssemblyUtil(os.environ['SDK_CALLBACK_URL'])
cls.setAPI = SetAPI(url=cls.cfg['srv-wiz-url'], token=cls.ctx['token'])
cls.gfu = GenomeFileUtil(os.environ['SDK_CALLBACK_URL'],
service_ver='dev')
cls.mu = MetagenomeUtils(os.environ['SDK_CALLBACK_URL'])
# stage an input and output directory
"""
cls.input_dir = os.path.join(cls.scratch, 'input_1')
cls.output_dir = os.path.join(cls.scratch, 'output_1')
cls.all_seq_fasta = os.path.join(cls.scratch, 'all_seq.fna')
shutil.copytree(os.path.join('data', 'example_out', 'input'), cls.input_dir)
shutil.copytree(os.path.join('data', 'example_out', 'output'), cls.output_dir)
shutil.copy(os.path.join('data', 'example_out', 'all_seq.fna'), cls.all_seq_fasta)
"""
# prepare WS data
cls.prepare_data()
def setUpClass(cls):
cls.token = environ.get('KB_AUTH_TOKEN', None)
cls.callbackURL = environ.get('SDK_CALLBACK_URL')
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('ExpressionUtils'):
cls.cfg[nameval[0]] = nameval[1]
# Getting username from Auth profile for token
authServiceUrl = cls.cfg['auth-service-url']
auth_client = _KBaseAuth(authServiceUrl)
user_id = auth_client.get_user(cls.token)
# WARNING: don't call any logging methods on the context object,
# it'll result in a NoneType error
cls.ctx = MethodContext(None)
cls.ctx.update({
'token':
cls.token,
'user_id':
user_id,
'provenance': [{
'service': 'ExpressionUtils',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated':
1
})
cls.shockURL = cls.cfg['shock-url']
cls.wsURL = cls.cfg['workspace-url']
cls.service_wizard_url = cls.cfg['srv-wiz-url']
cls.wsClient = workspaceService(cls.wsURL)
cls.ws = Workspace(cls.wsURL, token=cls.token)
cls.hs = HandleService(url=cls.cfg['handle-service-url'],
token=cls.token)
# create workspace
wssuffix = int(time.time() * 1000)
wsname = "test_expression_" + str(wssuffix)
cls.wsinfo = cls.wsClient.create_workspace({'workspace': wsname})
print('created workspace ' + cls.getWsName())
cls.serviceImpl = ExpressionUtils(cls.cfg)
cls.readUtils = ReadsUtils(cls.callbackURL)
cls.dfu = DataFileUtil(cls.callbackURL, service_ver='dev')
cls.dfu.ws_name_to_id(wsname)
cls.assemblyUtil = AssemblyUtil(cls.callbackURL)
cls.gfu = GenomeFileUtil(cls.callbackURL)
cls.gaAPI = GenomeAnnotationAPI(cls.service_wizard_url)
cls.rau = ReadsAlignmentUtils(cls.callbackURL)
cls.scratch = cls.cfg['scratch']
cls.staged = {}
cls.nodes_to_delete = []
cls.handles_to_delete = []
cls.setupTestData()
def load_fasta_file(self, filename, obj_name, contents):
f = open(filename, 'w')
f.write(contents)
f.close()
assemblyUtil = AssemblyUtil(self.callback_url)
assembly_ref = assemblyUtil.save_assembly_from_fasta({'file': {'path': filename},
'workspace_name': self.getWsName(),
'assembly_name': obj_name
})
return assembly_ref
def run_mash_sketch(self, ctx, params):
"""
Generate a sketch file from a fasta/fastq file
:param params: instance of type "MashSketchParams" (* * Pass in **one
of** input_path, assembly_ref, or reads_ref * input_path -
string - local file path to an input fasta/fastq * assembly_ref
- string - workspace reference to an Assembly type * reads_ref -
string - workspace reference to a Reads type * Optionally, pass in
a boolean indicating whether you are using paired-end reads. *
paired_ends - boolean - whether you are passing in paired ends) ->
structure: parameter "input_path" of String, parameter
"assembly_ref" of String, parameter "reads_ref" of String,
parameter "paired_ends" of type "boolean" (params:
input_upa: workspace reference to an assembly object
workspace_name: name of current workspace search_db: database to
search n_max_results: number of results to return, integer between
1 and 100)
:returns: instance of type "MashSketchResults" (* * Returns the local
scratch file path of the generated sketch file. * Will have the
extension '.msh') -> structure: parameter "sketch_path" of String
"""
# ctx is the context object
# return variables are: results
#BEGIN run_mash_sketch
if 'reads_ref' in params:
reads_utils = ReadsUtils(self.callbackURL)
result = reads_utils.download_reads({
'read_libraries': [params['reads_ref']],
'interleaved':
'true'
})
input_path = result['files'][params['reads_ref']]['files']['fwd']
elif 'assembly_ref' in params:
assembly_util = AssemblyUtil(self.callbackURL)
result = assembly_util.get_assembly_as_fasta(
{'ref': params['assembly_ref']})
input_path = result['path']
elif 'input_path' in params:
input_path = params['input_path']
else:
raise ValueError(
'Invalid params; must provide one of `reads_ref`, `assembly_ref`, or `input_path`.'
)
mash_utils = MashUtils(self.config, self.auth_token)
output_file_path = mash_utils.mash_sketch(
input_path, paired_ends=params.get('paired_ends'))
results = {'sketch_path': output_file_path}
#END run_mash_sketch
# At some point might do deeper type checking...
if not isinstance(results, dict):
raise ValueError('Method run_mash_sketch return value ' +
'results is not type dict as required.')
# return the results
return [results]
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('SetAPI'):
cls.cfg[nameval[0]] = nameval[1]
authServiceUrl = cls.cfg.get('auth-service-url',
"https://kbase.us/services/authorization/Sessions/Login")
auth_client = _KBaseAuth(authServiceUrl)
user_id = auth_client.get_user(token)
# WARNING: don't call any logging methods on the context object,
# it'll result in a NoneType error
cls.ctx = MethodContext(None)
cls.ctx.update({'token': token,
'user_id': user_id,
'provenance': [
{'service': 'SetAPI',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated': 1})
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = SetAPI(cls.cfg)
# setup data at the class level for now (so that the code is run
# once for all tests, not before each test case. Not sure how to
# do that outside this function..)
suffix = int(time.time() * 1000)
wsName = "test_SetAPI_" + str(suffix)
ret = cls.wsClient.create_workspace({'workspace': wsName})
# wsName = 'pranjan77:1477441032423'
cls.wsName = wsName
# copy test file to scratch area
fna_filename = "seq.fna"
fna_path = os.path.join(cls.cfg['scratch'], fna_filename)
shutil.copy(os.path.join("data", fna_filename), fna_path)
ru = AssemblyUtil(os.environ['SDK_CALLBACK_URL'])
ws_obj_name = 'MyNewAssembly'
cls.assembly1ref = ru.save_assembly_from_fasta(
{
'file':{'path':fna_path},
'workspace_name':wsName,
'assembly_name':'assembly_obj_1'
})
cls.assembly2ref = ru.save_assembly_from_fasta(
{
'file':{'path':fna_path},
'workspace_name':wsName,
'assembly_name':'assembly_obj_2'
})
def load_fasta_file(self, path, name):
assembly_util = AssemblyUtil(self.callback_url)
return assembly_util.save_assembly_from_fasta({
'file': {
'path': path
},
'workspace_name':
self.getWsName(),
'assembly_name':
name
})
def __init__(self, config):
self.ws_url = config["workspace-url"]
self.callback_url = config['SDK_CALLBACK_URL']
self.token = config['KB_AUTH_TOKEN']
self.scratch = config['scratch']
self.dfu = DataFileUtil(self.callback_url)
self.ru = ReadsUtils(self.callback_url)
self.au = AssemblyUtil(self.callback_url)
self.gfu = GenomeFileUtil(self.callback_url)
self.rau = ReadsAlignmentUtils(self.callback_url)
def get_fasta_file(self, filename, obj_name):
assemblyUtil = AssemblyUtil(self.callback_url)
assembly_ref = assemblyUtil.save_assembly_from_fasta({
'file': {
'path': filename
},
'workspace_name':
self.getWsName(),
'assembly_name':
obj_name
})
return assembly_ref
def test_filter_contigs_by_length_01(self):
method = 'filter_contigs_by_length_01'
print("\n\nRUNNING: test_filter_contigs_by_length_01()")
print("===========================================\n\n")
# upload test data
try:
auClient = AssemblyUtil(self.callback_url,
token=self.getContext()['token'])
except Exception as e:
raise ValueError(
'Unable to instantiate auClient with callbackURL: ' +
self.callback_url + ' ERROR: ' + str(e))
ass_file_1 = 'assembly_1.fa'
ass_file_2 = 'assembly_2.fa'
ass_path_1 = os.path.join(self.scratch, ass_file_1)
ass_path_2 = os.path.join(self.scratch, ass_file_2)
shutil.copy(os.path.join("data", ass_file_1), ass_path_1)
shutil.copy(os.path.join("data", ass_file_2), ass_path_2)
ass_ref_1 = auClient.save_assembly_from_fasta({
'file': {
'path': ass_path_1
},
'workspace_name':
self.getWsName(),
'assembly_name':
'assembly_1'
})
ass_ref_2 = auClient.save_assembly_from_fasta({
'file': {
'path': ass_path_2
},
'workspace_name':
self.getWsName(),
'assembly_name':
'assembly_2'
})
# run method
input_refs = [ass_ref_1, ass_ref_2]
base_output_name = method + '_output'
params = {
'workspace_name': self.getWsName(),
'input_assembly_refs': input_refs,
'min_contig_length': 1000,
'output_name': 'test_filtered'
}
result = self.getImpl().run_filter_contigs_by_length(
self.getContext(), params)
print('RESULT:')
pprint(result)
pass
def loadAssembly(self):
if hasattr(self.__class__, 'assembly_ref'):
return self.__class__.assembly_ref
fasta_path = os.path.join(self.scratch, 'test.fna')
shutil.copy(os.path.join('data', 'test.fna'), fasta_path)
au = AssemblyUtil(self.callback_url)
assembly_ref = au.save_assembly_from_fasta({'file': {'path': fasta_path},
'workspace_name': self.getWsName(),
'assembly_name': 'test_assembly'
})
self.__class__.assembly_ref = assembly_ref
return assembly_ref
def get_assembly(self, target_dir, assembly_upa):
auc = AssemblyUtil(self.callbackURL)
filename = os.path.join(target_dir, assembly_upa.replace('/', '_'))
try:
auc.get_assembly_as_fasta({
'ref': assembly_upa,
'filename': filename
})
except AssemblyUtilError as assembly_error:
print(str(assembly_error))
raise
return filename
def save_assembly(self, wsname, output_contigs, token, name, console):
self.log(console, 'Uploading FASTA file to Assembly')
assemblyUtil = AssemblyUtil(self.callbackURL,
token=token,
service_ver='dev')
assemblyUtil.save_assembly_from_fasta({
'file': {
'path': output_contigs
},
'workspace_name': wsname,
'assembly_name': name
})
def loadFasta2Assembly(self, filename):
fn, ext = os.path.splitext(filename)
fasta_path = os.path.join(self.scratch, filename)
shutil.copy(os.path.join('../testReads', filename), fasta_path)
au = AssemblyUtil(self.callback_url)
a_ref = au.save_assembly_from_fasta({
'file': {
'path': fasta_path
},
'workspace_name': self.getWsName(),
'assembly_name': fn
})
return a_ref
def fetch_fasta_from_assembly(assembly_ref, ws_url, callback_url):
"""
From an assembly or contigset, this uses a data file util to build a FASTA file and return the
path to it.
"""
allowed_types = ['KBaseFile.Assembly',
'KBaseGenomeAnnotations.Assembly',
'KBaseGenomes.ContigSet']
if not check_ref_type(assembly_ref, allowed_types, ws_url):
raise ValueError("The reference {} cannot be used to fetch a FASTA file".format(
assembly_ref))
au = AssemblyUtil(callback_url)
return au.get_assembly_as_fasta({'ref': assembly_ref})
def __init__(self, config):
self.ws_url = config["workspace-url"]
self.callback_url = config['SDK_CALLBACK_URL']
self.token = config['KB_AUTH_TOKEN']
self.shock_url = config['shock-url']
self.srv_wiz_url = config['srv-wiz-url']
self.scratch = config['scratch']
self.dfu = DataFileUtil(self.callback_url)
self.gfu = GenomeFileUtil(self.callback_url)
self.rau = ReadsAlignmentUtils(self.callback_url)
self.au = AssemblyUtil(self.callback_url)
self.eu = ExpressionUtils(self.callback_url, service_ver='dev')
self.ws = Workspace(self.ws_url, token=self.token)
self.set_client = SetAPI(self.srv_wiz_url)
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('kb_tophat2'):
cls.cfg[nameval[0]] = nameval[1]
# Getting username from Auth profile for token
authServiceUrl = cls.cfg['auth-service-url']
auth_client = _KBaseAuth(authServiceUrl)
user_id = auth_client.get_user(token)
# WARNING: don't call any logging methods on the context object,
# it'll result in a NoneType error
cls.ctx = MethodContext(None)
cls.ctx.update({
'token':
token,
'user_id':
user_id,
'provenance': [{
'service': 'kb_tophat2',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated':
1
})
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL)
cls.ws = Workspace(cls.wsURL, token=token)
cls.serviceImpl = kb_tophat2(cls.cfg)
cls.scratch = cls.cfg['scratch']
cls.callback_url = os.environ['SDK_CALLBACK_URL']
cls.srv_wiz_url = cls.cfg['srv-wiz-url']
suffix = int(time.time() * 1000)
cls.wsName = "test_kb_tophat2_" + str(suffix)
cls.wsClient.create_workspace({'workspace': cls.wsName})
cls.tophat_runner = TopHatUtil(cls.cfg)
cls.ru = ReadsUtils(cls.callback_url)
cls.au = AssemblyUtil(cls.callback_url)
cls.dfu = DataFileUtil(cls.callback_url)
cls.gfu = GenomeFileUtil(cls.callback_url)
cls.prepare_data()
def __init__(self, config):
self.scratch = config["scratch"]
self.ctx = config['ctx'];
self.callback_url = config["SDK_CALLBACK_URL"]
self.ws_client = workspaceService(config["workspace-url"])
self.gfu = GenomeFileUtil(self.callback_url)
self.au = AssemblyUtil(self.callback_url)
self.kbr = KBaseReport(self.callback_url)
self.dfu = DataFileUtil(self.callback_url)
self.genome_api = GenomeAnnotationAPI(self.callback_url)
self.sso_ref = None
self.sso_event = None
self.ec_to_sso = {}
self.output_workspace = None
def __init__(self, scratch_dir, workspace_url, callback_url, srv_wiz_url, provenance):
self.workspace_url = workspace_url
self.callback_url = callback_url
self.srv_wiz_url = srv_wiz_url
self.au = AssemblyUtil(self.callback_url)
self.dfu = DataFileUtil(self.callback_url, service_ver='beta')
self.scratch = scratch_dir
self.working_dir = scratch_dir
self.prog_runner = Program_Runner(self.STAR_BIN, self.scratch)
self.provenance = provenance
self.ws_client = Workspace(self.workspace_url)
self.parallel_runner = KBParallel(self.callback_url)
self.qualimap = kb_QualiMap(self.callback_url, service_ver='dev')
self.set_api_client = SetAPI(self.srv_wiz_url, service_ver='dev')
self.eu = ExpressionUtils(self.callback_url, service_ver='beta')
