def TestBuild(registry, out_dir): foo_path = os.path.join(SCRIPT_DIR, 'foo.txt') bar_path = os.path.join(SCRIPT_DIR, 'bar.txt') bottom_file = os.path.join(out_dir, 'bottom.txt') middle1_file = os.path.join(out_dir, 'middle1.txt') middle2_file = os.path.join(out_dir, 'middle2.txt') middle3_file = os.path.join(out_dir, 'middle3.txt') top_file = os.path.join(out_dir, 'top.txt') bottom = registry.SubRespire(GenerateBottom, out_dir=out_dir, out_file=bottom_file) middle1 = registry.SubRespire(CatBottomWith, out_dir=out_dir, bottom_file=bottom_file, cat_file=foo_path, out_file=middle1_file) middle2 = registry.SubRespire(CatBottomWith, out_dir=out_dir, bottom_file=bottom_file, cat_file=bar_path, out_file=middle2_file) middle3 = registry.SubRespire(CatFiles, out_dir=out_dir, inputs=[bottom, bottom], out_file=middle3_file) top = registry.SubRespire(CatFiles, out_dir=out_dir, inputs=[middle1, middle2, middle3], out_file=top_file) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'diamond.TestBuild.count'))
def TestBuild(registry, out_dir): out_dir = out_dir bar_path = os.path.join(SCRIPT_DIR, 'bar.txt') base_chain_out_file_1 = os.path.join(out_dir, 'chain_output_1') base_chain_out_file_2 = os.path.join(out_dir, 'chain_output_2') chain_results_1_path = os.path.join(out_dir, 'chain_results_1.txt') chain_results_2_path = os.path.join(out_dir, 'chain_results_2.txt') chain_results1 = registry.SubRespire(Chain, input=bar_path, base_out_file=base_chain_out_file_1, number=3, out_dir=out_dir) chain_results2 = registry.SubRespire(Chain, input=bar_path, base_out_file=base_chain_out_file_2, number=4, out_dir=out_dir) registry.SubRespire(WriteResults, results=chain_results1, out_file=chain_results_1_path, out_dir=out_dir) registry.SubRespire(WriteResults, results=chain_results2, out_file=chain_results_2_path, out_dir=out_dir) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'chain.TestBuild.count'))
def TestBuild(registry, out_dir): foo_path = os.path.join(SCRIPT_DIR, 'foo.txt') bar_path = os.path.join(SCRIPT_DIR, 'bar.txt') foo_foo_path = os.path.join(out_dir, 'foofoo.txt') bar_bar_path = os.path.join(out_dir, 'barbar.txt') foo_bar_path = os.path.join(out_dir, 'foofoobarbar.txt') registry.SystemCommand( inputs=[foo_path], outputs=[foo_foo_path], command=utils.CatCommand([foo_path, foo_path], foo_foo_path)) registry.SystemCommand( inputs=[bar_path], outputs=[bar_bar_path], command=utils.CatCommand([bar_path, bar_path], bar_bar_path, os.path.join(out_dir, 'bar_bar.count'))) registry.SystemCommand( inputs=[foo_foo_path, bar_bar_path], outputs=[foo_bar_path], command=utils.CatCommand([foo_foo_path, bar_bar_path], foo_bar_path)) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'single_function.count'))
def CatFiles(registry, out_dir, inputs, output_file): utils.AddCount(os.path.join(out_dir, 'CatFiles.count')) registry.SystemCommand( inputs=inputs, outputs=[output_file], command=utils.CatCommand(inputs, output_file)) return output_file
def WriteAsString(registry, out_dir, contents, out_file): registry.SystemCommand(inputs=[], outputs=[out_file], command=utils.EchoCommand(str(contents), out_file)) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'WriteAsString.count'))
def TestBuild(registry, out_dir): two_file = os.path.join(out_dir, 'two_file.txt') three_file = os.path.join(out_dir, 'three_file.txt') three_again_file = os.path.join(out_dir, 'three_again_file.txt') four_file = os.path.join(out_dir, 'four_file.txt') two = registry.SubRespire(AddNumbers, out_dir=out_dir, numbers=[1, 1]) three = registry.SubRespire(AddNumbers, out_dir=out_dir, numbers=[1, two]) three_again = registry.SubRespire(AddNumbers, out_dir=out_dir, numbers=[1, 2]) four = registry.SubRespire(AddNumbers, out_dir=out_dir, numbers=[1, 3]) registry.SubRespire(WriteAsString, out_dir=out_dir, out_file=two_file, contents=two) registry.SubRespire(WriteAsString, out_dir=out_dir, out_file=three_file, contents=three) registry.SubRespire(WriteAsString, out_dir=out_dir, out_file=three_again_file, contents=three_again) registry.SubRespire(WriteAsString, out_dir=out_dir, out_file=four_file, contents=four) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'add_numbers.TestBuild.count'))
def TestBuild(registry, out_dir): stdin_path = os.path.join(out_dir, 'stdin.txt') stdout_path = os.path.join(out_dir, 'stdout.txt') stderr_path = os.path.join(out_dir, 'stderr.txt') final_path = os.path.join(out_dir, 'final.txt') registry.SystemCommand( inputs=[], outputs=[stdin_path], command=utils.EchoCommand('in', stdin_path)) registry.SystemCommand( inputs=[], outputs=[], command=utils.EchoCommand('out', 'stdout'), stdout=stdout_path) registry.SystemCommand( inputs=[], outputs=[], command=utils.EchoCommand('err', 'stderr'), stderr=stderr_path) registry.SystemCommand( inputs=[stdout_path, stderr_path], outputs=[final_path], command=utils.CatCommand( [stdout_path, stderr_path, 'stdin'], final_path, os.path.join(out_dir, 'final.count')), stdin=stdin_path) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'stdouterrin_function.count'))
def GenerateBottom(registry, out_dir, out_file): registry.SystemCommand(inputs=[], outputs=[out_file], command=utils.EchoCommand('TheBottom', out_file)) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'GenerateBottom.count')) return out_file
def WriteResults(registry, out_dir, results, out_file): registry.SystemCommand(inputs=[], outputs=[out_file], command=utils.EchoCommand(str(results[1][1][0][1]), out_file)) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'WriteResults.count'))
def WriteObjectValueWithoutImport(registry, out_dir, a): out_file = os.path.join(out_dir, 'value_without_import.txt') utils.AddCount( os.path.join(out_dir, 'write_object_value_without_import.count')) registry.SystemCommand(inputs=[], outputs=[out_file], command=utils.EchoCommand(a.GetValue(), out_file))
def AddNumbers(registry, out_dir, numbers): utils.AddCount(os.path.join(out_dir, 'AddNumbers.count')) if numbers[1] == 0: return numbers[0] else: return registry.SubRespire(AddOne, number=registry.SubRespire( AddNumbers, out_dir=out_dir, numbers=[numbers[0], numbers[1] - 1]))
def CatBottomWith(registry, out_dir, bottom_file, cat_file, out_file): utils.AddCount(os.path.join(out_dir, 'CatBottomWith.count')) bottom = registry.SubRespire(GenerateBottom, out_dir=out_dir, out_file=bottom_file) return registry.SubRespire(CatFiles, out_dir=out_dir, inputs=[bottom, cat_file], out_file=out_file)
def TestBuild(registry, out_dir): foo_path = os.path.join(SCRIPT_DIR, 'foo.txt') foo_foo_path = os.path.join(out_dir, 'foofoo.txt') registry.SubRespire(DoubleInput, input=foo_path, output=foo_foo_path, out_dir=out_dir) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'double_input.TestBuild.count'))
def GenerateBar(registry, out_dir): bar_filepath = os.path.join(out_dir, 'bar.txt') registry.SystemCommand( inputs=[], outputs=[bar_filepath], command=utils.EchoCommand('bar', bar_filepath)) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'GenerateBar.count')) return bar_filepath
def CatDirectory(inputs, outputs, out_dir): with open(outputs[0], 'w') as o: # Sort the inputs by their filenames so that we're guaranteed to be # deterministic about it. for entry in sorted(os.listdir(inputs[0])): with open(os.path.join(inputs[0], entry), 'r') as i: o.write(i.read()) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'cat_directory.count'))
def GenerateFoo(registry, out_dir): foo_filepath = os.path.join(out_dir, 'foo.txt') registry.SystemCommand(inputs=[], outputs=[foo_filepath], command=utils.EchoCommand(get_foo_value.foo_value, foo_filepath)) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'GenerateFoo.count')) return foo_filepath
def TestBuild(registry, out_dir): input_file = os.path.join(out_dir, 'input_file.txt') output_file = os.path.join(out_dir, 'output_file.txt') registry.RegisterSelfDependency(input_file) with open(input_file, 'r') as f: input_contents = f.read() registry.PythonFunction(inputs=[], outputs=[output_file], function=WriteContent, content=input_contents) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'build_dynamic_dependency.count'))
def TestBuild(registry, out_dir): bottom_file = os.path.join(out_dir, 'bottom.txt') out_file = os.path.join(out_dir, 'out.txt') bottom = registry.SubRespire( GenerateBottom, out_dir=out_dir, out_file=bottom_file) # Ultimately these should all result in the same output command. out_file_1 = registry.SubRespire(CatFiles, out_dir=out_dir, inputs=[bottom, bottom], output_file=out_file) out_file_2 = registry.SubRespire(CatFiles, out_dir=out_dir, inputs=[bottom_file, bottom], output_file=out_file) out_file_3 = registry.SubRespire(CatFiles, out_dir=out_dir, inputs=[bottom, bottom_file], output_file=out_file) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'futures_resolve.TestBuild.count'))
def TestBuild(registry, out_dir): a = registry.SubRespireExternal('get_object_value.respire.py', 'GetObjectValue', out_dir=out_dir) registry.SubRespireExternal('write_object_value_with_import.respire.py', 'WriteObjectValueWithImport', out_dir=out_dir, a=a) registry.SubRespireExternal('write_object_value_without_import.respire.py', 'WriteObjectValueWithoutImport', out_dir=out_dir, a=a) utils.AddCount( os.path.join(out_dir, 'can_pass_object_as_parameter.TestBuild.count'))
def Chain(registry, out_dir, input, number, base_out_file): out_file = base_out_file + str(number) + '.txt' registry.SystemCommand(inputs=[input], outputs=[out_file], command=utils.CatCommand([input, input], out_file)) return_value = [[out_file, number]] if number > 1: return_value.append( registry.SubRespire(Chain, input=out_file, base_out_file=base_out_file, number=number - 1, out_dir=out_dir)) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'Chain.count')) return return_value
def TestBuild(registry, out_dir): foobar_filepath = os.path.join(out_dir, 'foobar.txt') foo = registry.SubRespireExternal('generate_foo.respire.py', 'GenerateFoo', out_dir=out_dir) bar = registry.SubRespireExternal('generate_bar.respire.py', 'GenerateBar', out_dir=out_dir) registry.SubRespireExternal('cat_files.respire.py', 'CatFiles', inputs=[foo, bar], output_file=foobar_filepath, out_dir=out_dir) # Track how many times this python is executed. utils.AddCount( os.path.join(out_dir, 'simple_test_entry_point.TestBuild.count'))
def TestBuild(registry, out_dir): foo_path = os.path.join(SCRIPT_DIR, 'foo.txt') bar_path = os.path.join(SCRIPT_DIR, 'bar.txt') foo_foo_path = os.path.join(out_dir, 'foofoo.txt') bar_bar_path = os.path.join(out_dir, 'barbar.txt') foo_bar_path = os.path.join(out_dir, 'foofoobarbar.txt') registry.SystemCommand(inputs=[foo_path], outputs=[foo_foo_path], command=utils.CatCommand([foo_path, foo_path], foo_foo_path)) registry.PythonFunction(inputs=[bar_path], outputs=[bar_bar_path], function=_DoubleFile, my_input=bar_path, my_output=bar_bar_path) registry.PythonFunction(inputs=[foo_foo_path, bar_bar_path], outputs=[foo_bar_path], function=_ConcatenateFiles) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'python_function.count'))
def DoubleInput(registry, out_dir, input, output): registry.SystemCommand(inputs=[input], outputs=[output], command=utils.CatCommand([input, input], output)) # Track how many times this python is executed. utils.AddCount(os.path.join(out_dir, 'DoubleInput.count'))
def GetObjectValue(registry, out_dir): utils.AddCount(os.path.join(out_dir, 'get_object_value.count')) return foo_class.Foo('woof', 'bark')