From 429491d9fe21ce650020b448ee9ad2041a02608d Mon Sep 17 00:00:00 2001 From: Sebastiaan Huber Date: Fri, 10 Jul 2020 18:16:03 +0200 Subject: [PATCH] Deprecate getter and setter methods of `Computer` properties From `aiida-core==1.0.0`, we have started using properties for getters and setters of the basic attributes of ORM entities. Rule of thumb here is that if the attribute corresponds to a column on the underlying database model, a property is used. In addition, `label` is the preferred name for the third entity identifier, alongside the ID and UUID. This is already the case for most entities, except for `Computer` which is still using `name`. Here, `name` is deprecated and replaced for `label`. The changes are not yet propagated to the backend, which will be done once the deprecated resources are fully removed. This is fine because the backend is not part of the public API so doesn't have to go through a deprecation path. The `name` keyword in `Computer.objects.get` is also deprecated and replaced by `label`. --- .ci/test_plugin_testcase.py | 4 +- aiida/backends/testimplbase.py | 2 +- aiida/manage/tests/pytest_fixtures.py | 8 +- aiida/orm/computers.py | 473 +++++++++++++------- aiida/orm/utils/builders/computer.py | 8 +- docs/source/working_with_aiida/cookbook.rst | 4 +- tests/cmdline/commands/test_calcjob.py | 2 +- tests/cmdline/commands/test_code.py | 2 +- tests/cmdline/commands/test_computer.py | 54 +-- tests/cmdline/commands/test_data.py | 6 +- tests/cmdline/commands/test_export.py | 2 +- tests/orm/test_querybuilder.py | 4 +- 12 files changed, 366 insertions(+), 203 deletions(-) diff --git a/.ci/test_plugin_testcase.py b/.ci/test_plugin_testcase.py index 838f03f2f4..0a8df61324 100644 --- a/.ci/test_plugin_testcase.py +++ b/.ci/test_plugin_testcase.py @@ -55,7 +55,7 @@ def get_computer(cls, temp_dir): from aiida import orm computer = orm.Computer( - name='localhost', + label='localhost', hostname='localhost', description='my computer', transport_type='local', @@ -80,7 +80,7 @@ def test_computer_loaded(self): work after resetting the DB. """ from aiida import orm - self.assertEqual(orm.Computer.objects.get(name='localhost').uuid, self.computer.uuid) + self.assertEqual(orm.Computer.objects.get(label='localhost').uuid, self.computer.uuid) def test_tear_down(self): """ diff --git a/aiida/backends/testimplbase.py b/aiida/backends/testimplbase.py index 32f22e0333..079da62be2 100644 --- a/aiida/backends/testimplbase.py +++ b/aiida/backends/testimplbase.py @@ -69,7 +69,7 @@ def create_user(self): def create_computer(self): """This method creates and stores a computer.""" self.computer = orm.Computer( - name='localhost', + label='localhost', hostname='localhost', transport_type='local', scheduler_type='pbspro', diff --git a/aiida/manage/tests/pytest_fixtures.py b/aiida/manage/tests/pytest_fixtures.py index 310b07e944..00a151e66a 100644 --- a/aiida/manage/tests/pytest_fixtures.py +++ b/aiida/manage/tests/pytest_fixtures.py @@ -94,15 +94,15 @@ def test_1(aiida_localhost): from aiida.orm import Computer from aiida.common.exceptions import NotExistent - name = 'localhost-test' + label = 'localhost-test' try: - computer = Computer.objects.get(name=name) + computer = Computer.objects.get(label=label) except NotExistent: computer = Computer( - name=name, + label=label, description='localhost computer set up by test manager', - hostname=name, + hostname=label, workdir=temp_dir, transport_type='local', scheduler_type='direct' diff --git a/aiida/orm/computers.py b/aiida/orm/computers.py index 2832733fa0..4b01032979 100644 --- a/aiida/orm/computers.py +++ b/aiida/orm/computers.py @@ -8,7 +8,6 @@ # For further information please visit http://www.aiida.net # ########################################################################### """Module for Computer entities""" - import logging import os import warnings @@ -17,6 +16,7 @@ from aiida.common import exceptions from aiida.common.warnings import AiidaDeprecationWarning from aiida.manage.manager import get_manager +from aiida.orm.implementation import Backend from aiida.plugins import SchedulerFactory, TransportFactory from . import entities @@ -51,33 +51,72 @@ class Computer(entities.Entity): class Collection(entities.Collection): """The collection of Computer entries.""" + def get(self, **filters): + """Get a single collection entry that matches the filter criteria. + + :param filters: the filters identifying the object to get + :type filters: dict + + :return: the entry + """ + if 'name' in filters: + warnings.warn('keyword `name` is deprecated, use `label` instead', AiidaDeprecationWarning) # pylint: disable=no-member + + # This switch needs to be here until we fully remove `name` and replace it with `label` even on the backend + # entities and database models. + if 'label' in filters: + filters['name'] = filters.pop('label') + + return super().get(**filters) + def list_names(self): - """Return a list with all the names of the computers in the DB.""" + """Return a list with all the names of the computers in the DB. + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use `list_labels` instead. + """ + return self._backend.computers.list_names() + + def list_labels(self): + """Return a list with all the labels of the computers in the DB.""" return self._backend.computers.list_names() def delete(self, id): # pylint: disable=redefined-builtin,invalid-name """Delete the computer with the given id""" return self._backend.computers.delete(id) - def __init__( - self, name, hostname, description='', transport_type='', scheduler_type='', workdir=None, backend=None - ): + def __init__( # pylint: disable=too-many-arguments + self, + label: str = None, + hostname: str = None, + description: str = '', + transport_type: str = '', + scheduler_type: str = '', + workdir: str = None, + backend: Backend = None, + name: str = None + ) -> 'Computer': """Construct a new computer - :type name: str - :type hostname: str - :type description: str - :type transport_type: str - :type scheduler_type: str - :type workdir: str - :type backend: :class:`aiida.orm.implementation.Backend` - - :rtype: :class:`aiida.orm.Computer` + .. deprecated:: 1.4.0 + The `name` keyword will be removed in `v2.0.0`, use `label` instead. """ - # pylint: disable=too-many-arguments + + # This needs to be here because `label` needed to get a default, since it was replacing `name` and during the + # deprecation period, it needs to be automatically set to whatever `name` is passed. As a knock-on effect, since + # a keyword argument cannot preceed a normal argument, `hostname` also needed to become a keyword argument, + # forcing us to set a default, which we set to `None`. We raise the same exception that Python would normally + # raise if a normally positional argument is not specified. + if hostname is None: + raise TypeError("missing 1 required positional argument: 'hostname'") + + if name is not None: + warnings.warn('keyword `name` is deprecated, use `label` instead', AiidaDeprecationWarning) # pylint: disable=no-member + label = name + backend = backend or get_manager().get_backend() model = backend.computers.create( - name=name, + name=label, hostname=hostname, description=description, transport_type=transport_type, @@ -91,23 +130,27 @@ def __repr__(self): return '<{}: {}>'.format(self.__class__.__name__, str(self)) def __str__(self): - return '{} ({}), pk: {}'.format(self.name, self.hostname, self.pk) + return '{} ({}), pk: {}'.format(self.label, self.hostname, self.pk) @property def full_text_info(self): """ Return a (multiline) string with a human-readable detailed information on this computer. + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `label` property instead. + :rtype: str """ + warnings.warn('this property is deprecated', AiidaDeprecationWarning) # pylint: disable=no-member ret_lines = [] - ret_lines.append('Computer name: {}'.format(self.name)) + ret_lines.append('Computer name: {}'.format(self.label)) ret_lines.append(' * PK: {}'.format(self.pk)) ret_lines.append(' * UUID: {}'.format(self.uuid)) ret_lines.append(' * Description: {}'.format(self.description)) ret_lines.append(' * Hostname: {}'.format(self.hostname)) - ret_lines.append(' * Transport type: {}'.format(self.get_transport_type())) - ret_lines.append(' * Scheduler type: {}'.format(self.get_scheduler_type())) + ret_lines.append(' * Transport type: {}'.format(self.transport_type)) + ret_lines.append(' * Scheduler type: {}'.format(self.scheduler_type)) ret_lines.append(' * Work directory: {}'.format(self.get_workdir())) ret_lines.append(' * Shebang: {}'.format(self.get_shebang())) ret_lines.append(' * mpirun command: {}'.format(' '.join(self.get_mpirun_command()))) @@ -137,8 +180,6 @@ def full_text_info(self): def logger(self): return self._logger - # region validation - @classmethod def _name_validator(cls, name): """ @@ -248,10 +289,10 @@ def validate(self): if not self.get_name().strip(): raise exceptions.ValidationError('No name specified') - self._hostname_validator(self.get_hostname()) - self._description_validator(self.get_description()) - self._transport_type_validator(self.get_transport_type()) - self._scheduler_type_validator(self.get_scheduler_type()) + self._hostname_validator(self.hostname) + self._description_validator(self.description) + self._transport_type_validator(self.transport_type) + self._scheduler_type_validator(self.scheduler_type) self._workdir_validator(self.get_workdir()) try: @@ -272,14 +313,10 @@ def _default_mpiprocs_per_machine_validator(cls, def_cpus_per_machine): if not isinstance(def_cpus_per_machine, int) or def_cpus_per_machine <= 0: raise exceptions.ValidationError( - 'Invalid value for default_mpiprocs_per_machine, ' - 'must be a positive integer, or an empty ' - 'string if you do not want to provide a ' - 'default value.' + 'Invalid value for default_mpiprocs_per_machine, must be a positive integer, or an empty string if you ' + 'do not want to provide a default value.' ) - # endregion - def copy(self): """ Return a copy of the current object to work with, not stored yet. @@ -297,49 +334,100 @@ def store(self): return super().store() @property - def name(self): + def label(self) -> str: + """Return the computer label. + + :return: the label. + """ return self._backend_entity.name + @label.setter + def label(self, value: str): + """Set the computer label. + + :param value: the label to set. + """ + self._backend_entity.set_name(value) + @property - def label(self): + def description(self) -> str: + """Return the computer computer. + + :return: the description. """ - The computer label + return self._backend_entity.description + + @description.setter + def description(self, value: str): + """Set the computer description. + + :param value: the description to set. """ - return self.name + self._backend_entity.set_description(value) - @label.setter - def label(self, value): + @property + def hostname(self) -> str: + """Return the computer hostname. + + :return: the hostname. """ - Set the computer label (i.e., name) + return self._backend_entity.hostname + + @hostname.setter + def hostname(self, value: str): + """Set the computer hostname. + + :param value: the hostname to set. """ - self.set_name(value) + self._backend_entity.set_hostname(value) @property - def description(self): + def scheduler_type(self) -> str: + """Return the computer scheduler type. + + :return: the scheduler type. """ - Get a description of the computer + return self._backend_entity.get_scheduler_type() - :return: the description - :rtype: str + @scheduler_type.setter + def scheduler_type(self, value: str): + """Set the computer scheduler type. + + :param value: the scheduler type to set. """ - return self._backend_entity.description + self._backend_entity.set_scheduler_type(value) @property - def hostname(self): - return self._backend_entity.hostname + def transport_type(self) -> str: + """Return the computer transport type. - def get_metadata(self): - return self._backend_entity.get_metadata() + :return: the transport_type. + """ + return self._backend_entity.get_transport_type() - def set_metadata(self, metadata): + @transport_type.setter + def transport_type(self, value: str): + """Set the computer transport type. + + :param value: the transport_type to set. """ - Set the metadata. + self._backend_entity.set_transport_type(value) - .. note: You still need to call the .store() method to actually save - data to the database! (The store method can be called multiple - times, differently from AiiDA Node objects). + @property + def metadata(self) -> str: + """Return the computer metadata. + + :return: the metadata. + """ + return self._backend_entity.get_metadata() + + @metadata.setter + def metadata(self, value: str): + """Set the computer metadata. + + :param value: the metadata to set. """ - self._backend_entity.set_metadata(metadata) + self._backend_entity.set_metadata(value) def delete_property(self, name, raise_exception=True): """ @@ -462,31 +550,6 @@ def set_minimum_job_poll_interval(self, interval): """ self.set_property(self.PROPERTY_MINIMUM_SCHEDULER_POLL_INTERVAL, interval) - def get_transport(self, user=None): - """ - Return a Transport class, configured with all correct parameters. - The Transport is closed (meaning that if you want to run any operation with - it, you have to open it first (i.e., e.g. for a SSH transport, you have - to open a connection). To do this you can call ``transports.open()``, or simply - run within a ``with`` statement:: - - transport = Computer.get_transport() - with transport: - print(transports.whoami()) - - :param user: if None, try to obtain a transport for the default user. - Otherwise, pass a valid User. - - :return: a (closed) Transport, already configured with the connection - parameters to the supercomputer, as configured with ``verdi computer configure`` - for the user specified as a parameter ``user``. - """ - from . import authinfos # pylint: disable=cyclic-import - - user = user or users.User.objects(self.backend).get_default() - authinfo = authinfos.AuthInfo.objects(self.backend).get(dbcomputer=self, aiidauser=user) - return authinfo.get_transport() - def get_workdir(self): """ Get the working directory for this computer @@ -513,44 +576,6 @@ def set_shebang(self, val): metadata['shebang'] = val self.set_metadata(metadata) - def get_name(self): - return self._backend_entity.get_name() - - def set_name(self, val): - self._backend_entity.set_name(val) - - def get_hostname(self): - """ - Get this computer hostname - :rtype: str - """ - return self._backend_entity.get_hostname() - - def set_hostname(self, val): - """ - Set the hostname of this computer - :param val: The new hostname - :type val: str - """ - self._backend_entity.set_hostname(val) - - def get_description(self): - """ - Get the description for this computer - - :return: the description - :rtype: str - """ - - def set_description(self, val): - """ - Set the description for this computer - - :param val: the new description - :type val: str - """ - self._backend_entity.set_description(val) - def get_authinfo(self, user): """ Return the aiida.orm.authinfo.AuthInfo instance for the @@ -592,43 +617,33 @@ def is_user_enabled(self, user): authinfo = self.get_authinfo(user) return authinfo.enabled except exceptions.NotExistent: - # Return False if the user is not configured (in a sense, - # it is disabled for that user) + # Return False if the user is not configured (in a sense, it is disabled for that user) return False - def get_scheduler_type(self): - """ - Get the scheduler type for this computer - - :return: the scheduler type - :rtype: str - """ - return self._backend_entity.get_scheduler_type() - - def set_scheduler_type(self, scheduler_type): - """ - :param scheduler_type: the new scheduler type + def get_transport(self, user=None): """ - self._scheduler_type_validator(scheduler_type) - self._backend_entity.set_scheduler_type(scheduler_type) + Return a Transport class, configured with all correct parameters. + The Transport is closed (meaning that if you want to run any operation with + it, you have to open it first (i.e., e.g. for a SSH transport, you have + to open a connection). To do this you can call ``transports.open()``, or simply + run within a ``with`` statement:: - def get_transport_type(self): - """ - Get the current transport type for this computer + transport = Computer.get_transport() + with transport: + print(transports.whoami()) - :return: the transport type - :rtype: str - """ - return self._backend_entity.get_transport_type() + :param user: if None, try to obtain a transport for the default user. + Otherwise, pass a valid User. - def set_transport_type(self, transport_type): + :return: a (closed) Transport, already configured with the connection + parameters to the supercomputer, as configured with ``verdi computer configure`` + for the user specified as a parameter ``user``. """ - Set the transport type for this computer + from . import authinfos # pylint: disable=cyclic-import - :param transport_type: the new transport type - :type transport_type: str - """ - self._backend_entity.set_transport_type(transport_type) + user = user or users.User.objects(self.backend).get_default() + authinfo = authinfos.AuthInfo.objects(self.backend).get(dbcomputer=self, aiidauser=user) + return authinfo.get_transport() def get_transport_class(self): """ @@ -637,12 +652,10 @@ def get_transport_class(self): :return: the transport class """ try: - return TransportFactory(self.get_transport_type()) + return TransportFactory(self.transport_type) except exceptions.EntryPointError as exception: raise exceptions.ConfigurationError( - 'No transport found for {} [type {}], message: {}'.format( - self.name, self.get_transport_type(), exception - ) + 'No transport found for {} [type {}], message: {}'.format(self.label, self.transport_type, exception) ) def get_scheduler(self): @@ -653,14 +666,12 @@ def get_scheduler(self): :rtype: :class:`aiida.schedulers.Scheduler` """ try: - scheduler_class = SchedulerFactory(self.get_scheduler_type()) + scheduler_class = SchedulerFactory(self.scheduler_type) # I call the init without any parameter return scheduler_class() except exceptions.EntryPointError as exception: raise exceptions.ConfigurationError( - 'No scheduler found for {} [type {}], message: {}'.format( - self.name, self.get_scheduler_type(), exception - ) + 'No scheduler found for {} [type {}], message: {}'.format(self.label, self.scheduler_type, exception) ) def configure(self, user=None, **kwargs): @@ -720,6 +731,158 @@ def get_configuration(self, user=None): return config + @property + def name(self): + """Return the computer name. + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `label` property instead. + """ + warnings.warn('this property is deprecated, use the `label` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + return self.label + + def get_name(self): + """Return the computer name. + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `label` property instead. + """ + warnings.warn('this property is deprecated, use the `label` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + return self.label + + def set_name(self, val): + """Set the computer name. + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `label` property instead. + """ + warnings.warn('this method is deprecated, use the `label` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + self.label = val + + def get_hostname(self): + """Get this computer hostname + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `hostname` property instead. + + :rtype: str + """ + warnings.warn('this method is deprecated, use the `hostname` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + return self.hostname + + def set_hostname(self, val): + """ + Set the hostname of this computer + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `hostname` property instead. + + :param val: The new hostname + :type val: str + """ + warnings.warn('this method is deprecated, use the `hostname` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + self.hostname = val + + def get_description(self): + """ + Get the description for this computer + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `description` property instead. + + :return: the description + :rtype: str + """ + warnings.warn('this method is deprecated, use the `description` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + return self.description + + def set_description(self, val): + """ + Set the description for this computer + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `description` property instead. + + :param val: the new description + :type val: str + """ + warnings.warn('this method is deprecated, use the `description` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + self.description = val + + def get_scheduler_type(self): + """ + Get the scheduler type for this computer + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `scheduler_type` property instead. + + :return: the scheduler type + :rtype: str + """ + warnings.warn('this method is deprecated, use the `scheduler_type` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + return self.scheduler_type + + def set_scheduler_type(self, scheduler_type): + """ + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `scheduler_type` property instead. + + :param scheduler_type: the new scheduler type + """ + warnings.warn('this method is deprecated, use the `scheduler_type` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + self._scheduler_type_validator(scheduler_type) + self.scheduler_type = scheduler_type + + def get_transport_type(self): + """ + Get the current transport type for this computer + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `transport_type` property instead. + + :return: the transport type + :rtype: str + """ + warnings.warn('this method is deprecated, use the `transport_type` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + return self.transport_type + + def set_transport_type(self, transport_type): + """ + Set the transport type for this computer + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `transport_type` property instead. + + :param transport_type: the new transport type + :type transport_type: str + """ + warnings.warn('this method is deprecated, use the `transport_type` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + self.transport_type = transport_type + + def get_metadata(self): + """ + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `metadata` property instead. + + """ + warnings.warn('this method is deprecated, use the `metadata` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + return self.metadata + + def set_metadata(self, metadata): + """ + Set the metadata. + + .. deprecated:: 1.4.0 + Will be removed in `v2.0.0`, use the `metadata` property instead. + + .. note: You still need to call the .store() method to actually save + data to the database! (The store method can be called multiple + times, differently from AiiDA Node objects). + """ + warnings.warn('this method is deprecated, use the `metadata` property instead', AiidaDeprecationWarning) # pylint: disable=no-member + self.metadata = metadata + @staticmethod def get_schema(): """ diff --git a/aiida/orm/utils/builders/computer.py b/aiida/orm/utils/builders/computer.py index 0de26f6ff3..f6e10c9ff0 100644 --- a/aiida/orm/utils/builders/computer.py +++ b/aiida/orm/utils/builders/computer.py @@ -36,9 +36,9 @@ def get_computer_spec(computer): spec = {} spec['label'] = computer.label spec['description'] = computer.description - spec['hostname'] = computer.get_hostname() - spec['scheduler'] = computer.get_scheduler_type() - spec['transport'] = computer.get_transport_type() + spec['hostname'] = computer.hostname + spec['scheduler'] = computer.scheduler_type + spec['transport'] = computer.transport_type spec['prepend_text'] = computer.get_prepend_text() spec['append_text'] = computer.get_append_text() spec['work_dir'] = computer.get_workdir() @@ -70,7 +70,7 @@ def new(self): passed_keys = set(self._computer_spec.keys()) used = set() - computer = Computer(name=self._get_and_count('label', used), hostname=self._get_and_count('hostname', used)) + computer = Computer(label=self._get_and_count('label', used), hostname=self._get_and_count('hostname', used)) computer.set_description(self._get_and_count('description', used)) computer.set_scheduler_type(self._get_and_count('scheduler', used)) diff --git a/docs/source/working_with_aiida/cookbook.rst b/docs/source/working_with_aiida/cookbook.rst index 844cfe187b..1e8ca01b5d 100644 --- a/docs/source/working_with_aiida/cookbook.rst +++ b/docs/source/working_with_aiida/cookbook.rst @@ -28,7 +28,7 @@ you can use a modification of the following script:: """ from aiida import orm - computer = Computer.get(name='deneb') + computer = Computer.get(label='deneb') transport = computer.get_transport() scheduler = computer.get_scheduler() scheduler.set_transport(transport) @@ -114,7 +114,7 @@ Here is, as an example, an useful utility function:: manager = get_manager() profile = manager.get_profile() return AuthInfo.objects.get( - dbcomputer_id=Computer.get(name=computername).id, + dbcomputer_id=Computer.get(label=computername).id, aiidauser_id=User.get(email=profile.default_user).id ) diff --git a/tests/cmdline/commands/test_calcjob.py b/tests/cmdline/commands/test_calcjob.py index b8072735c2..3ee3a833f2 100644 --- a/tests/cmdline/commands/test_calcjob.py +++ b/tests/cmdline/commands/test_calcjob.py @@ -37,7 +37,7 @@ def setUpClass(cls, *args, **kwargs): from aiida.engine import ProcessState cls.computer = orm.Computer( - name='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida' + label='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida' ).store() cls.code = orm.Code(remote_computer_exec=(cls.computer, '/bin/true')).store() diff --git a/tests/cmdline/commands/test_code.py b/tests/cmdline/commands/test_code.py index c09899fd2b..f8ef8b3085 100644 --- a/tests/cmdline/commands/test_code.py +++ b/tests/cmdline/commands/test_code.py @@ -120,7 +120,7 @@ class TestVerdiCodeCommands(AiidaTestCase): def setUpClass(cls, *args, **kwargs): super().setUpClass(*args, **kwargs) cls.computer = orm.Computer( - name='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida' + label='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida' ).store() def setUp(self): diff --git a/tests/cmdline/commands/test_computer.py b/tests/cmdline/commands/test_computer.py index b9a5467e79..e0beb4fa4b 100644 --- a/tests/cmdline/commands/test_computer.py +++ b/tests/cmdline/commands/test_computer.py @@ -146,13 +146,13 @@ def test_mixed(self): result = self.cli_runner.invoke(computer_setup, options, input=user_input) self.assertIsNone(result.exception, msg='There was an unexpected exception. Output: {}'.format(result.output)) - new_computer = orm.Computer.objects.get(name=label) + new_computer = orm.Computer.objects.get(label=label) self.assertIsInstance(new_computer, orm.Computer) self.assertEqual(new_computer.description, options_dict_full['description']) self.assertEqual(new_computer.hostname, options_dict_full['hostname']) - self.assertEqual(new_computer.get_transport_type(), options_dict_full['transport']) - self.assertEqual(new_computer.get_scheduler_type(), options_dict_full['scheduler']) + self.assertEqual(new_computer.transport_type, options_dict_full['transport']) + self.assertEqual(new_computer.scheduler_type, options_dict_full['scheduler']) self.assertEqual(new_computer.get_mpirun_command(), options_dict_full['mpirun-command'].split()) self.assertEqual(new_computer.get_shebang(), options_dict_full['shebang']) self.assertEqual(new_computer.get_workdir(), options_dict_full['work-dir']) @@ -173,13 +173,13 @@ def test_noninteractive(self): result = self.cli_runner.invoke(computer_setup, options) self.assertIsNone(result.exception, result.output[-1000:]) - new_computer = orm.Computer.objects.get(name=options_dict['label']) + new_computer = orm.Computer.objects.get(label=options_dict['label']) self.assertIsInstance(new_computer, orm.Computer) self.assertEqual(new_computer.description, options_dict['description']) self.assertEqual(new_computer.hostname, options_dict['hostname']) - self.assertEqual(new_computer.get_transport_type(), options_dict['transport']) - self.assertEqual(new_computer.get_scheduler_type(), options_dict['scheduler']) + self.assertEqual(new_computer.transport_type, options_dict['transport']) + self.assertEqual(new_computer.scheduler_type, options_dict['scheduler']) self.assertEqual(new_computer.get_mpirun_command(), options_dict['mpirun-command'].split()) self.assertEqual(new_computer.get_shebang(), options_dict['shebang']) self.assertEqual(new_computer.get_workdir(), options_dict['work-dir']) @@ -203,7 +203,7 @@ def test_noninteractive_optional_default_mpiprocs(self): # pylint: disable=inva self.assertIsNone(result.exception, result.output[-1000:]) - new_computer = orm.Computer.objects.get(name=options_dict['label']) + new_computer = orm.Computer.objects.get(label=options_dict['label']) self.assertIsInstance(new_computer, orm.Computer) self.assertIsNone(new_computer.get_default_mpiprocs_per_machine()) @@ -218,7 +218,7 @@ def test_noninteractive_optional_default_mpiprocs_2(self): # pylint: disable=in self.assertIsNone(result.exception, result.output[-1000:]) - new_computer = orm.Computer.objects.get(name=options_dict['label']) + new_computer = orm.Computer.objects.get(label=options_dict['label']) self.assertIsInstance(new_computer, orm.Computer) self.assertIsNone(new_computer.get_default_mpiprocs_per_machine()) @@ -298,7 +298,7 @@ def test_noninteractive_from_config(self): result = self.cli_runner.invoke(computer_setup, options) self.assertClickResultNoException(result) - self.assertIsInstance(orm.Computer.objects.get(name=label), orm.Computer) + self.assertIsInstance(orm.Computer.objects.get(label=label), orm.Computer) class TestVerdiComputerConfigure(AiidaTestCase): @@ -529,7 +529,7 @@ def setUpClass(cls, *args, **kwargs): super().setUpClass(*args, **kwargs) cls.computer_name = 'comp_cli_test_computer' cls.comp = orm.Computer( - name=cls.computer_name, + label=cls.computer_name, hostname='localhost', transport_type='local', scheduler_type='direct', @@ -638,9 +638,9 @@ def test_computer_rename(self): # Check that the name really was changed # The old name should not be available with self.assertRaises(NotExistent): - orm.Computer.objects.get(name='comp_cli_test_computer') + orm.Computer.objects.get(label='comp_cli_test_computer') # The new name should be avilable - orm.Computer.objects.get(name='renamed_test_computer') + orm.Computer.objects.get(label='renamed_test_computer') # Now change the name back options = ['renamed_test_computer', 'comp_cli_test_computer'] @@ -651,9 +651,9 @@ def test_computer_rename(self): # Check that the name really was changed # The old name should not be available with self.assertRaises(NotExistent): - orm.Computer.objects.get(name='renamed_test_computer') + orm.Computer.objects.get(label='renamed_test_computer') # The new name should be avilable - orm.Computer.objects.get(name='comp_cli_test_computer') + orm.Computer.objects.get(label='comp_cli_test_computer') def test_computer_delete(self): """ @@ -663,7 +663,7 @@ def test_computer_delete(self): # Setup a computer to delete during the test orm.Computer( - name='computer_for_test_delete', + label='computer_for_test_delete', hostname='localhost', transport_type='local', scheduler_type='direct', @@ -683,7 +683,7 @@ def test_computer_delete(self): self.assertClickResultNoException(result) # Check that the computer really was deleted with self.assertRaises(NotExistent): - orm.Computer.objects.get(name='computer_for_test_delete') + orm.Computer.objects.get(label='computer_for_test_delete') def test_computer_duplicate_interactive(self): """Test 'verdi computer duplicate' in interactive mode.""" @@ -696,11 +696,11 @@ def test_computer_duplicate_interactive(self): ) self.assertIsNone(result.exception, result.output) - new_computer = orm.Computer.objects.get(name=label) + new_computer = orm.Computer.objects.get(label=label) self.assertEqual(self.comp.description, new_computer.description) - self.assertEqual(self.comp.get_hostname(), new_computer.get_hostname()) - self.assertEqual(self.comp.get_transport_type(), new_computer.get_transport_type()) - self.assertEqual(self.comp.get_scheduler_type(), new_computer.get_scheduler_type()) + self.assertEqual(self.comp.hostname, new_computer.hostname) + self.assertEqual(self.comp.transport_type, new_computer.transport_type) + self.assertEqual(self.comp.scheduler_type, new_computer.scheduler_type) self.assertEqual(self.comp.get_shebang(), new_computer.get_shebang()) self.assertEqual(self.comp.get_workdir(), new_computer.get_workdir()) self.assertEqual(self.comp.get_mpirun_command(), new_computer.get_mpirun_command()) @@ -717,11 +717,11 @@ def test_computer_duplicate_non_interactive(self): ) self.assertIsNone(result.exception, result.output) - new_computer = orm.Computer.objects.get(name=label) + new_computer = orm.Computer.objects.get(label=label) self.assertEqual(self.comp.description, new_computer.description) - self.assertEqual(self.comp.get_hostname(), new_computer.get_hostname()) - self.assertEqual(self.comp.get_transport_type(), new_computer.get_transport_type()) - self.assertEqual(self.comp.get_scheduler_type(), new_computer.get_scheduler_type()) + self.assertEqual(self.comp.hostname, new_computer.hostname) + self.assertEqual(self.comp.transport_type, new_computer.transport_type) + self.assertEqual(self.comp.scheduler_type, new_computer.scheduler_type) self.assertEqual(self.comp.get_shebang(), new_computer.get_shebang()) self.assertEqual(self.comp.get_workdir(), new_computer.get_workdir()) self.assertEqual(self.comp.get_mpirun_command(), new_computer.get_mpirun_command()) @@ -744,13 +744,13 @@ def test_interactive(clear_database_before_test, aiida_localhost, non_interactiv result = CliRunner().invoke(computer_setup, input=user_input) assert result.exception is None, 'There was an unexpected exception. Output: {}'.format(result.output) - new_computer = orm.Computer.objects.get(name=label) + new_computer = orm.Computer.objects.get(label=label) assert isinstance(new_computer, orm.Computer) assert new_computer.description == options_dict['description'] assert new_computer.hostname == options_dict['hostname'] - assert new_computer.get_transport_type() == options_dict['transport'] - assert new_computer.get_scheduler_type() == options_dict['scheduler'] + assert new_computer.transport_type == options_dict['transport'] + assert new_computer.scheduler_type == options_dict['scheduler'] assert new_computer.get_mpirun_command() == options_dict['mpirun-command'].split() assert new_computer.get_shebang() == options_dict['shebang'] assert new_computer.get_workdir() == options_dict['work-dir'] diff --git a/tests/cmdline/commands/test_data.py b/tests/cmdline/commands/test_data.py index cbca51ae7f..df56fb6a8d 100644 --- a/tests/cmdline/commands/test_data.py +++ b/tests/cmdline/commands/test_data.py @@ -532,7 +532,7 @@ def create_trajectory_data(): def setUpClass(cls): # pylint: disable=arguments-differ super().setUpClass() orm.Computer( - name='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida' + label='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida' ).store() cls.ids = cls.create_trajectory_data() @@ -613,7 +613,7 @@ def create_structure_data(): def setUpClass(cls): # pylint: disable=arguments-differ super().setUpClass() orm.Computer( - name='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida' + label='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida' ).store() cls.ids = cls.create_structure_data() @@ -795,7 +795,7 @@ def setUpClass(cls): # pylint: disable=arguments-differ """Setup class to test CifData.""" super().setUpClass() orm.Computer( - name='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida' + label='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida' ).store() cls.ids = cls.create_cif_data() diff --git a/tests/cmdline/commands/test_export.py b/tests/cmdline/commands/test_export.py index 2683f745df..c7ecde0e2e 100644 --- a/tests/cmdline/commands/test_export.py +++ b/tests/cmdline/commands/test_export.py @@ -49,7 +49,7 @@ def setUpClass(cls, *args, **kwargs): from aiida import orm cls.computer = orm.Computer( - name='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida' + label='comp', hostname='localhost', transport_type='local', scheduler_type='direct', workdir='/tmp/aiida' ).store() cls.code = orm.Code(remote_computer_exec=(cls.computer, '/bin/true')).store() diff --git a/tests/orm/test_querybuilder.py b/tests/orm/test_querybuilder.py index 0c5a8729b9..46d09e76ba 100644 --- a/tests/orm/test_querybuilder.py +++ b/tests/orm/test_querybuilder.py @@ -1423,11 +1423,11 @@ def test_statistics_default_class(self): # pylint: disable=no-member expected_dict = { 'description': self.computer.description, - 'scheduler_type': self.computer.get_scheduler_type(), + 'scheduler_type': self.computer.scheduler_type, 'hostname': self.computer.hostname, 'uuid': self.computer.uuid, 'name': self.computer.name, - 'transport_type': self.computer.get_transport_type(), + 'transport_type': self.computer.transport_type, 'id': self.computer.id, 'metadata': self.computer.get_metadata(), }