def run(self, input_files, input_metadata, output_files):
"""
The main function to run the compute_metrics tool.
:param input_files: List of input files - In this case there are no input files required.
:param input_metadata: Matching metadata for each of the files, plus any additional data.
:param output_files: List of the output files that are to be generated.
:type input_files: dict
:type input_metadata: dict
:type output_files: dict
:return: List of files with a single entry (output_files), List of matching metadata for the returned files
(output_metadata).
:rtype: dict, dict
"""
try:
# Set and check execution directory. If not exists the directory will be created.
execution_path = os.path.abspath(self.configuration.get('execution', '.'))
execution_parent_dir = os.path.dirname(execution_path)
if not os.path.isdir(execution_parent_dir):
os.makedirs(execution_parent_dir)
# Update working directory to execution path
os.chdir(execution_path)
logger.debug("Execution path: {}".format(execution_path))
logger.debug("Init execution of the Segmentation")
# Prepare file paths
for key in input_files.keys():
if key == 'model':
model = input_files[key]
elif key == 'images':
datasets = input_files[key]
else:
logger.debug('Unrecognized key {}'.format(key))
continue
# Segment images
masks = run(model, datasets, input_metadata['output_folder'])
output_files = []
out_meta = []
for _file, _meta in masks:
if os.path.isfile(_file):
meta = Metadata()
meta.file_path = _file # Set file_path for output files
meta.data_type = 'image_mask'
meta.file_type = 'NIFTI'
meta.meta_data = _meta
out_meta.append(meta)
output_files.append({
'name': 'image_mask', 'file_path': _file
})
else:
logger.warning("Output not found. Path \"{}\" does not exist".format(_file))
output_metadata = {'output_files': out_meta}
logger.debug("Output metadata created")
return output_files, output_metadata
except Exception:
errstr = "VRE CWL RUNNER pipeline failed. See logs"
logger.fatal(errstr)
raise Exception(errstr)
def _write_results( # pylint: disable=no-self-use,too-many-arguments
input_files,
input_metadata, # pylint: disable=unused-argument
output_files,
output_metadata,
json_path):
"""
Write results.json using information from input_files and output_files:
- input_files: dict containing absolute paths of input files
- input_metadata: dict containing metadata on input files
- output_files: dict containing absolute paths of output files
- output_metadata: dict containing metadata on output files
Note that values of output_files may be either str or list,
according to whether "allow_multiple" is True for the role;
in which case, the Tool may have generated multiple output
files for that role.
Values of output_metadata for roles for which "allow_multiple"
is True can be either a list of instances of Metadata, or a
single instance. In the former case, the list is assumed to be
the same length as that in output_files. In the latter, the same
instance of Metadata is used for all outputs for that role.
For more information see the schema for results.json.
"""
results = []
def _newresult(role, path, metadata):
result = {
"name": role,
"type": path[1],
"file_path": path[0],
"data_type": metadata.data_type,
"file_type": metadata.file_type,
"compressed": metadata.compressed,
"sources": metadata.sources,
"meta_data": metadata.meta_data
}
if result["compressed"] is None:
del result["compressed"]
if result["sources"] is None:
del result["sources"]
return result
for role, path in (itertools.chain.from_iterable([
itertools.product((k, ), v) for k, v in output_files.items()
if v is not None
])):
for metadata in output_metadata:
name = metadata["name"]
if name == role:
meta = Metadata()
meta.type = path[1] # Set type
meta.file_path = path[0] # Set file_path
# Set data_type and file_type
meta.data_type = metadata["file"].get("data_type", None)
meta.file_type = metadata["file"].get("file_type", None)
# Set compressed
meta.compressed = metadata["file"].get("compressed", None)
# Set input sources
if meta.data_type == "provenance_data": # execution provenance
meta.sources = list(
) # FIXME: this is for RO-Crate hack
else:
# Set input sources
meta_sources_list = list()
for input_name in input_metadata.keys():
meta_sources_list.append(
input_metadata[input_name][1].file_path)
meta.sources = meta_sources_list
# Set metadata
meta.meta_data = metadata["file"].get("meta_data", None)
results.append(_newresult(role, path, meta))
# Create JSON output_metadata file
json.dump({"output_files": results},
open(json_path, 'w'),
indent=2,
separators=(',', ': '))
if os.path.isfile(
json_path
): # check if results was created, if not execution stops
return True
else:
return False