def create_code(self):
"""
Create a code with the information contained in this class,
BUT DOES NOT STORE IT.
"""
import os.path
from aiida.orm import Code as AiidaOrmCode
if self.is_local:
file_list = [
os.path.realpath(os.path.join(self.folder_with_code, f))
for f in os.listdir(self.folder_with_code)
]
code = AiidaOrmCode(local_executable=self.local_rel_path,
files=file_list)
else:
code = AiidaOrmCode(remote_computer_exec=(self.computer,
self.remote_abs_path))
code.label = self.label
code.description = self.description
code.set_input_plugin_name(self.input_plugin)
code.set_prepend_text(self.prepend_text)
code.set_append_text(self.append_text)
return code
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 _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 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 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 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 _get_mock_code(label: str,
entry_point: str,
data_dir_abspath: ty.Union[str, pathlib.Path],
ignore_files: ty.Iterable[str] = ('_aiidasubmit.sh', )):
"""
Creates a mock AiiDA code. If the same inputs have been run previously,
the results are copied over from the corresponding sub-directory of
the ``data_dir_abspath``. Otherwise, the code is executed if an
executable is specified in the configuration, or fails if it is not.
Parameters
----------
label :
Label by which the code is identified in the configuration file.
entry_point :
The AiiDA calculation entry point for the default calculation
of the code.
data_dir_abspath :
Absolute path of the directory where the code results are
stored.
ignore_files :
A list of files which are not copied to the results directory
when the code is executed.
"""
from aiida.orm import Code
# we want to set a custom prepend_text, which is why the code
# can not be reused.
code_label = f'mock-{label}-{uuid.uuid4()}'
executable_path = shutil.which('aiida-mock-code')
code = Code(input_plugin_name=entry_point,
remote_computer_exec=[aiida_localhost, executable_path])
code.label = code_label
code.set_prepend_text(
inspect.cleandoc(f"""
export {EnvKeys.LABEL.value}={label}
export {EnvKeys.DATA_DIR.value}={data_dir_abspath}
export {EnvKeys.EXECUTABLE_PATH.value}={config.get(label, '')}
export {EnvKeys.IGNORE_FILES.value}={':'.join(ignore_files)}
"""))
code.store()
return code
def _setup_code(self, _=None):
"""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.remote_abs_path:
print("You did not specify absolute path to the executable.")
return
if not self.inp_computer.selected_computer:
print(
"Please specify a computer that is configured in your AiiDA profile."
)
return False
if not self.input_plugin:
print(
"Please specify an input plugin that is installed in your AiiDA environment."
)
return False
if self.exists():
print(
f"Code {self.label}@{self.inp_computer.selected_computer.label} already exists."
)
return
code = Code(remote_computer_exec=(
self.inp_computer.selected_computer,
self.remote_abs_path,
))
code.label = self.label
code.description = self.description
code.set_input_plugin_name(self.input_plugin)
code.set_prepend_text(self.prepend_text)
code.set_append_text(self.append_text)
code.store()
code.reveal()
full_string = f"{self.label}@{self.inp_computer.selected_computer.label}"
print(
check_output(["verdi", "code", "show",
full_string]).decode("utf-8"))
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
