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 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 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 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 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 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): """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 _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 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 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 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 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 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 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 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 get_code(self): """Setup code on localhost computer""" from aiida.orm import Code script_dir = os.path.dirname(__file__) executable = os.path.realpath(os.path.join(script_dir, '../code.py')) code = Code( files=[executable], input_plugin_name='template.multiply', local_executable='code.py') code.label = 'plugin-template' code.description = 'multiply on this computer' return code
def setUp(self): from aiida.orm import Computer, Code self.comp = Computer.get('comp') try: code = Code.get_from_string('code') except NotExistent: code = Code( input_plugin_name='simpleplugins.arithmetic.add', remote_computer_exec=[self.comp, '/remote/abs/path'], ) code.label = 'code' code.store() self.code = code self.runner = CliRunner()
def test_test_and_get_codenode_inpgen(): from aiida_fleur.tools.common_fleur_wf import test_and_get_codenode from aiida.orm import Code from aiida.common.exceptions import NotExistent # install code setup code code = Code(input_plugin_name='fleur.inpgen') code.label = 'inpgen' #code = Code.get_from_string('inpgen@localhost') expected = 'fleur.inpgen' nonexpected = 'fleur.fleur' assert isinstance(test_and_get_codenode(code, expected), Code) with pytest.raises(ValueError) as msg: test_and_get_codenode(code, nonexpected, use_exceptions=True) assert 'Code not valid' in str(msg)
def get_or_create_code(entry_point, computer, executable, exec_path=None): """Setup code on localhost computer""" if isinstance(computer, str): computer = Computer.objects.get(label=computer) try: code = Code.objects.get( # pylint: disable=no-member label=f'{entry_point}-{executable}-{computer.label}') except NotExistent: if exec_path is None: exec_path = get_path_to_executable(executable) code = Code(input_plugin_name=entry_point, remote_computer_exec=[computer, exec_path]) code.label = f'{entry_point}-{executable}-{computer.label}' code.store() return code
def get_code(entry_point, computer_name='localhost-test'): """Set up code on provided computer""" executable = EXECUTABLES[entry_point] try: codes = Code.objects.find(filters={'label': executable}) # pylint: disable=no-member code = codes[0] except IndexError: path = get_path_to_executable(executable) code = Code( input_plugin_name=entry_point, remote_computer_exec=[get_computer(computer_name), path], ) code.label = executable code.store() return 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 get_code(entry_point, computer_name='localhost'): """Setup code on localhost computer""" from aiida.orm import Code from aiida.common.exceptions import NotExistent computer = get_computer(computer_name) executable = executables[entry_point] 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 get_or_create_code(entry_point, computer, executable, exec_path=None): """Setup code on localhost computer""" from aiida.common import NotExistent from aiida.orm import Code, Computer if isinstance(computer, str): computer = Computer.objects.get(label=computer) try: code = Code.objects.get( label="{}-{}-{}".format(entry_point, executable, computer.label)) except NotExistent: if exec_path is None: exec_path = get_path_to_executable(executable) code = Code(input_plugin_name=entry_point, remote_computer_exec=[computer, exec_path]) code.label = "{}-{}-{}".format(entry_point, executable, computer.label) code.store() return code
def get_code(entry_point, computer_name='localhost-test'): """Set up code on provided computer""" from aiida.orm import Code from aiida.common import NotExistent computer = get_computer(computer_name) executable = executables[entry_point] try: code = Code.objects.get( # pylint: disable=no-member label='{}@{}'.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 _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
def get_code(entry_point, computer): """Get local code. Sets up code for given entry point on a given computer. :param entry_point: Entry point of calculation plugin :param computer: computer :return: The code node :rtype: :py:class:`aiida.orm.Code` """ from aiida.orm import Code from aiida.common.exceptions import NotExistent if os.environ.get(MOCK_GLOBAL_VAR, False): print("NB: using mock executable") exec_lookup = mock_executables else: exec_lookup = executables try: executable = exec_lookup[entry_point] except KeyError: raise KeyError("Entry point {} not recognized. Allowed values: {}" .format(entry_point, exec_lookup.keys())) try: code = Code.get_from_string('{}-{}@{}'.format(entry_point, executable, computer.get_name())) except NotExistent: path = get_path_to_executable(executable) code = Code( input_plugin_name=entry_point, remote_computer_exec=[computer, path], ) code.label = '{}-{}'.format(entry_point, executable) code.store() return code