def test_input_in_input_novalue_nooptional_nodefault(self):
wf = WorkflowBuilder(
"test_cwl_input_in_input_novalue_nooptional_nodefault")
wf.input("inpId", String())
# included because no value, no default, and not optional
self.assertDictEqual({"inpId": None},
self.translator.build_inputs_file(wf))
def test_add_non_scatter2(self):
w = WorkflowBuilder("scatterededge")
w.input("inp", Array(String()))
w.step("stp", ArrayTestTool(inputs=w.inp))
e = first_value(w.stp.sources["inputs"].source_map)
self.assertFalse(e.scatter)
def test_inputs_generator_secondary_files(self):
w = WorkflowBuilder("tst")
w.input("wsec", TestTypeWithSecondary, default="test.ext")
# w._add_input(Input("wsec", TestTypeWithSecondary(), value="test.ext"))
inpsdict = WdlTranslator().build_inputs_file(w, merge_resources=False)
self.assertEqual("test.ext", inpsdict.get("tst.wsec"))
self.assertEqual("test.txt", inpsdict.get("tst.wsec_txt"))
def test_two_similar_tools(self):
w = WorkflowBuilder("testTwoToolsWithSameId")
w.input("inp", str)
w.step("stp1", TestTool(testtool=w.inp))
w.step("stp2", TestToolV2(testtool=w.inp))
wf_wdl, _ = WdlTranslator.translate_workflow(w)
expected = """\
version development
import "tools/TestTranslationtool.wdl" as T
import "tools/TestTranslationtool_v0_0_2.wdl" as T2
workflow testTwoToolsWithSameId {
input {
String inp
}
call T.TestTranslationtool as stp1 {
input:
testtool=inp
}
call T2.TestTranslationtool as stp2 {
input:
testtool=inp
}
}"""
self.assertEqual(expected, wf_wdl.get_string())
def test_workflow_string_not_null(self):
w = WorkflowBuilder("wf")
w.input("inp", Optional[str])
w.output("out", source=w.inp.assert_not_null())
cwltool = w.translate("cwl", allow_empty_container=True, to_console=False)[0]
print(cwltool)
def test_dot_3(self):
w = WorkflowBuilder("sbmf")
w.input("inp", Array(str))
w.input("inp2", Array(str))
w.input("inp3", Array(str))
step = w.step(
"dotTool",
SingleTestTool(inputs=w.inp, input2=w.inp2, input3=w.inp3),
scatter=ScatterDescription(
fields=["inputs", "input2", "input3"], method=ScatterMethods.dot
),
)
outp = wdl.translate_step_node(
step, "A.SingleTestTool", {}, {"inp", "inp2", "inp3"}
)
expected = """\
scatter (Q in zip(inp, zip(inp2, inp3))) {
call A.SingleTestTool as dotTool {
input:
inputs=Q.left,
input2=Q.right.left,
input3=Q.right.right
}
}"""
self.assertEqual(expected, outp.get_string(indent=0))
def test_add_single_to_array_edge(self):
w = WorkflowBuilder("test_add_single_to_array_edge")
w.input("inp1", String())
w.step("stp1", ArrayTestTool(inputs=w.inp1))
e = first_value(w.stp1.sources["inputs"].source_map)
self.assertTrue(w.has_multiple_inputs)
self.assertTrue(e.compatible_types)
def test_input_in_input_value_optional_default(self):
wf = WorkflowBuilder("test_input_in_inputfile")
wf.input("inpId", String(optional=True), default="1")
self.assertDictEqual(
{"test_input_in_inputfile.inpId": "1"},
self.translator.build_inputs_file(wf),
)
def test_add_non_scatter_fail(self):
w = WorkflowBuilder("scatterededge")
w.input("inp", Array(str))
stp = w.step("stp", SingleTestTool(inputs=w.inp))
e = first_value(w.stp.sources["inputs"].source_map)
self.assertFalse(e.compatible_types)
def test_add_single_to_array_edge(self):
w = WorkflowBuilder("test_add_single_to_array_edge")
w.input("inp1", str)
w.step("stp1", ArrayTestTool(inputs=w.inp1))
c, _, _ = CwlTranslator().translate(w,
to_console=False,
allow_empty_container=True)
self.assertEqual(cwl_multiinput, c)
def test_add_scatter_nested_arrays(self):
w = WorkflowBuilder("scatterededge")
w.input("inp", Array(Array(str)))
stp = w.step("stp", ArrayTestTool(inps=w.inp), scatter="inps")
e = w.stp.sources["inps"].source_map[0]
self.assertTrue(e.compatible_types)
self.assertListEqual(["inps"], stp.scatter.fields)
def test_add_scatter_incompatible(self):
w = WorkflowBuilder("scatterededge")
w.input("inp", Array(int))
stp = w.step("stp", SingleTestTool(inputs=w.inp), scatter="inputs")
e = first_value(w.stp.sources["inputs"].source_map)
self.assertTrue(e.scatter)
self.assertFalse(e.compatible_types)
def test_add_scatter(self):
w = WorkflowBuilder("scatterededge")
w.input("inp", Array(str))
stp = w.step("stp", SingleTestTool(inputs=w.inp), scatter="inputs")
e = first_value(w.stp.sources["inputs"].source_map)
self.assertTrue(e.compatible_types)
self.assertListEqual(["inputs"], stp.scatter.fields)
def test_input_in_input_novalue_optional_default(self):
wf = WorkflowBuilder("test_input_in_inputfile")
wf.input("inpId", String(optional=True), default="2")
# new interpretation: defaults appear in inputs
self.assertDictEqual(
{"test_input_in_inputfile.inpId": "2"},
self.translator.build_inputs_file(wf),
)
def test_add_scatter_nested_arrays_incompatible(self):
w = WorkflowBuilder("scatterededge")
w.input("inp", Array(Array(int)))
stp = w.step("stp", ArrayTestTool(inputs=w.inp), scatter="inputs")
e = first_value(w.stp.sources["inputs"].source_map)
self.assertFalse(e.compatible_types)
self.assertListEqual(["inputs"], stp.scatter.fields)
def test_alias_selector(self):
w = WorkflowBuilder("wf")
w.input("inp", str)
w.step("echo", EchoTestTool(inp=w.inp.as_type(str)))
w.output("out", source=w.echo.out)
sn: List[cwlgen.WorkflowStep] = cwl.translate_step_node(
w.step_nodes["echo"], inputs_dict={"inp": ToolInput("inp", str)}
)
self.assertEqual("inp", sn[0].in_[0].source)
def process_subpipeline(**connections):
w = WorkflowBuilder("split_bam_subpipeline")
w.input("bam", BamBai)
w.input("intervals", Bed(optional=True))
w.step("split_bam",
gatk4.Gatk4SplitReads_4_1_3(bam=w.bam, intervals=w.intervals))
w.output("out", source=w.split_bam.out)
return w(**connections)
def test_output_name_and_folder(self):
w = WorkflowBuilder("wf")
w.input("inp", str)
w.step("print", Echo(inp=w.inp))
w.output("out", source=w.print, output_name=w.inp, output_folder=[w.inp])
inputs = {"inp": ["test1", "test2"]}
modifier = BatchPipelineModifier(BatchRunRequirements(["inp"], "inp"))
new_workflow = modifier.tool_modifier(w, inputs, {})
print(new_workflow)
def test_invalid_scatter_field_list(self):
w = WorkflowBuilder("scatterededge")
w.input("inp", Array(String()))
self.assertRaises(
Exception,
w.step,
identifier="stp",
tool=ArrayTestTool(inputs=w.inp),
scatter=["inputs", "randomfield"],
)
def test_overrided_input_optional_default(self):
wf = WorkflowBuilder("test_input_in_inputfile")
wf.input("inpId", String(optional=True), default="2")
ad = {"inpId": "4"}
# new interpretation: defaults appear in inputs
self.assertDictEqual(
{"test_input_in_inputfile.inpId": "4"},
self.translator.build_inputs_file(wf, additional_inputs=ad),
)
def test_translate_single_to_array_edge(self):
w = WorkflowBuilder("wf")
w.input("inp", str)
stp1 = w.step("stp1", TestTool(testtool=w.inp), ignore_missing=True)
stp2 = w.step("stp2",
TestTool(arrayInp=stp1.std, testtool=w.inp),
ignore_missing=True)
outp = wdl.translate_step_node(stp2, stp2.id(), {}, set())
self.assertEqual(outp.get_string().split("\n")[3].strip(),
f"arrayInp=[{stp1.id()}.std]")
def test_two_similar_tools(self):
w = WorkflowBuilder("testTwoToolsWithSameId")
w.input("inp", str)
w.step("stp1", TestTool(testtool=w.inp))
w.step("stp2", TestToolV2(testtool=w.inp))
wf_cwl, _ = CwlTranslator.translate_workflow(w)
stps = {stp.id: stp for stp in wf_cwl.steps}
self.assertEqual("tools/TestTranslationtool.cwl", stps["stp1"].run)
self.assertEqual("tools/TestTranslationtool_v0_0_2.cwl", stps["stp2"].run)
def test_add_rescatter_scattered(self):
w = WorkflowBuilder("scatterededge")
w.input("inp1", Array(String()))
stp1 = w.step("stp1", SingleTestTool(inputs=w.inp1), scatter="inputs")
stp2 = w.step("stp2", SingleTestTool(inputs=stp1), scatter="inputs")
e1 = first_value(stp1.sources["inputs"].source_map)
e2 = first_value(stp2.sources["inputs"].source_map)
self.assertTrue(e1.scatter)
self.assertTrue(e2.scatter)
def test_read_contents(self):
w = WorkflowBuilder("wf")
w.input("inp", str)
w.step("stp", EchoTestTool(inp=w.inp))
w.output("out", source=w.stp.out.contents())
w_cwl = cwl.CwlTranslator().translate_workflow(w, with_container=False)[0]
self.assertEqual(2, len(w_cwl.steps))
self.assertEqual(
"${return {out: inputs._stpout.contents }}", w_cwl.steps[1].run.expression
)
self.assertTrue(w_cwl.steps[1].run.inputs[0].loadContents)
def process_subpipeline(**connections):
w = WorkflowBuilder("somatic_subpipeline")
w.input("bam", BamBai)
w.input("intervals", Bed)
w.input("reference", FastaWithDict)
w.input("known_sites", Array(VcfTabix))
w.step(
"base_recalibrator",
gatk4.Gatk4BaseRecalibratorLatest(
bam=w.bam,
intervals=w.intervals,
reference=w.reference,
knownSites=w.known_sites,
),
)
w.step(
"apply_bqsr",
gatk4.Gatk4ApplyBqsrLatest(
bam=w.bam,
recalFile=w.base_recalibrator.out,
intervals=w.intervals,
reference=w.reference,
),
)
w.output("out", source=w.apply_bqsr.out)
return w(**connections)
def setUpClass(cls):
wf = WorkflowBuilder("test_workflow_input_collection")
cls.inmap = {
"user": InputQualityType.user,
"static": InputQualityType.static,
"configuration": InputQualityType.configuration,
"none": None,
}
for i, itype in cls.inmap.items():
wf.input(i, str, doc=InputDocumentation(None, quality=itype))
cls.wf = wf
def test_expression_default(self):
wf = WorkflowBuilder("test_expression_defaults")
wf.input("inp", Optional[str])
wf.step(
"echo",
EchoTestTool(inp="Hello, " +
If(IsDefined(wf.inp), wf.inp, ", Michael!")),
)
wf.output("out", source=wf.echo)
wf.translate("cwl")
def test_subworkflow(self):
w = WorkflowBuilder("test_subworkflow")
sub_w = WorkflowBuilder("subworkflow")
sub_w.input("sub_inp", str)
sub_w.step("sub_stp", SingleTestTool(inputs=sub_w.sub_inp))
sub_w.output("sub_out", source=sub_w.sub_stp.out)
w.input("inp", str)
w.step("stp_workflow", sub_w(sub_inp=w.inp))
w.output("out", source=w.stp_workflow.sub_out)
# would be good to come up with some tests
# w.translate("wdl")
self.assertTrue(True)
def test_merge(self):
w = WorkflowBuilder("scatterededge")
w.input("inp1", Array(String()))
w.step("scatteredStp1",
SingleTestTool(inputs=w.inp1),
scatter="inputs")
stp = w.step("mergeStp2", ArrayTestTool(inputs=w.scatteredStp1))
e1 = first_value(w.scatteredStp1.sources["inputs"].source_map)
e2 = first_value(w.mergeStp2.sources["inputs"].source_map)
self.assertTrue(e1.scatter)
self.assertFalse(e2.scatter)
self.assertTrue(e2.compatible_types)
def test_add_non_scatter(self):
w = WorkflowBuilder("scatterededge")
inp = w.input("inp", str)
stp = w.step("stp", SingleTestTool(inputs=inp))
e = first_value(w.stp.sources["inputs"].source_map)
self.assertIsNone(stp.scatter)
