예제 #1
0
    def testActionScript(self):
        '''Test action script'''
        script = SoS_Script(r'''
[A_1]
script: interpreter='python'
  with open('something.txt', 'w') as tmp:
    tmp.write('something')
''')
        wf = script.workflow()
        Base_Executor(wf).run()
        self.assertTrue(file_target('something.txt').target_exists())
        with open('something.txt') as tmp:
            self.assertEqual('something', tmp.read())
예제 #2
0
    def testRemoteExecute(self):
        if os.path.isfile('result_remote.txt'):
            os.remove('result_remote.txt')
        if os.path.isfile('local.txt'):
            os.remove('local.txt')
        with open('local.txt', 'w') as w:
            w.write('something')
        self.assertEqual(
            subprocess.call('sos push local.txt -c ~/docker.yml --to docker',
                            shell=True), 0)
        with open('test_remote.sos', 'w') as tr:
            tr.write('''
[10]
input: 'local.txt'
output: 'result_remote.txt'
task:

run:
  cp local.txt result_remote.txt
  echo 'adf' >> 'result_remote.txt'

''')
        self.assertEqual(
            subprocess.call(
                'sos run test_remote.sos -c ~/docker.yml -r docker -s force',
                shell=True), 0)
        self.assertFalse(file_target('result_remote.txt').target_exists())
        #self.assertEqual(subprocess.call('sos preview result_remote.txt -c ~/docker.yml -r docker', shell=True), 0)
        #self.assertNotEqual(subprocess.call('sos preview result_remote.txt', shell=True), 0)
        self.assertEqual(
            subprocess.call(
                'sos pull result_remote.txt -c ~/docker.yml --from docker',
                shell=True), 0)
        self.assertTrue(file_target('result_remote.txt').target_exists())
        #self.assertEqual(subprocess.call('sos preview result_remote.txt', shell=True), 0)
        with open('result_remote.txt') as w:
            content = w.read()
            self.assertTrue('something' in content, 'Got {}'.format(content))
            self.assertTrue('adf' in content, 'Got {}'.format(content))
예제 #3
0
파일: test_task.py 프로젝트: yzhao2020/sos
    def test_concurrent_task(self):
        '''Test submitting tasks from concurrent substeps'''
        for f in [f'con_{x}.txt' for x in range(5)]:
            if file_target(f).exists():
                file_target(f).unlink()
        script = SoS_Script('''
[10]
input: for_each={'i': range(5)}
output: f'con_{i}.txt'

task:
run: expand=True
  echo {i} > {_output}
''')
        wf = script.workflow()
        Base_Executor(
            wf, config={
                'sig_mode': 'force',
                'default_queue': 'localhost'
            }).run()
        for f in [f'con_{x}.txt' for x in range(5)]:
            self.assertTrue(file_target(f).exists())
예제 #4
0
 def testFileSig(self):
     '''test save and validate of file signature'''
     with open('test_sig.txt', 'w') as ts:
         ts.write('ba')
     a = file_target('test_sig.txt')
     a.write_sig()
     self.assertTrue(a.validate())
     #
     a.zap()
     self.assertTrue(a.validate())
     with open('test_sig.txt', 'w') as ts:
         ts.write('bac')
     self.assertFalse(a.validate())
예제 #5
0
    def testSharedVarInForEach(self):
        self.touch(['1.txt', '2.txt'])
        for file in ('1.out', '2.out', '1.out2', '2.out2'):
            if file_target(file).exists():
                file_target(file).unlink()
        script = SoS_Script('''
[work_1: shared = {'data': 'step_output'}]
input: "1.txt", "2.txt", group_by = 'single', pattern = '{name}.{ext}'
output: expand_pattern('{_name}.out')
run: expand=True
  touch {_output}

[work_2]
depends: sos_variable('data')
input: "1.txt", "2.txt", group_by = 'single', for_each = dict(data=data),  pattern = '{name}.{ext}'
output: expand_pattern('{data}_{_name}.out2')
run: expand=True
  touch {_output}

''')
        wf = script.workflow()
        Base_Executor(wf).run()
