def get_probanno(self, ctx, input): # ctx is the context object # return variables are: output #BEGIN get_probanno ''' Convert a probabilistic annotation object into a human-readbable table. @param ctx Current context object @param input Dictionary with input parameters for function @return Dictionary keyed by gene to a list of tuples with roleset and likelihood @raise WrongVersionError when ProbAnno object version number is invalid ''' input = self._checkInputArguments(ctx, input, ['probanno', 'probanno_workspace'], { 'probanno_version': None } ) wsClient = Workspace(self.config["workspace_url"], token=ctx['token']) probAnnoObjectId = make_object_identity(input["probanno_workspace"], input["probanno"], input['probanno_version']) objectList = wsClient.get_objects( [ probAnnoObjectId ] ) probAnnoObject = objectList[0] if probAnnoObject['info'][2] != ProbAnnoType: message = 'ProbAnno object type %s is not %s for object %s' %(probAnnoObject['info'][2], ProbAnnoType, probAnnoObject['info'][1]) ctx.log_err(message) raise WrongVersionError(message) output = probAnnoObject["data"]["roleset_probabilities"] #END get_probanno # At some point might do deeper type checking... if not isinstance(output, dict): raise ValueError('Method get_probanno return value ' + 'output is not type dict as required.') # return the results return [output]
def get_genome(genome_id=None, workspace_id=None, token=None, workspace_url=None): #download genome object from workspace if workspace_url is None: workspace_url = 'https://kbase.us/services/ws/' if token is None: with open('/kb/dev_container/modules/genome_util/mytoken.txt' ) as token_file: token = token_file.read() token = token.rstrip() #print token #print genome_id #print workspace_id workspace_client = Workspace(url=workspace_url, token=token) #genome=workspace_client.get_object({'id':genome_id, 'workspace':workspace_id, 'type':'KBaseGenomes.Genome'}) genome = workspace_client.get_object({ 'id': 'Bifidobacterium_animalis_subsp._lactis_AD011', 'type': 'KBaseGenomes.Genome', 'workspace': 'plane83:1436884411390' }) return genome
def BuildFastaFromSequenceSet(self, ctx, params): """ :param params: instance of type "BuildSeqIn" -> structure: parameter "workspace_name" of String, parameter "SequenceSetRef" of String, parameter "fasta_outpath" of String :returns: instance of type "BuildSeqOut" -> structure: parameter "fasta_outpath" of String """ # ctx is the context object # return variables are: output #BEGIN BuildFastaFromSequenceSet #END BuildFastaFromSequenceSet # At some point might do deeper type checking... dfu = DataFileUtil(self.callback_url) bu = BackgroundUtils() TU = TestUtils() if params['TESTFLAG'] and params['background']: targetpath = '/kb/module/work/tmp/testgenome.fa' TU.GetGenome(targetpath) bu.BuildBackground(targetpath) elif params['background']: ws = Workspace('https://appdev.kbase.us/services/ws') subset = ws.get_object_subset([{ 'included':['/features/[*]/location', '/features/[*]/id','/assembly_ref'], 'ref':params['genome_ref']}]) aref = subset[0]['data']['assembly_ref'] assembly_ref = {'ref': aref} print('Downloading Assembly data as a Fasta file.') assemblyUtil = AssemblyUtil(self.callback_url) fasta_file = assemblyUtil.get_assembly_as_fasta(assembly_ref)['path'] bu.BuildBackground(fasta_file) get_objects_params = {'object_refs' : [params['SequenceSetRef']]} SeqSet = dfu.get_objects(get_objects_params)['data'][0]['data'] outFile = open(params['fasta_outpath'],'w') for s in SeqSet['sequences']: sname = '>' + s['sequence_id'] + '\n' outFile.write(sname) sseq = s['sequence'] + '\n' outFile.write(sseq) outFile.close() fu=FastaUtils() if params['mask_repeats']: fu.RemoveRepeats(params['fasta_outpath'],params['fasta_outpath']) output = {'fasta_outpath' : params['fasta_outpath']} #END BuildFastaFromSequenceSet # At some point might do deeper type checking... if not isinstance(output, dict): raise ValueError('Method BuildFastaFromSequenceSet return value ' + 'output is not type dict as required.') # return the results return [output]
def download_workspace_data(ws_url, source_ws, source_obj, working_dir, logger): ws = Workspace(ws_url, token=TOKEN) objdata = ws.get_objects([{'ref': source_ws + '/' + source_obj}])[0] info = objdata['info'] if info[2].split('-')[0] != 'KBaseFile.AssemblyFile': raise ValueError( 'This method only works on the KBaseFile.AssemblyFile type') shock_url = objdata['data']['assembly_file']['file']['url'] shock_id = objdata['data']['assembly_file']['file']['id'] ref = str(info[6]) + '/' + str(info[0]) + '/' + str(info[4]) source = objdata['data'].get('source') outfile = os.path.join(working_dir, source_obj) shock_node = shock_url + '/node/' + shock_id + '/?download' headers = {'Authorization': 'OAuth ' + TOKEN} with open(outfile, 'w') as f: response = requests.get(shock_node, stream=True, headers=headers) if not response.ok: try: err = json.loads(response.content)['error'][0] except: logger.error("Couldn't parse response error content: " + response.content) response.raise_for_status() raise Exception(str(err)) for block in response.iter_content(1024): if not block: break f.write(block) return shock_url, shock_id, ref, source
def get_object_from_ref(ref): objid = int(ref.split("/")[1]) WS_URL = "https://ci.kbase.us/services/ws/" from biokbase.workspace.client import Workspace ws = Workspace(WS_URL) return ws.get_objects([dict(workspace=os.environ["KB_WORKSPACE_ID"], objid=objid)])[0]["data"]
def __init__(self, url=None, token=None, user_id=None, password=None, wsid=None, create=False, **create_kw): """Constructor. :param url: URL of remote WS service :type url: str :param token: Authorization token, overrides 'user_id'/'password' :type token: str :param user_id: User ID for authentication (overridden by 'token') :type user_id: str :param user_id: Password for authentication (overridden by 'token') :type user_id: str :param wsid: Workspace ID or name :type wsid: str :param create_kw: Any extra keywords to create a new workspace :type create_kw: None or dict :raise: ValueError if workspace id is empty, KeyError if there is no workspace by that name, WorkspaceException if creation of the workspace fails. """ WS2.__init__(self, url=url, user_id=user_id, password=password, token=token) self.has_wsid = False if wsid is not None: self._init_ws(wsid, create_kw) self.has_wsid = True
def get_object_uid(name): WS_URL = "https://ci.kbase.us/services/ws/" from biokbase.workspace.client import Workspace ws = Workspace(WS_URL) info = ws.get_objects([dict(workspace=os.environ["KB_WORKSPACE_ID"], name=name)])[0]["info"] return "%s/%s/%s" % (info[6], info[0], info[4])
def associateReads(self, ctx, params): # ctx is the context object # return variables are: returnVal # BEGIN associateReads user_token = ctx["token"] ws_client = Workspace(url=self.__WS_URL, token=user_token) out = dict() out["metadata"] = { k: v for k, v in params.iteritems() if not k in ("ws_id", "analysis_id", "genome_id", "singleend_sample", "pairedend_sample") and v is not None } self.__LOGGER.info("Uploading RNASeqSample {0}".format(out["metadata"]["sample_id"])) if "genome_id" in params and params["genome_id"] is not None: out["metadata"]["genome_id"] = script_util.get_obj_info( self.__LOGGER, self.__WS_URL, [params["genome_id"]], params["ws_id"], user_token )[0] if "analysis_id" in params and params["analysis_id"] is not None: g_ref = script_util.get_obj_info( self.__LOGGER, self.__WS_URL, [params["analysis_id"]], params["ws_id"], user_token )[0] out["analysis_id"] = g_ref if "singleend_sample" in params and params["singleend_sample"] is not None: try: s_res = ws_client.get_objects([{"name": params["singleend_sample"], "workspace": params["ws_id"]}]) out["singleend_sample"] = s_res[0]["data"] print out["singleend_sample"] except Exception, e: raise KBaseRNASeqException( "Error Downloading SingleEndlibrary object from the workspace {0},{1}".format( params["singleend_sample"], e ) )
def delete_narrative(ws_id, auth_token, url=ci_ws): """ Deletes a workspace with the given id. Throws a ServerError if the user given by auth_token isn't allowed to do so. """ ws_client = Workspace(url=url, token=auth_token.token) ws_client.delete_workspace({'id': ws_id})
def get_object_uid(name): WS_URL = 'https://ci.kbase.us/services/ws/' from biokbase.workspace.client import Workspace ws = Workspace(WS_URL) info = ws.get_objects( [dict(workspace=os.environ['KB_WORKSPACE_ID'], name=name)])[0]['info'] return '%s/%s/%s' % (info[6], info[0], info[4])
def delete_narrative(ws_id, auth_token, url=ci_ws): """ Deletes a workspace with the given id. Throws a ServerError if the user given by auth_token isn't allowed to do so. """ ws_client = Workspace(url=url, token=auth_token) ws_client.delete_workspace({"id": ws_id})
def TophatCall(self, ctx, params): # ctx is the context object # return variables are: returnVal # BEGIN TophatCall ws_client = Workspace(url=self.__WS_URL, token=user_token) hs = HandleService(url=self.__HS_URL, token=user_token) try: ### Make a function to download the workspace object and prepare dict of genome ,lib_type self.__LOGGER.info("Downloading RNASeq Sample file") try: ret = ws_client.get_objects( [ {"name": params["sample_id"], "workspace": params["ws_id"]}, {"name": params["reference"], "workspace": params["ws_id"]}, {"name": params["bowtie_index"], "workspace": params["ws_id"]}, {"name": params["annotation_gtf"], "workspace": params["ws_id"]}, ] ) except Exception, e: raise KBaseRNASeqException("Error Downloading objects from the workspace ") # Download reads from the JSON object genome = params["reference"] if "data" in reads: # if 'metadata' in reads['data']: # genome = reads['data']['metadata']['ref_genome'] if "singleend_sample" in reads["data"]: lib_type = "SingleEnd" # cmdstring = elif "pairedend_sample" in reads["data"]: lib_type = "PairedEnd"
def get_object_from_ref(ref): objid = int(ref.split('/')[1]) WS_URL = 'https://ci.kbase.us/services/ws/' from biokbase.workspace.client import Workspace ws = Workspace(WS_URL) return ws.get_objects( [dict(workspace=os.environ['KB_WORKSPACE_ID'], objid=objid)])[0]['data']
def create(self, ctx, params): # ctx is the context object # return variables are: info #BEGIN create print('Creating KBase Report.') # check that the basic parameters are set if 'report' not in params: raise ValueError('Field "report" must be defined to save a report') if 'workspace_name' not in params: raise ValueError( 'Field "workspace_name" must be defined to save a report') # setup proper provenance for the report provenance = [{}] if 'provenance' in ctx: provenance = ctx['provenance'] # generate a random report name reportName = 'report_' + str(uuid.uuid4()) if 'prefix' in params: reportName = params['prefix'] + reportName print('Report Name' + reportName) # let any workspace errors just percolate up for now ws = Workspace(self.workspaceURL, token=ctx['token']) report_info = ws.save_objects({ 'workspace': params['workspace_name'], 'objects': [{ 'type': 'KBaseReport.Report', 'data': params['report'], 'name': reportName, 'meta': {}, 'hidden': 1, 'provenance': provenance }] })[0] info = { 'ref': str(report_info[6]) + '/' + str(report_info[0]) + '/' + str(report_info[4]), 'name': report_info[1] } #END create # At some point might do deeper type checking... if not isinstance(info, dict): raise ValueError('Method create return value ' + 'info is not type dict as required.') # return the results return [info]
def main(): admin_token = create_user(mini_ws_admin) admin_ws = Workspace(url=mini_ws_url, token=admin_token) versions = load_narrative_type(admin_ws) versions = {"old_ver": "1.0", "new_ver": "2.0"} user_token = create_user(test_user) user_ws = Workspace(url=mini_ws_url, token=user_token) loaded_info = load_narrative_test_data(user_ws, versions) pprint(loaded_info)
def create(self, ctx, params): # ctx is the context object # return variables are: info #BEGIN create print('Creating KBase Report.') # check that the basic parameters are set if 'report' not in params: raise ValueError('Field "report" must be defined to save a report') if 'workspace_name' not in params: raise ValueError('Field "workspace_name" must be defined to save a report') # setup proper provenance for the report provenance = [{}] if 'provenance' in ctx: provenance = ctx['provenance'] # generate a random report name reportName = 'report_'+str(uuid.uuid4()) if 'prefix' in params: reportName = params['prefix'] + reportName print('Report Name' + reportName) # let any workspace errors just percolate up for now ws = Workspace(self.workspaceURL, token=ctx['token']) report_info = ws.save_objects({ 'workspace':params['workspace_name'], 'objects':[ { 'type':'KBaseReport.Report', 'data':params['report'], 'name':reportName, 'meta':{}, 'hidden':1, 'provenance':provenance } ] })[0] info = { 'ref' : str(report_info[6]) + '/' + str(report_info[0]) + '/' + str(report_info[4]), 'name' : report_info[1] } #END create # At some point might do deeper type checking... if not isinstance(info, dict): raise ValueError('Method create return value ' + 'info is not type dict as required.') # return the results return [info]
def upload_narrative(nar_file, auth_token, user_id, url=ci_ws, set_public=False): """ Uploads a Narrative from a downloaded object file. This file needs to be in JSON format, and it expects all data and info that is usually returned by the Workspace.get_objects method. Returns a dict of three elements: ws: the id of the workspace that was created obj: the id of the narrative object ref: the above two joined together into an object ref (for convenience) """ # read the file f = open(nar_file, 'r') nar = json.loads(f.read()) f.close() # do some setup. current_nar_metadata = ws_metadata current_nar_metadata['narrative_nice_name'] = nar['data']['metadata']['name'] ws_client = Workspace(url=url, token=auth_token) # create the new workspace for the narrative ws_info = ws_client.create_workspace({ 'workspace': '{}:{}'.format(user_id, str(time.time()).replace('.', '')), 'meta': current_nar_metadata, 'globalread': 'r' if set_public else 'n' }) ws_id = ws_info[0] # setup and save the narrative object metadata = nar['info'][10] ws_save_obj = { 'type': 'KBaseNarrative.Narrative', 'data': nar['data'], 'name': nar['info'][1], 'meta': nar['info'][10], 'provenance': [{ 'script': 'upload_narrative_test.py', 'description': 'Temporary Narrative uploaded for automated testing' }] } obj_info = ws_client.save_objects({'id': ws_id, 'objects': [ws_save_obj]}) # tweak the workspace's metadata to properly present its narrative ws_client.alter_workspace_metadata({'wsi': {'id': ws_id}, 'new': {'narrative': obj_info[0][0]}}) return { 'ws': ws_info[0], 'obj': obj_info[0][0], 'refstr': '{}/{}'.format(ws_info[0], obj_info[0][0]), 'ref': NarrativeRef({'wsid': ws_info[0], 'objid': obj_info[0][0]}) }
def test_annotate(self): ''' Run pa-annotate on a valid Genome object and verify that the job runs and returns a valid ProbAnno object in the expected time.''' # Run the annotate() function to generate a ProbAnno object. paClient = ProbabilisticAnnotation(self._config["probanno_url"], token=self._token) jobid = paClient.annotate({ "genome": self._config["genomeid"], "genome_workspace": self._config["test_ws"], "probanno": self._config["probannoid"], "probanno_workspace": self._config["test_ws"] }) # Allow time for the command to run. time.sleep(float(self._config["runtime"])) # Make sure the job has completed. ujsClient = UserAndJobState(self._config['ujs_url'], token=self._token) jobList = ujsClient.list_jobs([self._config['test_user']], 'CE') jobCompleted = False for job in jobList: if jobid == job[0]: jobCompleted = True jobInfo = job self.assertTrue( jobCompleted, 'Job did not complete before timeout of %s seconds' % (self._config['runtime'])) # See if the job ended in error. details = '' if jobInfo[11] == 1: details = ujsClient.get_detailed_error(jobInfo[0]) self.assertEqual(jobInfo[11], 0, 'Job ended in error: %s' % (details)) # Look for the ProbAnno object in the test workspace. wsClient = Workspace(self._config["workspace_url"], token=self._token) try: probannoObjectId = { 'workspace': self._config['test_ws'], 'name': self._config['probannoid'] } objectList = wsClient.get_objects([probannoObjectId]) probannoObject = objectList[0] self.assertEqual( probannoObject['info'][1], self._config['probannoid'], 'ProbAnno object id %s is not %s' % (probannoObject['info'][1], self._config['probannoid'])) except WorkspaceServerError as e: traceback.print_exc(file=sys.stderr) self.fail( msg= "The expected object %s did not get created in the workspace %s!\n" % (self._config["probannoid"], self._config["test_ws"]))
def get_obj_info(logger,ws_url,objects,ws_id,token): """ function to get the workspace object id from a object name """ ret = [] ws_client=Workspace(url=ws_url, token=token) for obj in objects: try: obj_infos = ws_client.get_object_info_new({"objects": [{'name': obj, 'workspace': ws_id}]}) ret.append("{0}/{1}/{2}".format(obj_infos[0][6],obj_infos[0][0],obj_infos[0][4])) except Exception, e: logger.error("Couldn't retrieve %s:%s from the workspace , %s " %(ws_id,obj,e))
def handler (args) : ### # download ws object and convert them to csv wsd = Workspace(url=args.ws_url, token=os.environ.get('KB_AUTH_TOKEN')) indata = wsd.get_object({'id' : args.inobj_id, #'type' : 'KBaseExpression.ExpressionSeries', 'workspace' : args.ws_id})['data'] if indata is None: raise Exception("Object {} not found in workspace {}".format(args.inobj_id, args.ws_id)) ### # execute filtering flt_cmd_lst = ['mys_example', "-i", "{}-{}".format(os.getpid(),args.exp_fn) ] if (args.method is not None): flt_cmd_lst.append('-m') flt_cmd_lst.append(args.method) if (args.p_value is not None): flt_cmd_lst.append('-p') flt_cmd_lst.append(args.p_value) if (args.num_genes is not None): flt_cmd_lst.append('-n') flt_cmd_lst.append(args.num_genes) if (args.flt_out_fn is not None): flt_cmd_lst.append('-o') flt_cmd_lst.append("{}-{}".format(os.getpid(),args.flt_out_fn)) p1 = Popen(flt_cmd_lst, stdout=PIPE) out_str = p1.communicate() # print output message for error tracking if out_str[0] is not None : print out_str[0] if out_str[1] is not None : print >> sys.stderr, out_str[1] flt_cmd = " ".join(flt_cmd_lst) ### # put it back to workspace #fif = open("{}-{}".format(os.getpid(),args.flt_out_fn), 'r') #fif.readline(); # skip header # assume only one genome id outdata = {} outdata['key'] = indata['key'] outdata['value'] = "{}{}".format(indata['value'], indata['value']) data_list = [] data_list.append({'type' : 'MyService.PairString', 'data' : outdata, 'name' : args.outobj_id, 'meta' : {'org.series' : args.inobj_id}}) wsd.save_objects({'workspace' : args.ws_id, 'objects' : data_list}) if(args.del_tmps is "true") : os.remove("{}-{}".format(os.getpid(), args.exp_fn)) os.remove("{}-{}".format(os.getpid(), args.flt_out_fn))
def __init__(self, ws_url, auth_url, token): """ The data fetcher needs a workspace client and auth client. It needs Auth to get the current user id out of the token, so we know what workspaces are actually shared as opposed to just visible. Args: ws_url (str): Workspace service URL auth_url (str): Auth service URL token (str): auth token """ self._ws = Workspace(url=ws_url, token=token) auth = KBaseAuth(auth_url=auth_url) self._user = auth.get_user(token)
def test_handles(self): wsName = self.generatePesudoRandomWorkspaceName() self.ws.set_permissions({ 'workspace': wsName, 'new_permission': 'w', 'users': [self.ctx2['user_id']] }) temp_shock_file = "/kb/module/work/tmp/shock1.txt" with open(temp_shock_file, "w") as f1: f1.write("Test Shock Handle") token1 = self.ctx['token'] dfu = DataFileUtil(os.environ['SDK_CALLBACK_URL'], token=token1) handle1 = dfu.file_to_shock({ 'file_path': temp_shock_file, 'make_handle': 1 })['handle'] hid1 = handle1['hid'] genome_name = "Genome.1" ws2 = Workspace(self.cfg['workspace-url'], token=token1) ws2.save_objects({ 'workspace': wsName, 'objects': [{ 'name': genome_name, 'type': 'KBaseGenomes.Genome', 'data': { 'id': "qwerty", 'scientific_name': "Qwerty", 'domain': "Bacteria", 'genetic_code': 11, 'genbank_handle_ref': hid1 } }] }) genome = self.impl.get_genome_v1( self.ctx2, {'genomes': [{ 'ref': wsName + '/' + genome_name }]})[0]['genomes'][0]['data'] self.impl.save_one_genome_v1(self.ctx2, { 'workspace': wsName, 'name': genome_name, 'data': genome })[0] genome = self.impl.get_genome_v1( self.ctx2, {'genomes': [{ 'ref': wsName + '/' + genome_name }]})[0]['genomes'][0]['data'] self.assertTrue('genbank_handle_ref' in genome) hid2 = genome['genbank_handle_ref'] self.assertNotEqual(hid1, hid2)
def export_genome_annotation_as_genbank(self, ctx, params): """ A method designed especially for download, this calls 'genome_annotation_to_genbank' to do the work, but then packages the output with WS provenance and object info into a zip file and saves to shock. :param params: instance of type "ExportParams" -> structure: parameter "input_ref" of String :returns: instance of type "ExportOutput" -> structure: parameter "shock_id" of String """ # ctx is the context object # return variables are: output #BEGIN export_genome_annotation_as_genbank # validate parameters if 'input_ref' not in params: raise ValueError('Cannot export GenomeAnnotation- not input_ref field defined.') # get WS metadata to get ws_name and obj_name ws = Workspace(url=self.workspaceURL) info = ws.get_object_info_new({'objects':[{'ref': params['input_ref'] }],'includeMetadata':0, 'ignoreErrors':0})[0] # export to a file file = self.genome_annotation_to_genbank(ctx, { 'genome_ref': params['input_ref'], 'new_genbank_file_name': info[1]+'.gbk' })[0] # create the output directory and move the file there export_package_dir = os.path.join(self.sharedFolder, info[1]) os.makedirs(export_package_dir) shutil.move(file['path'], os.path.join(export_package_dir, os.path.basename(file['path']))) # package it up and be done dfUtil = DataFileUtil(self.callback_url) package_details = dfUtil.package_for_download({ 'file_path': export_package_dir, 'ws_refs': [ params['input_ref'] ] }) output = { 'shock_id': package_details['shock_id'] } #END export_genome_annotation_as_genbank # At some point might do deeper type checking... if not isinstance(output, dict): raise ValueError('Method export_genome_annotation_as_genbank return value ' + 'output is not type dict as required.') # return the results return [output]
def test_cleanup(self): ''' Cleanup objects created by tests. ''' # Delete all of the objects in the test workspace. wsClient = Workspace(self._config["workspace_url"], token=self._token) listObjectsParams = dict() listObjectsParams['workspaces'] = [ self._config['test_ws'] ] objectList = wsClient.list_objects(listObjectsParams) deleteList = list() for object in objectList: deleteList.append( { 'wsid': object[6], 'objid': object[0], 'ver': object[4] }) wsClient.delete_objects(deleteList) objectList = wsClient.list_objects(listObjectsParams) for object in objectList: print 'After delete Object %s %s' %(object[1], object[4])
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'] 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 = Workspace(url=cls.wsURL, token=token) cls.serviceImpl = kb_cufflinks(cls.cfg) cls.scratch = cls.cfg['scratch'] cls.callback_url = environ.get('SDK_CALLBACK_URL') cls.srv_wiz_url = cls.cfg['srv-wiz-url'] # cls.wsName = 'cufflinks_test_' + user_id # reuse existing workspace suffix = int(time.time() * 1000) cls.wsName = "test_kb_cufflinks_" + str(suffix) print('workspace_name: ' + cls.wsName) try: # reuse existing (previously torn down) workspace cls.wsClient.undelete_workspace({'workspace': cls.wsName}) print('reusing old workspace...') except BaseException: try: # create if workspace does not exist cls.wsClient.create_workspace({'workspace': cls.wsName}) except BaseException: # get workspace if it exists and was not previously deleted (previously # not torn down) ws_info = cls.wsClient.get_workspace_info({'workspace': cls.wsName}) print("creating new workspace: " + str(ws_info)) cls.dfu = DataFileUtil(cls.callback_url) cls.gfu = GenomeFileUtil(cls.callback_url) cls.ru = ReadsUtils(cls.callback_url) cls.rau = ReadsAlignmentUtils(cls.callback_url) cls.set_api = SetAPI(cls.srv_wiz_url, service_ver='dev') cls.cufflinks_runner = CufflinksUtils(cls.cfg) cls.prepare_data()
def get_genome(genome_id=None,workspace_id=None,token=None,workspace_url=None): #download genome object from workspace if workspace_url is None: workspace_url='https://ci.kbase.us/services/ws' #print token #print genome_id #print workspace_id workspace_client=Workspace(url=workspace_url, token=token) genome=workspace_client.get_object({'id':genome_id, 'workspace':workspace_id, 'type':'KBaseGenomes.Genome'}) #genome = workspace_client.get_object({'id' : 'Bifidobacterium_animalis_subsp._lactis_AD011', 'type' : 'KBaseGenomes.Genome', 'workspace' : 'plane83:1436884411390'}) return genome
def main(): endpoint = 'prod' ws = Workspace(WS_URL[endpoint]) target_dir = os.path.abspath('../specs') repo = Repo(os.path.abspath('../')) # create the manifest manifest = Manifest(os.path.abspath('../manifest.json')) manifest.set_ws_url(WS_URL[endpoint]) modules = [ 'DataPalette', 'GenomeComparison', 'KBaseAssembly', 'KBaseBiochem', 'KBaseCommon', 'KBaseFBA', 'KBaseFeatureValues', 'KBaseFile', 'KBaseGeneFamilies', 'KBaseGenomeAnnotations', 'KBaseGenomes', 'KBaseNarrative', 'KBaseOntology', 'KBasePhenotypes', 'KBaseRNASeq', 'KBaseSets', 'KBaseTrees', 'ProbabilisticAnnotation' ] for m in modules: try: mu = ModuleUpdater(ws, m, target_dir, repo) mu.update(manifest) except Exception as e: print(str(e))
def setUpClass(cls): token = os.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': 'GenomeAnnotationAPI', 'method': 'please_never_use_it_in_production', 'method_params': [] }], 'authenticated': 1 }) config_file = os.environ.get('KB_DEPLOYMENT_CONFIG', None) config = ConfigParser.ConfigParser() config.read(config_file) cls.cfg = {n[0]: n[1] for n in config.items('GenomeAnnotationAPI')} cls.ws = Workspace(cls.cfg['workspace-url'], token=token) cls.impl = GenomeAnnotationAPI(cls.cfg) cls.ga_ref = "8020/81/1" cls.genome_ref = "8020/83/1"
def upload_workspace_data(cs, ws_url, source_ref, target_ws, obj_name): ws = Workspace(ws_url, token=TOKEN) type_ = ws.translate_from_MD5_types([CS_MD5_TYPE])[CS_MD5_TYPE][0] ws.save_objects( {'workspace': target_ws, 'objects': [{'name': obj_name, 'type': type_, 'data': cs, 'provenance': [{'script': SCRIPT_NAME, 'script_ver': __VERSION__, 'input_ws_objects': [source_ref], }] } ] } )
def _init_clients(): ws_c = Workspace(ws_url) # The KBase web-client instantiated below is being deprecated and no longer works for all functions. # A local work-around has been added using kb_sdk and fba_tools fba_c = fbaModelServices(fba_url) gap_c = LocalFbaModelServices return ws_c, fba_c, gap_c
class Validator(TransformBase): def __init__(self, args): TransformBase.__init__(self, args) self.ws_url = args.ws_url self.cfg_name = args.cfg_name self.sws_id = args.sws_id self.etype = args.etype self.opt_args = args.opt_args # download ws object and find where the validation script is located self.wsd = Workspace(url=self.ws_url, token=self.token) self.config = self.wsd.get_object({ 'id': self.cfg_name, 'workspace': self.sws_id })['data']['config_map'] if self.config is None: raise Exception("Object {} not found in workspace {}".format( self.cfg_name, self.sws_id)) def validation_handler(self): ### # execute validation ## TODO: Add logging if self.etype not in self.config['validator']: raise Exception( "No validation script was registered for {}".format( self.etype)) fd_list = [] if os.path.exists("{}/{}".format(self.sdir, self.itmp)): fd_list.append("{}/{}".format(self.sdir, self.itmp)) else: fd_list = glob.glob("{}/{}_*".format(self.sdir, self.itmp)) for fd in fd_list: vcmd_lst = [ self.config['validator'][self.etype]['cmd_name'], self.config['validator'][self.etype]['cmd_args']['input'], fd ] if 'validator' in self.opt_args: opt_args = self.opt_args['validator'] for k in opt_args: if k in self.config['validator'][etype][ 'opt_args'] and opt_args[k] is not None: vcmd_lst.append(self.config['validator'][self.etype] ['opt_args'][k]) vcmd_lst.append(opt_args[k]) p1 = Popen(vcmd_lst, stdout=PIPE) out_str = p1.communicate() # print output message for error tracking if out_str[0] is not None: print out_str[0] if out_str[1] is not None: print >> sys.stderr, out_str[1] if p1.returncode != 0: raise Exception(out_str[1])
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.dfu = DataFileUtil(self.callback_url) self.ws = Workspace(self.ws_url, token=self.token) self.scratch = config['scratch']
def test_loadGenome(self): ''' Load a test Genome object into the test workspace. ''' # Create the test workspace. wsClient = Workspace(self._config["workspace_url"], token=self._token) try: # See if the workspace exists. wsInfo = wsClient.get_workspace_info( { "workspace": self._config["test_ws"] } ) except WorkspaceServerError as e: # Hopefully this means the workspace does not exist. (It could also mean someone messed up setting up the URLs) traceback.print_exc(file=sys.stderr) wsInfo = wsClient.create_workspace( { "workspace": self._config["test_ws"] } ) # We also need to put in a mapping and a biochemistry object somewhere. # To do this, I just create a "dependency workspace" and pull them from there. try: # See if the workspace exists. wsInfo = wsClient.get_workspace_info( { "workspace": self._config["dependency_ws"] } ) except WorkspaceServerError as e: # Hopefully this means the workspace does not exist. (It could also mean someone messed up setting up the URLs) # traceback.print_exc(file=sys.stderr) depWsInfo = wsClient.create_workspace( { "workspace": self._config["dependency_ws"] } ) # Load the mapping and biochemistry objects testContigSet = json.load(open(self._config['contigset_file'], 'r')) contigSetSaveData = dict() contigSetSaveData['type'] = 'KBaseGenomes.ContigSet' contigSetSaveData['name'] = self._config['contigsetid'] contigSetSaveData['data'] = testContigSet testGenome = json.load(open(self._config["genome_file"], "r")) genomeSaveData = dict() genomeSaveData['type'] = 'KBaseGenomes.Genome' genomeSaveData['name'] = self._config['genomeid'] genomeSaveData['data'] = testGenome wsClient.save_objects( { 'workspace': self._config['test_ws'], 'objects': [ genomeSaveData, contigSetSaveData ] } )
def handler (args) : ### # download ws object and find where the validation script is located wsd = Workspace(url=args.ws_url, token=os.environ.get('KB_AUTH_TOKEN')) indata = wsd.get_object({'id' : args.etype, 'workspace' : args.sws_id})['data'] if indata is None: raise Exception("Object {} not found in workspace {}".format(args.inobj_id, args.sws_id)) try: os.mkdir(args.sdir) except: raise Exception("Could not create directory {}".format(args.sdir)) if indata['validation_script']['id'] is None: raise Exception("Script Shock node id information is not provided") surl = args.shock_url if indata['validation_script']['shock_url'] is not None: surl = indata['validation_script']['shock_url'] meta = urllib.urlopen("{}/node/{}".format(surl, indata['validation_script']['id'])) script = urllib.urlopen("{}/node/{}?Download".format(surl, indata['id'])) data = urllib.urlopen("{}/node/{}?Download".format(surl, args.inobj_id)) # TODO: add compressed file handling using meta (tar.gz, tgz, etc). sif = open("{}/validator".format(args.sdir),'w') sif.write(script.read()) sif.close() dif = open("{}/in_file".format(args.sdir),'w') dif.write(data.read()) dif.close() script.close() data.close() ### # execute validation vcmd_lst = ["{}/validator".format(args.sdir), "-i", "{}/in_file".format(args.sdir) ] p1 = Popen(vcmd_lst, stdout=PIPE) out_str = p1.communicate() # print output message for error tracking if out_str[0] is not None : print out_str[0] if out_str[1] is not None : print >> sys.stderr, out_str[1]
def manyHellos_runEach(self, ctx, task): """ :param task: instance of type "ManyHellos_task" -> structure: parameter "msg" of String, parameter "job_number" of Long, parameter "workspace" of String :returns: instance of type "ManyHellos_runEachResult" (runEach()) -> structure: parameter "message" of String """ # ctx is the context object # return variables are: returnVal #BEGIN manyHellos_runEach print("this is manyHellos_runEach...") pprint(["task is ", task]) res = "{0}: {1}".format(task['job_number'], task['msg']) ws_client = Workspace(url=self.config['workspace-url'], token=ctx['token']) res_obj = ws_client.save_objects({ "workspace": task['workspace'], "objects": [{ 'type': 'KBaseReport.Report', "data": { 'objects_created': [], 'text_message': res }, "name": "{0}_{1}.rpt".format(task['msg'], task['job_number']), "meta": {} }] }) res = json.dumps(res_obj) print("exiting manyHellos_runEach(), res is", res) returnVal = {'message': res} #END manyHellos_runEach # At some point might do deeper type checking... if not isinstance(returnVal, dict): raise ValueError('Method manyHellos_runEach return value ' + 'returnVal is not type dict as required.') # return the results return [returnVal]
def __init__(self, args): TransformBase.__init__(self, args) self.ws_url = args.ws_url self.cfg_name = args.cfg_name self.sws_id = args.sws_id self.etype = args.etype self.opt_args = args.opt_args # download ws object and find where the validation script is located self.wsd = Workspace(url=self.ws_url, token=self.token) self.config = self.wsd.get_object({ 'id': self.cfg_name, 'workspace': self.sws_id })['data']['config_map'] if self.config is None: raise Exception("Object {} not found in workspace {}".format( self.cfg_name, self.sws_id))
def setUp(self): # Set configuration variables. self._config = get_config(os.environ["KB_TEST_CONFIG"]) # Get an authorization token for the test user. wsClient = Workspace(self._config["workspace_url"], user_id=self._config["test_user"], password=self._config["test_pwd"]) self._token = wsClient._headers['AUTHORIZATION']
def fetch_narrative(nar_id, auth_token, url=ci_ws, file_name=None): """ Fetches a Narrative object with the given reference id (of the form ##/##). If a file_name is given, then it is printed to that file. If the narrative is found, the jsonized string of it is returned. If nothing is found, an empty Dict is returned. """ ws_client = Workspace(url=url, token=auth_token) nar_data = ws_client.get_objects([{"ref": nar_id}]) if len(nar_data) > 0: nar_json = json.dumps(nar_data[0]) if file_name is not None: f = open(file_name, "w") f.write(nar_json) f.close() return nar_json return {}
def fetch_narrative(nar_id, auth_token, url=ci_ws, file_name=None): """ Fetches a Narrative object with the given reference id (of the form ##/##). If a file_name is given, then it is printed to that file. If the narrative is found, the jsonized string of it is returned. If nothing is found, an empty Dict is returned. """ ws_client = Workspace(url=url, token=auth_token) nar_data = ws_client.get_objects([{'ref':nar_id}]) if len(nar_data) > 0: nar_json = json.dumps(nar_data[0]) if file_name is not None: f = open(file_name, 'w') f.write(nar_json) f.close() return nar_json return {}
def __init__(self): c = Config() c.HTMLExporter.preprocessors = [NarrativePreprocessor] c.TemplateExporter.template_path = [ '.', self._narrative_template_path() ] c.CSSHTMLHeaderPreprocessor.enabled = True self.html_exporter = HTMLExporter(config=c) self.html_exporter.template_file = 'narrative' self.ws_client = Workspace(URLS.workspace) self.narr_fetcher = NarrativeIO()
def upload_workspace_data(cs, ws_url, source_ref, target_ws, obj_name): ws = Workspace(ws_url, token=TOKEN) type_ = ws.translate_from_MD5_types([CS_MD5_TYPE])[CS_MD5_TYPE][0] ws.save_objects({ 'workspace': target_ws, 'objects': [{ 'name': obj_name, 'type': type_, 'data': cs, 'provenance': [{ 'script': SCRIPT_NAME, 'script_ver': __VERSION__, 'input_ws_objects': [source_ref], }] }] })
def get_genome(genome_id=None, workspace_id=None, token=None, workspace_url=None): #download genome object from workspace if workspace_url is None: workspace_url = 'https://ci.kbase.us/services/ws' #print token #print genome_id #print workspace_id workspace_client = Workspace(url=workspace_url, token=token) genome = workspace_client.get_object({ 'id': genome_id, 'workspace': workspace_id, 'type': 'KBaseGenomes.Genome' }) #genome = workspace_client.get_object({'id' : 'Bifidobacterium_animalis_subsp._lactis_AD011', 'type' : 'KBaseGenomes.Genome', 'workspace' : 'plane83:1436884411390'}) return genome
def get_genome(genome_id=None,workspace_id=None,token=None,workspace_url=None): #download genome object from workspace if workspace_url is None: workspace_url='https://kbase.us/services/ws/' if token is None: with open('/kb/dev_container/modules/genome_util/mytoken.txt') as token_file: token=token_file.read() token=token.rstrip() #print token #print genome_id #print workspace_id workspace_client=Workspace(url=workspace_url, token=token) #genome=workspace_client.get_object({'id':genome_id, 'workspace':workspace_id, 'type':'KBaseGenomes.Genome'}) genome = workspace_client.get_object({'id' : 'Bifidobacterium_animalis_subsp._lactis_AD011', 'type' : 'KBaseGenomes.Genome', 'workspace' : 'plane83:1436884411390'}) return genome
def test_annotate(self): ''' Run pa-annotate on a valid Genome object and verify that the job runs and returns a valid ProbAnno object in the expected time.''' # Run the annotate() function to generate a ProbAnno object. paClient = ProbabilisticAnnotation(self._config["probanno_url"], token=self._token) jobid = paClient.annotate( { "genome": self._config["genomeid"], "genome_workspace": self._config["test_ws"], "probanno": self._config["probannoid"], "probanno_workspace": self._config["test_ws"] } ) # Allow time for the command to run. time.sleep(float(self._config["runtime"])) # Make sure the job has completed. ujsClient = UserAndJobState(self._config['ujs_url'], token=self._token) jobList = ujsClient.list_jobs([ self._config['test_user'] ], 'CE') jobCompleted = False for job in jobList: if jobid == job[0]: jobCompleted = True jobInfo = job self.assertTrue(jobCompleted, 'Job did not complete before timeout of %s seconds' %(self._config['runtime'])) # See if the job ended in error. details = '' if jobInfo[11] == 1: details = ujsClient.get_detailed_error(jobInfo[0]) self.assertEqual(jobInfo[11], 0, 'Job ended in error: %s' %(details)) # Look for the ProbAnno object in the test workspace. wsClient = Workspace(self._config["workspace_url"], token=self._token) try: probannoObjectId = { 'workspace': self._config['test_ws'], 'name': self._config['probannoid'] } objectList = wsClient.get_objects( [ probannoObjectId ] ) probannoObject = objectList[0] self.assertEqual(probannoObject['info'][1], self._config['probannoid'], 'ProbAnno object id %s is not %s' %(probannoObject['info'][1], self._config['probannoid'])) except WorkspaceServerError as e: traceback.print_exc(file=sys.stderr) self.fail(msg = "The expected object %s did not get created in the workspace %s!\n" %(self._config["probannoid"], self._config["test_ws"]))
def get_rxnprobs(self, ctx, input): # ctx is the context object # return variables are: output #BEGIN get_rxnprobs ''' Convert a reaction probability object into a human-readable table. @param ctx Current context object @param input Dictionary with input parameters for function @return List of reaction_probability tuples @raise WrongVersionError when RxnProbs object version number is invalid ''' # Sanity check on input arguments input = self._checkInputArguments(ctx, input, [ "rxnprobs", "rxnprobs_workspace" ], { 'rxnprobs_version': None, 'sort_field': 'rxnid' } ) wsClient = Workspace(self.config["workspace_url"], token=ctx['token']) rxnProbsObjectId = make_object_identity(input["rxnprobs_workspace"], input["rxnprobs"], input['rxnprobs_version']) objectList = wsClient.get_objects( [ rxnProbsObjectId ] ) rxnProbsObject = objectList[0] if rxnProbsObject['info'][2] != RxnProbsType: message = 'RxnProbs object type %s is not %s for object %s' %(rxnProbsObject['info'][2], RxnProbsType, rxnProbsObject['info'][1]) ctx.log_err(message) raise WrongVersionError(message) output = rxnProbsObject["data"]["reaction_probabilities"] if input['sort_field'] == 'rxnid': output.sort(key=lambda tup: tup[0]) elif input['sort_field'] == 'probability': output.sort(key=lambda tup: tup[1], reverse=True) #END get_rxnprobs # At some point might do deeper type checking... if not isinstance(output, list): raise ValueError('Method get_rxnprobs return value ' + 'output is not type list as required.') # return the results return [output]
def save_ws_object(obj): """Save an object to the workspace Parameters ---------- obj : dict Object with the fields: type, data, and name. The type must be the full typespec (e.g. 'MetaboliteAtlas.Compound-0.3') Returns ------- id : str Object workspace id """ from biokbase.workspace.client import Workspace ws = Workspace(WS_URL) obj.setdefault('hidden', 0) wks = ws.list_workspaces({'excludeGlobal': 1}) ws_id = [wk[-1] for wk in wks if wk[0] == os.environ['KB_WORKSPACE_ID']][0] save_objects_params = {'id': ws_id, 'objects': [obj]} return ws.save_objects(save_objects_params)[0][-2]
def upload_narrative(nar_file, auth_token, user_id, url=ci_ws, set_public=False): """ Uploads a Narrative from a downloaded object file. This file needs to be in JSON format, and it expects all data and info that is usually returned by the Workspace.get_objects method. Returns a dict of three elements: ws: the id of the workspace that was created obj: the id of the narrative object ref: the above two joined together into an object ref (for convenience) """ # read the file f = open(nar_file, "r") nar = json.loads(f.read()) f.close() # do some setup. current_nar_metadata = ws_metadata current_nar_metadata["narrative_nice_name"] = nar["data"]["metadata"]["name"] ws_client = Workspace(url=url, token=auth_token) # create the new workspace for the narrative ws_info = ws_client.create_workspace( { "workspace": "{}:{}".format(user_id, str(time.time()).replace(".", "")), "meta": current_nar_metadata, "globalread": "r" if set_public else "n", } ) ws_id = ws_info[0] # setup and save the narrative object nar["info"][10] ws_save_obj = { "type": "KBaseNarrative.Narrative", "data": nar["data"], "name": nar["info"][1], "meta": nar["info"][10], "provenance": [ { "script": "upload_narrative_test.py", "description": "Temporary Narrative uploaded for automated testing", } ], } obj_info = ws_client.save_objects({"id": ws_id, "objects": [ws_save_obj]}) # tweak the workspace's metadata to properly present its narrative ws_client.alter_workspace_metadata( {"wsi": {"id": ws_id}, "new": {"narrative": obj_info[0][0]}} ) return { "ws": ws_info[0], "obj": obj_info[0][0], "refstr": "{}/{}".format(ws_info[0], obj_info[0][0]), "ref": NarrativeRef({"wsid": ws_info[0], "objid": obj_info[0][0]}), }
def test_calculate(self): ''' Run pa-calculate on a valid ProbAnno object and verify that the job runs and returns a valid RxnProbs object.''' # Run the calculate() function to generate a RxnProbs object. paClient = ProbabilisticAnnotation(self._config["probanno_url"], token=self._token) rxnprobsMetadata = paClient.calculate( { "probanno": self._config["probannoid"], "probanno_workspace": self._config["test_ws"], "rxnprobs": self._config["rxnprobsid"], "rxnprobs_workspace": self._config["test_ws"] } ) # Look for the RxnProbs object in the test workspace. wsClient = Workspace(self._config["workspace_url"], token=self._token) try: rxnprobsObjectId = { 'workspace': self._config['test_ws'], 'name': self._config['rxnprobsid'] } objectList = wsClient.get_objects( [ rxnprobsObjectId ] ) rxnprobsObject = objectList[0] self.assertEqual(rxnprobsObject['info'][1], self._config['rxnprobsid'], 'RxnProbs object id %s is not %s' %(rxnprobsObject['info'][1], self._config['rxnprobsid'])) except WorkspaceServerError as e: traceback.print_exc(file=sys.stderr) self.fail(msg = "The expected object %s did not get created in the workspace %s!\n" %(self._config["rxnprobsid"], self._config["test_ws"]))
def save_ws_object(obj): """Save an object to the workspace Parameters ---------- obj : dict Object with the fields: type, data, and name. The type must be the full typespec (e.g. 'MetaboliteAtlas.Compound-0.3') Returns ------- id : str Object workspace id """ from biokbase.workspace.client import Workspace ws = Workspace(WS_URL) obj.setdefault("hidden", 0) wks = ws.list_workspaces({"excludeGlobal": 1}) ws_id = [wk[-1] for wk in wks if wk[0] == os.environ["KB_WORKSPACE_ID"]][0] save_objects_params = {"id": ws_id, "objects": [obj]} return ws.save_objects(save_objects_params)[0][-2]
def __init__(self, args): TransformBase.__init__(self,args) self.ws_url = args.ws_url self.cfg_name = args.cfg_name self.sws_id = args.sws_id self.etype = args.etype self.opt_args = args.opt_args # download ws object and find where the validation script is located self.wsd = Workspace(url=self.ws_url, token=self.token) self.config = self.wsd.get_object({'id' : self.cfg_name, 'workspace' : self.sws_id})['data']['config_map'] if self.config is None: raise Exception("Object {} not found in workspace {}".format(self.cfg_name, self.sws_id))
def SetupRNASeqAnalysis(self, ctx, params): # ctx is the context object # return variables are: returnVal # BEGIN SetupRNASeqAnalysis user_token = ctx["token"] ws_client = Workspace(url=self.__WS_URL, token=user_token) out_obj = {k: v for k, v in params.iteritems() if not k in ("ws_id", "genome_id", "annotation_id") and v} pprint(out_obj) if "num_samples" in out_obj: out_obj["num_samples"] = int(out_obj["num_samples"]) if "num_replicates" in out_obj: out_obj["num_replicates"] = int(out_obj["num_replicates"]) if "genome_id" in params and params["genome_id"] is not None: out_obj["genome_id"] = script_util.get_obj_info( self.__LOGGER, self.__WS_URL, [params["genome_id"]], params["ws_id"], user_token )[0] if "annotation_id" in params and params["annotation_id"] is not None: g_ref = script_util.get_obj_info( self.__LOGGER, self.__WS_URL, [params["annotation_id"]], params["ws_id"], user_token )[0] out_obj["annotation_id"] = g_ref self.__LOGGER.info("Uploading RNASeq Analysis object to workspace {0}".format(out_obj["experiment_id"])) try: res = ws_client.save_objects( { "workspace": params["ws_id"], "objects": [ {"type": "KBaseRNASeq.RNASeqAnalysis", "data": out_obj, "name": out_obj["experiment_id"]} ], } ) returnVal = {"workspace": params["ws_id"], "output": out_obj["experiment_id"]} except Exception, e: raise KBaseRNASeqException( "Error Saving the object to workspace {0},{1}".format(out_obj["experiment_id"], e) )
class Validator(TransformBase): def __init__(self, args): TransformBase.__init__(self,args) self.ws_url = args.ws_url self.cfg_name = args.cfg_name self.sws_id = args.sws_id self.etype = args.etype self.opt_args = args.opt_args # download ws object and find where the validation script is located self.wsd = Workspace(url=self.ws_url, token=self.token) self.config = self.wsd.get_object({'id' : self.cfg_name, 'workspace' : self.sws_id})['data']['config_map'] if self.config is None: raise Exception("Object {} not found in workspace {}".format(self.cfg_name, self.sws_id)) def validation_handler (self) : ### # execute validation ## TODO: Add logging if self.etype not in self.config['validator']: raise Exception("No validation script was registered for {}".format(self.etype)) fd_list = [] if os.path.exists("{}/{}".format(self.sdir,self.itmp)): fd_list.append( "{}/{}".format(self.sdir,self.itmp)) else: fd_list = glob.glob("{}/{}_*".format(self.sdir,self.itmp)) for fd in fd_list: vcmd_lst = [self.config['validator'][self.etype]['cmd_name'], self.config['validator'][self.etype]['cmd_args']['input'], fd] if 'validator' in self.opt_args: opt_args = self.opt_args['validator'] for k in opt_args: if k in self.config['validator'][etype]['opt_args'] and opt_args[k] is not None: vcmd_lst.append(self.config['validator'][self.etype]['opt_args'][k]) vcmd_lst.append(opt_args[k]) p1 = Popen(vcmd_lst, stdout=PIPE) out_str = p1.communicate() # print output message for error tracking if out_str[0] is not None : print out_str[0] if out_str[1] is not None : print >> sys.stderr, out_str[1] if p1.returncode != 0: raise Exception(out_str[1])
def _find_narrative_py2_code(ws_id: int, ws: Workspace, rt: RefactoringTool, verbose: bool = False) -> NarrativeInfo: """ ws_id - workspace id to scan for Narratives ws - an authenticated workspace client returns a NarrativeInfo object """ if verbose: print(f"WS:{ws_id} Checking workspace {ws_id}") ws_info = ws.administer({ "command": "getWorkspaceInfo", "params": { "id": ws_id, }, }) narr_id = ws_info[8].get("narrative") if narr_id is None: print(f"WS:{ws_id} has no linked Narrative") return narr_obj = ws.administer({ "command": "getObjects", "params": { "objects": [{ "ref": f"{ws_id}/{narr_id}" }] }, })["data"][0] if not narr_obj["info"][2].startswith("KBaseNarrative.Narrative"): raise TypeError(f"Object {ws_id}/{narr_id} is not a Narrative!") return _update_narrative(narr_obj, ws_info, rt)
def test_calculate(self): ''' Run pa-calculate on a valid ProbAnno object and verify that the job runs and returns a valid RxnProbs object.''' # Run the calculate() function to generate a RxnProbs object. paClient = ProbabilisticAnnotation(self._config["probanno_url"], token=self._token) rxnprobsMetadata = paClient.calculate({ "probanno": self._config["probannoid"], "probanno_workspace": self._config["test_ws"], "rxnprobs": self._config["rxnprobsid"], "rxnprobs_workspace": self._config["test_ws"] }) # Look for the RxnProbs object in the test workspace. wsClient = Workspace(self._config["workspace_url"], token=self._token) try: rxnprobsObjectId = { 'workspace': self._config['test_ws'], 'name': self._config['rxnprobsid'] } objectList = wsClient.get_objects([rxnprobsObjectId]) rxnprobsObject = objectList[0] self.assertEqual( rxnprobsObject['info'][1], self._config['rxnprobsid'], 'RxnProbs object id %s is not %s' % (rxnprobsObject['info'][1], self._config['rxnprobsid'])) except WorkspaceServerError as e: traceback.print_exc(file=sys.stderr) self.fail( msg= "The expected object %s did not get created in the workspace %s!\n" % (self._config["rxnprobsid"], self._config["test_ws"]))
def get_feature_ids(self, ctx, p): """ :param p: instance of type "Params" (Insert your typespec information here.) -> structure: parameter "ref" of String :returns: instance of type "Output" -> structure: """ # ctx is the context object # return variables are: o #BEGIN get_feature_ids ws = Workspace(self.workspaceURL, token = ctx['token']) featureContainers = ws.get_object_subset([{ 'included':['feature_container_references'], 'ref':p['ref']}])[0]['data']['feature_container_references'] all_features = {} for fc in featureContainers: fc_ws_id = featureContainers[fc] features = ws.get_object_subset([{ 'included':['/features/*/feature_id'], 'ref':fc_ws_id}])[0]['data']['features'] all_features[fc] = features.keys() #feature_list = [] #for f in features: # feature_list.append(features[f]['feature_id']) #all_features[fc] = feature_list o = all_features #END get_feature_ids # At some point might do deeper type checking... if not isinstance(o, dict): raise ValueError('Method get_feature_ids return value ' + 'o is not type dict as required.') # return the results return [o]
def CreateRNASeqSampleSet(self, ctx, params): """ :param params: instance of type "CreateRNASeqSampleSetParams" (FUNCTIONS used in the service) -> structure: parameter "ws_id" of String, parameter "sampleset_id" of String, parameter "sampleset_desc" of String, parameter "domain" of String, parameter "platform" of String, parameter "sample_ids" of list of String, parameter "condition" of list of String, parameter "source" of String, parameter "Library_type" of String, parameter "publication_id" of String, parameter "external_source_date" of String :returns: instance of type "RNASeqSampleSet" (Object to Describe the RNASeq SampleSet @optional platform num_replicates source publication_Id external_source_date sample_ids @metadata ws sampleset_id @metadata ws platform @metadata ws num_samples @metadata ws num_replicates @metadata ws length(condition)) -> structure: parameter "sampleset_id" of String, parameter "sampleset_desc" of String, parameter "domain" of String, parameter "platform" of String, parameter "num_samples" of Long, parameter "num_replicates" of Long, parameter "sample_ids" of list of String, parameter "condition" of list of String, parameter "source" of String, parameter "Library_type" of String, parameter "publication_Id" of String, parameter "external_source_date" of String """ # ctx is the context object # return variables are: returnVal #BEGIN CreateRNASeqSampleSet user_token=ctx['token'] ws_client=Workspace(url=self.__WS_URL, token=user_token) hs = HandleService(url=self.__HS_URL, token=user_token) try: ### Create the working dir for the method; change it to a function call out_obj = { k:v for k,v in params.iteritems() if not k in ('ws_id')} sample_ids = params["sample_ids"] out_obj['num_samples'] = len(sample_ids) ## Validation to check if the Set contains more than one samples if len(sample_ids) < 2: raise ValueError("This methods can only take 2 or more RNASeq Samples. If you have only one read sample, run either 'Align Reads using Tophat/Bowtie2' methods directly for getting alignment") ## Validation to Check if the number of samples is equal to number of condition if len(params["condition"]) != out_obj['num_samples']: raise ValueError("Please specify a treatment label for each sample in the RNA-seq SampleSet. Please enter the same label for the replicates in a sample type") ## Validation to Check if the user is loading the same type as specified above if params["Library_type"] == 'PairedEnd' : lib_type = 'KBaseAssembly.PairedEndLibrary' else: lib_type = 'KBaseAssembly.SingleEndLibrary' for i in sample_ids: s_info = ws_client.get_object_info_new({"objects": [{'name': i, 'workspace': params['ws_id']}]}) obj_type = s_info[0][2].split('-')[0] if obj_type != lib_type: raise ValueError("Library_type mentioned : {0}. Please add only {1} typed objects in Reads fields".format(lib_type,lib_type)) ## Code to Update the Provenance; make it a function later 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['ws_id']+'/'+sample for sample in sample_ids] #Saving RNASeqSampleSet to Workspace self.__LOGGER.info("Saving {0} object to workspace".format(params['sampleset_id'])) res= ws_client.save_objects( {"workspace":params['ws_id'], "objects": [{ "type":"KBaseRNASeq.RNASeqSampleSet", "data":out_obj, "name":out_obj['sampleset_id'], "provenance": provenance}] }) returnVal = out_obj except Exception,e: raise KBaseRNASeqException("Error Saving the object to workspace {0},{1}".format(out_obj['sampleset_id'],"".join(traceback.format_exc())))
from biokbase.workspace.client import Workspace ws_client = Workspace() ws_next_client = Workspace(url='https://next.kbase.us/services/ws') a, b = ws_next_client.get_objects([{'objid' : '4', 'wsid' : '68'}, {'objid' : '5', 'wsid' : '68'}])[0:2] a_params = {'type' : a['info'][2], 'data': a['data']} b_params = {'type' : b['info'][2], 'data': b['data']} ws_client.save_objects({'id': '9145', 'objects': [a_params, b_params]})