def translate_workflow_to_all_in_one(
cls,
wf,
with_resource_overrides=False,
is_nested_tool=False) -> cwlgen.Workflow:
from janis_core.workflow.workflow import Workflow
metadata = wf.metadata
w = cwlgen.Workflow(
wf.identifier,
wf.friendly_name(),
metadata.documentation,
cwl_version=CWL_VERSION,
)
w.inputs: List[cwlgen.InputParameter] = [
translate_input(i) for i in wf.input_nodes.values()
]
resource_inputs = []
if with_resource_overrides:
resource_inputs = build_resource_override_maps_for_workflow(wf)
w.inputs.extend(resource_inputs)
w.steps: List[cwlgen.WorkflowStep] = []
for s in wf.step_nodes.values():
resource_overrides = {}
for r in resource_inputs:
if not r.id.startswith(s.id()):
continue
resource_overrides[r.id[(len(s.id()) + 1):]] = r.id
w.steps.append(
translate_step(
s,
is_nested_tool=is_nested_tool,
resource_overrides=resource_overrides,
use_run_ref=False,
))
w.outputs = [translate_output_node(o) for o in wf._outputs]
w.requirements.append(cwlgen.InlineJavascriptReq())
w.requirements.append(cwlgen.StepInputExpressionRequirement())
if wf.has_scatter:
w.requirements.append(cwlgen.ScatterFeatureRequirement())
if wf.has_subworkflow:
w.requirements.append(cwlgen.SubworkflowFeatureRequirement())
if wf.has_multiple_inputs:
w.requirements.append(cwlgen.MultipleInputFeatureRequirement())
return w
def test_add_requirements(self):
w = cwlgen.Workflow()
req = cwlgen.InlineJavascriptReq()
w.requirements.append(req)
generated = self.capture_tempfile(w.export)
expected = b"""#!/usr/bin/env cwl-runner
class: Workflow
cwlVersion: v1.0
inputs: {}
outputs: {}
requirements:
InlineJavascriptRequirement: {}
"""
self.assertEqual(expected, generated)
def test_add_without_lib(self):
tool = {}
req = cwlgen.InlineJavascriptReq()
req.add(tool)
self.assertEqual(tool, {'InlineJavascriptRequirement': {}})
def setUp(self):
self.js_req = cwlgen.InlineJavascriptReq(expression_lib='expression')
def translate_workflow(cls,
wf,
with_docker=True,
with_resource_overrides=False,
is_nested_tool=False) -> Tuple[any, Dict[str, any]]:
from janis_core.workflow.workflow import Workflow
metadata = wf.metadata
w = cwlgen.Workflow(wf.id(),
wf.friendly_name(),
metadata.documentation,
cwl_version=CWL_VERSION)
w.inputs: List[cwlgen.InputParameter] = [
translate_input(i) for i in wf.input_nodes.values()
]
resource_inputs = []
if with_resource_overrides:
resource_inputs = build_resource_override_maps_for_workflow(wf)
w.inputs.extend(resource_inputs)
w.steps: List[cwlgen.WorkflowStep] = []
for s in wf.step_nodes.values():
resource_overrides = {}
for r in resource_inputs:
if not r.id.startswith(s.id()):
continue
resource_overrides[r.id[(len(s.id()) + 1):]] = r.id
w.steps.append(
translate_step(
s,
is_nested_tool=is_nested_tool,
resource_overrides=resource_overrides,
))
w.outputs = [
translate_output_node(o) for o in wf.output_nodes.values()
]
w.requirements.append(cwlgen.InlineJavascriptReq())
w.requirements.append(cwlgen.StepInputExpressionRequirement())
if wf.has_scatter:
w.requirements.append(cwlgen.ScatterFeatureRequirement())
if wf.has_subworkflow:
w.requirements.append(cwlgen.SubworkflowFeatureRequirement())
if wf.has_multiple_inputs:
w.requirements.append(cwlgen.MultipleInputFeatureRequirement())
tools = {}
tools_to_build: Dict[str, Tool] = {
s.tool.id(): s.tool
for s in wf.step_nodes.values()
}
for t in tools_to_build:
tool: Tool = tools_to_build[t]
if isinstance(tool, Workflow):
wf_cwl, subtools = cls.translate_workflow(
tool,
is_nested_tool=True,
with_docker=with_docker,
with_resource_overrides=with_resource_overrides,
)
tools[tool.id()] = wf_cwl
tools.update(subtools)
elif isinstance(tool, CommandTool):
tool_cwl = cls.translate_tool_internal(
tool,
with_docker=with_docker,
with_resource_overrides=with_resource_overrides,
)
tools[tool.id()] = tool_cwl
else:
raise Exception(f"Unknown tool type: '{type(tool)}'")
return w, tools
def translate_tool_internal(cls,
tool,
with_docker=True,
with_resource_overrides=False):
metadata = tool.metadata if tool.metadata else ToolMetadata()
stdouts = [
o.output_type for o in tool.outputs()
if isinstance(o.output_type, Stdout) and o.output_type.stdoutname
]
stdout = stdouts[0].stdoutname if len(stdouts) > 0 else None
if isinstance(stdout, InputSelector):
stdout = translate_input_selector(stdout, code_environment=False)
tool_cwl = cwlgen.CommandLineTool(
tool_id=tool.id(),
base_command=tool.base_command(),
label=tool.id(),
doc=metadata.documentation,
cwl_version=CWL_VERSION,
stdin=None,
stderr=None,
stdout=stdout,
)
# if any(not i.shell_quote for i in tool.inputs()):
tool_cwl.requirements.append(cwlgen.ShellCommandRequirement())
tool_cwl.requirements.extend([cwlgen.InlineJavascriptReq()])
inputs_that_require_localisation = [
ti for ti in tool.inputs()
if ti.localise_file and (issubclass(type(ti.input_type), File) or (
issubclass(type(ti.input_type), Array)
) and issubclass(type(ti.input_type.subtype()), File))
]
if inputs_that_require_localisation:
tool_cwl.requirements.append(
cwlgen.InitialWorkDirRequirement([
"$(inputs.%s)" % ti.id()
for ti in inputs_that_require_localisation
]))
if with_docker:
tool_cwl.requirements.append(
cwlgen.DockerRequirement(
docker_pull=tool.container(),
# docker_load=None,
# docker_file=None,
# docker_import=None,
# docker_image_id=None,
# docker_output_dir=None
))
tool_cwl.inputs.extend(translate_tool_input(i) for i in tool.inputs())
tool_cwl.outputs.extend(
translate_tool_output(o, tool=tool.id()) for o in tool.outputs())
args = tool.arguments()
if args:
tool_cwl.arguments.extend(
translate_tool_argument(a) for a in tool.arguments())
if with_resource_overrides:
# work out whether (the tool of) s is a workflow or tool
tool_cwl.inputs.extend([
cwlgen.CommandInputParameter("runtime_memory",
param_type="float?"),
cwlgen.CommandInputParameter("runtime_cpu", param_type="int?"),
# cwlgen.CommandInputParameter("runtime_disks", param_type="string?"),
])
tool_cwl.requirements.append(
cwlgen.ResourceRequirement(
cores_min="$(inputs.runtime_cpu ? inputs.runtime_cpu : 1)",
ram_min=
"$(inputs.runtime_memory ? Math.floor(1024 * inputs.runtime_memory) : 4096)",
))
return tool_cwl