예제 #6
0
    def testPassOfTargetSource(self):
        '''Test passing of source information from step_output'''
        script = SoS_Script('''
[1]
output: 'a.txt'
_output.touch()

[2]
assert step_input.sources == ['1']
''')
        wf = script.workflow()
        Base_Executor(wf).run()
        #
        script = SoS_Script('''
[1]
input: for_each={'i': range(2)}
output: 'a.txt', 'b.txt', group_by=1
_output.touch()

[2]
assert step_input.sources == ['1', '1']
''')
        wf = script.workflow()
        Base_Executor(wf).run()
        #
        file_target('c.txt').touch()
        script = SoS_Script('''
[1]
input: for_each={'i': range(2)}
output: 'a.txt', 'b.txt', group_by=1
_output.touch()

[2]
input: 'c.txt'
assert step_input.sources == ['2']
''')
        wf = script.workflow()
        Base_Executor(wf).run()
예제 #7
0
    def testLiteralConnection(self):
        '''Testing the connection of steps with by variables.'''
        for f in ['A1.txt']:
            if file_target(f).exists():
                file_target(f).unlink()
        #
        # A1 introduces a shared variable ss, A3 depends on ss but not A2
        #
        script = SoS_Script('''
[A_1: shared='p']
run:
    touch 'A1.txt'

p = 'A1.txt'

[A_2]
input: None

run:
    sleep 0

[A_3]
input: p
depends: sos_variable('p')

run:
    sleep 0

[A_4]
input: p
depends: sos_variable('p')
run:
    sleep 0

[A_5]
input: dynamic(p)
depends: sos_variable('p')
''')
        wf = script.workflow('A')
        dag = Base_Executor(wf).initialize_dag()
        self.assertDAG(
            dag, '''
strict digraph "" {
A_1;
A_4;
A_2;
A_3;
A_5;
A_1 -> A_4;
A_1 -> A_3;
A_1 -> A_5;
}
''')
        env.max_jobs = 3
        Base_Executor(wf).run()
        for f in ['A1.txt']:
            self.assertTrue(file_target(f).target_exists())
            file_target(f).unlink()
예제 #8
0
    def test_rmarkdown(self):
        '''Test action Rmarkdown'''
        if file_target('myreport.html').exists():
            file_target('myreport.html').unlink()
        script = SoS_Script(r'''
[10]

report:
## Some random figure

Generated by matplotlib


[100]
# generate report
output: 'myreport.html'
Rmarkdown(output=_output[0])
''')
        wf = script.workflow()
        Base_Executor(wf, config={'report_output': 'report.md'}).run()
        self.assertTrue(os.path.isfile('myreport.html'))
        #
        file_target('myreport.html').unlink()
예제 #9
0
    def testStepWithMultipleOutput(self):
        '''Test addition of steps with multiple outputs. It should be added only once'''
        script = SoS_Script('''
[test_1: provides=['{}.txt'.format(i) for i in range(10)]]
output: ['{}.txt'.format(i) for i in range(10)]
run:
  touch {output}

[test_2: provides=['{}.txt'.format(i) for i in range(10, 20)]]
depends: ['{}.txt'.format(i) for i in range(10)]
output: ['{}.txt'.format(i) for i in range(10, 20)]
run:
  touch {output}

[default]
depends: ['{}.txt'.format(i) for i in range(10, 20)]
''')
        wf = script.workflow()
        Base_Executor(wf, config={'output_dag': 'test.dot'}).initialize_dag()
        with open('test.dot') as dot:
            lc = len(dot.readlines())
        self.assertTrue(lc, 6)
        file_target('test.dot').unlink()
