class WorkspaceAdminUtils:
def __init__(self, config):
wsurl = config.get('workspace-url')
self.atoken = config.get('workspace-admin-token')
self.noadmin = False
if self.atoken is None or self.atoken == '':
self.noadmin = True
self.atoken = os.environ.get('KB_AUTH_TOKEN', None)
self.ws = Workspace(wsurl, token=self.atoken)
def list_objects(self, params):
"""
Provide something that acts like a standard listObjects
"""
if self.noadmin:
return self.ws.list_objects(params)
return self.ws.administer({'command': 'listObjects', 'params': params})
def get_objects2(self, params):
"""
Provide something that acts like a standard getObjects
"""
if self.noadmin:
return self.ws.get_objects2(params)
return self.ws.administer({'command': 'getObjects', 'params': params})
def get_workspace_info(self, params):
"""
Provide something that acts like a standard getObjects
"""
if self.noadmin:
return self.ws.get_workspace_info(params)
return self.ws.administer({
'command': 'getWorkspaceInfo',
'params': params
})
def run_generate_metadata_report(self, ctx, params):
"""
This example function accepts any number of parameters and returns results in a KBaseReport
:param params: instance of mapping from String to unspecified object
:returns: instance of type "ReportResults" -> structure: parameter
"report_name" of String, parameter "report_ref" of String
"""
# ctx is the context object
# return variables are: output
#BEGIN run_generate_metadata_report
object_type = params['object_type']
workspace_name = params['workspace_name']
ws = Workspace(self.ws_url)
print(params)
objects_in_workspace = ws.list_objects({
'workspaces': [workspace_name],
'type': object_type
})
object_names = sorted([j[1] for j in objects_in_workspace])
d = dict()
if (object_type == 'KBaseRNASeq.RNASeqAlignment'):
for object_name in object_names:
alignment_stats = ws.get_objects2({
'objects': [{
'workspace': workspace_name,
'name': object_name
}]
})['data'][0]['data']['alignment_stats']
metadata_keys = alignment_stats.keys()
object_pd = pd.Series(alignment_stats, index=metadata_keys)
d[object_name] = object_pd
else:
for object_name in object_names:
obj_meta_data = ws.get_object_info3(
{
'objects': [{
'workspace': workspace_name,
'name': object_name
}],
'includeMetadata':
1
}, )
metadata = obj_meta_data.get('infos')[0][10]
metadata_keys = metadata.keys()
object_pd = pd.Series(metadata, index=metadata_keys)
d[object_name] = object_pd
df = pd.DataFrame(d)
htmlDir = os.path.join(self.shared_folder, str(uuid.uuid4()))
self._mkdir_p(htmlDir)
report_file_path = os.path.join(htmlDir, "index.html")
#df.to_html(report_file_path)
self.write_pd_html(df.T, report_file_path)
try:
html_upload_ret = self.dfu.file_to_shock({
'file_path': htmlDir,
'make_handle': 0,
'pack': 'zip'
})
except Exception:
raise ValueError('Error uploading HTML file: ' + str(htmlDir) +
' to shock')
reportname = 'generate_metadata_report_' + str(uuid.uuid4())
reportobj = {
'message': '',
'direct_html': None,
'direct_html_link_index': 0,
'file_links': [],
'html_links': [],
'html_window_height': 500,
'workspace_name': params['workspace_name'],
'report_object_name': reportname
}
# attach to report obj
reportobj['direct_html'] = ''
reportobj['direct_html_link_index'] = 0
reportobj['html_links'] = [{
'shock_id': html_upload_ret['shock_id'],
'name': 'index.html',
'label': 'index.html'
}]
report = KBaseReport(self.callback_url, token=ctx['token'])
report_info = report.create_extended_report(reportobj)
output = {
'report_name': report_info['name'],
'report_ref': report_info['ref']
}
print(output)
#END run_generate_metadata_report
# At some point might do deeper type checking...
if not isinstance(output, dict):
raise ValueError(
'Method run_generate_metadata_report return value ' +
'output is not type dict as required.')
# return the results
return [output]
