def test_session_update_and_expiration_2(self): """ expire_on_commit=True & committing computer and code objects with their built-in store function. """ from aiida.backends.sqlalchemy.models.user import DbUser from aiida.orm.computer import Computer from aiida.orm.code import Code from aiida.orm.user import User session = aiida.backends.sqlalchemy.get_scoped_session() self.set_connection(expire_on_commit=True) user = User(email=get_configured_user_email()) session.add(user._dbuser) session.commit() defaults = dict(name='localhost', hostname='localhost', transport_type='local', scheduler_type='pbspro', workdir='/tmp/aiida') computer = Computer(**defaults) computer.store() code = Code() code.set_remote_computer_exec((computer, '/x.x')) code.store() self.drop_connection()
def test_computer_delete(self): """ Test if 'verdi computer delete' command works """ from aiida.orm.computer import Computer as AiidaOrmComputer from aiida.common.exceptions import NotExistent # Setup a computer to delete during the test comp = AiidaOrmComputer(name='computer_for_test_delete', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida') comp.store() # See if the command complains about not getting an invalid computer options = ['non_existent_computer_name'] result = self.runner.invoke(computer_delete, options) # Exception should be raised self.assertIsNotNone(result.exception) # Delete a computer name successully. options = ['computer_for_test_delete'] result = self.runner.invoke(computer_delete, options) # Exception should be not be raised self.assertIsNone(result.exception) # Check that the computer really was deleted with self.assertRaises(NotExistent): AiidaOrmComputer.get('computer_for_test_delete')
def computer_setup(self, *args): """ Setup a new or existing computer """ import readline if len(args) != 0: print >> sys.stderr, ("after 'computer setup' there cannot be any " "argument.") sys.exit(1) if not is_dbenv_loaded(): load_dbenv() from aiida.common.exceptions import NotExistent, ValidationError from aiida.orm.computer import Computer as AiidaOrmComputer print "At any prompt, type ? to get some help." print "---------------------------------------" # get the new computer name readline.set_startup_hook(lambda: readline.insert_text(previous_value)) input_txt = raw_input("=> Computer name: ") if input_txt.strip() == '?': print "HELP:", "The computer name" computer_name = input_txt.strip() try: computer = self.get_computer(name=computer_name) print "A computer called {} already exists.".format(computer_name) print "Use 'verdi computer update' to update it, and be careful if" print "you really want to modify a database entry!" print "Now exiting..." sys.exit(1) except NotExistent: computer = AiidaOrmComputer(name=computer_name) print "Creating new computer with name '{}'".format(computer_name) prompt_for_computer_configuration(computer) try: computer.store() except ValidationError as e: print "Unable to store the computer: {}. Exiting...".format( e.message) sys.exit(1) print "Computer '{}' successfully stored in DB.".format(computer_name) print "pk: {}, uuid: {}".format(computer.pk, computer.uuid) print "Note: before using it with AiiDA, configure it using the command" print " verdi computer configure {}".format(computer_name) print "(Note: machine_dependent transport parameters cannot be set via " print "the command-line interface at the moment)"
def setUpClass(cls): """ Basides the standard setup we need to add few more objects in the database to be able to explore different requests/filters/orderings etc. """ # call parent setUpClass method super(RESTApiTestCase, cls).setUpClass() # connect the app and the api # Init the api by connecting it the the app (N.B. respect the following # order, api.__init__) kwargs = dict(PREFIX=cls._url_prefix, PERPAGE_DEFAULT=cls._PERPAGE_DEFAULT, LIMIT_DEFAULT=cls._LIMIT_DEFAULT) cls.app = App(__name__) cls.app.config['TESTING'] = True api = AiidaApi(cls.app, **kwargs) # create test inputs cell = ((2., 0., 0.), (0., 2., 0.), (0., 0., 2.)) structure = StructureData(cell=cell) structure.append_atom(position=(0., 0., 0.), symbols=['Ba']) structure.store() cif = CifData(ase=structure.get_ase()) cif.store() parameter1 = ParameterData(dict={"a": 1, "b": 2}) parameter1.store() parameter2 = ParameterData(dict={"c": 3, "d": 4}) parameter2.store() kpoint = KpointsData() kpoint.set_kpoints_mesh([4, 4, 4]) kpoint.store() calc = Calculation() calc._set_attr("attr1", "OK") calc._set_attr("attr2", "OK") calc.store() calc.add_link_from(structure) calc.add_link_from(parameter1) kpoint.add_link_from(calc, link_type=LinkType.CREATE) calc1 = Calculation() calc1.store() from aiida.orm.computer import Computer dummy_computers = [{ "name": "test1", "hostname": "test1.epfl.ch", "transport_type": "ssh", "scheduler_type": "pbspro", }, { "name": "test2", "hostname": "test2.epfl.ch", "transport_type": "ssh", "scheduler_type": "torque", }, { "name": "test3", "hostname": "test3.epfl.ch", "transport_type": "local", "scheduler_type": "slurm", }, { "name": "test4", "hostname": "test4.epfl.ch", "transport_type": "ssh", "scheduler_type": "slurm", }] for dummy_computer in dummy_computers: computer = Computer(**dummy_computer) computer.store() # Prepare typical REST responses cls.process_dummy_data()
class DjangoTests(AiidaTestImplementation): """ Automatically takes care of the setUpClass and TearDownClass, when needed. """ # Note this is has to be a normal method, not a class method def setUpClass_method(self): self.clean_db() self.insert_data() def setUp_method(self): pass def tearDown_method(self): pass def insert_data(self): """ Insert default data into the DB. """ from django.core.exceptions import ObjectDoesNotExist from aiida.backends.djsite.db.models import DbUser from aiida.orm.computer import Computer from aiida.common.utils import get_configured_user_email # We create the user only once: # Otherwise, get_automatic_user() will fail when the # user is recreated because it caches the user! # In any case, store it in self.user though try: self.user = DbUser.objects.get(email=get_configured_user_email()) except ObjectDoesNotExist: self.user = DbUser.objects.create_user(get_configured_user_email(), 'fakepwd') # Reqired by the calling class self.user_email = self.user.email # Also self.computer is required by the calling class self.computer = Computer(name='localhost', hostname='localhost', transport_type='local', scheduler_type='pbspro', workdir='/tmp/aiida') self.computer.store() def clean_db(self): from aiida.backends.djsite.db.models import DbComputer # I first delete the workflows from aiida.backends.djsite.db.models import DbWorkflow, DbWorkflowStep, DbWorkflowData # Complicated way to make sure we 'unwind' all the relationships # between workflows and their children. DbWorkflowStep.calculations.through.objects.all().delete() DbWorkflowStep.sub_workflows.through.objects.all().delete() DbWorkflowData.objects.all().delete() DbWorkflowStep.objects.all().delete() DbWorkflow.objects.all().delete() # Delete groups from aiida.backends.djsite.db.models import DbGroup DbGroup.objects.all().delete() # I first need to delete the links, because in principle I could # not delete input nodes, only outputs. For simplicity, since # I am deleting everything, I delete the links first from aiida.backends.djsite.db.models import DbLink DbLink.objects.all().delete() # Then I delete the nodes, otherwise I cannot # delete computers and users from aiida.backends.djsite.db.models import DbNode DbNode.objects.all().delete() ## I do not delete it, see discussion in setUpClass # try: # DbUser.objects.get(email=get_configured_user_email()).delete() # except ObjectDoesNotExist: # pass DbComputer.objects.all().delete() from aiida.backends.djsite.db.models import DbLog DbLog.objects.all().delete() # Note this is has to be a normal method, not a class method def tearDownClass_method(self): from aiida.settings import REPOSITORY_PATH from aiida.common.setup import TEST_KEYWORD from aiida.common.exceptions import InvalidOperation base_repo_path = os.path.basename(os.path.normpath(REPOSITORY_PATH)) if TEST_KEYWORD not in base_repo_path: raise InvalidOperation("Be careful. The repository for the tests " "is not a test repository. I will not " "empty the database and I will not delete " "the repository. Repository path: " "{}".format(REPOSITORY_PATH)) self.clean_db() # I clean the test repository shutil.rmtree(REPOSITORY_PATH, ignore_errors=True) os.makedirs(REPOSITORY_PATH)
def setUpClass(cls): """ Basides the standard setup we need to add few more objects in the database to be able to explore different requests/filters/orderings etc. """ # call parent setUpClass method super(RESTApiTestCase, cls).setUpClass() # create test inputs cell = ((2., 0., 0.), (0., 2., 0.), (0., 0., 2.)) structure = StructureData(cell=cell) structure.append_atom(position=(0., 0., 0.), symbols=['Ba']) structure.store() parameter1 = ParameterData(dict={"a": 1, "b": 2}) parameter1.store() parameter2 = ParameterData(dict={"c": 3, "d": 4}) parameter2.store() kpoint = KpointsData() kpoint.set_kpoints_mesh([4, 4, 4]) kpoint.store() calc = Calculation() calc._set_attr("attr1", "OK") calc._set_attr("attr2", "OK") calc.store() calc.add_link_from(structure) calc.add_link_from(parameter1) kpoint.add_link_from(calc, link_type=LinkType.CREATE) calc1 = Calculation() calc1.store() from aiida.orm.computer import Computer dummy_computers = [{ "name": "test1", "hostname": "test1.epfl.ch", "transport_type": "ssh", "scheduler_type": "pbspro", }, { "name": "test2", "hostname": "test2.epfl.ch", "transport_type": "ssh", "scheduler_type": "torque", }, { "name": "test3", "hostname": "test3.epfl.ch", "transport_type": "local", "scheduler_type": "slurm", }, { "name": "test4", "hostname": "test4.epfl.ch", "transport_type": "ssh", "scheduler_type": "slurm", }] for dummy_computer in dummy_computers: computer = Computer(**dummy_computer) computer.store() # Prepare typical REST responses cls.process_dummy_data()
class TestWf(PluginTestCase): def setUp(self): """ """ from aiida import work from aiida.orm.code import Code from aiida.orm.nodes.parameter import Dict from aiida.orm.nodes.structure import StructureData from aiida.orm.nodes.remote import RemoteData from ase.spacegroup import crystal from aiida_quantumespresso.calculations.pw import PwCalculation from aiida_yambo.calculations.gw import YamboCalculation from aiida.common.links import LinkType from aiida.orm.computer import Computer as AiidaOrmComputer from aiida.common.datastructures import calc_states from aiida.plugins.utils import DataFactory runner = work.Runner(poll_interval=0., rmq_config=None, enable_persistence=None) work.set_runner(runner) self.computer = AiidaOrmComputer(name="testcase") # conf_attrs hostname, description, enabled_state, transport_type, scheduler_type, workdir # mpirun_command , default_mpiprocs_per_machine, self.computer._set_hostname_string("localhost") self.computer._set_enabled_state_string('True') self.computer._set_transport_type_string("local") self.computer._set_scheduler_type_string("direct") self.computer._set_workdir_string("/tmp/testcase/{username}/base") self.computer.store() create_authinfo(computer=self.computer).store() self.code_yambo = Code() self.code_yambo.label = "yambo" os_env = os.environ.copy() yambo_path = subprocess.check_output(['which', 'mock_yambo'], env=os_env).strip() self.code_yambo.set_remote_computer_exec((self.computer, yambo_path)) self.code_yambo.set_input_plugin_name('yambo.yambo') self.code_p2y = Code() self.code_p2y.label = "p2y" p2y_path = subprocess.check_output(['which', 'mock_p2y'], env=os_env).strip() self.code_p2y.set_remote_computer_exec((self.computer, p2y_path)) self.code_p2y.set_input_plugin_name('yambo.yambo') self.code_yambo.store() self.code_p2y.store() self.calc_pw = PwCalculation() self.calc_pw.set_computer(self.computer) self.calc_pw.set_resources({ "num_machines": 1, "num_mpiprocs_per_machine": 16, 'default_mpiprocs_per_machine': 16 }) StructureData = DataFactory('structure') cell = [[15.8753100000, 0.0000000000, 0.0000000000], [0.0000000000, 15.8753100000, 0.0000000000], [0.0000000000, 0.0000000000, 2.4696584760]] s = StructureData(cell=cell) self.calc_pw.use_structure(s) print((self.calc_pw.store_all(), " pw calc")) pw_remote_folder = RemoteData(computer=self.computer, remote_path="/tmp/testcase/work/calcPW") print((pw_remote_folder.store(), "pw remote data")) self.calc_pw._set_state(calc_states.PARSING) pw_remote_folder.add_link_from(self.calc_pw, label='remote_folder', link_type=LinkType.CREATE) outputs = Dict( dict={ "lsda": False, "number_of_bands": 80, "number_of_electrons": 8.0, "number_of_k_points": 147, "non_colinear_calculation": False }) outputs.store() outputs.add_link_from(self.calc_pw, label='output_parameters', link_type=LinkType.CREATE) self.calc = YamboCalculation() self.calc.set_computer(self.computer) self.calc.use_code(self.code_p2y) p2y_settings = { u'ADDITIONAL_RETRIEVE_LIST': [u'r-*', u'o-*', u'l-*', u'l_*', u'LOG/l-*_CPU_1'], u'INITIALISE': True } yambo_settings = { u'ADDITIONAL_RETRIEVE_LIST': [u'r-*', u'o-*', u'l-*', u'l_*', u'LOG/l-*_CPU_1'] } self.calc.use_settings(Dict(dict=p2y_settings)) self.calc.set_resources({ "num_machines": 1, "num_mpiprocs_per_machine": 16, 'default_mpiprocs_per_machine': 16 }) self.calc.use_parent_calculation(self.calc_pw) print((self.calc.store_all(), " yambo calc")) self.calc._set_state(calc_states.PARSING) a = 5.388 cell = crystal('Si', [(0, 0, 0)], spacegroup=227, cellpar=[a, a, a, 90, 90, 90], primitive_cell=True) self.struc = StructureData(ase=cell) self.struc.store() self.parameters = Dict( dict={ "BndsRnXp": [1.0, 48.0], "Chimod": "Hartree", "DysSolver": "n", "FFTGvecs": 25, "FFTGvecs_units": "Ry", "GbndRnge": [1.0, 48.0], "HF_and_locXC": True, "LongDrXp": [1.0, 0.0, 0.0], "NGsBlkXp": 2, "NGsBlkXp_units": "Ry", "QPkrange": [[1, 145, 3, 5]], "SE_CPU": "1 2 4", "SE_ROLEs": "q qp b", "X_all_q_CPU": "1 1 4 2", "X_all_q_ROLEs": "q k c v", "em1d": True, "gw0": True, "ppa": True, "rim_cut": True }) self.yambo_settings = Dict( dict={ "ADDITIONAL_RETRIEVE_LIST": [ "r-*", "o-*", "l-*", "l_*", "LOG/l-*_CPU_1", "aiida/ndb.QP", "aiida/ndb.HF_and_locXC" ] }) self.p2y_settings = Dict( dict={ "ADDITIONAL_RETRIEVE_LIST": [ 'r-*', 'o-*', 'l-*', 'l_*', 'LOG/l-*_CPU_1', 'aiida/ndb.QP', 'aiida/ndb.HF_and_locXC' ], 'INITIALISE': True }) self.yambo_calc_set = Dict( dict={ 'resources': { "num_machines": 1, "num_mpiprocs_per_machine": 16 }, 'max_wallclock_seconds': 60 * 29, 'max_memory_kb': 1 * 88 * 1000000, "queue_name": "s3parvc3", #'custom_scheduler_commands': u"#PBS -A Pra14_3622" , 'environment_variables': { "OMP_NUM_THREADS": "1" } }) self.p2y_calc_set = Dict( dict={ 'resources': { "num_machines": 1, "num_mpiprocs_per_machine": 2 }, 'max_wallclock_seconds': 60 * 2, 'max_memory_kb': 1 * 10 * 1000000, "queue_name": "s3parvc3", # 'custom_scheduler_commands': u"#PBS -A Pra14_3622" , 'environment_variables': { "OMP_NUM_THREADS": "2" } }) self.remote_folder = RemoteData(computer=self.computer, remote_path="/tmp/testcase/work/calcX") self.remote_folder.store() self.remote_folder.add_link_from(self.calc, label='remote_folder', link_type=LinkType.CREATE) self.calc._set_state(calc_states.FINISHED) #self.calc.store_all() def tearDown(self): """ """ pass def test_simple_log(self): from aiida.engine.launch import run from aiida.orm.nodes import Float, Str, NumericType, List, Bool from aiida_yambo.workflows.yamborestart import YamboRestartWf p2y_result = run(YamboRestartWf, precode=Str('p2y'), yambocode=Str('yambo'), parameters=self.parameters, calculation_set=self.yambo_calc_set, parent_folder=self.remote_folder, settings=self.yambo_settings) assert 'retrieved' in p2y_result