예제 #10
0
    def testSignatureWithSharedVariable(self):
        '''Test restoration of signature from variables.'''
        file_target('a.txt').remove('both')
        # shared
        script = SoS_Script(r"""
[0: shared='a']
output: 'a.txt'
run:
   sleep 3
   touch a.txt

a= 5

[1]
print(a)

""")
        # alias should also be recovered.
        wf = script.workflow('default')
        Base_Executor(wf).run()
        # rerun
        Base_Executor(wf).run()
        file_target('a.txt').remove('both')
예제 #11
0
파일: test_remote.py 프로젝트: pgcudahy/sos
def test_remote_exec_workdir_named_path(clear_now_and_after):
    clear_now_and_after(file_target("#home/wd/result_workdir_named_path.txt"))
    execute_workflow(
        """
        output: '#home/wd/result_workdir_named_path.txt'

        task: workdir='/root'
        sh: expand=True
            echo Output: {_output} > {_output}
            echo PWD: `pwd`. >> {_output}
        """,
        options={
            "config_file": "~/docker.yml",
            "default_queue": "docker",
            "sig_mode": "force",
        },
    )
    assert file_target(
        "#home/wd/result_workdir_named_path.txt").target_exists()
    with open(file_target("#home/wd/result_workdir_named_path.txt")) as res:
        result = res.read()
        assert "Output: /root/wd/result_workdir_named_path.txt" in result
        assert "PWD: /root." in result
예제 #12
0
파일: test_remote.py 프로젝트: pgcudahy/sos
def test_remote_exec(clear_now_and_after):
    clear_now_and_after("result_exec.txt")
    root_dir = "/root/build" if "TRAVIS" in os.environ else "/root"
    execute_workflow(
        """
        output: 'result_exec.txt'

        task:
        sh: expand=True
            echo Output: {_output} > {_output}
            echo PWD: `pwd`. >> {_output}
        """,
        options={
            "config_file": "~/docker.yml",
            "default_queue": "docker",
            "sig_mode": "force",
        },
    )
    assert file_target("result_exec.txt").target_exists()
    with open(file_target("result_exec.txt")) as res:
        result = res.read()
        assert "Output: result_exec.txt" in result
        assert f"PWD: {root_dir}/vatlab/sos/test." in result
예제 #13
0
    def testSignatureWithVars(self):
        '''Test revaluation with variable change'''
        self.touch(('a1.out', 'a2.out'))
        for f in ('b1.out', 'b2.out'):
            if file_target(f).exists():
                file_target(f).unlink()
        script = SoS_Script('''
parameter: DB = {'input': ['a1.out'], 'output': ['b1.out']}
parameter: input_file = DB['input']
parameter: output_file =  DB['output']

[2]
input: input_file, group_by = 1
output: output_file[_index]
run: expand=True
  touch {_output}
  ''')
        wf = script.workflow()
        res = Base_Executor(wf).run()
        self.assertEqual(res['__completed__']['__step_completed__'], 1)
        ts = os.path.getmtime('b1.out')
        #
        script = SoS_Script('''
parameter: DB = {'input': ['a1.out', 'a2.out'], 'output': ['b1.out', 'b2.out']}
parameter: input_file = DB['input']
parameter: output_file =  DB['output']

[2]
input: input_file, group_by = 1
output: output_file[_index]
run: expand=True
  touch {_output}
  ''')
        wf = script.workflow()
        res = Base_Executor(wf).run()
        self.assertEqual(res['__completed__']['__step_completed__'], 0.5)
        self.assertEqual(ts, os.path.getmtime('b1.out'))
