def test_serialize_builder(self):
"""
Test serailization when using a builder.
"""
builder = SerializeWorkChain.get_builder()
builder.test = Int
builder.reference = Str(ObjectLoader().identify_object(Int))
launch.run(builder)
def test_serialize(self):
"""
Test a simple serialization of a class to its identifier.
"""
run_and_check_success(SerializeWorkChain,
test=Int,
reference=Str(
ObjectLoader().identify_object(Int)))
def define(cls, spec):
super().define(spec)
spec.input('test',
valid_type=Str,
serializer=lambda x: Str(ObjectLoader().identify_object(x)))
spec.outline(cls.echo)
spec.outputs.dynamic = True
def define(cls, spec):
super().define(spec)
spec.input(
'test',
valid_type=Str,
serializer=lambda x: Str(ObjectLoader().identify_object(x)),
)
spec.input('reference', valid_type=Str)
spec.outline(cls.do_test)
def main():
"""Launch a bunch of calculation jobs and workchains."""
# pylint: disable=too-many-locals,too-many-statements,too-many-branches
expected_results_process_functions = {}
expected_results_calculations = {}
expected_results_workchains = {}
code_doubler = load_code(CODENAME_DOUBLER)
# Run the `ArithmeticAddCalculation`
print('Running the `ArithmeticAddCalculation`')
run_arithmetic_add()
# Run the `AddArithmeticBaseWorkChain`
print('Running the `AddArithmeticBaseWorkChain`')
run_base_restart_workchain()
# Run the `MultiplyAddWorkChain`
print('Running the `MultiplyAddWorkChain`')
run_multiply_add_workchain()
# Submitting the calcfunction through the launchers
print('Submitting calcfunction to the daemon')
proc, expected_result = launch_calcfunction(inputval=1)
expected_results_process_functions[proc.pk] = expected_result
# Submitting the workfunction through the launchers
print('Submitting workfunction to the daemon')
proc, expected_result = launch_workfunction(inputval=1)
expected_results_process_functions[proc.pk] = expected_result
# Submitting the Calculations the new way directly through the launchers
print(f'Submitting {NUMBER_CALCULATIONS} calculations to the daemon')
for counter in range(1, NUMBER_CALCULATIONS + 1):
inputval = counter
calc, expected_result = launch_calculation(code=code_doubler,
counter=counter,
inputval=inputval)
expected_results_calculations[calc.pk] = expected_result
# Submitting the Workchains
print(f'Submitting {NUMBER_WORKCHAINS} workchains to the daemon')
for index in range(NUMBER_WORKCHAINS):
inp = Int(index)
_, node = run.get_node(NestedWorkChain, inp=inp)
expected_results_workchains[node.pk] = index
print("Submitting a workchain with 'submit'.")
builder = NestedWorkChain.get_builder()
input_val = 4
builder.inp = Int(input_val)
proc = submit(builder)
expected_results_workchains[proc.pk] = input_val
print('Submitting a workchain with a nested input namespace.')
value = Int(-12)
pk = submit(NestedInputNamespace, foo={'bar': {'baz': value}}).pk
print('Submitting a workchain with a dynamic non-db input.')
value = [4, 2, 3]
pk = submit(DynamicNonDbInput, namespace={'input': value}).pk
expected_results_workchains[pk] = value
print('Submitting a workchain with a dynamic db input.')
value = 9
pk = submit(DynamicDbInput, namespace={'input': Int(value)}).pk
expected_results_workchains[pk] = value
print('Submitting a workchain with a mixed (db / non-db) dynamic input.')
value_non_db = 3
value_db = Int(2)
pk = submit(DynamicMixedInput,
namespace={
'inputs': {
'input_non_db': value_non_db,
'input_db': value_db
}
}).pk
expected_results_workchains[pk] = value_non_db + value_db
print('Submitting the serializing workchain')
pk = submit(SerializeWorkChain, test=Int).pk
expected_results_workchains[pk] = ObjectLoader().identify_object(Int)
print('Submitting the ListEcho workchain.')
list_value = List()
list_value.extend([1, 2, 3])
pk = submit(ListEcho, list=list_value).pk
expected_results_workchains[pk] = list_value
print('Submitting a WorkChain which contains a workfunction.')
value = Str('workfunction test string')
pk = submit(WorkFunctionRunnerWorkChain, input=value).pk
expected_results_workchains[pk] = value
print('Submitting a WorkChain which contains a calcfunction.')
value = Int(1)
pk = submit(CalcFunctionRunnerWorkChain, input=value).pk
expected_results_workchains[pk] = Int(2)
calculation_pks = sorted(expected_results_calculations.keys())
workchains_pks = sorted(expected_results_workchains.keys())
process_functions_pks = sorted(expected_results_process_functions.keys())
pks = calculation_pks + workchains_pks + process_functions_pks
print('Wating for end of execution...')
start_time = time.time()
exited_with_timeout = True
while time.time() - start_time < TIMEOUTSECS:
time.sleep(15) # Wait a few seconds
# Print some debug info, both for debugging reasons and to avoid
# that the test machine is shut down because there is no output
print('#' * 78)
print(f'####### TIME ELAPSED: {time.time() - start_time} s')
print('#' * 78)
print("Output of 'verdi process list -a':")
try:
print(
subprocess.check_output(
['verdi', 'process', 'list', '-a'],
stderr=subprocess.STDOUT,
))
except subprocess.CalledProcessError as exception:
print(f'Note: the command failed, message: {exception}')
print("Output of 'verdi daemon status':")
try:
print(
subprocess.check_output(
['verdi', 'daemon', 'status'],
stderr=subprocess.STDOUT,
))
except subprocess.CalledProcessError as exception:
print(f'Note: the command failed, message: {exception}')
if jobs_have_finished(pks):
print('Calculation terminated its execution')
exited_with_timeout = False
break
if exited_with_timeout:
print_daemon_log()
print('')
print(
f'Timeout!! Calculation did not complete after {TIMEOUTSECS} seconds'
)
sys.exit(2)
else:
# Launch the same calculations but with caching enabled -- these should be FINISHED immediately
cached_calcs = []
with enable_caching(identifier='aiida.calculations:templatereplacer'):
for counter in range(1, NUMBER_CALCULATIONS + 1):
inputval = counter
calc, expected_result = run_calculation(code=code_doubler,
counter=counter,
inputval=inputval)
cached_calcs.append(calc)
expected_results_calculations[calc.pk] = expected_result
if (validate_calculations(expected_results_calculations)
and validate_workchains(expected_results_workchains)
and validate_cached(cached_calcs)
and validate_process_functions(
expected_results_process_functions)):
print_daemon_log()
print('')
print('OK, all calculations have the expected parsed result')
sys.exit(0)
else:
print_daemon_log()
print('')
print(
'ERROR! Some return values are different from the expected value'
)
sys.exit(3)
def launch_all():
"""Launch a bunch of calculation jobs and workchains.
:returns: dictionary with expected results and pks of all launched calculations and workchains
"""
# pylint: disable=too-many-locals,too-many-statements
expected_results_process_functions = {}
expected_results_calculations = {}
expected_results_workchains = {}
code_doubler = load_code(CODENAME_DOUBLER)
# Run the `ArithmeticAddCalculation`
print('Running the `ArithmeticAddCalculation`')
run_arithmetic_add()
# Run the `AddArithmeticBaseWorkChain`
print('Running the `AddArithmeticBaseWorkChain`')
run_base_restart_workchain()
# Run the `MultiplyAddWorkChain`
print('Running the `MultiplyAddWorkChain`')
run_multiply_add_workchain()
# Testing the stashing functionality
process, inputs, expected_result = create_calculation_process(
code=code_doubler, inputval=1)
with tempfile.TemporaryDirectory() as tmpdir:
# Delete the temporary directory to test that the stashing functionality will create it if necessary
shutil.rmtree(tmpdir, ignore_errors=True)
source_list = ['output.txt', 'triple_value.tmp']
inputs['metadata']['options']['stash'] = {
'target_base': tmpdir,
'source_list': source_list
}
_, node = run.get_node(process, **inputs)
assert node.is_finished_ok
assert 'remote_stash' in node.outputs
remote_stash = node.outputs.remote_stash
assert remote_stash.stash_mode == StashMode.COPY
assert remote_stash.target_basepath.startswith(tmpdir)
assert sorted(remote_stash.source_list) == sorted(source_list)
assert sorted(p for p in os.listdir(
remote_stash.target_basepath)) == sorted(source_list)
# Submitting the calcfunction through the launchers
print('Submitting calcfunction to the daemon')
proc, expected_result = launch_calcfunction(inputval=1)
expected_results_process_functions[proc.pk] = expected_result
# Submitting the workfunction through the launchers
print('Submitting workfunction to the daemon')
proc, expected_result = launch_workfunction(inputval=1)
expected_results_process_functions[proc.pk] = expected_result
# Submitting the Calculations the new way directly through the launchers
print(f'Submitting {NUMBER_CALCULATIONS} calculations to the daemon')
for counter in range(1, NUMBER_CALCULATIONS + 1):
inputval = counter
calc, expected_result = launch_calculation(code=code_doubler,
counter=counter,
inputval=inputval)
expected_results_calculations[calc.pk] = expected_result
# Submitting the Workchains
print(f'Submitting {NUMBER_WORKCHAINS} workchains to the daemon')
for index in range(NUMBER_WORKCHAINS):
inp = Int(index)
_, node = run.get_node(NestedWorkChain, inp=inp)
expected_results_workchains[node.pk] = index
print("Submitting a workchain with 'submit'.")
builder = NestedWorkChain.get_builder()
input_val = 4
builder.inp = Int(input_val)
pk = submit(builder).pk
expected_results_workchains[pk] = input_val
print('Submitting a workchain with a nested input namespace.')
value = Int(-12)
pk = submit(NestedInputNamespace, foo={'bar': {'baz': value}}).pk
print('Submitting a workchain with a dynamic non-db input.')
value = [4, 2, 3]
pk = submit(DynamicNonDbInput, namespace={'input': value}).pk
expected_results_workchains[pk] = value
print('Submitting a workchain with a dynamic db input.')
value = 9
pk = submit(DynamicDbInput, namespace={'input': Int(value)}).pk
expected_results_workchains[pk] = value
print('Submitting a workchain with a mixed (db / non-db) dynamic input.')
value_non_db = 3
value_db = Int(2)
pk = submit(DynamicMixedInput,
namespace={
'inputs': {
'input_non_db': value_non_db,
'input_db': value_db
}
}).pk
expected_results_workchains[pk] = value_non_db + value_db
print('Submitting the serializing workchain')
pk = submit(SerializeWorkChain, test=Int).pk
expected_results_workchains[pk] = ObjectLoader().identify_object(Int)
print('Submitting the ListEcho workchain.')
list_value = List()
list_value.extend([1, 2, 3])
pk = submit(ListEcho, list=list_value).pk
expected_results_workchains[pk] = list_value
print('Submitting a WorkChain which contains a workfunction.')
value = Str('workfunction test string')
pk = submit(WorkFunctionRunnerWorkChain, input=value).pk
expected_results_workchains[pk] = value
print('Submitting a WorkChain which contains a calcfunction.')
value = Int(1)
pk = submit(CalcFunctionRunnerWorkChain, input=value).pk
expected_results_workchains[pk] = Int(2)
calculation_pks = sorted(expected_results_calculations.keys())
workchains_pks = sorted(expected_results_workchains.keys())
process_functions_pks = sorted(expected_results_process_functions.keys())
return {
'pks': calculation_pks + workchains_pks + process_functions_pks,
'calculations': expected_results_calculations,
'process_functions': expected_results_process_functions,
'workchains': expected_results_workchains,
}
