def create_codes(tmpdir, aiida_localhost):
"""Create a local and remote `Code` instance."""
filename = 'add.sh'
filepath = str(tmpdir / filename) # Cast the filepath to str as Python 3.5 does not support Path objects for `open`
with open(filepath, 'w'):
pass
code_local = Code(local_executable=filename, files=[filepath]).store()
code_remote = Code(remote_computer_exec=(aiida_localhost, '/bin/true')).store()
return code_local, code_remote
def create_codes(tmpdir, aiida_localhost):
"""Create a local and remote `Code` instance."""
filename = 'add.sh'
filepath = tmpdir / filename
with open(filepath, 'w'):
pass
code_local = Code(local_executable=filename, files=[filepath]).store()
code_remote = Code(remote_computer_exec=(aiida_localhost, '/bin/true')).store()
return code_local, code_remote
def test_remote(self):
"""Test remote code."""
import tempfile
from aiida.orm import Code
from aiida.common.exceptions import ValidationError
with self.assertRaises(ValueError):
# remote_computer_exec has length 2 but is not a list or tuple
Code(remote_computer_exec='ab')
# invalid code path
with self.assertRaises(ValueError):
Code(remote_computer_exec=(self.computer, ''))
# Relative path is invalid for remote code
with self.assertRaises(ValueError):
Code(remote_computer_exec=(self.computer, 'subdir/run.exe'))
# first argument should be a computer, not a string
with self.assertRaises(TypeError):
Code(remote_computer_exec=('localhost', '/bin/ls'))
code = Code(remote_computer_exec=(self.computer, '/bin/ls'))
with tempfile.NamedTemporaryFile(mode='w+') as fhandle:
fhandle.write('#/bin/bash\n\necho test run\n')
fhandle.flush()
code.put_object_from_filelike(fhandle, 'test.sh')
with self.assertRaises(ValidationError):
# There are files inside
code.store()
# If there are no files, I can store
code.delete_object('test.sh')
code.store()
self.assertEqual(code.get_remote_computer().pk, self.computer.pk) # pylint: disable=no-member
self.assertEqual(code.get_remote_exec_path(), '/bin/ls')
self.assertEqual(code.get_execname(), '/bin/ls')
self.assertTrue(code.can_run_on(self.computer))
othercomputer = orm.Computer(
label='another_localhost',
hostname='localhost',
transport_type='local',
scheduler_type='pbspro',
workdir='/tmp/aiida'
).store()
self.assertFalse(code.can_run_on(othercomputer))
def setUp(self):
# Create some code nodes
code = Code()
code.set_remote_computer_exec((self.computer, '/bin/true'))
code.label = self.CODE_LABEL
code.set_input_plugin_name(self.INPUT_PLUGIN_NAME)
code.store()
def code_echo(self):
"""Fixture of a code that just echos"""
code = Code()
code.set_remote_computer_exec((self.localhost, "/bin/echo"))
code.set_input_plugin_name("castep.castep")
code.store()
return code
def test_code_list(self):
# set up second code 'code2'
from aiida.orm import Code
try:
code = Code.get_from_string('code2')
except NotExistent:
code = Code(
input_plugin_name='simpleplugins.templatereplacer',
remote_computer_exec=[self.comp, '/remote/abs/path'],
)
code.label = 'code2'
code.store()
options = [
'-A', '-a', '-o', '--input-plugin=simpleplugins.arithmetic.add',
'--computer={}'.format(self.comp.name)
]
result = self.runner.invoke(code_list, options)
self.assertIsNone(result.exception)
self.assertTrue(
str(self.code.pk) in result.output,
'PK of first code should be included')
self.assertTrue('code2' not in result.output,
'label of second code should not be included')
self.assertTrue('comp' in result.output,
'computer name should be included')
def get_code(entry_point, executable, computer=aiida_localhost):
"""Get local code.
Sets up code for given entry point on given computer.
:param entry_point: Entry point of calculation plugin
:param executable: name of executable; will be searched for in local system PATH.
:param computer: (local) AiiDA computer
:return: The code node
:rtype: :py:class:`aiida.orm.Code`
"""
from aiida.orm import Code
codes = Code.objects.find(filters={'label': executable}) # pylint: disable=no-member
if codes:
return codes[0]
executable_path = shutil.which(executable)
if not executable_path:
raise ValueError(
'The executable "{}" was not found in the $PATH.'.format(
executable))
code = Code(
input_plugin_name=entry_point,
remote_computer_exec=[computer, executable_path],
)
code.label = executable
return code.store()
def test_code_get_builder(self):
"""
Test that the get_builder method of Code returns a builder
where the code is already set.
"""
from aiida.orm import Code
code1 = Code()
# This also sets the code as a remote code
code1.set_remote_computer_exec((self.computer, '/bin/true'))
code1.label = 'test_code1'
code1.set_input_plugin_name('simpleplugins.templatereplacer')
code1.store()
# Check that I can get a builder
builder = code1.get_builder()
self.assertEquals(builder.code.pk, code1.pk)
# Check that I can set the parameters
builder.parameters = ParameterData(dict={})
# Check that it complains for an unknown input
with self.assertRaises(AttributeError):
builder.unknown_parameter = 3
# Check that it complains if the type is not the correct one
# (for the simpleplugins.templatereplacer, it should be a
# ParameterData)
with self.assertRaises(ValueError):
builder.parameters = Int(3)
def get_code(entry_point, computer_name='localhost'):
"""Get local code.
Sets up code for given entry point on given computer.
:param entry_point: Entry point of calculation plugin
:param computer_name: Name of (local) computer
:return: The code node
:rtype: :py:class:`aiida.orm.Code`
"""
from aiida.orm import Code
from aiida.common.exceptions import NotExistent
computer = get_computer(computer_name)
try:
executable = executables[entry_point]
except KeyError:
raise KeyError(
"Entry point {} not recognized. Allowed values: {}".format(
entry_point, executables.keys()))
try:
code = Code.get_from_string('{}@{}'.format(executable, computer_name))
except NotExistent:
path = get_path_to_executable(executable)
code = Code(
input_plugin_name=entry_point,
remote_computer_exec=[computer, path],
)
code.label = executable
code.store()
return code
def mock_vasp(fresh_aiida_env, localhost):
"""Points to a mock-up of a VASP executable."""
from aiida.orm import Code
from aiida.orm.querybuilder import QueryBuilder
query_builder = QueryBuilder()
query_builder.append(Code, tag='code')
query_builder.add_filter('code', {'label': {'==': 'mock-vasp'}})
query_results = query_builder.all()
if query_results:
code = query_results[0][0]
else:
os_env = os.environ.copy()
if not localhost.pk:
localhost.store()
# returns unicode
mock_vasp_path = sp.check_output(['which', 'mock-vasp'],
env=os_env,
universal_newlines=True).strip()
code = Code()
code.label = 'mock-vasp'
code.description = 'Mock VASP for tests'
code.set_remote_computer_exec((localhost, mock_vasp_path))
code.set_input_plugin_name('vasp.vasp')
aiidapath = py_path.local(
fresh_aiida_env._manager.root_dir).join('.aiida')
code.set_prepend_text('export AIIDA_PATH={}'.format(aiidapath))
return code
def setUp(self):
"""Set up test environment"""
self.calc_cls = CalculationFactory('vasp.scf')
self.code = Code()
self.code.set_computer(self.computer)
self.code.set_remote_computer_exec((self.computer, '/bin/foo'))
Common.import_paw()
def prepare_code(codename, codelocation, computername, workdir):
"""."""
# first create or read computer
comp = prepare_computer(computername, workdir)
# now decide which code to add
if codename == 'kkrhost':
execname = 'kkr.x'
pluginname = 'kkr.kkr'
elif codename == 'voronoi':
execname = 'voronoi.exe'
pluginname = 'kkr.voro'
elif codename == 'kkrimp':
execname = 'kkrflex.exe'
pluginname = 'kkr.kkrimp'
else:
raise ValueError('unknown codename')
# then get code from database or create a new code
from aiida.orm import Code
from aiida.common.exceptions import NotExistent
try:
code = Code.get_from_string(codename + '@' + computername)
except NotExistent as exception:
code = Code()
code.label = codename
code.description = ''
code.set_remote_computer_exec((comp, codelocation + execname))
code.set_input_plugin_name(pluginname)
if codename == 'voronoi':
code.set_prepend_text('ln -s ' + codelocation +
'ElementDataBase .')
code.store()
def get_code(entry_point, computer):
"""Get local code.
Sets up code for given entry point on given computer.
:param entry_point: Entry point of calculation plugin
:param computer: (local) AiiDA computer
:return: The code node
:rtype: :py:class:`aiida.orm.Code`
"""
from aiida.orm import Code
try:
executable = executables[entry_point]
except KeyError:
raise KeyError(
"Entry point '{}' not recognized. Allowed values: {}".format(
entry_point, list(executables.keys())))
codes = Code.objects.find(filters={'label': executable}) # pylint: disable=no-member
if codes:
return codes[0]
path = get_path_to_executable(executable)
code = Code(
input_plugin_name=entry_point,
remote_computer_exec=[computer, path],
)
code.label = executable
return code.store()
def _setup_code(self, change=None): # pylint: disable=unused-argument
"""Setup an AiiDA code."""
with self._setup_code_out:
clear_output()
if self.label is None:
print("You did not specify code label")
return
if not self.exec_path:
print("You did not specify absolute path to the executable")
return
if self.exists():
print("Code {}@{} already exists".format(
self.label, self.computer.name))
return
code = Code(remote_computer_exec=(self.computer, self.exec_path))
code.label = self.label
code.description = self.description
code.set_input_plugin_name(self.plugin)
code.set_prepend_text(self.prepend_text)
code.set_append_text(self.append_text)
code.store()
code.reveal()
full_string = "{}@{}".format(self.label, self.computer.name)
print(
check_output(['verdi', 'code', 'show',
full_string]).decode('utf-8'))
def get_code(entry_point, computer):
"""Get local code.
Sets up code for given entry point on given computer.
:param entry_point: Entry point of calculation plugin
:param computer: (local) AiiDA computer
:return: The code node
:rtype: :py:class:`aiida.orm.Code`
"""
from aiida.orm import Code, QueryBuilder, Computer
try:
executable = EXECUTABLE[entry_point]
except KeyError:
raise KeyError(
"Entry point '{}' not recognized. Allowed values: {}".format(
entry_point, list(EXECUTABLE.keys())))
qbuilder = QueryBuilder()
qbuilder.append(Computer, filters={'id': computer.pk})
qbuilder.append(Code,
with_computer=Computer,
filters={'label': executable})
codes = [_[0] for _ in qbuilder.all()]
if codes:
return codes[0]
path = get_path_to_executable(executable)
code = Code(
input_plugin_name=entry_point,
remote_computer_exec=[computer, path],
)
code.label = executable
return code.store()
def setup_codes(clear_database_before_test, aiida_localhost):
"""Create some `Code` instances to test the `CodeParamType` parameter type for the command line infrastructure.
We create an initial code with a random name and then on purpose create two code with a name that matches exactly
the ID and UUID, respectively, of the first one. This allows us to test the rules implemented to solve ambiguities
that arise when determing the identifier type.
"""
entity_01 = Code(remote_computer_exec=(aiida_localhost, '/bin/true')).store()
entity_02 = Code(remote_computer_exec=(aiida_localhost, '/bin/true'), input_plugin_name='arithmetic.add').store()
entity_03 = Code(remote_computer_exec=(aiida_localhost, '/bin/true'), input_plugin_name='templatereplacer').store()
entity_01.label = 'computer_01'
entity_02.label = str(entity_01.pk)
entity_03.label = str(entity_01.uuid)
return entity_01, entity_02, entity_03
def get_code(entry_point,
executable,
computer=aiida_localhost,
label=None,
prepend_text=None,
append_text=None):
"""Get local code.
Sets up code for given entry point on given computer.
:param entry_point: Entry point of calculation plugin
:param executable: name of executable; will be searched for in local system PATH.
:param computer: (local) AiiDA computer
:param prepend_text: a string of code that will be put in the scheduler script before the execution of the code.
:param append_text: a string of code that will be put in the scheduler script after the execution of the code.
:return: the `Code` either retrieved from the database or created if it did not yet exist.
:rtype: :py:class:`aiida.orm.Code`
"""
from aiida.common import exceptions
from aiida.orm import Code, Computer, QueryBuilder
if label is None:
label = executable
builder = QueryBuilder().append(Computer,
filters={'uuid': computer.uuid},
tag='computer')
builder.append(Code,
filters={
'label': label,
'attributes.input_plugin': entry_point
},
with_computer='computer')
try:
code = builder.one()[0]
except (exceptions.MultipleObjectsError, exceptions.NotExistent):
code = None
else:
return code
executable_path = shutil.which(executable)
if not executable_path:
raise ValueError(
'The executable "{}" was not found in the $PATH.'.format(
executable))
code = Code(input_plugin_name=entry_point,
remote_computer_exec=[computer, executable_path])
code.label = label
code.description = label
if prepend_text is not None:
code.set_prepend_text(prepend_text)
if append_text is not None:
code.set_append_text(append_text)
return code.store()
def code_mock_factory(self, overide=None):
"""Mock calculation, can overide by prepend path"""
code = Code()
exec_path = this_folder.parent.parent / 'utils/mock.py'
code.set_remote_computer_exec((self.localhost, str(exec_path)))
code.set_input_plugin_name('castep.castep')
if overide:
code.set_prepend_text('export MOCK_CALC={}'.format(overide))
return code
def vasp_code(localhost):
"""Fixture for a vasp code, the executable it points to does not exist"""
from aiida.orm import Code
localhost.store()
code = Code()
code.label = 'vasp'
code.description = 'VASP code'
code.set_remote_computer_exec((localhost, '/usr/local/bin/vasp'))
code.set_input_plugin_name('vasp.vasp')
return code
def setUp(self):
self.calc_cls = CalculationFactory('vasp.base.BasicCalculation')
Common.import_paw()
Paw = DataFactory('vasp.paw')
self.code = Code()
self.code.set_computer(self.computer)
self.code.set_remote_computer_exec((self.computer, '/bin/foo'))
self.paw_in = Paw.load_paw(element='In')[0]
self.paw_as = Paw.load_paw(element='As')[0]
self.tmp, self.tmpf = tempfile.mkstemp()
def test_complete(setup_codes, parameter_type, aiida_localhost):
"""Test the `complete` method that provides auto-complete functionality."""
entity_01, entity_02, entity_03 = setup_codes
entity_04 = Code(label='xavier', remote_computer_exec=(aiida_localhost, '/bin/true')).store()
options = [item[0] for item in parameter_type.complete(None, '')]
assert sorted(options) == sorted([entity_01.label, entity_02.label, entity_03.label, entity_04.label])
options = [item[0] for item in parameter_type.complete(None, 'xa')]
assert sorted(options) == sorted([entity_04.label])
def test_properties_code(test_computer):
from aiida.orm import Code
if not test_computer.pk:
test_computer.store()
code = Code()
code.label = 'properties'
code.description = 'CRYSTAL properties code'
mock_exec = os.path.join(TEST_DIR, 'mock', 'crystal')
code.set_remote_computer_exec((test_computer, mock_exec))
code.set_input_plugin_name('crystal_dft.properties')
return code
def setUpClass(cls):
"""
Create some code to test the CodeParamType parameter type for the command line infrastructure
We create an initial code with a random name and then on purpose create two code with a name
that matches exactly the ID and UUID, respectively, of the first one. This allows us to test
the rules implemented to solve ambiguities that arise when determing the identifier type
"""
super(TestCodeParamType, cls).setUpClass()
cls.param = CodeParamType()
cls.entity_01 = Code(remote_computer_exec=(cls.computer,
'/bin/true')).store()
cls.entity_02 = Code(remote_computer_exec=(cls.computer,
'/bin/true')).store()
cls.entity_03 = Code(remote_computer_exec=(cls.computer,
'/bin/true')).store()
cls.entity_01.label = 'computer_01'
cls.entity_02.label = str(cls.entity_01.pk)
cls.entity_03.label = str(cls.entity_01.uuid)
def setUp(self):
self.calc_cls = CalculationFactory('vasp.amn')
self.code = Code()
self.code.set_computer(self.computer)
self.code.set_remote_computer_exec((self.computer, '/bin/foo'))
Common.import_paw()
self.tmpd, self.tmpf = tempfile.mkstemp()
self.wdat = Common.wdat()
self.wdat.add_file(self.tmpf, 'test1')
self.wdat.add_file(self.tmpf, 'test2')
self.wdat._make_archive()
def test_crystal_code(test_computer):
from aiida.orm import Code
if not test_computer.pk:
test_computer.store()
code = Code()
code.label = 'crystal'
code.description = 'CRYSTAL code'
mock_exec = os.path.join(MOCK_DIR, 'crystal')
code.set_remote_computer_exec((test_computer, mock_exec))
code.set_input_plugin_name('crystal_dft.serial')
return code
def cstdn_code(computer):
"""
Setup a new code object.
"""
from aiida.orm import Code
code = Code(remote_computer_exec=(computer, '/path/to/cstdn'))
code.label = 'cstdncode'
code.set_prepend_text('custodian code prepend')
code.set_append_text('custodian code append')
# do not store the code yet such that the default plugin can be set later
yield code
def setUpClass(cls, *args, **kwargs):
"""
Create some code to test the CodeParamType parameter type for the command line infrastructure
We create an initial code with a random name and then on purpose create two code with a name
that matches exactly the ID and UUID, respectively, of the first one. This allows us to test
the rules implemented to solve ambiguities that arise when determing the identifier type
"""
super().setUpClass(*args, **kwargs)
cls.param_base = CodeParamType()
cls.param_entry_point = CodeParamType(entry_point='arithmetic.add')
cls.entity_01 = Code(remote_computer_exec=(cls.computer,
'/bin/true')).store()
cls.entity_02 = Code(remote_computer_exec=(cls.computer, '/bin/true'),
input_plugin_name='arithmetic.add').store()
cls.entity_03 = Code(remote_computer_exec=(cls.computer, '/bin/true'),
input_plugin_name='templatereplacer').store()
cls.entity_01.label = 'computer_01'
cls.entity_02.label = str(cls.entity_01.pk)
cls.entity_03.label = str(cls.entity_01.uuid)
def new(self):
"""Build and return a new code instance (not stored)"""
self.validate()
from aiida.orm import Code
# Will be used at the end to check if all keys are known (those that are not None)
passed_keys = set([
k for k in self._code_spec.keys() if self._code_spec[k] is not None
])
used = set()
if self._get_and_count('code_type',
used) == self.CodeType.STORE_AND_UPLOAD:
file_list = [
os.path.realpath(os.path.join(self.code_folder, f))
for f in os.listdir(self._get_and_count('code_folder', used))
]
code = Code(local_executable=self._get_and_count(
'code_rel_path', used),
files=file_list)
else:
code = Code(remote_computer_exec=(
self._get_and_count('computer', used),
self._get_and_count('remote_abs_path', used)))
code.label = self._get_and_count('label', used)
code.description = self._get_and_count('description', used)
code.set_input_plugin_name(
self._get_and_count('input_plugin', used).name)
code.set_prepend_text(self._get_and_count('prepend_text', used))
code.set_append_text(self._get_and_count('append_text', used))
# Complain if there are keys that are passed but not used
if passed_keys - used:
raise self.CodeValidationError(
'Unknown parameters passed to the CodeBuilder: {}'.format(
", ".join(sorted(passed_keys - used))))
return code
def test_load_code(self):
"""Test the functionality of load_code."""
from aiida.orm import Code
label = 'compy'
code = Code()
code.label = label
code.set_remote_computer_exec((self.computer, '/x.x'))
code.store()
# Load through full label
loaded_code = load_code(code.full_label)
self.assertEquals(loaded_code.uuid, code.uuid)
# Load through label
loaded_code = load_code(code.label)
self.assertEquals(loaded_code.uuid, code.uuid)
# Load through uuid
loaded_code = load_code(code.uuid)
self.assertEquals(loaded_code.uuid, code.uuid)
# Load through pk
loaded_code = load_code(code.pk)
self.assertEquals(loaded_code.uuid, code.uuid)
# Load through full label explicitly
loaded_code = load_code(label=code.full_label)
self.assertEquals(loaded_code.uuid, code.uuid)
# Load through label explicitly
loaded_code = load_code(label=code.label)
self.assertEquals(loaded_code.uuid, code.uuid)
# Load through uuid explicitly
loaded_code = load_code(uuid=code.uuid)
self.assertEquals(loaded_code.uuid, code.uuid)
# Load through pk explicitly
loaded_code = load_code(pk=code.pk)
self.assertEquals(loaded_code.uuid, code.uuid)
# Load through partial uuid without a dash
loaded_code = load_code(uuid=code.uuid[:8])
self.assertEquals(loaded_code.uuid, code.uuid)
# Load through partial uuid including a dash
loaded_code = load_code(uuid=code.uuid[:10])
self.assertEquals(loaded_code.uuid, code.uuid)
with self.assertRaises(NotExistent):
load_code('non-existent-uuid')
def setUpClass(cls):
super(TestQEPWInputGeneration, cls).setUpClass()
cls.calc_params = {
'computer': cls.computer,
'resources': {
'num_machines': 1,
'num_mpiprocs_per_machine': 1
}
}
cls.code = Code()
cls.code.set_remote_computer_exec((cls.computer, '/x.x'))
cls.code.store()