예제 #14
0
    def testSoSStep(self):
        '''Test target sos_step'''
        for file in ['t1.txt', 't2.txt', '5.txt', '10.txt', '20.txt']:
            file_target(file).remove('both')
        script = SoS_Script('''
[t1]
run:
    touch t1.txt

[t2: provides='t2.txt']
depends: sos_step('t1')
run:
    touch t2.txt

[5]
run:
    touch 5.txt

[10]
depends: sos_step('t2')
run:
    touch 10.txt

[20]
depends: sos_step('t1')
task:
run:
    touch 20.txt
''')
        wf = script.workflow()
        env.config['sig_mode'] = 'force'
        # this should be ok.
        Base_Executor(wf).run()
        for file in ['t1.txt', 't2.txt', '5.txt', '10.txt', '20.txt']:
            self.assertTrue(
                file_target(file).target_exists(), file + ' should exist')
            file_target(file).remove('both')
예제 #15
0
    def testSignatureAfterRemovalOfFiles(self):
        '''test action shrink'''
        if os.path.isfile('largefile.txt'):
            os.remove('largefile.txt')
        script = SoS_Script(r'''
[10]

# generate a file
output: 'largefile.txt'

run: expand='${ }'
    for x in {1..1000}
    do
        echo $x >> ${output}
    done

''')
        wf = script.workflow()
        Base_Executor(wf).run()
        # sleep 3
        # rerun, because this is the final target, it has to be
        # re-generated
        os.remove('largefile.txt')
        Base_Executor(wf).run()
        self.assertTrue(os.path.isfile('largefile.txt'))
        #
        # we discard the signature, the step would still be
        # skipped because file signature will be calculated
        # during verification
        file_target('largefile.txt').remove('signature')
        Base_Executor(wf).run()
        #
        # now if we touch the file, it needs to be regenerated
        with open('largefile.txt', 'a') as lf:
            lf.write('something')
        Base_Executor(wf).run()
        file_target('largefile.txt').remove('both')
예제 #16
0
    def testRegenerateReport(self):
        '''Testing the regeneration of report once is needed. The problem
        here is the 'input' parameter of report.'''
        script = SoS_Script(r'''
[A_1]
output: 'a1.txt', 'a1.md'
run:
    echo 'a1' >> a1.txt

report: output='a1.md'
    a1

[A_2]
output: 'a2.txt', 'a2.md'
run:
    echo 'a2' >> a2.txt
report: output='a2.md'
    a2

[A_3]
input: 'a1.md', 'a2.md'
output: 'out.md'
report:     input=['a1.md', 'a2.md'], output='out.md'
''')
        wf = script.workflow()
        Base_Executor(wf).run()
        with open('a1.md') as a:
            self.assertEqual(a.read(), 'a1\n\n')
        with open('a2.md') as a:
            self.assertEqual(a.read(), 'a2\n\n')
        with open('out.md') as a:
            self.assertEqual(a.read(), 'a1\n\na2\n\n')
        for name in ('a1.md', 'a2.md', 'out.md'):
            if file_target(name).exists():
                file_target(name).unlink()
        wf = script.workflow()
        Base_Executor(wf).run()
예제 #17
0
파일: test_nested.py 프로젝트: stvhanna/sos
    def testLoopedNestedWorkflow(self):
        # step will be looped
        self.touch(['a.txt', 'b.txt'])
        script = SoS_Script('''
if 'executed' not in locals():
    executed = []
if 'inputs' not in locals():
    inputs = []

[a_1:shared=['executed', 'inputs']]
executed.append(step_name)
output: _input[0] + '.a1'
inputs.append(_input)
run: expand=True
    touch {_output}

[a_2:shared=['executed', 'inputs']]
executed.append(step_name)
output: _input[0] + '.a2'
inputs.append(_input)
run: expand=True
    touch {_output}

[c:shared=['executed', 'inputs']]
executed.append(step_name)
input: 'a.txt', 'b.txt', group_by='single'
inputs.append(_input)
sos_run('a', shared=['executed', 'inputs'])
''')
        wf = script.workflow('c')
        Base_Executor(wf).run()
        self.assertEqual(env.sos_dict['executed'],
                         ['c', 'a_1', 'a_2', 'a_1', 'a_2'])
        #self.assertEqual(env.sos_dict['inputs'], [['a.txt'], ['a.txt'], ['a.txt.a1'], ['b.txt'], ['b.txt'], ['b.txt.a1']])
        for file in ('a.txt.a1', 'a.txt.a1.a2', 'b.txt.a1', 'b.txt.a1.a2'):
            if file_target(file).exists():
                file_target(file).unlink()
