def _method_get_state(workspace, token, URLS, job_manager, method_spec_json, param_values_json, method_job_id):
methodSpec = json.loads(method_spec_json)
methodInputValues = json.loads(correct_method_specs_json(param_values_json))
njsClient = NarrativeJobService(URLS.job_service, token = token)
wsClient = workspaceService(URLS.workspace, token = token)
if method_job_id.startswith("method:"):
method_job_id = method_job_id[7:]
is_async = is_async_method(methodSpec)
appState = None
if is_async:
# It's an SDK method, we use narrative proxy user to deal with sharing
ujs_proxy = job_manager.proxy_client()
appState = ujs_proxy.check_app_state(method_job_id)
else: # If it's NJS script method then we cannot use narrative proxy user
appState = njsClient.check_app_state(method_job_id)
for stepId in appState['step_outputs']:
rpcOut = appState['step_outputs'][stepId]
appState['widget_outputs'] = app_state_output_into_method_output(workspace, token, wsClient, methodSpec, methodInputValues, rpcOut)
appState['job_id'] = "method:" + appState['job_id']
return appState
else:
input = {}
rpcArgs = prepare_generic_method_input(token, workspace, methodSpec, methodInputValues, input);
output = method_job_id
methodOut = prepare_generic_method_output(token, workspace, methodSpec, input, output)
return methodOut
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_muscle'):
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_muscle',
'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_muscle(cls.cfg)
cls.scratch = cls.cfg['scratch']
cls.callback_url = os.environ['SDK_CALLBACK_URL']
def _assemble_contigs(meth, asm_input):
"""Use the AssemblyRAST service to assemble a set of contigs from sequenced reads.
This starts a job that might run for several hours.
When it finishes, the assembled ContigSet will be stored in your data space. [1]
:param asm_input: A list of files with read information [1.1]
:type asm_input: kbtypes.KBaseAssembly.AssemblyInput
:ui_name asm_input: Assembly Input file
:return: An assembly job
:rtype: kbtypes.Unicode
:output_widget: AssemblyWidget
"""
ws = os.environ['KB_WORKSPACE_ID']
token = os.environ['KB_AUTH_TOKEN']
arURL = 'http://kbase.us/services/assembly/'
ar_user = token.split('=')[1].split('|')[0]
wsClient = workspaceService(service.URLS.workspace, token=token)
ws_request = {'id': asm_input,
'workspace': ws}
asm_data = wsClient.get_object(ws_request)
meth.debug(str(asm_data))
return json.dumps({"ar_url": arURL,
"ar_user" : ar_user,
"ar_token" : token,
"ws_url" : service.URLS.workspace,
"ws_name" : os.environ['KB_WORKSPACE_ID'],
"kbase_assembly_input": asm_data['data']})
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
cls.ctx = {'token': token, 'provenance': [{'service': 'data_api2',
'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('data_api2'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = data_api2(cls.cfg)
cls.obj_name="ReferenceGenomeAnnotations/kb|g.207118"
cls.obj_name="ReferenceGenomeAnnotations/kb|g.217864"
cls.feature='kb|g.207118.CDS.3237'
cls.feature='kb|g.217864.CDS.11485'
cls.gene='kb|g.217864.locus.10619'
cls.obj_name="ReferenceGenomeAnnotations/kb|g.140057"
cls.feature='kb|g.140057.CDS.2901'
cls.gene='kb|g.140057.locus.2922'
cls.mrna='kb|g.140057.mRNA.2840'
cls.taxon= u'1779/523209/1'
cls.assembly='1837/56/1'
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
cls.token = token
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('kb_trimmomatic'):
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(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': token,
'user_id': user_id,
'provenance': [
{'service': 'kb_trimmomatic',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated': 1})
cls.wsURL = cls.cfg['workspace-url']
cls.shockURL = cls.cfg['shock-url']
cls.handleURL = cls.cfg['handle-service-url']
cls.serviceWizardURL = cls.cfg['service-wizard-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = kb_trimmomatic(cls.cfg)
def prepareInputfiles(token,workspace=None,files=None,wstype=None):
auth = Authentication(userFromToken(token), "", token)
json_error = None
status = None
job_ids = []
meta = []
ret_code = "FAILED"
ws = workspaceService(OTHERURLS.workspace)
files = files.split(",")
for nfile in files:
filename = os.path.basename(nfile)
try:
obj = ws.get_object({'auth': token, 'workspace': workspace, 'id': filename.strip(), 'type': wstype})
except Exception as err:
raise FileNotFound("File Not Found: {}".format(err))
#return {"output" : str(status), "error": json_error}
if 'data' in obj and 'shock_ref' in obj['data'] and 'shock_id' in obj['data']['shock_ref']:
node_id = obj['data']['shock_ref']['shock_id']
if 'data' in obj and 'metadata' in obj['data']:
meta.append(obj['data']['metadata'])
shockfilename = filename.replace("|","_")
if isFileFound(shockfilename,auth):
pass
job_ids.append(readShock(node_id,shockfilename,auth))
for jid in job_ids:
status = pollGridJob(jid, auth)
if status and not status.running_state == 2:
json_error = status.failure_info
ret_code = "SUCCESS"
return {"status" : ret_code ,"job_ids" : [x.job_id for x in job_ids] ,"metadata" : meta, "error": json_error}
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': 'testGenAnnoAPI',
'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('testGenAnnoAPI'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = testGenAnnoAPI(cls.cfg)
cls.obj_name="ReferenceGenomeAnnotations/kb|g.207118"
cls.obj_name="ReferenceGenomeAnnotations/kb|g.217864"
cls.feature='kb|g.207118.CDS.3237'
cls.feature='kb|g.217864.CDS.11485'
cls.gene='kb|g.217864.locus.10619'
cls.obj_name="ReferenceGenomeAnnotations/kb|g.140057"
cls.feature='kb|g.140057.CDS.2901'
cls.gene='kb|g.140057.locus.2922'
cls.mrna='kb|g.140057.mRNA.2840'
cls.taxon= u'1779/523209/1'
cls.assembly='1837/56/2'
def _app_get_state(workspace, token, URLS, job_manager, app_spec_json, method_specs_json, param_values_json, app_job_id):
appSpec = json.loads(app_spec_json)
paramValues = json.loads(correct_method_specs_json(param_values_json))
methIdToSpec = json.loads(correct_method_specs_json(method_specs_json))
njsClient = NarrativeJobService(URLS.job_service, token = token)
wsClient = workspaceService(URLS.workspace, token = token)
if app_job_id.startswith("njs:"):
app_job_id = app_job_id[4:]
appState = njsClient.check_app_state(app_job_id)
appState['widget_outputs'] = {}
prevStepReady = True
for stepSpec in appSpec['steps']:
stepId = stepSpec['step_id']
methodId = stepSpec['method_id']
methodSpec = methIdToSpec[methodId]
if stepId in appState['step_outputs']:
rpcOut = appState['step_outputs'][stepId]
prevStepReady = True
elif 'output_mapping' in methodSpec['behavior'] and prevStepReady:
rpcOut = None
prevStepReady = True
else:
prevStepReady = False
continue
methodInputValues = extract_param_values(paramValues, stepId)
appState['widget_outputs'][stepId] = app_state_output_into_method_output(workspace, token, wsClient, methodSpec, methodInputValues, rpcOut)
appState['job_id'] = "njs:" + appState['job_id']
return appState
def setUpClass(cls):
cls.token = environ.get('KB_AUTH_TOKEN')
cls.callbackURL = environ.get('SDK_CALLBACK_URL')
print('CB URL: ' + cls.callbackURL)
# 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,
'provenance': [
{'service': 'gaprice_SPAdes_test',
'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('gaprice_SPAdes_test'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.shockURL = cls.cfg['shock-url']
cls.hs = HandleService(url=cls.cfg['handle-service-url'],
token=cls.token)
cls.wsClient = workspaceService(cls.wsURL, token=cls.token)
wssuffix = int(time.time() * 1000)
wsName = "test_gaprice_SPAdes_test_" + str(wssuffix)
cls.wsinfo = cls.wsClient.create_workspace({'workspace': wsName})
print('created workspace ' + cls.getWsName())
cls.serviceImpl = gaprice_SPAdes_test(cls.cfg)
cls.staged = {}
cls.nodes_to_delete = []
cls.handles_to_delete = []
cls.setupTestData()
print('\n\n=============== Starting tests ==================')
def setUpClass(cls):
cls.token = environ.get('KB_AUTH_TOKEN', None)
cls.ctx = {'token': cls.token,
'provenance': [
{'service': 'gaprice_SPAdes',
'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('gaprice_SPAdes'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.shockURL = cls.cfg['shock-url']
cls.hs = HandleService(url=cls.cfg['handle-service-url'],
token=cls.token)
cls.wsClient = workspaceService(cls.wsURL, token=cls.token)
wssuffix = int(time.time() * 1000)
wsName = "test_gaprice_SPAdes_" + str(wssuffix)
cls.wsinfo = cls.wsClient.create_workspace({'workspace': wsName})
print('created workspace ' + cls.getWsName())
cls.serviceImpl = gaprice_SPAdes(cls.cfg)
cls.staged = {}
cls.nodes_to_delete = []
cls.handles_to_delete = []
cls.setupTestData()
print('\n\n=============== Starting tests ==================')
def build_msa(self, ctx, workspace_name, featureset_id, msa_id):
# ctx is the context object
# return variables are: returnVal
#BEGIN build_msa
returnVal = ''
# create workspace client
token = ctx['token']
ws = workspaceService(self.workspaceURL, token=token)
# Export fasta
self.exportFasta(ws, workspace_name, featureset_id)
# Run muscle
os.system('/kb/runtime/bin/muscle ' + ' -in ' + self.fileFastaName + ' -out ' + self.fileOutputName)
# Create MSA object
returnVal = self.createMSA(ws, workspace_name, featureset_id, msa_id)
#END build_msa
# At some point might do deeper type checking...
if not isinstance(returnVal, basestring):
raise ValueError('Method build_msa return value ' +
'returnVal is not type basestring as required.')
# return the results
return [returnVal]
def featureset_protein_sequence(self, ctx, workspace_name, featureset_id):
# ctx is the context object
# return variables are: returnVal
#BEGIN featureset_protein_sequence
returnVal = []
# create workspace client
token = ctx['token']
ws = workspaceService(self.workspaceURL, token=token)
# Build genome2Features hash
genome2Features = self.buildGenome2Features(ws, workspace_name, featureset_id)
# Process each genome one by one
for genomeRef in genome2Features:
genome = ws.get_objects([{'ref':genomeRef}])[0]['data']
featureIds = genome2Features[genomeRef]
for feature in genome['features']:
for fId in featureIds:
if fId == feature['id']:
returnVal.append({'feature_id' : fId, 'genome_ref' : genomeRef,'sequence': feature['protein_translation']})
#END featureset_protein_sequence
# At some point might do deeper type checking...
if not isinstance(returnVal, list):
raise ValueError('Method featureset_protein_sequence return value ' +
'returnVal is not type list as required.')
# return the results
return [returnVal]
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
user_id = requests.post(
'https://kbase.us/services/authorization/Sessions/Login',
data='token={}&fields=user_id'.format(token)).json()['user_id']
# 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': 'TestServiceCalls',
'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('TestServiceCalls'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = TestServiceCalls(cls.cfg)
def gene_network(meth,workspace_id=None,hm=None):
"""It takes the filtered expression data table and generates the heatmap
:param workspace_id: Name of the workspace; default is current
:type workspace_id: kbtypes.Unicode
:ui_name workspace_id : Workspace
:param hm: Filtered Datatable
:type hm: kbtypes.Unicode
:ui_name hm : Filtered Datatable
:return: Rows for display
:rtype: kbtypes.Unicode
:output_widget: kbaseHeatmap
"""
if not workspace_id:
workspace_id = meth.workspace_id
meth.stages = 1
# if not workspace_id:
# meth.debug("Workspace ID is empty, setting to current ({})".format(meth.workspace_id))
# workspace_id = meth.workspace_id
meth.advance("Retrieve network table from workspace")
if hm:
auth = Authentication(userFromToken(meth.token), "", meth.token)
ws = workspaceService(OTHERURLS.workspace)
dt_type = WSTYPES.datatabletype
raw_data = ws.get_object({'auth': meth.token, 'workspace': workspace_id, 'id': hm.strip(), 'type': dt_type})
else:
raw_data = {}
data = {'dataset': raw_data, 'height' : str(len(raw_data["data"]["row_labels"]) * 18) + "px"}
return json.dumps(data)
def __init__(self, scratch, workspaceURL, params, token, provenance):
self.scratch = scratch
self.workspaceURL = workspaceURL
self.params = params
self.token = token
self.provenance = provenance
self.plbin = "/kb/deployment/plbin"
self.log = ""
self.ws = workspaceService(self.workspaceURL, token=self.token)
def _method_call(meth, method_spec_json, param_values_json):
"""Generic service method calls
:param method_spec_json: Method descriptor JSON string
:type method_spec_json: kbtypes.Unicode
:ui_name method_spec_json: Method descriptor JSON string
:param param_values_json: Parameter values JSON string
:type param_values_json: kbtypes.Unicode
:ui_name param_values_json: Parameter values JSON string
:return: Service method response
:rtype: kbtypes.Unicode
"""
token = os.environ['KB_AUTH_TOKEN']
workspace = os.environ['KB_WORKSPACE_ID']
methodSpec = json.loads(correct_method_specs_json(method_spec_json))
paramValues = json.loads(correct_method_specs_json(param_values_json))
methodOut = None
behavior = methodSpec['behavior']
scriptStep = is_script_method(methodSpec)
async = is_async_method(methodSpec)
if scriptStep or async:
wsClient = workspaceService(service.URLS.workspace, token = token)
steps = []
methodId = methodSpec['info']['id']
app = { 'name' : 'App wrapper for method ' + methodId,'steps' : steps }
steps.append(create_app_step(workspace, token, wsClient, methodSpec, paramValues, methodId, scriptStep))
meth.debug(json.dumps(app))
njsClient = NarrativeJobService(service.URLS.job_service, token = token)
appState = njsClient.run_app(app)
jobId = "method:" + appState["job_id"]
meth.register_app(jobId)
methodOut = {'job_id': jobId}
else:
input = {}
output = None
if 'kb_service_input_mapping' in behavior:
rpcArgs = prepare_generic_method_input(token, workspace, methodSpec, paramValues, input);
url = behavior['kb_service_url']
serviceName = behavior['kb_service_name']
methodName = behavior['kb_service_method']
if serviceName:
methodName = serviceName + '.' + methodName
genericClient = GenericService(url = url, token = token)
output = genericClient.call_method(methodName, rpcArgs)
else:
parameters = methodSpec['parameters']
for paramPos in range(0, len(parameters)):
param = parameters[paramPos]
paramId = param['id']
paramValue = paramValues[paramPos]
input[paramId] = paramValue
methodOut = prepare_generic_method_output(token, workspace, methodSpec, input, output)
if 'job_id_output_field' in methodSpec:
jobIdField = methodSpec['job_id_output_field']
if jobIdField in methodOut:
meth.register_job(methodOut[jobIdField])
return json.dumps(methodOut)
def convert_read_library_to_file(self, ctx, params):
# ctx is the context object
# return variables are: output
#BEGIN convert_read_library_to_file
''' potential improvements:
Add continue_on_failure mode that reports errors for each failed
conversion rather than failing completely. This would need
a similar boolean to ignore failures in the workspace
get_objects method, or it'd require getting the reads objects
one by one. Yuck.
Alternatively - call get_object_info_new and then only process
the reads files that return. Race conditions possible though.
Probably better to add flag to get_objects.
Parallelize - probably not worth it, this is all IO bound. Try if
there's nothing better to do. If so, each process/thread needs
its own shock_tmp folder.
Add user specified failure conditions - e.g. fail if is/is not
metagenome, outwards reads, etc.
'''
self.log('Running convert_read_library_to_file with params:\n' +
pformat(params))
token = ctx['token']
self.process_params(params)
# self.log('\n' + pformat(params))
# Get the reads library
ws = workspaceService(self.workspaceURL, token=token)
ws_reads_ids = []
for read_name in params[self.PARAM_IN_LIB]:
ws_reads_ids.append({'ref': params[self.PARAM_IN_WS] + '/' +
read_name})
try:
reads = ws.get_objects(ws_reads_ids)
except WorkspaceException as e:
self.log('Logging stacktrace from workspace exception:\n' + e.data)
raise
output = {}
for read_name, read in zip(params[self.PARAM_IN_LIB], reads):
self.log('=== processing read library ' + read_name + '===\n',
prefix_newline=True)
output[read_name] = self.process_reads(
read, params[self.PARAM_IN_GZIP],
params[self.PARAM_IN_INTERLEAVED], token)
output = {'files': output}
#END convert_read_library_to_file
# At some point might do deeper type checking...
if not isinstance(output, dict):
raise ValueError('Method convert_read_library_to_file return value ' +
'output is not type dict as required.')
# return the results
return [output]
def featureset_nucleotide_sequence(self, ctx, workspace_name, featureset_id):
# ctx is the context object
# return variables are: returnVal
#BEGIN featureset_nucleotide_sequence
returnVal = []
# create workspace client
token = ctx['token']
ws = workspaceService(self.workspaceURL, token=token)
# Build genome2Features hash
genome2Features = self.buildGenome2Features(ws, workspace_name, featureset_id)
for genomeRef in genome2Features:
genome = ws.get_objects([{'ref':genomeRef}])[0]['data']
contigSet = ws.get_objects([{'ref': genome['contigset_ref']}])[0]['data']
# build a hash by contig name
contigs = {}
for contig in contigSet['contigs']:
contigs[contig['name']] = contig
# proces features
featureIds = genome2Features[genomeRef]
for feature in genome['features']:
for fId in featureIds:
if fId == feature['id']:
sequence = ''
fStrand = ''
for location in feature['location']:
(contigId, fStart, fStrand, fLen) = location
contig = contigs[contigId]
if fStrand == '+':
start = int(fStart) - 1
end = start + int(fLen)
else:
end = int(fStart)
start = end - int(fLen)
sequence += contig['sequence'][start:end]
if fStrand == '-':
sequence = self.reverseComplement( sequence )
returnVal.append({'feature_id' : fId, 'genome_ref' : genomeRef,'sequence': sequence})
#END featureset_nucleotide_sequence
# At some point might do deeper type checking...
if not isinstance(returnVal, list):
raise ValueError('Method featureset_nucleotide_sequence return value ' +
'returnVal is not type list as required.')
# return the results
return [returnVal]
def run_megahit(self, ctx, params):
# ctx is the context object
# return variables are: output
#BEGIN run_megahit
ws = workspaceService(self.workspaceURL, token=ctx['token'])
objects = ws.get_objects([{'ref': params['workspace_name']+'/'+params['read_library_name']}])
data = objects[0]['data']
info = objects[0]['info']
type_name = info[2].split('.')[1].split('-')[0]
report = 'report will go here'
report += 'input data type: '+type_name
reportObj = {
# 'objects_created':[{'ref':params['workspace_name']+'/'+params['output_contigset_name'], 'description':'Assembled contigs'}],
'objects_created':[],
'text_message':report
}
provenance = [{}]
if 'provenance' in ctx:
provenance = ctx['provenance']
# add additional info to provenance here, in this case the input data object reference
provenance[0]['input_ws_objects']=[params['workspace_name']+'/'+params['read_library_name']]
reportName = 'megahit_report_'+str(hex(uuid.getnode()))
report_obj_info = ws.save_objects({
'id':info[6],
'objects':[
{
'type':'KBaseReport.Report',
'data':reportObj,
'name':reportName,
'meta':{},
'hidden':1,
'provenance':provenance
}
]
})[0]
output = { 'report_name': reportName, 'report_ref': str(report_obj_info[6]) + '/' + str(report_obj_info[0]) + '/' + str(report_obj_info[4]) }
#END run_megahit
# At some point might do deeper type checking...
if not isinstance(output, dict):
raise ValueError('Method run_megahit return value ' +
'output is not type dict as required.')
# return the results
return [output]
def _prepare_genome(meth, contig_set, scientific_name, genetic_code, out_genome):
"""Build a Genome object from a ContigSet, creating structural and functional annotations.
The annotation job may run for an hour or longer. When the annotation job finishes,
the annotated Genome object will be stored in your workspace. [3]
:param contig_set: An object with contig data [3.1]
:type contig_set: kbtypes.KBaseGenomes.ContigSet
:ui_name contig_set: Contig Set Object
:param scientific_name: enter the scientific name to assign to your new genome [3.2]
:type scientific_name: kbtypes.Unicode
:ui_name scientific_name: Scientific Name
:param genetic_code: enter the genetic code for your new genome (default is 11) [3.2]
:type genetic_code: kbtypes.Unicode
:ui_name genetic_code: Genetic Code
:param out_genome: Annotated output genome ID. If empty, an ID will be chosen randomly. [3.3]
:type out_genome: kbtypes.KBaseGenomes.Genome
:ui_name out_genome: Output Genome ID
:return: Preparation message
:rtype: kbtypes.Unicode
:output_widget: GenomeAnnotation
"""
if not scientific_name:
return json.dump({'error': 'output genome name should be defined'})
if not genetic_code:
genetic_code = 11
if not out_genome:
out_genome = "genome_" + ''.join([chr(random.randrange(0, 26) + ord('A')) for _ in xrange(8)])
meth.stages = 2
meth.advance("Annotating the contigs (3-4 minutes)...")
token = os.environ['KB_AUTH_TOKEN']
workspace = os.environ['KB_WORKSPACE_ID']
fbaClient = fbaModelServices(url = service.URLS.fba, token = token)
# create the model object
contigset_to_genome_params = {
'auth': token,
'ContigSet_ws': workspace,
'ContigSet_uid': contig_set,
'workspace': workspace,
'uid': out_genome,
'scientific_name': scientific_name,
'domain': 'Bacteria',
'genetic_code': genetic_code,
}
fbaClient.ContigSet_to_Genome(contigset_to_genome_params)
wsClient = workspaceService(service.URLS.workspace, token=token)
genomeData = wsClient.get_objects([{'ref': workspace+'/'+out_genome}])[0]
genome = genomeData['data']
meta = genomeData['info'][10]
if not meta:
meta = {}
meta['Scientific name'] = scientific_name
wsClient.save_objects({'workspace': workspace, 'objects': [{'type': 'KBaseGenomes.Genome', 'name': out_genome, 'data': genome, 'meta': meta}]})
return json.dumps({'ws_name': workspace, 'ws_id': out_genome})
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
cls.ctx = {'token': token}
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('arkincount'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = arkincount(cls.cfg)
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
cls.ctx = {'token': token, 'provenance': [{'service': 'ContigFilterPython',
'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('ContigFilterPython'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = ContigFilterPython(cls.cfg)
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
auth_client = biokbase.nexus.Client(config={'server': 'nexus.api.globusonline.org',
'verify_ssl': True, 'client': None, 'client_secret': None})
user, _, _ = auth_client.validate_token(token)
cls.ctx = {'token': token, 'authenticated': 1, 'user_id': user}
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('onerepotest'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = onerepotest(cls.cfg)
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 setUpClass(cls):
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_ballgown'):
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': 'kb_ballgown',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated': 1})
cls.hs = HandleService(url=cls.cfg['handle-service-url'],
token=cls.token)
cls.shockURL = cls.cfg['shock-url']
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=cls.token)
cls.serviceImpl = kb_ballgown(cls.cfg)
cls.scratch = cls.cfg['scratch']
cls.callback_url = os.environ['SDK_CALLBACK_URL']
cls.gfu = GenomeFileUtil(cls.callback_url)
cls.dfu = DataFileUtil(cls.callback_url)
cls.ru = ReadsUtils(cls.callback_url)
cls.rau = ReadsAlignmentUtils(cls.callback_url, service_ver='dev')
cls.eu = ExpressionUtils(cls.callback_url, service_ver='dev')
cls.set_api = SetAPI(cls.callback_url)
suffix = int(time.time() * 1000)
cls.wsName = "test_kb_ballgown_" + str(suffix)
#cls.wsName = "test_kb_ballgown_1004"
cls.wsClient.create_workspace({'workspace': cls.wsName})
cls.nodes_to_delete = []
cls.handles_to_delete = []
cls.prepare_data()
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
cls.ctx = {'token': token}
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('PEReadUploaderTest'):
print(nameval[0] + '=' + nameval[1])
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.ws = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = PEReadUploaderTest(cls.cfg)
cls.shockURL = cls.cfg['shock-url']
cls.handleURL = cls.cfg['handle-service-url']
def count_contigs(self, ctx, workspace_name, contigset_id):
# ctx is the context object
# return variables are: returnVal
#BEGIN count_contigs
token = ctx['token']
wsClient = workspaceService(self.workspaceURL, token=token)
contigSet = wsClient.get_objects([{'ref': workspace_name+'/'+contigset_id}])[0]['data']
returnVal = {'contig_count': len(contigSet['contigs'])}
#END count_contigs
# At some point might do deeper type checking...
if not isinstance(returnVal, dict):
raise ValueError('Method count_contigs return value ' +
'returnVal is not type dict as required.')
# return the results
return [returnVal]
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_ea_utils'):
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': 'kb_ea_utils',
'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('kb_ea_utils'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.shockURL = cls.cfg['shock-url']
cls.handleURL = cls.cfg['handle-service-url']
cls.serviceWizardURL = cls.cfg['service-wizard-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = kb_ea_utils(cls.cfg)
cls.scratch = cls.cfg['scratch']
cls.callback_url = os.environ['SDK_CALLBACK_URL']
cls.dfu = DataFileUtil(cls.callback_url)
def _assemble_genome(meth, contig_file, out_genome):
"""This assembles a ContigSet into a Genome object in your workspace.
This should be run before trying to annotate a Genome. [2]
:param contig_file: A FASTA file with contig data [2.1]
:type contig_file: kbtypes.Unicode
:ui_name contig_file: Contig File ID
:param out_genome: Annotated output genome ID. If empty, an ID will be chosen randomly. [2.2]
:type out_genome: kbtypes.KBaseGenomes.Genome
:ui_name out_genome: Output Genome ID
:return: Assembled output genome ID
:rtype: kbtypes.KBaseGenomes.Genome
"""
# Regarding annotation, here's the latest. You want to take the fasta file that the above command
# created ("contigs.fasta"), and load it to the workspace as a contig set:
# "ga-loadfasta contigs.fasta -u MyContigs"
#
# -- this is already in the workspace by this point.
meth.stages = 4
token = os.environ['KB_AUTH_TOKEN']
workspace = os.environ['KB_WORKSPACE_ID']
# Setup invocation and double-check workspace
meth.advance("Initialize Annotation Service")
inv = InvocationService(service.URLS.invocation)
inv.run_pipeline("", "kbws-workspace " + workspace, [], 100, '/')
# Run sequence to genome.
meth.advance("Build Contig Set into a Genome")
inv.run_pipeline("", "ga-seq-to-genome " + contig_file + " --genomeid " + out_genome, [], 100, '/')
# 4. Fetch genome.
meth.advance("Fetching Genome for Display")
wsClient = workspaceService(service.URLS.workspace)
get_genome_params = {
'id': out_genome,
'type': 'Genome',
'workspace': workspace,
'auth': token,
}
genome_meta = wsClient.get_objectmeta(get_genome_params)
# 5. Pass it forward to the client.
meth.advance("Rendering Genome Information")
return json.dumps(genome_meta)
def _method_call(meth, method_spec_json, param_values_json):
"""Generic service method calls
:param method_spec_json: Method descriptor JSON string
:type method_spec_json: kbtypes.Unicode
:ui_name method_spec_json: Method descriptor JSON string
:param param_values_json: Parameter values JSON string
:type param_values_json: kbtypes.Unicode
:ui_name param_values_json: Parameter values JSON string
:return: Service method response
:rtype: kbtypes.Unicode
"""
token = os.environ['KB_AUTH_TOKEN']
workspace = os.environ['KB_WORKSPACE_ID']
methodSpec = json.loads(method_spec_json)
paramValues = json.loads(param_values_json)
methodOut = None
if is_script_method(methodSpec):
wsClient = workspaceService(service.URLS.workspace, token = token)
steps = []
methodId = methodSpec['info']['id']
app = { 'name' : 'App wrapper for method ' + methodId,'steps' : steps }
steps.append(create_app_step(workspace, token, wsClient, methodSpec, paramValues, methodId, True))
njsClient = NarrativeJobService(service.URLS.job_service, token = token)
appState = njsClient.run_app(app)
jobId = "method:" + appState["job_id"]
meth.register_app(jobId)
methodOut = {'job_id': jobId}
else:
input = {}
rpcArgs = prepare_generic_method_input(token, workspace, methodSpec, paramValues, input);
behavior = methodSpec['behavior']
url = behavior['kb_service_url']
serviceName = behavior['kb_service_name']
methodName = behavior['kb_service_method']
if serviceName:
methodName = serviceName + '.' + methodName
genericClient = GenericService(url = url, token = token)
output = genericClient.call_method(methodName, rpcArgs)
methodOut = prepare_generic_method_output(token, workspace, methodSpec, input, output)
if 'job_id_output_field' in methodSpec:
jobIdField = methodSpec['job_id_output_field']
if jobIdField in methodOut:
meth.register_job(methodOut[jobIdField])
return json.dumps(methodOut)
def setUpClass(cls):
cls.token = environ.get('KB_AUTH_TOKEN', None)
user_id = requests.post(
'https://kbase.us/services/authorization/Sessions/Login',
data='token={}&fields=user_id'.format(cls.token)).json()['user_id']
# 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': 'kb_PRINSEQ',
'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('kb_PRINSEQ'):
cls.cfg[nameval[0]] = nameval[1]
cls.shockURL = cls.cfg['shock-url']
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=cls.token)
cls.serviceImpl = kb_PRINSEQ(cls.cfg)
# cls.ws = workspaceService(cls.wsURL, token=token)
# cls.ws = Workspace(cls.cfg['workspace-url'], token=cls.token)
# cls.hs = HandleService(url=cls.cfg['handle-service-url'],
# token=cls.token)
cls.scratch = cls.cfg['scratch']
shutil.rmtree(cls.scratch)
os.mkdir(cls.scratch)
suffix = int(time.time() * 1000)
wsName = "test_kb_PRINSEQ_" + str(suffix)
cls.ws_info = cls.wsClient.create_workspace({'workspace': wsName})
cls.dfu = DataFileUtil(os.environ['SDK_CALLBACK_URL'], token=cls.token)
cls.nodes_to_delete = []
cls.nodes_to_delete.extend(cls.upload_test_reads())
print "NODES TO DELETE: {}".format(str(cls.nodes_to_delete))
print('\n\n=============== Starting tests ==================')
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_fastqc'):
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': 'kb_fastqc',
'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 = kb_fastqc(cls.cfg)
#retrieve and setup test files
test_fq_filename = "test_1.fastq.gz"
output = subprocess.check_output([
"curl", "-o", test_fq_filename,
"http://bioseed.mcs.anl.gov/~seaver/Files/Sample_Reads/WT1_S1_L001_R2_001.fastq.gz"
])
cls.large_fq_test_file1 = os.path.join(cls.cfg['scratch'],
test_fq_filename)
shutil.copy(test_fq_filename, cls.large_fq_test_file1)
fq_filename = "interleaved.fq"
cls.small_fq_test_file2 = os.path.join(cls.cfg['scratch'], fq_filename)
shutil.copy(os.path.join("data", fq_filename), cls.small_fq_test_file2)
def check_feature_cache(self, ref, token):
ws_client = workspaceService(self.ws_url, token=token)
info = ws_client.get_object_info_new({"objects": [{"ref": ref}]})[0]
inner_chsum = info[8]
index_file = os.path.join(self.genome_index_dir, inner_chsum + "_ftr.tsv.gz")
if not os.path.isfile(index_file):
if self.debug:
print(" Loading WS object...")
t1 = time.time()
genome = ws_client.get_objects2({"objects": [{"ref": ref, "included": [
"/features/[*]/id", "/features/[*]/type", "/features/[*]/function",
"/features/[*]/aliases", "/features/[*]/location",
"/features/[*]/ontology_terms/*/*/term_name"]}]})["data"][0]["data"]
self.save_feature_tsv(genome["features"], inner_chsum)
if self.debug:
print(" (time=" + str(time.time() - t1) + ")")
return inner_chsum
def setUpClass(cls):
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_uploadmethods'):
cls.cfg[nameval[0]] = nameval[1]
authServiceUrl = cls.cfg.get(
'auth-service-url',
"https://kbase.us/services/authorization/Sessions/Login")
auth_client = _KBaseAuth(authServiceUrl)
cls.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':
cls.user_id,
'provenance': [{
'service': 'kb_uploadmethods',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated':
1
})
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=cls.token)
cls.serviceImpl = kb_uploadmethods(cls.cfg)
cls.dfu = DataFileUtil(os.environ['SDK_CALLBACK_URL'], token=cls.token)
cls.gfu = GenomeFileUtil(os.environ['SDK_CALLBACK_URL'],
token=cls.token)
cls.fba_tools = fba_tools(os.environ['SDK_CALLBACK_URL'],
token=cls.token)
cls.scratch = cls.cfg['scratch']
cls.shockURL = cls.cfg['shock-url']
suffix = int(time.time() * 1000)
cls.wsName = "test_kb_uploadmethods_phenotype_set" + str(suffix)
cls.wsClient.create_workspace({'workspace': cls.wsName})
cls.prepare_data()
def setUpClass(cls):
cls.__LOGGER = logging.getLogger('ExpressionUtils_test')
cls.__LOGGER.setLevel(logging.INFO)
streamHandler = logging.StreamHandler(sys.stdout)
formatter = logging.Formatter(
"%(asctime)s - %(filename)s - %(lineno)d - %(levelname)s - %(message)s"
)
formatter.converter = time.gmtime
streamHandler.setFormatter(formatter)
cls.__LOGGER.addHandler(streamHandler)
cls.__LOGGER.info("Logger was set")
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('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(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': 'ExpressionUtils',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated':
1
})
cls.wsURL = cls.cfg['workspace-url']
cls.callback_url = os.environ['SDK_CALLBACK_URL']
cls.cfg['SDK_CALLBACK_URL'] = cls.callback_url
cls.wsClient = workspaceService(cls.wsURL)
cls.serviceImpl = ExpressionUtils(cls.cfg)
cls.scratch = cls.cfg['scratch']
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
cls.ctx = {'token': token, 'provenance': [{'service': 'AssemblyRAST',
'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('AssemblyRAST'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.ws = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = AssemblyRAST(cls.cfg)
cls.shockURL = cls.cfg['shock-url']
cls.handleURL = cls.cfg['handle-service-url']
logger.info('shockURL='+cls.shockURL)
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
cls.ctx = {'token': token, 'provenance': [{'service': 'AssemblyRAST',
'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('AssemblyRAST'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.ws = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = AssemblyRAST(cls.cfg)
cls.shockURL = cls.cfg['shock-url']
cls.handleURL = cls.cfg['handle-service-url']
logger.info('shockURL='+cls.shockURL)
def _get_ws(wsname, name, wtype,auth):
#token = os.environ['KB_AUTH_TOKEN']
ws = workspaceService(OTHERURLS.workspace)
obj = ws.get_object({'auth': auth, 'workspace': wsname, 'id': name, 'type': wtype})
data = None
# Data format
if 'data' in obj['data']:
data = obj['data']['data']
# Handle format
elif 'shock_ref' in obj['data']:
data = obj['data']['shock_ref']
# Collection format
elif 'members' in obj['data']:
data = [m['ID'] for m in obj['data']['members']]
# just return the whole thing
else:
data = obj['data']
return data
def setUpClass(cls):
token = environ.get("KB_AUTH_TOKEN", None)
cls.ctx = {
"token": token,
"provenance": [
{"service": "ContigCount_mshukla", "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("ContigCount_mshukla"):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg["workspace-url"]
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = ContigCount_mshukla(cls.cfg)
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_cufflinks'):
cls.cfg[nameval[0]] = nameval[1]
# Getting username from Auth profile for token
authServiceUrl = cls.cfg['auth-service-url']
# authServiceUrlAllowInsecure = cls.cfg['auth_service_url_allow_insecure']
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_cufflinks',
'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_cufflinks(cls.cfg)
cls.scratch = cls.cfg['scratch']
cls.callback_url = os.environ['SDK_CALLBACK_URL']
cls.gfu = GenomeFileUtil(cls.callback_url)
cls.dfu = DataFileUtil(cls.callback_url)
cls.ru = ReadsUtils(cls.callback_url)
cls.rau = ReadsAlignmentUtils(cls.callback_url)
cls.deu = DifferentialExpressionUtils(cls.callback_url,
service_ver='beta')
suffix = int(time.time() * 1000)
cls.wsName = "test_cuffdiff_" + str(suffix)
cls.wsClient.create_workspace({'workspace': cls.wsName})
cls.upload_genome()
def _compute_pan_genome(meth, genome_set,pangenome_id):
""" Rapidly compute gene families for a set of phylogenetically close genomes
:param genome_set: a Genome Set to compute pangenome for
:type genome_set: kbtypes.KBaseSearch.GenomeSet
:ui_name genome_set: Genome Set ID
:param pangenome_id: ID for output pangenome
:type pangenome_id: kbtypes.KBaseGenomes.Pangenome
:ui_name pangenome_id: Pangenome ID
:return: Generated Pangenome Object
:rtype: kbtypes.KBaseGenomes.Pangenome
:output_widget: kbasePanGenome
"""
meth.stages = 2
meth.advance("Computing pangenome (20 sec per genome)...")
usertoken, workspace_id = meth.token, meth.workspace_id
ws = workspaceService(service.URLS.workspace, token=usertoken)
data = ws.get_objects([{'ref': workspace_id+'/'+genome_set}])[0]
genome_set_elements = data['data']['elements']
genomes = []
gwss = []
for key in genome_set_elements:
array = genome_set_elements[key]['ref'].split('/')
gwss.append(array[0])
genomes.append(array[1])
pangenome_parameters = {
'genomes':genomes,
'genome_workspaces':gwss,
'workspace':workspace_id,
'auth':usertoken,
'wsurl':service.URLS.workspace}
if pangenome_id:
pangenome_parameters['output_id']=pangenome_id
fbaclient = fbaModelServices(url = service.URLS.fba, token=usertoken)
meta = fbaclient.build_pangenome(pangenome_parameters)
return json.dumps({'ws': workspace_id, 'name':meta[1]})
def count_contigs(self, ctx, workspace_name, contigset_id):
# ctx is the context object
# return variables are: returnVal
#BEGIN count_contigs
token = ctx['token']
wsClient = workspaceService(self.workspaceURL, token=token)
contigSet = wsClient.get_objects([{
'ref':
workspace_name + '/' + contigset_id
}])[0]['data']
returnVal = {'contig_count': len(contigSet['contigs'])}
#END count_contigs
# At some point might do deeper type checking...
if not isinstance(returnVal, dict):
raise ValueError('Method count_contigs return value ' +
'returnVal is not type dict as required.')
# return the results
return [returnVal]
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('ExpressionAPI'):
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': 'ExpressionAPI',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated':
1
})
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL)
suffix = int(time.time() * 1000)
cls.wsName = "test_exprAPI_FEM_test_ws_" + str(suffix)
cls.wsClient.create_workspace({'workspace': cls.wsName})
cls.serviceImpl = ExpressionAPI(cls.cfg)
cls.scratch = cls.cfg['scratch']
cls.callback_url = os.environ['SDK_CALLBACK_URL']
cls.dfu = DataFileUtil(cls.callback_url)
cls.ws_id = cls.dfu.ws_name_to_id(cls.wsName)
cls.serviceWizardURL = cls.cfg['srv-wiz-url']
print "### serviceWizardURL = {0}".format(cls.serviceWizardURL)
cls.gaa = GenomeAnnotationAPI(cls.serviceWizardURL)
cls.setupdata()
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('PanGenomeAPI'):
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': 'PanGenomeAPI',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated':
1
})
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL)
cls.serviceImpl = PanGenomeAPI(cls.cfg)
cls.scratch = cls.cfg['scratch']
shutil.rmtree(cls.scratch)
os.mkdir(cls.scratch)
cls.callback_url = os.environ['SDK_CALLBACK_URL']
suffix = int(time.time() * 1000)
wsName = "test_pangenome_api_" + str(suffix)
cls.ws_info = cls.wsClient.create_workspace({'workspace': wsName})
cls.gcs = GenomeComparisonSDK(cls.callback_url)
cls.gaa = GenomeAnnotationAPI(cls.callback_url)
cls.prepare_data()
def _align_protein_sequences(meth, feature_set, alignment_method, out_msa):
"""Construct multiple sequence alignment object based on set of proteins. [27]
:param feature_set: An object with protein features [27.1]
:type feature_set: kbtypes.KBaseSearch.FeatureSet
:ui_name feature_set: Feture Set Object
:param alignment_method: name of alignment method (one of Muscle, Clustal, ProbCons, T-Coffee, Mafft), leave it blank for default Clustal method [27.2]
:type alignment_method: kbtypes.Unicode
:ui_name alignment_method: Multiple Alignment Method
:param out_msa: Multiple sequence alignment object ID. If empty, an ID will be chosen randomly. [27.3]
:type out_msa: kbtypes.KBaseTrees.MSA
:ui_name out_msa: Output MSA ID
:return: Preparation message
:rtype: kbtypes.Unicode
:output_widget: kbaseMSA
"""
if not alignment_method:
alignment_method = 'Clustal'
if not out_msa:
out_msa = "msa_" + ''.join([chr(random.randrange(0, 26) + ord('A')) for _ in xrange(8)])
meth.stages = 1
token, workspace = meth.token, meth.workspace_id
ws = workspaceService(service.URLS.workspace, token=token)
elements = ws.get_objects([{'ref': workspace+'/'+feature_set}])[0]['data']['elements']
gene_sequences = {}
for key in elements:
elem = elements[key]['data']
id = elem['id']
if 'genome_ref' in elem:
genome_obj_name = ws.get_object_info([{'ref' : elem['genome_ref']}],0)[0][1]
id = genome_obj_name + '/' + id
seq = elements[key]['data']['protein_translation']
gene_sequences[id] = seq
treeClient = KBaseTrees(url = service.URLS.trees, token = token)
construct_multiple_alignment_params = {
'gene_sequences': gene_sequences,
'alignment_method': alignment_method,
'out_workspace': workspace,
'out_msa_id': out_msa
}
job_id = treeClient.construct_multiple_alignment(construct_multiple_alignment_params)
return json.dumps({'workspaceID': workspace, 'msaID': out_msa, 'jobID' : job_id})
def setUpClass(cls):
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_uploadmethods'):
cls.cfg[nameval[0]] = nameval[1]
authServiceUrl = cls.cfg.get(
'auth-service-url',
"https://kbase.us/services/authorization/Sessions/Login")
auth_client = _KBaseAuth(authServiceUrl)
cls.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':
cls.user_id,
'provenance': [{
'service': 'kb_uploadmethods',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated':
1
})
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=cls.token)
cls.serviceImpl = kb_uploadmethods(cls.cfg)
cls.dfu = DataFileUtil(os.environ['SDK_CALLBACK_URL'], token=cls.token)
cls.scratch = cls.cfg['scratch']
cls.shockURL = cls.cfg['shock-url']
cls.ftp_domain = socket.gethostbyname(socket.gethostname())
cls.ftp_port = 21
thread = threading.Thread(target=cls.start_ftp_service,
args=(cls.ftp_domain, cls.ftp_port))
thread.daemon = True
thread.start()
time.sleep(5)
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
cls.callback_url = os.environ['SDK_CALLBACK_URL']
cls.ctx = {'token': token}
config_file = environ.get('KB_DEPLOYMENT_CONFIG', None)
cls.cfg = {}
config = ConfigParser()
config.read(config_file)
for nameval in config.items('kb_cummerbund'):
cls.cfg[nameval[0]] = nameval[1]
cls.scratch = cls.cfg['scratch']
cls.wsURL = cls.cfg['ws_url']
cls.gfu = GenomeFileUtil(cls.callback_url)
cls.ru = ReadsUtils(cls.callback_url)
cls.rau = ReadsAlignmentUtils(cls.callback_url, service_ver='dev')
cls.eu = ExpressionUtils(cls.callback_url, service_ver='dev')
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.dfu = DataFileUtil(cls.callback_url, token=token)
cls.serviceImpl = kb_cummerbund(cls.cfg)
cls.prepare_data()
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_cutadapt'):
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': 'kb_cutadapt',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated': 1})
cls.wsURL = cls.cfg['workspace-url']
cls.shockURL = cls.cfg['shock-url']
cls.handleURL = cls.cfg['handle-service-url']
cls.serviceWizardURL = cls.cfg['service-wizard-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = kb_cutadapt(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})
cls.wsName = wsName
# handle files in test
"""
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_MaSuRCA'):
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': 'MaSuRCA',
'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_MaSuRCA(cls.cfg)
cls.scratch = cls.cfg['scratch']
cls.callback_url = os.environ['SDK_CALLBACK_URL']
cls.masurca_PROJECT_DIR = 'masurca_outputs'
cls.scratch = cls.cfg['scratch']
if not os.path.exists(cls.scratch):
os.makedirs(cls.scratch)
cls.masurca_prjdir = os.path.join(cls.scratch, cls.masurca_PROJECT_DIR)
cls.masurca_assembler = MaSuRCA_Assembler(cls.cfg, cls.ctx.provenance)
cls.masurca_utils = masurca_utils(cls.masurca_prjdir, cls.cfg)
def setUpClass(cls):
cls.token = environ.get('KB_AUTH_TOKEN')
cls.callbackURL = environ.get('SDK_CALLBACK_URL')
print('CB URL: ' + cls.callbackURL)
# 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,
'provenance': [{
'service': 'kb_IDBA',
'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('kb_IDBA'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.shockURL = cls.cfg['shock-url']
cls.hs = HandleService(url=cls.cfg['handle-service-url'],
token=cls.token)
cls.wsClient = workspaceService(cls.wsURL, token=cls.token)
wssuffix = int(time.time() * 1000)
wsName = "test_kb_IDBA" + str(wssuffix)
cls.wsinfo = cls.wsClient.create_workspace({'workspace': wsName})
print('created workspace ' + cls.getWsName())
cls.serviceImpl = kb_IDBA(cls.cfg)
cls.readUtilsImpl = ReadsUtils(cls.callbackURL, token=cls.token)
cls.staged = {}
cls.nodes_to_delete = []
cls.handles_to_delete = []
cls.setupTestData()
print('\n\n=============== Starting tests ==================')
def view_phenotype(meth, phenotype_set_id):
"""Bring up a detailed view of your Phenotype Simulation results within the narrative.
:param phenotype_set_id: the phenotype results to view
:type phenotype_set_id: kbtypes.KBasePhenotypes.PhenotypeSimulationSet
:ui_name phenotype_set_id: Phenotype Simulation Set
:return: Phenotype Simulation Set Data
:rtype: kbtypes.KBasePhenotypes.PhenotypeSimulationSet
:output_widget: kbaseSimulationSet
"""
meth.stages = 2 # for reporting progress
meth.advance("Starting...")
#grab token and workspace info, setup the client
userToken, workspaceName = meth.token, meth.workspace_id;
meth.advance("Loading the phenotype simulation results")
ws = workspaceService(service.URLS.workspace, token=userToken)
return json.dumps({'ws': meth.workspace_id, 'name' : phenotype_set_id})
def create_app_for_njs(workspace, token, URLS, appId, stepSpecs, methIdToSpec, paramValues):
steps = []
app = { 'name' : appId,'steps' : steps }
wsClient = workspaceService(URLS.workspace, token=token)
scriptApp = False
for stepSpec in stepSpecs:
methodId = stepSpec['method_id']
methodSpec = methIdToSpec[methodId]
if is_script_method(methodSpec):
scriptApp = True
break
for stepSpec in stepSpecs:
stepId = stepSpec['step_id']
methodId = stepSpec['method_id']
methodSpec = methIdToSpec[methodId]
methodInputValues = extract_param_values(paramValues, stepId)
step = create_app_step(workspace, token, wsClient, methodSpec, methodInputValues, stepId, scriptApp)
if step is None:
continue
steps.append(step)
return app
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': 'GenomeFileUtil',
'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('GenomeFileUtil'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = GenomeFileUtil(cls.cfg)
def featureset_protein_sequence(self, ctx, workspace_name, featureset_id):
# ctx is the context object
# return variables are: returnVal
#BEGIN featureset_protein_sequence
returnVal = []
# create workspace client
token = ctx['token']
ws = workspaceService(self.workspaceURL, token=token)
# Build genome2Features hash
genome2Features = self.buildGenome2Features(ws, workspace_name,
featureset_id)
# Process each genome one by one
for genomeRef in genome2Features:
genome = ws.get_objects([{'ref': genomeRef}])[0]['data']
featureIds = genome2Features[genomeRef]
for feature in genome['features']:
for fId in featureIds:
if fId == feature['id']:
returnVal.append({
'feature_id':
fId,
'genome_ref':
genomeRef,
'sequence':
feature['protein_translation']
})
#END featureset_protein_sequence
# At some point might do deeper type checking...
if not isinstance(returnVal, list):
raise ValueError(
'Method featureset_protein_sequence return value ' +
'returnVal is not type list as required.')
# return the results
return [returnVal]
def get_fastq_ea_utils_stats(self, ctx, input_params):
"""
This function should be used for getting statistics on read library object types
The results are returned as a string.
:param input_params: instance of type
"get_fastq_ea_utils_stats_params" (if read_library_ref is set,
then workspace_name and read_library_name are ignored) ->
structure: parameter "workspace_name" of String, parameter
"read_library_name" of String, parameter "read_library_ref" of
String
:returns: instance of String
"""
# ctx is the context object
# return variables are: ea_utils_stats
#BEGIN get_fastq_ea_utils_stats
token = ctx['token']
wsClient = workspaceService(self.workspaceURL)
# add additional info to provenance here, in this case the input data object reference
input_reads_ref = self.get_reads_ref_from_params(input_params)
info = None
readLibrary = None
try:
readLibrary = wsClient.get_objects2({'objects':[{'ref': input_reads_ref}]})['data'][0]
info = readLibrary['info']
readLibrary = readLibrary['data']
except Exception as e:
raise ValueError('Unable to get read library object from workspace: (' + input_reads_ref + ')' + str(e))
ea_utils_stats = ''
ea_utils_stats = self.get_ea_utils_result(input_reads_ref, input_params)
#END get_fastq_ea_utils_stats
# At some point might do deeper type checking...
if not isinstance(ea_utils_stats, basestring):
raise ValueError('Method get_fastq_ea_utils_stats return value ' +
'ea_utils_stats is not type basestring as required.')
# return the results
return [ea_utils_stats]
def setUpClass(cls):
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_ke_util'):
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': 'kb_ke_util',
'method': 'please_never_use_it_in_production',
'method_params': []
}],
'authenticated': 1})
cls.shockURL = cls.cfg['shock-url']
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL)
cls.serviceImpl = kb_ke_util(cls.cfg)
cls.scratch = cls.cfg['scratch']
cls.callback_url = os.environ['SDK_CALLBACK_URL']
cls.dfu = DataFileUtil(cls.callback_url)
cls.cfg['KB_AUTH_TOKEN'] = cls.token
cls.ke_util = KnowledgeEngineUtil(cls.cfg)
suffix = int(time.time() * 1000)
cls.wsName = "test_kb_ke_apps_" + str(suffix)
cls.wsClient.create_workspace({'workspace': cls.wsName})
cls.nodes_to_delete = []
cls.prepare_data()
def setUpClass(cls):
token = environ.get('KB_AUTH_TOKEN', None)
cls.ctx = {
'token':
token,
'provenance': [{
'service': 'MegaHitTest',
'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('MegaHitTest'):
cls.cfg[nameval[0]] = nameval[1]
cls.wsURL = cls.cfg['workspace-url']
cls.wsClient = workspaceService(cls.wsURL, token=token)
cls.serviceImpl = MegaHitTest(cls.cfg)
def _save_report(self, base_report_name, report_obj, provenance, ws_name, token):
"""
Raises the usual exceptions if there's a failure while saving.
"""
wsClient = workspaceService(self.workspaceURL, token=token)
report_name = '{}_{}'.format(base_report_name, str(hex(uuid.getnode())))
report_info_list = None
report_info_list = wsClient.save_objects({
'workspace': ws_name,
'objects': [
{
'type': 'KBaseReport.Report',
'data': report_obj,
'name': report_name,
'meta': {},
'hidden': 1, # important! make sure the report is hidden
'provenance': provenance
}
]
})
return report_info_list[0]
