import json import os import stat import sys import tempfile from typing import List import biosimulators_utils.sedml.utils import fire import matplotlib.pyplot as plt import numpy as np import pandas as pd import seaborn as sns from biosimulators_utils.combine.data_model import CombineArchive from biosimulators_utils.combine.io import CombineArchiveReader from biosimulators_utils.combine.utils import get_sedml_contents from biosimulators_utils.config import Config from biosimulators_utils.log.data_model import Status, CombineArchiveLog, SedDocumentLog # noqa: F401 from biosimulators_utils.combine.validation import validate from biosimulators_utils.combine.data_model import CombineArchiveContentFormat from biosimulators_utils.report.data_model import DataSetResults, ReportResults, ReportFormat # noqa: F401 from biosimulators_utils.sedml.data_model import Report, Plot2D, Plot3D, DataSet, SedDocument from biosimulators_utils.sedml.io import SedmlSimulationReader, SedmlSimulationWriter # Move status PY code here # Create temp directory tmp_dir = tempfile.mkdtemp() def validate_omex(omex_file_path: str, temp_dir_path: str, omex_json_report_path: str) -> str: if not os.path.exists(temp_dir_path): os.mkdir(temp_dir_path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO) # defining archive config = Config( VALIDATE_OMEX_MANIFESTS=True, VALIDATE_SEDML=True, VALIDATE_SEDML_MODELS=True, VALIDATE_IMPORTED_MODEL_FILES=True, VALIDATE_OMEX_METADATA=True, VALIDATE_IMAGES=True, VALIDATE_RESULTS=True ) reader = CombineArchiveReader() archive: CombineArchive = reader.run(in_file=omex_file_path, out_dir=temp_dir_path, config=config) print("errors: "+str(reader.errors)+"\n"+"warnings: "+str(reader.warnings)) validator_errors: List[str] = [] validator_warnings: List[str] = [] if len(reader.errors) == 0: validator_errors, validator_warnings = validate( archive, temp_dir_path, formats_to_validate=list(CombineArchiveContentFormat.__members__.values()), config=config ) results_dict = { "parse_errors": reader.errors, "parse_warnings": reader.warnings, "validator_errors": validator_errors, "validator_warnings": validator_warnings } with open(omex_json_report_path, "w") as file: file.write(json.dumps(results_dict, indent=2)) return repr(results_dict) def gen_sedml_2d_3d(omex_file_path, base_out_path) -> str: temp_path = os.path.join(base_out_path, "temp") if not os.path.exists(temp_path): os.mkdir(temp_path, stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO) # defining archive config = Config(VALIDATE_OMEX_MANIFESTS=True) archive = CombineArchiveReader().run(in_file=omex_file_path, out_dir=temp_path, config=config) # determine files to execute sedml_contents = get_sedml_contents(archive) for i_content, content in enumerate(sedml_contents): content_filename = os.path.normpath(os.path.join(temp_path, content.location)) starting_sedml_name_index = content.location.rfind("/") + 1 if '/' in content.location else 0 ending_sedml_name_index = content.location.rfind(".") sedml_name = content.location[starting_sedml_name_index:ending_sedml_name_index] # sedml_name = Path(content.location).stem print("name: ", sedml_name, file=sys.stdout) print("sedml_name: ", sedml_name, file=sys.stdout) print("content.location: ", content.location, file=sys.stdout) print("content_filename: ", content_filename, file=sys.stdout) doc = SedmlSimulationReader().run(content_filename) for output in doc.outputs: if isinstance(output, (Plot2D, Plot3D)): report = Report( id='__plot__' + output.id, name=output.name) data_generators = {} if isinstance(output, Plot2D): for curve in output.curves: data_generators[curve.x_data_generator.id] = curve.x_data_generator data_generators[curve.y_data_generator.id] = curve.y_data_generator elif isinstance(output, Plot3D): for surface in output.surfaces: data_generators[surface.x_data_generator.id] = surface.x_data_generator data_generators[surface.y_data_generator.id] = surface.y_data_generator data_generators[surface.z_data_generator.id] = surface.z_data_generator for data_generator in data_generators.values(): report.data_sets.append(DataSet( id='__vcell_reserved_data_set_prefix__{}_{}'.format( output.id, data_generator.id), name=data_generator.name, label=data_generator.id, data_generator=data_generator, )) report.data_sets.sort(key=lambda data_set: data_set.id) doc.outputs.append(report) filename_with_reports_for_plots = os.path.join( temp_path, f'simulation_{sedml_name}.sedml') SedmlSimulationWriter().run(doc, filename_with_reports_for_plots, validate_models_with_languages=False) if not os.path.exists(filename_with_reports_for_plots): raise FileNotFoundError("The desired pseudo-sedml failed to generate!") return temp_path def transpose_vcml_csv(csv_file_path: str) -> str: df = pd.read_csv(csv_file_path, header=None) cols = list(df.columns) final_cols = [col for col in cols if col != ''] df[final_cols].transpose().to_csv(csv_file_path, header=False, index=False) print("Success!") return csv_file_path def get_all_dataref_and_curves(sedml_path): all_plot_curves = {} all_report_dataref = {} sedml: SedDocument = SedmlSimulationReader().run(sedml_path) for output in sedml.outputs: if isinstance(output, Plot2D): all_curves = {} for curve in output.curves: all_curves[curve.getId()] = { 'x': curve.getXDataReference(), 'y': curve.getYDataReference() } all_plot_curves[output.id] = all_curves if isinstance(output, Report): for dataset in output.data_sets(): ###### if output.id in all_report_dataref: all_report_dataref[output.id].append({ 'data_reference': dataset.getDataReference(), 'data_label': dataset.getLabel() }) else: all_report_dataref[output.id] = [] all_report_dataref[output.id].append({ 'data_reference': dataset.getDataReference(), 'data_label': dataset.getLabel() }) return all_report_dataref, all_plot_curves def get_report_label_from_data_ref(dataref: str, all_report_dataref): for report in all_report_dataref.keys(): for data_ref in all_report_dataref[report]: if dataref == data_ref['data_reference']: return report, data_ref['data_label'] # Update plots dict def update_dataref_with_report_label(all_report_dataref, all_plot_curves): for plot, curves in all_plot_curves.items(): for curve_name, datarefs in curves.items(): new_ref = dict(datarefs) new_ref['x'] = get_report_label_from_data_ref( datarefs['x'], all_report_dataref)[1] new_ref['y'] = get_report_label_from_data_ref( datarefs['y'], all_report_dataref)[1] new_ref['report'] = get_report_label_from_data_ref( datarefs['y'], all_report_dataref)[0] curves[curve_name] = new_ref return all_report_dataref, all_plot_curves def get_report_dataframes(all_report_dataref, result_out_dir): report_frames = {} reports_list = list(set(all_report_dataref.keys())) for report in reports_list: report_frames[report] = pd.read_csv(str(os.path.join(result_out_dir, report + ".csv"))).T.reset_index() report_frames[report].columns = report_frames[report].iloc[0].values report_frames[report].drop(index=0, inplace=True) return report_frames # PLOTTING def plot_and_save_curves(all_plot_curves, report_frames, result_out_dir) -> str: all_plots = dict(all_plot_curves) for plot, curve_dat in all_plots.items(): dims = (12, 8) fig, ax = plt.subplots(figsize=dims) for curve, data in curve_dat.items(): df = report_frames[data['report']] df.to_csv(os.path.join(result_out_dir, plot + '.csv'), index=False, header=True) transpose_vcml_csv(os.path.join(result_out_dir, plot + '.csv')) sns.lineplot(x=df[data['x']].astype( np.float64), y=df[data['y']].astype(np.float64), ax=ax, label=curve) ax.set_ylabel('') # plt.show() plt.savefig(os.path.join(result_out_dir, plot + '.pdf'), dpi=300) return os.path.join(result_out_dir, plot + '.pdf') def gen_plot_pdfs(sedml_path, result_out_dir): all_report_dataref, all_plot_curves = get_all_dataref_and_curves( sedml_path) all_report_dataref, all_plot_curves = update_dataref_with_report_label( all_report_dataref, all_plot_curves) report_frames = get_report_dataframes(all_report_dataref, result_out_dir) print("Success!") return plot_and_save_curves(all_plot_curves, report_frames, result_out_dir) def gen_plots_for_sed2d_only(sedml_path, result_out_dir): sedml: SedDocument = SedmlSimulationReader().run(sedml_path) # Generate all_plot_curves all_plot_curves = {} for output in sedml.outputs: if not isinstance(output, Plot2D): continue sed_plot_2d: Plot2D = output all_curves = {} for curve in sed_plot_2d.curves: all_curves[curve.id] = { 'x': curve.x_data_generator, 'y': curve.y_data_generator, 'name': curve.name } all_plot_curves[sed_plot_2d.id] = all_curves all_plots = dict(all_plot_curves) for plot_id, curve_dat_dict in all_plots.items(): # curve_dat_dict <--> all_curves dims = (12, 8) fig, ax = plt.subplots(figsize=dims) labelMap = {} df = pd.read_csv(os.path.join(result_out_dir, plot_id + '.csv'), header=None).T # create mapping from task to all repeated tasks (or just itself) for elem in df.iloc[1]: if elem not in labelMap: labelMap[elem] = [] labelMap[elem].append(str(elem) + "_" + str(len(labelMap[elem]))) # Prepare new labels labels = [] for key in labelMap: if len(labelMap[key]) == 1: labelMap[key][0] = key # If there wasn't repeated tasks, restore the old name for elem in labelMap[key]: labels.append(elem) # format data frame df.columns = labels labels_df = df.copy() df.drop(df.index[:3], inplace=True) labels_df.drop(labels_df.index[:2], inplace=True) labels_df.drop(labels_df.index[1:], inplace=True) df.reset_index(inplace=True) df.drop('index', axis=1, inplace=True) for curve_id, data in curve_dat_dict.items(): # data <--> (dict)all_curves.values() shouldLabel = True x_axis_id = data['x'].id y_axis_id = data['y'].id x_data_sets = labelMap[x_axis_id] y_data_sets = labelMap[y_axis_id] for i in range(len(y_data_sets)): series_name = y_data_sets[i] x_data_set = x_data_sets[0] if len(x_data_sets) == 1 else x_data_sets[i] label_name = data['name'] if data['name'] is not None else curve_id sns.lineplot(data=df, x=x_data_set, y=series_name, ax=ax, label=(label_name if shouldLabel else None)) ax.set_ylabel('') ax.set_xlabel(labels_df.at[labels_df.index[0], x_data_set]) shouldLabel = False plt.savefig(os.path.join(result_out_dir, plot_id + '.pdf'), dpi=300) print("Success!") return result_out_dir if __name__ == "__main__": fire.Fire({ 'genSedml2d3d': gen_sedml_2d_3d, 'genPlotsPseudoSedml': gen_plots_for_sed2d_only, 'transposeVcmlCsv': transpose_vcml_csv, 'genPlotPdfs': gen_plot_pdfs, })