예제 #18
0
    def testReverseSharedVariable(self):
        '''Test shared variables defined in auxiliary steps'''
        file_target('a.txt').remove('both')
        script = r'''
%run B
[A: shared='b', provides='a.txt']
b = 1
run:
    touch a.txt

[B_1]
depends: 'a.txt'

[B_2]
print(b)

'''
        with sos_kernel() as kc:
            iopub = kc.iopub_channel
            execute(kc=kc, code=script)
            wait_for_idle(kc)
            execute(kc=kc, code="b")
            res = get_result(iopub)
            self.assertEqual(res, 1)
예제 #19
0
 def test_zap(self):
     """Test zap"""
     with open("testzap.txt", "w") as sf:
         sf.write("some text")
     path("testzap.txt").zap()
     self.assertTrue(os.path.isfile("testzap.txt.zapped"))
     self.assertFalse(os.path.isfile("testzap.txt"))
     # re-zap is ok
     file_target("testzap.txt").zap()
     self.assertTrue(os.path.isfile("testzap.txt.zapped"))
     self.assertFalse(os.path.isfile("testzap.txt"))
     # non-existent file
     os.remove("testzap.txt.zapped")
     self.assertRaises(FileNotFoundError, path("testzap.txt").zap)
     #
     with open("testzap.txt", "w") as sf:
         sf.write("some text")
     with open("testzap1.txt", "w") as sf:
         sf.write("some text")
     paths("testzap.txt", "testzap1.txt").zap()
     self.assertTrue(os.path.isfile("testzap.txt.zapped"))
     self.assertFalse(os.path.isfile("testzap.txt"))
     self.assertTrue(os.path.isfile("testzap1.txt.zapped"))
     self.assertFalse(os.path.isfile("testzap1.txt"))
     #
     os.remove("testzap.txt.zapped")
     os.remove("testzap1.txt.zapped")
     with open("testzap.txt", "w") as sf:
         sf.write("some text")
     with open("testzap1.txt", "w") as sf:
         sf.write("some text")
     sos_targets(["testzap.txt", "testzap1.txt"]).zap()
     self.assertTrue(os.path.isfile("testzap.txt.zapped"))
     self.assertFalse(os.path.isfile("testzap.txt"))
     self.assertTrue(os.path.isfile("testzap1.txt.zapped"))
     self.assertFalse(os.path.isfile("testzap1.txt"))
예제 #20
0
    def testExecutionLock(self):
        '''Test execution lock of two processes'''
        with open('lock.sos', 'w') as lock:
            lock.write(r'''
import time
[A_1]
output: 'a.txt'
with open('a.txt', 'w') as txt:
    txt.write('A1\n')

# A1 and A2 are independent
[A_2]
input: None
output: 'b.txt'
with open('b.txt', 'w') as txt:
    txt.write('A2\n')
        ''')
        ret1 = subprocess.Popen('sos run lock -j1', shell=True)
        ret2 = subprocess.Popen('sos run lock -j1', shell=True)
        ret1.wait()
        ret2.wait()
        # two processes execute A_1 and A_2 separately, usually
        # takes less than 5 seconds
        file_target('lock.sos').remove('both')
