def _generate_report(self, report_message, params, created_objects=None):
"""
generate_report: generate summary report
"""
log('Generating report')
uuid_string = str(uuid.uuid4())
upload_message = 'Job Finished\n\n'
upload_message += report_message
log(f'Report message:\n{upload_message}')
report_params = {
'message': upload_message,
'workspace_name': params.get('workspace_name'),
'report_object_name': 'MetagenomeUtils_report_' + uuid_string
}
if created_objects:
report_params['objects_created'] = created_objects
kbase_report_client = KBaseReport(self.callback_url)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
'report_name': output['name'],
'report_ref': output['ref']
}
return report_output
def run_TaxonomyAbundance(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_TaxonomyAbundance
amplicon_matrix_ref = params.get('amplicon_matrix_ref')
attri_mapping_ref = params.get('attri_mapping_ref')
cutoff = params.get('threshold')
grouping_label = params.get(
'meta_group') # can be: None, [], [`label`]
if isinstance(grouping_label, list):
if len(grouping_label) == 0:
grouping_label = None
elif len(grouping_label) == 1:
grouping_label = grouping_label[0]
else:
raise ValueError('`grouping_label` wrong value')
elif grouping_label is not None:
raise TypeError('`grouping_label` wrong type')
csv_fp = "/kb/module/data/smalltx.csv"
xls_fp = "/kb/module/data/moss_f50_metadata.xls"
html_link = run(amp_id=amplicon_matrix_ref,
attri_map_id=attri_mapping_ref,
grouping_label=grouping_label,
cutoff=cutoff,
callback_url=self.callback_url,
scratch=self.shared_folder)
report_client = KBaseReport(self.callback_url, token=self.token)
report_name = "TaxonomyAbundance_report_" + str(uuid.uuid4())
report_info = report_client.create_extended_report({
'direct_html_link_index':
0,
'html_links': [html_link],
'report_object_name':
report_name,
'workspace_name':
params['workspace_name']
})
output = {
'report_ref': report_info['ref'],
'report_name': report_info['name'],
}
#END run_TaxonomyAbundance
# At some point might do deeper type checking...
if not isinstance(output, dict):
raise ValueError('Method run_TaxonomyAbundance return value ' +
'output is not type dict as required.')
# return the results
return [report_info]
def _upload_report(self, report_dir, file_links, workspace_name,
saved_objects):
dfu = DataFileUtil(self.callback_url)
upload_info = dfu.file_to_shock({
'file_path': report_dir,
'pack': 'zip'
})
shock_id = upload_info['shock_id']
report_params = {
'message':
'JGI metagenome assembly report',
'direct_html_link_index':
0,
'html_links': [{
'shock_id': shock_id,
'name': 'index.html',
'description': 'assembly report'
}],
'file_links':
file_links,
'report_object_name':
'JGI_assembly_pipeline.' + str(uuid.uuid4()),
'workspace_name':
workspace_name,
'objects_created':
saved_objects
}
report_client = KBaseReport(self.callback_url)
report = report_client.create_extended_report(report_params)
return {'report_ref': report['ref'], 'report_name': report['name']}
def standardize_matrix(self, params):
"""
standardize a matrix
"""
input_matrix_ref = params.get('input_matrix_ref')
workspace_name = params.get('workspace_name')
new_matrix_name = params.get('new_matrix_name')
with_mean = params.get('with_mean', 1)
with_std = params.get('with_std', 1)
if not isinstance(workspace_name, int):
workspace_id = self.dfu.ws_name_to_id(workspace_name)
else:
workspace_id = workspace_name
input_matrix_obj = self.dfu.get_objects({'object_refs': [input_matrix_ref]})['data'][0]
input_matrix_info = input_matrix_obj['info']
input_matrix_name = input_matrix_info[1]
input_matrix_data = input_matrix_obj['data']
if not new_matrix_name:
current_time = time.localtime()
new_matrix_name = input_matrix_name + time.strftime('_%H_%M_%S_%Y_%m_%d', current_time)
data_matrix = self.data_util.fetch_data({'obj_ref': input_matrix_ref}).get('data_matrix')
df = pd.read_json(data_matrix)
standardize_df = self._standardize_df(df, with_mean, with_std)
new_matrix_data = {'row_ids': df.index.tolist(),
'col_ids': df.columns.tolist(),
'values': standardize_df.values.tolist()}
input_matrix_data['data'] = new_matrix_data
logging.info("Saving new standardized matrix object")
info = self.dfu.save_objects({
"id": workspace_id,
"objects": [{
"type": input_matrix_info[2],
"data": input_matrix_data,
"name": new_matrix_name
}]
})[0]
new_matrix_obj_ref = "%s/%s/%s" % (info[6], info[0], info[4])
objects_created = [{'ref': new_matrix_obj_ref, 'description': 'Standardized Matrix'}]
report_params = {'message': '',
'objects_created': objects_created,
'workspace_name': workspace_name,
'report_object_name': 'import_matrix_from_biom_' + str(uuid.uuid4())}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
return {'new_matrix_obj_ref': new_matrix_obj_ref,
'report_name': output['name'], 'report_ref': output['ref']}
def _generate_report(self, matrix_obj_ref, workspace_name, new_row_attr_ref=None,
new_col_attr_ref=None):
"""
_generate_report: generate summary report
"""
objects_created = [{'ref': matrix_obj_ref, 'description': 'Imported Matrix'}]
if new_row_attr_ref:
objects_created.append({'ref': new_row_attr_ref,
'description': 'Imported Row Attribute Mapping'})
if new_col_attr_ref:
objects_created.append({'ref': new_col_attr_ref,
'description': 'Imported Column Attribute Mapping'})
report_params = {'message': '',
'objects_created': objects_created,
'workspace_name': workspace_name,
'report_object_name': 'import_matrix_from_excel_' + str(uuid.uuid4())}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
report_output = {'report_name': output['name'], 'report_ref': output['ref']}
return report_output
def generate_report(self, binned_contig_obj_ref, params):
"""
generate_report: generate summary report
"""
log('Generating report')
params['result_directory'] = self.BINNER_RESULT_DIRECTORY
output_files = self.generate_output_file_list(
params['result_directory'])
output_html_files = self.generate_html_report(
params['result_directory'], params['assembly_ref'],
binned_contig_obj_ref)
report_params = {
'message': '',
'workspace_name': params.get('workspace_name'),
'file_links': output_files,
'html_links': output_html_files,
'direct_html_link_index': 0,
'html_window_height': 500,
'report_object_name': 'kb_das_tool_report_' + str(uuid.uuid4())
}
kbase_report_client = KBaseReport(self.callback_url)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
'report_name': output['name'],
'report_ref': output['ref']
}
return report_output
def _generate_report(self, pdb_obj_ref, workspace_name, n_poly_pep,
pdb_name, pdb_path):
"""
_generate_report: generate summary report for upload
"""
output_html_files = self._generate_report_html(pdb_name, pdb_path)
report_params = {
'message':
f'You uploaded a PDB file. {n_poly_pep} polypeptides were detected.',
'html_links':
output_html_files,
'direct_html_link_index':
0,
'objects_created': [{
'ref': pdb_obj_ref,
'description': 'Imported PDB'
}],
'workspace_name':
workspace_name,
'report_object_name':
'import_pdb_from_staging_' + str(uuid.uuid4())
}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
'report_name': output['name'],
'report_ref': output['ref']
}
return report_output
def gen_func_profile_report(self, func_profile_ref, workspace_name):
logging.info('start generating report')
objects_created = [{
'ref': func_profile_ref,
'description': 'Imported FunctionalProfile'
}]
output_html_files = self._generate_html_report(func_profile_ref)
report_params = {
'message': '',
'objects_created': objects_created,
'workspace_name': workspace_name,
'html_links': output_html_files,
'direct_html_link_index': 0,
'html_window_height': 1400,
'report_object_name': 'func_profile_viewer_' + str(uuid.uuid4())
}
kbase_report_client = KBaseReport(self.callback_url)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
'report_name': output['name'],
'report_ref': output['ref']
}
return report_output
def _save_to_ws_and_report(self, ws_id, source, compoundset, message=None):
"""Save compound set to the workspace and make report"""
info = self.dfu.save_objects(
{'id': ws_id,
"objects": [{
"type": "KBaseBiochem.CompoundSet",
"data": compoundset,
"name": compoundset['name']
}]})[0]
compoundset_ref = "%s/%s/%s" % (info[6], info[0], info[4])
if not message:
message = 'Imported %s as %s' % (source, info[1])
report_params = {
'objects_created': [{'ref': compoundset_ref,
'description': 'Compound Set'}],
'message': message,
'workspace_name': info[7],
'report_object_name': 'compound_set_creation_report'
}
# Construct the output to send back
report_client = KBaseReport(self.callback_url)
report_info = report_client.create_extended_report(report_params)
output = {'report_name': report_info['name'],
'report_ref': report_info['ref'],
'compoundset_ref': compoundset_ref}
return output
def create_html_report(self, callback_url, output_dir, workspace_name):
'''
'''
dfu = DataFileUtil(callback_url)
report_name = 'kb_gsea_report_' + str(uuid.uuid4())
report = KBaseReport(callback_url)
#copyfile(os.path.join(os.path.dirname(__file__), 'index.html'),
# os.path.join(output_dir, 'index.html'))
report_shock_id = dfu.file_to_shock({
'file_path': output_dir,
'pack': 'zip'
})['shock_id']
html_file = {
'shock_id': report_shock_id,
'name': 'index.html',
'label': 'index.html',
'description': 'HTMLL report for GSEA'
}
report_info = report.create_extended_report({
'direct_html_link_index':
0,
'html_links': [html_file],
'report_object_name':
report_name,
'workspace_name':
workspace_name
})
return {
'report_name': report_info['name'],
'report_ref': report_info['ref']
}
def filter_matrix_with_fs(self, params):
self.validate_params(params, ('feature_set_ref', 'workspace_name',
'expression_matrix_ref', 'filtered_expression_matrix_suffix'))
ret = self.dfu.get_objects(
{'object_refs': [params['feature_set_ref']]}
)['data'][0]
feature_set = ret['data']
feature_set_name = ret['info'][1]
feature_ids = set(feature_set['elements'].keys())
filtered_matrix_ref = self._filter_expression_matrix(
params['expression_matrix_ref'], feature_ids, params['workspace_name'],
params['filtered_expression_matrix_suffix'])
objects_created = [{'ref': filtered_matrix_ref,
'description': 'Filtered ExpressionMatrix Object'}]
message = "Filtered Expression Matrix based of the {} feature ids present in {}"\
.format(len(feature_ids), feature_set_name)
report_params = {'message': message,
'workspace_name': params['workspace_name'],
'objects_created': objects_created,
'report_object_name': 'kb_FeatureSetUtils_report_' + str(uuid.uuid4())}
kbase_report_client = KBaseReport(self.callback_url)
output = kbase_report_client.create_extended_report(report_params)
return {'filtered_expression_matrix_ref': filtered_matrix_ref,
'report_name': output['name'], 'report_ref': output['ref']}
def _generate_corr_report(self, workspace_name, matrix_df):
"""
_generate_report: generate summary report
"""
logging.info('Start creating report')
output_html_files = self._generate_matrix_html_report(matrix_df)
report_params = {
'message': '',
'workspace_name': workspace_name,
'html_links': output_html_files,
'direct_html_link_index': 0,
'html_window_height': 666,
'report_object_name': 'matrix_viewer_report_' + str(uuid.uuid4())
}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
'report_name': output['name'],
'report_ref': output['ref']
}
return report_output
def _generate_network_report(self, graph, network_obj_ref, workspace_name):
"""
_generate_report: generate summary report
"""
logging.info('Start creating report')
output_html_files = self._generate_plotly_network(graph)
report_params = {
'message': '',
'objects_created': [{
'ref': network_obj_ref,
'description': 'Network'
}],
'workspace_name': workspace_name,
'html_links': output_html_files,
'direct_html_link_index': 0,
'html_window_height': 333,
'report_object_name': 'build_network_' + str(uuid.uuid4())
}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
'report_name': output['name'],
'report_ref': output['ref']
}
return report_output
def _generate_report(self, matrix_obj_ref, workspace_name):
"""
_generate_report: generate summary report
"""
report_params = {
'message':
'',
'objects_created': [{
'ref': matrix_obj_ref,
'description': 'Imported Matrix'
}],
'workspace_name':
workspace_name,
'report_object_name':
'import_matrix_from_excel_' + str(uuid.uuid4())
}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
'report_name': output['name'],
'report_ref': output['ref']
}
return report_output
def run_ThermoStoichWizard(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_ThermoStoichWizard
uuid_string = str(uuid.uuid4())
#######################################################################
# run
#######################################################################
print ("Input parameter", params['input_tbl'].keys())
from ThermoStoichWizard.ThermoStoichiometry import ThermoStoichiometry
mf = 'C35H32O6C13S2'
therm = ThermoStoichiometry(mf)
print(therm.extract_composition())
#######################################################################
#
#######################################################################
html_folder = os.path.join(self.shared_folder, 'html')
os.mkdir(html_folder)
html_str = "<html><head>Thermo Stoich Wizard Report</head><body><br><br>{}:{}</body></html>"
html_str = html_str.format(mf, therm.extract_composition())
with open(os.path.join(html_folder, "index.html"), 'w') as index_file:
index_file.write(html_str)
report = KBaseReport(self.callback_url)
html_dir = {
'path': html_folder,
'name': 'index.html', # MUST match the filename of your main html page
'description': 'Thermo Stoich Wizard Report'
}
report_info = report.create_extended_report({
'html_links': [html_dir],
'direct_html_link_index': 0,
'report_object_name': 'thermo_stoich_wizard_report_' + uuid_string,
'workspace_name': params['workspace_name']
})
# report_info = report.create({'report': {'objects_created':[],
# 'text_message': "OK"},
# 'workspace_name': params['workspace_name']})
output = {
'report_name': report_info['name'],
'report_ref': report_info['ref'],
}
#END run_ThermoStoichWizard
# At some point might do deeper type checking...
if not isinstance(output, dict):
raise ValueError('Method run_ThermoStoichWizard return value ' +
'output is not type dict as required.')
# return the results
return [output]
def generate_OTU_sheet(self, ctx, params):
"""
:param params: instance of type "GenerateOTUSheetParams" (Generate a
customized OTU worksheet using a SampleSet input to generate the
appropriate columns.) -> structure: parameter "workspace_name" of
String, parameter "workspace_id" of Long, parameter
"sample_set_ref" of String, parameter "output_name" of String,
parameter "output_format" of String, parameter "num_otus" of Long,
parameter "taxonomy_source" of String, parameter "incl_seq" of
Long, parameter "otu_prefix" of String
:returns: instance of type "GenerateOTUSheetOutputs" -> structure:
parameter "report_name" of String, parameter "report_ref" of String
"""
# ctx is the context object
# return variables are: output
#BEGIN generate_OTU_sheet
# first we download sampleset
sample_set_ref = params.get('sample_set_ref')
ret = self.dfu.get_objects({'object_refs':
[sample_set_ref]})['data'][0]
sample_set = ret['data']
if params.get('output_name'):
output_name = params.get('output_name')
else:
# if output_name not specified use name of sample_set as output + "_OTUs"
output_name = ret['info'][1] + "_OTUs"
otu_path = sample_set_to_OTU_sheet(sample_set, output_name,
self.scratch, params)
report_client = KBaseReport(self.callback_url)
report_name = "Generate_OTU_sheet_report_" + str(uuid.uuid4())
report_info = report_client.create_extended_report({
'file_links': [{
'path':
otu_path,
'name':
os.path.basename(otu_path),
'label':
"CSV with headers for OTU",
'description':
"CSV file with each column containing the assigned sample_id and sample "
"name of each saved sample. Intended for uploading OTU data."
}],
'report_object_name':
report_name,
'workspace_name':
params['workspace_name']
})
output = {
'report_ref': report_info['ref'],
'report_name': report_info['name'],
}
#END generate_OTU_sheet
# At some point might do deeper type checking...
if not isinstance(output, dict):
raise ValueError('Method generate_OTU_sheet return value ' +
'output is not type dict as required.')
# return the results
return [output]
def create_report(callback_url, scratch, workspace_name, result_file):
html = create_html_tables(result_file)
dfu = DataFileUtil(callback_url)
report_name = 'fastANI_report_' + str(uuid.uuid4())
report_client = KBaseReport(callback_url)
html_dir = os.path.join(scratch, report_name)
os.mkdir(html_dir)
with open(os.path.join(html_dir, "index.html"), 'w') as file:
file.write(html)
shock = dfu.file_to_shock({
'file_path': html_dir,
'make_handle': 0,
'pack': 'zip'
})
html_file = {
'shock_id': shock['shock_id'],
'name': 'index.html',
'label': 'html_files',
'description': 'FastANI HTML report'
}
report = report_client.create_extended_report({
'direct_html_link_index':
0,
'html_links': [html_file],
'report_object_name':
report_name,
'workspace_name':
params['workspace_name']
})
return {'report_name': report['name'], 'report_ref': report['ref']}
def generate_report(self, params):
"""
generate_report: generate summary report
"""
log('Generating report')
output_html_files = self.generate_html_report()
report_params = {
'message': '',
'workspace_name': params.get('workspace_name'),
'html_links': output_html_files,
'direct_html_link_index': 0,
'html_window_height': 500,
'report_object_name': 'kb_eukrep_report_' + str(uuid.uuid4())
}
kbase_report_client = KBaseReport(self.callback_url)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
'report_name': output['name'],
'report_ref': output['ref']
}
return report_output
def create_html_report(self, callback_url, output_dir, workspace_name):
'''
function for creating html report
'''
dfu = DataFileUtil(callback_url)
report_name = 'VariationReport' + str(uuid.uuid4())
report = KBaseReport(callback_url)
report_shock_id = dfu.file_to_shock({
'file_path': output_dir,
'pack': 'zip'
})['shock_id']
html_file = {
'shock_id': report_shock_id,
'name': 'index.html',
'label': 'index.html',
'description': 'Variation HTML report'
}
report_info = report.create_extended_report({
'direct_html_link_index':
0,
'html_links': [html_file],
'report_object_name':
report_name,
'workspace_name':
workspace_name
})
return {
'report_name': report_info['name'],
'report_ref': report_info['ref']
}
def create_html_report(callback_url, scratch, workspace_name):
'''
'''
output_dir = os.path.join(scratch, 'output')
dfu = DataFileUtil(callback_url)
report_name = 'METABOLIC_report_' + str(uuid.uuid4())
report = KBaseReport(callback_url)
copyfile(os.path.join(os.path.dirname(__file__), 'report_template.html'),
os.path.join(output_dir, 'report_template.html'))
report_shock_id = dfu.file_to_shock({
'file_path': output_dir,
'pack': 'zip'
})['shock_id']
html_file = {
'shock_id': report_shock_id,
'name': 'report_template.html',
'label': 'report_template.html',
'description': 'HTML report for METABOLIC'
}
report_info = report.create_extended_report({
'direct_html_link_index':
0,
'html_links': [html_file],
'report_object_name':
report_name,
'workspace_name':
workspace_name
})
return {
'report_name': report_info['name'],
'report_ref': report_info['ref']
}
def _generate_mds_report(self, mds_ref, output_dir, workspace_name, n_components):
logging.info('Creating MDS report...')
output_files = self._generate_output_file_list(output_dir)
output_html_files = self._generate_mds_html_report(output_dir, n_components)
objects_created = list()
objects_created.append({'ref': mds_ref,
'description': 'MDS Matrix'})
report_params = {'message': '',
'workspace_name': workspace_name,
'file_links': output_files,
'objects_created': objects_created,
'html_links': output_html_files,
'direct_html_link_index': 0,
'html_window_height': 666,
'report_object_name': 'kb_mds_report_' + str(uuid.uuid4())}
kbase_report_client = KBaseReport(self.callback_url)
output = kbase_report_client.create_extended_report(report_params)
report_output = {'report_name': output['name'], 'report_ref': output['ref']}
return report_output
def _generate_report(self, matrix_obj_ref, amplicon_set_obj_ref, new_row_attr_ref,
new_col_attr_ref, workspace_name):
"""
_generate_report: generate summary report
"""
objects_created = [{'ref': matrix_obj_ref, 'description': 'Imported Amplicon Matrix'},
{'ref': amplicon_set_obj_ref, 'description': 'Imported Amplicon Set'}]
if new_row_attr_ref:
objects_created.append({'ref': new_row_attr_ref,
'description': 'Imported Amplicons(Row) Attribute Mapping'})
if new_col_attr_ref:
objects_created.append({'ref': new_col_attr_ref,
'description': 'Imported Samples(Column) Attribute Mapping'})
report_params = {'message': '',
'objects_created': objects_created,
'workspace_name': workspace_name,
'report_object_name': 'import_matrix_from_biom_' + str(uuid.uuid4())}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
report_output = {'report_name': output['name'], 'report_ref': output['ref']}
#{'report_name': 'import_matrix_from_biom_db306341-c03a-4e60-b8a4-2bd7f6a48925', 'report_ref': '44071/200/1'}
return report_output
def generate_report(self, binned_contig_obj_ref, task_params):
"""
generate_report: generate summary report
"""
log('Generating report')
result_directory = os.path.join(self.scratch, "cocacola_output_dir")
task_params['result_directory'] = result_directory
output_files = self.generate_output_file_list(task_params['result_directory'])
output_html_files = self.generate_html_report(task_params['result_directory'],
task_params['assembly_ref'],
binned_contig_obj_ref)
report_params = {
'message': '',
'workspace_name': task_params['workspace_name'],
'file_links': output_files,
'html_links': output_html_files,
'direct_html_link_index': 0,
'html_window_height': 266,
'report_object_name': 'kb_cocacola_report_' + str(uuid.uuid4())
}
kbase_report_client = KBaseReport(self.callback_url)
output = kbase_report_client.create_extended_report(report_params)
report_output = {'report_name': output['name'], 'report_ref': output['ref']}
return report_output
def _generate_report(self, template_file, workspace_id):
file_links = [{
'path':
template_file,
'name':
os.path.basename(template_file),
'label':
'Chemical Abundance Matrix template file',
'description':
'use this file for Chemical Abundance Matrix uploader'
}]
message = 'Successfully created a template for Chemical Abundance Matrix uploader'
report_params = {
'message': message,
'workspace_id': workspace_id,
'file_links': file_links,
'report_object_name': 'chem_abun_template_' + str(uuid.uuid4())
}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
'report_name': output['name'],
'report_ref': output['ref']
}
return report_output
def build_feature_set(self, params):
self.validate_params(params, {'output_feature_set', 'workspace_name', },
{'genome', 'feature_ids', 'feature_ids_custom', 'base_feature_sets',
'description'})
feature_sources = ('feature_ids', 'feature_ids_custom', 'base_feature_sets')
if not any([params.get(x) for x in feature_sources]):
raise ValueError("You must supply at least one feature source: {}".format(
", ".join(feature_sources)))
workspace_id = self.dfu.ws_name_to_id(params['workspace_name'])
new_feature_set = self._build_fs_obj(params)
save_object_params = {
'id': workspace_id,
'objects': [{'type': 'KBaseCollections.FeatureSet',
'data': new_feature_set,
'name': params['output_feature_set']}]}
dfu_oi = self.dfu.save_objects(save_object_params)[0]
feature_set_obj_ref = '{}/{}/{}'.format(dfu_oi[6], dfu_oi[0], dfu_oi[4])
objects_created = [{'ref': feature_set_obj_ref,
'description': 'Feature Set'}]
message = 'A new feature set containing {} features was created.'.format(
len(new_feature_set['elements']))
report_params = {'message': message,
'workspace_name': params['workspace_name'],
'objects_created': objects_created,
'report_object_name': 'kb_FeatureSetUtils_report_' + str(uuid.uuid4())}
kbase_report_client = KBaseReport(self.callback_url)
output = kbase_report_client.create_extended_report(report_params)
return {'feature_set_ref': feature_set_obj_ref,
'report_name': output['name'], 'report_ref': output['ref']}
def _generate_corr_report(self, corr_matrix_obj_ref, workspace_name, corr_matrix_plot_path,
scatter_plot_path=None):
"""
_generate_report: generate summary report
"""
logging.info('Start creating report')
output_html_files = self._generate_corr_html_report(corr_matrix_obj_ref,
corr_matrix_plot_path,
scatter_plot_path)
report_params = {'message': '',
'objects_created': [{'ref': corr_matrix_obj_ref,
'description': 'Correlation Matrix'}],
'workspace_name': workspace_name,
'html_links': output_html_files,
'direct_html_link_index': 0,
'html_window_height': 666,
'report_object_name': 'compute_correlation_matrix_' + str(uuid.uuid4())}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
report_output = {'report_name': output['name'], 'report_ref': output['ref']}
return report_output
def _generate_search_report(self, header_str, table_str, workspace_name):
logging.info('Start creating report')
output_html_files = self._generate_search_html_report(
header_str, table_str)
report_params = {
'message': '',
'workspace_name': workspace_name,
'html_links': output_html_files,
'direct_html_link_index': 0,
'html_window_height': 366,
'report_object_name':
'kb_matrix_filter_report_' + str(uuid.uuid4())
}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
'report_name': output['name'],
'report_ref': output['ref']
}
return report_output
def _generate_merge_report(self, workspace_name, result_directory):
"""
_generate_merge_report: generate summary report
"""
log("creating merge report")
output_files = self._generate_output_file_list(result_directory)
output_html_files = self._generate_merge_html_report(result_directory)
report_params = {
"message": "",
"workspace_name": workspace_name,
"file_links": output_files,
"html_links": output_html_files,
"direct_html_link_index": 0,
"html_window_height": 366,
"report_object_name": "kb_stringtie_report_" + str(uuid.uuid4()),
}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
"report_name": output["name"],
"report_ref": output["ref"]
}
return report_output
def get_report(self, html_path):
'''
'''
report_client = KBaseReport(self.callback_url)
report_name = 'kb_cmash_' + str(uuid.uuid4())
html_link = {
'path': html_path,
'name': 'index.html',
'description': 'CMash output similarity list'
}
report_info = report_client.create_extended_report({
'direct_html_link_index':
0,
'html_links': [html_link],
'workspace_name':
self.workspace_name,
'report_object_name':
report_name,
})
return {
'report_name': report_info['name'],
'report_ref': report_info['ref']
}
def generate_report(self, genome_ref, params):
"""
:param genome_ref: Return Val from GenomeFileUtil for Uploaded metagenome
Need to get report warnings and message from it.
:return:
"""
uuid_string = str(uuid.uuid4())
objects_created = [{
'ref':
genome_ref,
'description':
'Imported Annotated Metagenome Assembly'
}]
output_html_files = self.generate_html_report(genome_ref, params)
report_params = {
'message': '',
'workspace_name': params.get('workspace_name'),
'objects_created': objects_created,
'html_links': output_html_files,
'direct_html_link_index': 0,
'html_window_height': 300,
'report_object_name': 'kb_metagenome_upload_report_' + uuid_string
}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
'report_name': output['name'],
'report_ref': output['ref']
}
return report_output
def create_report(self, context, template_file=None, height=500):
html_report_folder = os.path.join(self.scratch_folder, 'htmlreport')
os.makedirs(html_report_folder, exist_ok=True)
with open(os.path.join(html_report_folder, 'view.html'), 'w') as f:
self.report_html = self.build_report(context, template_file)
f.write(self.report_html)
report_shock_id = ""
if self.config["save_report_to_kbase"] == "1":
report_shock_id = self.dfu.file_to_shock({
'file_path': html_report_folder,
'pack': 'zip'
})['shock_id']
html_output = {'name': 'view.html', 'shock_id': report_shock_id}
report_params = {
'objects_created': self.objects_created,
'workspace_name': self.workspace,
'html_links': [html_output],
'direct_html_link_index': 0,
'html_window_height': height,
'report_object_name': self.name + '_report_' + str(uuid.uuid4())
}
if self.config["save_report_to_kbase"] == "1":
report = KBaseReport(self.callback_url, token=self.ctx['token'])
self.report_info = report.create_extended_report(report_params)
return self.report_html
def _generate_pca_report(self, pca_ref, score_plots, loading_plots,
bi_plots, workspace_name, n_components):
logging.info('creating report')
output_html_files = self._generate_pca_html_report(
score_plots, loading_plots, bi_plots, n_components)
objects_created = list()
objects_created.append({'ref': pca_ref, 'description': 'PCA Matrix'})
report_params = {
'message': '',
'workspace_name': workspace_name,
'objects_created': objects_created,
'html_links': output_html_files,
'direct_html_link_index': 0,
'html_window_height': 1050,
'report_object_name': 'kb_pca_report_' + str(uuid.uuid4())
}
kbase_report_client = KBaseReport(self.callback_url)
output = kbase_report_client.create_extended_report(report_params)
report_output = {
'report_name': output['name'],
'report_ref': output['ref']
}
return report_output
def _generate_report(self, expression_matrix_ref, workspace_name):
"""
_generate_report: generate report
"""
objects_created = [{'ref': expression_matrix_ref,
'description': 'Average ExpressionMatrix'}]
report_params = {'message': '',
'workspace_name': workspace_name,
'objects_created': objects_created,
# 'html_links': output_html_files,
# 'direct_html_link_index': 0,
'html_window_height': 366,
'report_object_name': 'kb_ave_expr_matrix_report_' + str(uuid.uuid4())}
kbase_report_client = KBaseReport(self.callback_url, token=self.token)
output = kbase_report_client.create_extended_report(report_params)
report_output = {'report_name': output['name'], 'report_ref': output['ref']}
return report_output
def _generate_report(self, up_feature_set_ref_list, down_feature_set_ref_list,
filtered_expression_matrix_ref_list, workspace_name):
"""
_generate_report: generate summary report
"""
log('start creating report')
output_html_files = self._generate_html_report(up_feature_set_ref_list,
down_feature_set_ref_list)
objects_created = list()
for up_feature_set_ref in up_feature_set_ref_list:
objects_created += [{'ref': up_feature_set_ref,
'description': 'Upper FeatureSet Object'}]
for down_feature_set_ref in down_feature_set_ref_list:
objects_created += [{'ref': down_feature_set_ref,
'description': 'Lower FeatureSet Object'}]
for filtered_expression_matrix_ref in filtered_expression_matrix_ref_list:
objects_created += [{'ref': filtered_expression_matrix_ref,
'description': 'Filtered ExpressionMatrix Object'}]
report_params = {'message': '',
'workspace_name': workspace_name,
'objects_created': objects_created,
'html_links': output_html_files,
'direct_html_link_index': 0,
'html_window_height': 333,
'report_object_name': 'kb_FeatureSetUtils_report_' + str(uuid.uuid4())}
kbase_report_client = KBaseReport(self.callback_url)
output = kbase_report_client.create_extended_report(report_params)
report_output = {'report_name': output['name'], 'report_ref': output['ref']}
return report_output
def run_Gblocks(self, ctx, params):
"""
Method for trimming MSAs of either DNA or PROTEIN sequences
**
** input_type: MSA
** output_type: MSA
:param params: instance of type "Gblocks_Params" (Gblocks Input
Params) -> structure: parameter "workspace_name" of type
"workspace_name" (** The workspace object refs are of form: ** **
objects = ws.get_objects([{'ref':
params['workspace_id']+'/'+params['obj_name']}]) ** ** "ref" means
the entire name combining the workspace id and the object name **
"id" is a numerical identifier of the workspace or object, and
should just be used for workspace ** "name" is a string identifier
of a workspace or object. This is received from Narrative.),
parameter "desc" of String, parameter "input_ref" of type
"data_obj_ref", parameter "output_name" of type "data_obj_name",
parameter "trim_level" of Long, parameter "min_seqs_for_conserved"
of Long, parameter "min_seqs_for_flank" of Long, parameter
"max_pos_contig_nonconserved" of Long, parameter "min_block_len"
of Long, parameter "remove_mask_positions_flag" of Long
:returns: instance of type "Gblocks_Output" (Gblocks Output) ->
structure: parameter "report_name" of type "data_obj_name",
parameter "report_ref" of type "data_obj_ref"
"""
# ctx is the context object
# return variables are: returnVal
#BEGIN run_Gblocks
console = []
invalid_msgs = []
self.log(console,'Running run_Gblocks with params=')
self.log(console, "\n"+pformat(params))
report = ''
# report = 'Running run_Gblocks with params='
# report += "\n"+pformat(params)
#### do some basic checks
#
if 'workspace_name' not in params:
raise ValueError('workspace_name parameter is required')
if 'input_ref' not in params:
raise ValueError('input_ref parameter is required')
if 'output_name' not in params:
raise ValueError('output_name parameter is required')
#### Get the input_ref MSA object
##
try:
ws = workspaceService(self.workspaceURL, token=ctx['token'])
objects = ws.get_objects([{'ref': params['input_ref']}])
data = objects[0]['data']
info = objects[0]['info']
input_name = info[1]
input_type_name = info[2].split('.')[1].split('-')[0]
except Exception as e:
raise ValueError('Unable to fetch input_ref object from workspace: ' + str(e))
#to get the full stack trace: traceback.format_exc()
if input_type_name == 'MSA':
MSA_in = data
row_order = []
default_row_labels = dict()
if 'row_order' in MSA_in.keys():
row_order = MSA_in['row_order']
else:
row_order = sorted(MSA_in['alignment'].keys())
if 'default_row_labels' in MSA_in.keys():
default_row_labels = MSA_in['default_row_labels']
else:
for row_id in row_order:
default_row_labels[row_id] = row_id
if len(row_order) < 2:
self.log(invalid_msgs,"must have multiple records in MSA: "+params['input_ref'])
# export features to FASTA file
input_MSA_file_path = os.path.join(self.scratch, input_name+".fasta")
self.log(console, 'writing fasta file: '+input_MSA_file_path)
records = []
for row_id in row_order:
#self.log(console,"row_id: '"+row_id+"'") # DEBUG
#self.log(console,"alignment: '"+MSA_in['alignment'][row_id]+"'") # DEBUG
# using SeqIO makes multiline sequences. (Gblocks doesn't care, but FastTree doesn't like multiline, and I don't care enough to change code)
#record = SeqRecord(Seq(MSA_in['alignment'][row_id]), id=row_id, description=default_row_labels[row_id])
#records.append(record)
#SeqIO.write(records, input_MSA_file_path, "fasta")
records.extend(['>'+row_id,
MSA_in['alignment'][row_id]
])
with open(input_MSA_file_path,'w',0) as input_MSA_file_handle:
input_MSA_file_handle.write("\n".join(records)+"\n")
# Determine whether nuc or protein sequences
#
NUC_MSA_pattern = re.compile("^[\.\-_ACGTUXNRYSWKMBDHVacgtuxnryswkmbdhv \t\n]+$")
all_seqs_nuc = True
for row_id in row_order:
#self.log(console, row_id+": '"+MSA_in['alignment'][row_id]+"'")
if NUC_MSA_pattern.match(MSA_in['alignment'][row_id]) == None:
all_seqs_nuc = False
break
# Missing proper input_type
#
else:
raise ValueError('Cannot yet handle input_ref type of: '+type_name)
# DEBUG: check the MSA file contents
# with open(input_MSA_file_path, 'r', 0) as input_MSA_file_handle:
# for line in input_MSA_file_handle:
# #self.log(console,"MSA_LINE: '"+line+"'") # too big for console
# self.log(invalid_msgs,"MSA_LINE: '"+line+"'")
# validate input data
#
N_seqs = 0
L_first_seq = 0
with open(input_MSA_file_path, 'r', 0) as input_MSA_file_handle:
for line in input_MSA_file_handle:
if line.startswith('>'):
N_seqs += 1
continue
if L_first_seq == 0:
for c in line:
if c != '-' and c != ' ' and c != "\n":
L_first_seq += 1
# min_seqs_for_conserved
if 'min_seqs_for_conserved' in params and params['min_seqs_for_conserved'] != None and int(params['min_seqs_for_conserved']) != 0:
if int(params['min_seqs_for_conserved']) < int(0.5*N_seqs)+1:
self.log(invalid_msgs,"Min Seqs for Conserved Pos ("+str(params['min_seqs_for_conserved'])+") must be >= N/2+1 (N="+str(N_seqs)+", N/2+1="+str(int(0.5*N_seqs)+1)+")\n")
if int(params['min_seqs_for_conserved']) > int(params['min_seqs_for_flank']):
self.log(invalid_msgs,"Min Seqs for Conserved Pos ("+str(params['min_seqs_for_conserved'])+") must be <= Min Seqs for Flank Pos ("+str(params['min_seqs_for_flank'])+")\n")
# min_seqs_for_flank
if 'min_seqs_for_flank' in params and params['min_seqs_for_flank'] != None and int(params['min_seqs_for_flank']) != 0:
if int(params['min_seqs_for_flank']) > N_seqs:
self.log(invalid_msgs,"Min Seqs for Flank Pos ("+str(params['min_seqs_for_flank'])+") must be <= N (N="+str(N_seqs)+")\n")
# max_pos_contig_nonconserved
if 'max_pos_contig_nonconserved' in params and params['max_pos_contig_nonconserved'] != None and int(params['max_pos_contig_nonconserved']) != 0:
if int(params['max_pos_contig_nonconserved']) < 0:
self.log(invalid_msgs,"Max Num Non-Conserved Pos ("+str(params['max_pos_contig_nonconserved'])+") must be >= 0"+"\n")
if int(params['max_pos_contig_nonconserved']) > L_first_seq or int(params['max_pos_contig_nonconserved']) >= 32000:
self.log(invalid_msgs,"Max Num Non-Conserved Pos ("+str(params['max_pos_contig_nonconserved'])+") must be <= L first seq ("+str(L_first_seq)+") and < 32000\n")
# min_block_len
if 'min_block_len' in params and params['min_block_len'] != None and int(params['min_block_len']) != 0:
if int(params['min_block_len']) < 2:
self.log(invalid_msgs,"Min Block Len ("+str(params['min_block_len'])+") must be >= 2"+"\n")
if int(params['min_block_len']) > L_first_seq or int(params['min_block_len']) >= 32000:
self.log(invalid_msgs,"Min Block Len ("+str(params['min_block_len'])+") must be <= L first seq ("+str(L_first_seq)+") and < 32000\n")
# trim_level
if 'trim_level' in params and params['trim_level'] != None and int(params['trim_level']) != 0:
if int(params['trim_level']) < 0 or int(params['trim_level']) > 2:
self.log(invalid_msgs,"Trim Level ("+str(params['trim_level'])+") must be >= 0 and <= 2"+"\n")
if len(invalid_msgs) > 0:
# load the method provenance from the context object
self.log(console,"SETTING PROVENANCE") # DEBUG
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'] = []
provenance[0]['input_ws_objects'].append(params['input_ref'])
provenance[0]['service'] = 'kb_gblocks'
provenance[0]['method'] = 'run_Gblocks'
# report
report += "FAILURE\n\n"+"\n".join(invalid_msgs)+"\n"
reportObj = {
'objects_created':[],
'text_message':report
}
reportName = 'gblocks_report_'+str(uuid.uuid4())
report_obj_info = ws.save_objects({
# 'id':info[6],
'workspace':params['workspace_name'],
'objects':[
{
'type':'KBaseReport.Report',
'data':reportObj,
'name':reportName,
'meta':{},
'hidden':1,
'provenance':provenance
}
]
})[0]
self.log(console,"BUILDING RETURN OBJECT")
returnVal = { 'report_name': reportName,
'report_ref': str(report_obj_info[6]) + '/' + str(report_obj_info[0]) + '/' + str(report_obj_info[4])
# 'output_ref': None
}
self.log(console,"run_Gblocks DONE")
return [returnVal]
### Construct the command
#
# e.g.
# for "0.5" gaps: cat "o\n<MSA_file>\nb\n5\ng\nm\nq\n" | Gblocks
# for "all" gaps: cat "o\n<MSA_file>\nb\n5\n5\ng\nm\nq\n" | Gblocks
#
gblocks_cmd = [self.GBLOCKS_bin]
# check for necessary files
if not os.path.isfile(self.GBLOCKS_bin):
raise ValueError("no such file '"+self.GBLOCKS_bin+"'")
if not os.path.isfile(input_MSA_file_path):
raise ValueError("no such file '"+input_MSA_file_path+"'")
if not os.path.getsize(input_MSA_file_path) > 0:
raise ValueError("empty file '"+input_MSA_file_path+"'")
# DEBUG
# with open(input_MSA_file_path,'r',0) as input_MSA_file_handle:
# for line in input_MSA_file_handle:
# #self.log(console,"MSA LINE: '"+line+"'") # too big for console
# self.log(invalid_msgs,"MSA LINE: '"+line+"'")
# set the output path
timestamp = int((datetime.utcnow() - datetime.utcfromtimestamp(0)).total_seconds()*1000)
output_dir = os.path.join(self.scratch,'output.'+str(timestamp))
if not os.path.exists(output_dir):
os.makedirs(output_dir)
# Gblocks names output blocks MSA by appending "-gb" to input file
#output_GBLOCKS_file_path = os.path.join(output_dir, input_name+'-gb')
output_GBLOCKS_file_path = input_MSA_file_path+'-gb'
output_aln_file_path = output_GBLOCKS_file_path
# Gblocks is interactive and only accepts args from pipe input
#if 'arg' in params and params['arg'] != None and params['arg'] != 0:
# fasttree_cmd.append('-arg')
# fasttree_cmd.append(val)
# Run GBLOCKS, capture output as it happens
#
self.log(console, 'RUNNING GBLOCKS:')
self.log(console, ' '+' '.join(gblocks_cmd))
# report += "\n"+'running GBLOCKS:'+"\n"
# report += ' '+' '.join(gblocks_cmd)+"\n"
# FastTree requires shell=True in order to see input data
env = os.environ.copy()
#joined_fasttree_cmd = ' '.join(fasttree_cmd) # redirect out doesn't work with subprocess unless you join command first
#p = subprocess.Popen([joined_fasttree_cmd], \
p = subprocess.Popen(gblocks_cmd, \
cwd = self.scratch, \
stdin = subprocess.PIPE, \
stdout = subprocess.PIPE, \
stderr = subprocess.PIPE, \
shell = True, \
env = env)
# executable = '/bin/bash' )
# write commands to process
#
# for "0.5" gaps: cat "o\n<MSA_file>\nb\n5\ng\nm\nq\n" | Gblocks
# for "all" gaps: cat "o\n<MSA_file>\nb\n5\n5\ng\nm\nq\n" | Gblocks
p.stdin.write("o"+"\n") # open MSA file
p.stdin.write(input_MSA_file_path+"\n")
if 'trim_level' in params and params['trim_level'] != None and int(params['trim_level']) != 0:
p.stdin.write("b"+"\n")
if int(params['trim_level']) >= 1:
self.log (console,"changing trim level")
p.stdin.write("5"+"\n") # set to "half"
if int(params['trim_level']) == 2:
self.log (console,"changing trim level")
p.stdin.write("5"+"\n") # set to "all"
elif int(params['trim_level']) > 2:
raise ValueError ("trim_level ("+str(params['trim_level'])+") was not between 0-2")
p.stdin.write("m"+"\n")
# flank must precede conserved because it acts us upper bound for acceptable conserved values
if 'min_seqs_for_flank' in params and params['min_seqs_for_flank'] != None and int(params['min_seqs_for_flank']) != 0:
self.log (console,"changing min_seqs_for_flank")
p.stdin.write("b"+"\n")
p.stdin.write("2"+"\n")
p.stdin.write(str(params['min_seqs_for_flank'])+"\n")
p.stdin.write("m"+"\n")
if 'min_seqs_for_conserved' in params and params['min_seqs_for_conserved'] != None and int(params['min_seqs_for_conserved']) != 0:
self.log (console,"changing min_seqs_for_conserved")
p.stdin.write("b"+"\n")
p.stdin.write("1"+"\n")
p.stdin.write(str(params['min_seqs_for_conserved'])+"\n")
p.stdin.write("m"+"\n")
if 'max_pos_contig_nonconserved' in params and params['max_pos_contig_nonconserved'] != None and int(params['max_pos_contig_nonconserved']) > -1:
self.log (console,"changing max_pos_contig_nonconserved")
p.stdin.write("b"+"\n")
p.stdin.write("3"+"\n")
p.stdin.write(str(params['max_pos_contig_nonconserved'])+"\n")
p.stdin.write("m"+"\n")
if 'min_block_len' in params and params['min_block_len'] != None and params['min_block_len'] != 0:
self.log (console,"changing min_block_len")
p.stdin.write("b"+"\n")
p.stdin.write("4"+"\n")
p.stdin.write(str(params['min_block_len'])+"\n")
p.stdin.write("m"+"\n")
p.stdin.write("g"+"\n") # get blocks
p.stdin.write("q"+"\n") # quit
p.stdin.close()
p.wait()
# Read output
#
while True:
line = p.stdout.readline()
#line = p.stderr.readline()
if not line: break
self.log(console, line.replace('\n', ''))
p.stdout.close()
#p.stderr.close()
p.wait()
self.log(console, 'return code: ' + str(p.returncode))
# if p.returncode != 0:
if p.returncode != 1:
raise ValueError('Error running GBLOCKS, return code: '+str(p.returncode) +
'\n\n'+ '\n'.join(console))
# Check that GBLOCKS produced output
#
if not os.path.isfile(output_GBLOCKS_file_path):
raise ValueError("failed to create GBLOCKS output: "+output_GBLOCKS_file_path)
elif not os.path.getsize(output_GBLOCKS_file_path) > 0:
raise ValueError("created empty file for GBLOCKS output: "+output_GBLOCKS_file_path)
# load the method provenance from the context object
#
self.log(console,"SETTING PROVENANCE") # DEBUG
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'] = []
provenance[0]['input_ws_objects'].append(params['input_ref'])
provenance[0]['service'] = 'kb_gblocks'
provenance[0]['method'] = 'run_Gblocks'
# reformat output to single-line FASTA MSA and check that output not empty (often happens when param combinations don't produce viable blocks
#
output_fasta_buf = []
id_order = []
this_id = None
ids = dict()
alignment = dict()
L_alignment = 0;
L_alignment_set = False
with open(output_GBLOCKS_file_path,'r',0) as output_GBLOCKS_file_handle:
for line in output_GBLOCKS_file_handle:
line = line.rstrip()
if line.startswith('>'):
this_id = line[1:]
output_fasta_buf.append ('>'+re.sub('\s','_',default_row_labels[this_id]))
id_order.append(this_id)
alignment[this_id] = ''
if L_alignment != 0 and not L_alignment_set:
L_alignment_set = True
continue
output_fasta_buf.append (line)
for c in line:
if c != ' ' and c != "\n":
alignment[this_id] += c
if not L_alignment_set:
L_alignment += 1
if L_alignment == 0:
self.log(invalid_msgs,"params produced no blocks. Consider changing to less stringent values")
else:
if 'remove_mask_positions_flag' in params and params['remove_mask_positions_flag'] != None and params['remove_mask_positions_flag'] != '' and params['remove_mask_positions_flag'] == 1:
self.log (console,"removing mask positions")
mask = []
new_alignment = dict()
for i in range(0,L_alignment):
mask[i] = '+'
if alignment[id_order[0]][i] == '-' \
or alignment[id_order[0]][i] == 'X' \
or alignment[id_order[0]][i] == 'x':
mask[i] = '-'
for row_id in id_order:
new_alignment[row_id] = ''
for i,c in enumerate(alignment[row_id]):
if mask[i] == '+':
new_alignment[row_id] += c
alignment = new_alignment
L_alignment = len(alignment[id_order[0]])
# write fasta with tidied ids
output_MSA_file_path = os.path.join(output_dir, params['output_name']+'.fasta');
with open(output_MSA_file_path,'w',0) as output_MSA_file_handle:
output_MSA_file_handle.write("\n".join(output_fasta_buf)+"\n")
# Upload results
#
if len(invalid_msgs) == 0:
self.log(console,"UPLOADING RESULTS") # DEBUG
# Didn't write file
# with open(output_MSA_file_path,'r',0) as output_MSA_file_handle:
# output_MSA_buf = output_MSA_file_handle.read()
# output_MSA_buf = output_MSA_buf.rstrip()
# self.log(console,"\nMSA:\n"+output_MSA_buf+"\n")
# Build output_MSA structure
# first extract old info from MSA (labels, ws_refs, etc.)
#
MSA_out = dict()
for key in MSA_in.keys():
MSA_out[key] = MSA_in[key]
# then replace with new info
#
MSA_out['alignment'] = alignment
MSA_out['name'] = params['output_name']
MSA_out['alignment_length'] = alignment_length = L_alignment
MSA_name = params['output_name']
MSA_description = ''
if 'desc' in params and params['desc'] != None and params['desc'] != '':
MSA_out['desc'] = MSA_description = params['desc']
# Store MSA_out
#
new_obj_info = ws.save_objects({
'workspace': params['workspace_name'],
'objects':[{
'type': 'KBaseTrees.MSA',
'data': MSA_out,
'name': params['output_name'],
'meta': {},
'provenance': provenance
}]
})[0]
# create CLW formatted output file
max_row_width = 60
id_aln_gap_width = 1
gap_chars = ''
for sp_i in range(id_aln_gap_width):
gap_chars += ' '
# DNA
if all_seqs_nuc:
strong_groups = { 'AG': True,
'CTU': True
}
weak_groups = None
# PROTEINS
else:
strong_groups = { 'AST': True,
'EKNQ': True,
'HKNQ': True,
'DENQ': True,
'HKQR': True,
'ILMV': True,
'FILM': True,
'HY': True,
'FWY': True
}
weak_groups = { 'ACS': True,
'ATV': True,
'AGS': True,
'KNST': True,
'APST': True,
'DGNS': True,
'DEKNQS': True,
'DEHKNQ': True,
'EHKNQR': True,
'FILMV': True,
'FHY': True
}
clw_buf = []
clw_buf.append ('CLUSTALW format of GBLOCKS trimmed MSA '+MSA_name+': '+MSA_description)
clw_buf.append ('')
long_id_len = 0
aln_pos_by_id = dict()
for row_id in row_order:
aln_pos_by_id[row_id] = 0
row_id_disp = default_row_labels[row_id]
if long_id_len < len(row_id_disp):
long_id_len = len(row_id_disp)
full_row_cnt = alignment_length // max_row_width
if alignment_length % max_row_width == 0:
full_row_cnt -= 1
for chunk_i in range (full_row_cnt + 1):
for row_id in row_order:
row_id_disp = re.sub('\s','_',default_row_labels[row_id])
for sp_i in range (long_id_len-len(row_id_disp)):
row_id_disp += ' '
aln_chunk_upper_bound = (chunk_i+1)*max_row_width
if aln_chunk_upper_bound > alignment_length:
aln_chunk_upper_bound = alignment_length
aln_chunk = alignment[row_id][chunk_i*max_row_width:aln_chunk_upper_bound]
for c in aln_chunk:
if c != '-':
aln_pos_by_id[row_id] += 1
clw_buf.append (row_id_disp+gap_chars+aln_chunk+' '+str(aln_pos_by_id[row_id]))
# conservation line
cons_line = ''
for pos_i in range(chunk_i*max_row_width, aln_chunk_upper_bound):
col_chars = dict()
seq_cnt = 0
for row_id in row_order:
char = alignment[row_id][pos_i]
if char != '-':
seq_cnt += 1
col_chars[char] = True
if seq_cnt <= 1:
cons_char = ' '
elif len(col_chars.keys()) == 1:
cons_char = '*'
else:
strong = False
for strong_group in strong_groups.keys():
this_strong_group = True
for seen_char in col_chars.keys():
if seen_char not in strong_group:
this_strong_group = False
break
if this_strong_group:
strong = True
break
if not strong:
weak = False
if weak_groups != None:
for weak_group in weak_groups.keys():
this_weak_group = True
for seen_char in col_chars.keys():
if seen_char not in weak_group:
this_strong_group = False
break
if this_weak_group:
weak = True
if strong:
cons_char = ':'
elif weak:
cons_char = '.'
else:
cons_char = ' '
cons_line += cons_char
lead_space = ''
for sp_i in range(long_id_len):
lead_space += ' '
lead_space += gap_chars
clw_buf.append(lead_space+cons_line)
clw_buf.append('')
# write clw to file
clw_buf_str = "\n".join(clw_buf)+"\n"
output_clw_file_path = os.path.join(output_dir, input_name+'-MSA.clw');
with open (output_clw_file_path, "w", 0) as output_clw_file_handle:
output_clw_file_handle.write(clw_buf_str)
output_clw_file_handle.close()
# upload GBLOCKS FASTA output to SHOCK for file_links
dfu = DFUClient(self.callbackURL)
try:
output_upload_ret = dfu.file_to_shock({'file_path': output_aln_file_path,
# DEBUG
# 'make_handle': 0,
# 'pack': 'zip'})
'make_handle': 0})
except:
raise ValueError ('error loading aln_out file to shock')
# upload GBLOCKS CLW output to SHOCK for file_links
try:
output_clw_upload_ret = dfu.file_to_shock({'file_path': output_clw_file_path,
# DEBUG
# 'make_handle': 0,
# 'pack': 'zip'})
'make_handle': 0})
except:
raise ValueError ('error loading clw_out file to shock')
# make HTML reports
#
# HERE
# build output report object
#
self.log(console,"BUILDING REPORT") # DEBUG
reportName = 'gblocks_report_'+str(uuid.uuid4())
reportObj = {
'objects_created':[{'ref':params['workspace_name']+'/'+params['output_name'],
'description':'GBLOCKS MSA'}],
#'message': '',
'message': clw_buf_str,
'direct_html': '',
#'direct_html_link_index': 0,
'file_links': [],
'html_links': [],
'workspace_name': params['workspace_name'],
'report_object_name': reportName
}
reportObj['file_links'] = [{'shock_id': output_upload_ret['shock_id'],
'name': params['output_name']+'-GBLOCKS.FASTA',
'label': 'GBLOCKS-trimmed MSA FASTA'
},
{'shock_id': output_clw_upload_ret['shock_id'],
'name': params['output_name']+'-GBLOCKS.CLW',
'label': 'GBLOCKS-trimmed MSA CLUSTALW'
}]
# save report object
#
SERVICE_VER = 'release'
reportClient = KBaseReport(self.callbackURL, token=ctx['token'], service_ver=SERVICE_VER)
#report_info = report.create({'report':reportObj, 'workspace_name':params['workspace_name']})
report_info = reportClient.create_extended_report(reportObj)
else: # len(invalid_msgs) > 0
reportName = 'gblocks_report_'+str(uuid.uuid4())
report += "FAILURE:\n\n"+"\n".join(invalid_msgs)+"\n"
reportObj = {
'objects_created':[],
'text_message':report
}
ws = workspaceService(self.workspaceURL, token=ctx['token'])
report_obj_info = ws.save_objects({
#'id':info[6],
'workspace':params['workspace_name'],
'objects':[
{
'type':'KBaseReport.Report',
'data':reportObj,
'name':reportName,
'meta':{},
'hidden':1,
'provenance':provenance
}
]
})[0]
report_info = dict()
report_info['name'] = report_obj_info[1]
report_info['ref'] = str(report_obj_info[6])+'/'+str(report_obj_info[0])+'/'+str(report_obj_info[4])
# done
returnVal = { 'report_name': report_info['name'],
'report_ref': report_info['ref']
}
self.log(console,"run_Gblocks DONE")
#END run_Gblocks
# At some point might do deeper type checking...
if not isinstance(returnVal, dict):
raise ValueError('Method run_Gblocks return value ' +
'returnVal is not type dict as required.')
# return the results
return [returnVal]