예제 #21
0
 def test_zap(self):
     '''Test zap'''
     with open('testzap.txt', 'w') as sf:
         sf.write('some text')
     path('testzap.txt').zap()
     self.assertTrue(os.path.isfile('testzap.txt.zapped'))
     self.assertFalse(os.path.isfile('testzap.txt'))
     # re-zap is ok
     file_target('testzap.txt').zap()
     self.assertTrue(os.path.isfile('testzap.txt.zapped'))
     self.assertFalse(os.path.isfile('testzap.txt'))
     # non-existent file
     os.remove('testzap.txt.zapped')
     self.assertRaises(FileNotFoundError, path('testzap.txt').zap)
     #
     with open('testzap.txt', 'w') as sf:
         sf.write('some text')
     with open('testzap1.txt', 'w') as sf:
         sf.write('some text')
     paths('testzap.txt', 'testzap1.txt').zap()
     self.assertTrue(os.path.isfile('testzap.txt.zapped'))
     self.assertFalse(os.path.isfile('testzap.txt'))
     self.assertTrue(os.path.isfile('testzap1.txt.zapped'))
     self.assertFalse(os.path.isfile('testzap1.txt'))
     #
     os.remove('testzap.txt.zapped')
     os.remove('testzap1.txt.zapped')
     with open('testzap.txt', 'w') as sf:
         sf.write('some text')
     with open('testzap1.txt', 'w') as sf:
         sf.write('some text')
     sos_targets(['testzap.txt', 'testzap1.txt']).zap()
     self.assertTrue(os.path.isfile('testzap.txt.zapped'))
     self.assertFalse(os.path.isfile('testzap.txt'))
     self.assertTrue(os.path.isfile('testzap1.txt.zapped'))
     self.assertFalse(os.path.isfile('testzap1.txt'))
예제 #22
0
    def testOptionWorkdir(self):
        '''Test option workdir of tasks'''
        if not os.path.isdir('temp_wdr'):
            os.mkdir('temp_wdr')
        with open(os.path.join('temp_wdr', 'a.txt'), 'w') as tmp:
            tmp.write('hello')
        script = SoS_Script(r'''
[A_1]
run: workdir='temp_wdr'
  cp -f a.txt a2.txt
''')
        wf = script.workflow()
        Base_Executor(wf).run()
        self.assertTrue(file_target(os.path.join('temp_wdr', 'a2.txt')).target_exists())
        with open(os.path.join('temp_wdr', 'a.txt')) as tmp:
            self.assertEqual('hello', tmp.read())
예제 #23
0
def testOptionWorkdir(temp_factory):
    '''Test option workdir of tasks'''
    temp_factory(dir='temp_wdr')

    with open(os.path.join('temp_wdr', 'a.txt'), 'w') as tmp:
        tmp.write('hello')

    execute_workflow(r'''
        [A_1]
        run: workdir='temp_wdr'
        cp -f a.txt a2.txt
        ''')

    assert file_target(os.path.join('temp_wdr', 'a2.txt')).target_exists()
    with open(os.path.join('temp_wdr', 'a.txt')) as tmp:
        assert 'hello' == tmp.read()
예제 #24
0
    def testRemoteTS(self):
        if os.path.exists('ar.txt'):
            os.remove('ar.txt')
        with open('remote_ts.sos', 'w') as rt:
            rt.write('''
[10]
task:
sh:
  echo "I am done" >> ar.txt
''')
        ret = subprocess.call('sos run remote_ts -c ~/docker.yml -q ts',
                              shell=True)
        self.assertTrue(ret == 0)
        ret = subprocess.call('sos pull ar.txt -c ~/docker.yml --from ts',
                              shell=True)
        self.assertTrue(ret == 0)
        self.assertTrue(file_target('ar.txt').target_exists())
예제 #25
0
def test_forward_style_depend(clear_now_and_after, temp_factory):
    '''Test the execution of forward-style workflow with undtermined dependency'''
    clear_now_and_after('a.txt.bak')
    temp_factory('a.txt')
    execute_workflow('''
        [10]
        input: 'a.txt'
        output: f"{_input}.bak"
        run: expand=True
            cp {_input} {_output}

        [20]
        depends: "a.txt.bak"
        run: expand=True
            ls {_depends}
        ''')
    assert file_target('a.txt.bak').target_exists()
예제 #26
0
파일: test_utils.py 프로젝트: pgcudahy/sos
def test_file_sig(clear_now_and_after):
    '''test save and validate of file signature'''
    clear_now_and_after('test_sig.txt')

    with open('test_sig.txt', 'w') as ts:
        ts.write('ba')
    a = file_target('test_sig.txt')
    a.write_sig()
    assert a.validate()
    #
    a.zap()
    assert a.validate()

    with open('test_sig.txt', 'w') as ts:
        ts.write('bac')

    assert not a.validate()
예제 #27
0
    def testSharedOption(self):
        '''Test shared option of task'''
        for f in ('a.txt', 'a100.txt'):
            if file_target(f).exists():
                file_target(f).unlink()
        script = SoS_Script('''
[10: shared = 'a']
output: 'a.txt'
task: shared={'a': 'int(open("a.txt").read())'}
run:
  echo 100 > a.txt

[20]
run: expand=True
    touch a{a}.txt
''')
        wf = script.workflow()
        Base_Executor(wf, config={'sig_mode': 'force'}).run()
        self.assertTrue(os.path.isfile("a100.txt"))
        # sequence of var or mapping
        for f in ('a.txt', 'a100.txt'):
            if file_target(f).exists():
                file_target(f).unlink()
        script = SoS_Script('''
[10: shared = ['a', 'b']]
output: 'a.txt'
task: shared=[{'a': 'int(open("a.txt").read())'}, 'b']
b = 20
run:
  echo 100 > a.txt

[20]
run: expand=True
    touch a{a}_{b}.txt
''')
        wf = script.workflow()
        Base_Executor(wf, config={'sig_mode': 'force'}).run()
        self.assertTrue(os.path.isfile("a100_20.txt"))

        script = SoS_Script('''
[10 (simulate): shared=['rng', 'step_rng']]
input: for_each={'i': range(5)}
task: shared='rng'
print(f"{i}")
import random
rng = random.randint(1, 1000)
''')
        wf = script.workflow()
        Base_Executor(wf).run()
        var = env.sos_dict['rng']
        self.assertTrue(isinstance(var, int))
        self.assertTrue(isinstance(env.sos_dict['step_rng'], list))
        self.assertEqual(env.sos_dict['step_rng'][-1], var)
예제 #28
0
파일: test_remote.py 프로젝트: pgcudahy/sos
def test_remote_exec_workdir_wo_named_path(clear_now_and_after):
    clear_now_and_after(file_target("result_workdir_wo_named.txt"))
    with pytest.raises(Exception):
        execute_workflow(
            """
        output: 'result_workdir_wo_named.txt'

        task: workdir='/other'
        sh: expand=True
            echo Output: {_output} > {_output}
            echo PWD: `pwd`. >> {_output}
        """,
            options={
                "config_file": "~/docker.yml",
                "default_queue": "docker",
                "sig_mode": "force",
            },
        )
예제 #29
0
def test_report_3(clear_now_and_after):
    '''Test action report'''
    clear_now_and_after('report.txt')
    #
    execute_workflow(r'''
        [A_1]
        run: output='a.txt'
        echo something > a.txt

        [A_2]
        run: output='b.txt'
        echo something else > b.txt

        [A_3]
        report(input=['a.txt', 'b.txt'], output='out.txt')
        ''')
    for name in ('a.txt', 'b.txt', 'out.txt'):
        assert (file_target(name).target_exists())
예제 #30
0
    def testLocalTS(self):
        #
        if os.path.exists('a.txt'):
            os.remove('a.txt')
        script = SoS_Script('''
[10]
task:
sh:
  echo "I am done" >> a.txt
''')
        wf = script.workflow()
        Base_Executor(wf,
                      config={
                          'config_file': '~/docker.yml',
                          'wait_for_task': True,
                          'default_queue': 'local_ts',
                          'sig_mode': 'force',
                      }).run()
        self.assertTrue(file_target('a.txt').target_exists())