def get(self, computer, user): """Return an entry from the collection that is configured for the given computer and user :param computer: a :class:`aiida.orm.implementation.computers.BackendComputer` instance :param user: a :class:`aiida.orm.implementation.users.BackendUser` instance :return: :class:`aiida.orm.implementation.authinfos.BackendAuthInfo` :raise aiida.common.exceptions.NotExistent: if no entry exists for the computer/user pair :raise aiida.common.exceptions.MultipleObjectsError: if multiple entries exist for the computer/user pair """ # pylint: disable=import-error,no-name-in-module from django.core.exceptions import ObjectDoesNotExist, MultipleObjectsReturned try: authinfo = DbAuthInfo.objects.get(dbcomputer=computer.id, aiidauser=user.id) except ObjectDoesNotExist: raise exceptions.NotExistent( f'User<{user.email}> has no configuration for Computer<{computer.name}>' ) except MultipleObjectsReturned: raise exceptions.MultipleObjectsError( f'User<{user.email}> has multiple configurations for Computer<{computer.name}>' ) else: return self.from_dbmodel(authinfo)
def get(cls, **kwargs): """ Custom get for group which can be used to get a group with the given attributes :param kwargs: the attributes to match the group to :return: the group :type nodes: :class:`aiida.orm.Node` or list """ from aiida.orm import QueryBuilder filters = {} if 'type_string' in kwargs: if not isinstance(kwargs['type_string'], six.string_types): raise exceptions.ValidationError( 'type_string must be {}, you provided an object of type ' '{}'.format(str, type(kwargs['type_string']))) query = QueryBuilder() for key, val in kwargs.items(): filters[key] = val query.append(cls, filters=filters) results = query.all() if len(results) > 1: raise exceptions.MultipleObjectsError( "Found {} groups matching criteria '{}'".format( len(results), kwargs)) if not results: raise exceptions.NotExistent( "No group found matching criteria '{}'".format(kwargs)) return results[0][0]
def get(cls, pk=None, label=None, machinename=None): """ Get a Computer object with given identifier string, that can either be the numeric ID (pk), or the label (and computername) (if unique). :param pk: the numeric ID (pk) for code :param label: the code label identifying the code to load :param machinename: the machine name where code is setup :raise aiida.common.NotExistent: if no code identified by the given string is found :raise aiida.common.MultipleObjectsError: if the string cannot identify uniquely a code :raise aiida.common.InputValidationError: if neither a pk nor a label was passed in """ # pylint: disable=arguments-differ from aiida.orm.utils import load_code # first check if code pk is provided if pk: code_int = int(pk) try: return load_code(pk=code_int) except exceptions.NotExistent: raise ValueError('{} is not valid code pk'.format(pk)) except exceptions.MultipleObjectsError: raise exceptions.MultipleObjectsError( "More than one code in the DB with pk='{}'!".format(pk)) # check if label (and machinename) is provided elif label is not None: return cls.get_code_helper(label, machinename) else: raise exceptions.InputValidationError( 'Pass either pk or code label (and machinename)')
def get(self, computer, user): """Return an entry from the collection that is configured for the given computer and user :param computer: a :class:`aiida.orm.implementation.computers.BackendComputer` instance :param user: a :class:`aiida.orm.implementation.users.BackendUser` instance :return: :class:`aiida.orm.implementation.authinfos.BackendAuthInfo` :raise aiida.common.exceptions.NotExistent: if no entry exists for the computer/user pair :raise aiida.common.exceptions.MultipleObjectsError: if multiple entries exist for the computer/user pair """ # pylint: disable=import-error,no-name-in-module from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound session = get_scoped_session() try: authinfo = session.query(DbAuthInfo).filter_by( dbcomputer_id=computer.id, aiidauser_id=user.id).one() except NoResultFound: raise exceptions.NotExistent( f'User<{user.email}> has no configuration for Computer<{computer.name}>' ) except MultipleResultsFound: raise exceptions.MultipleObjectsError( f'User<{user.email}> has multiple configurations for Computer<{computer.name}>' ) else: return self.from_dbmodel(authinfo)
def get_or_create(self, label=None, **kwargs): """ Try to retrieve a group from the DB with the given arguments; create (and store) a new group if such a group was not present yet. :param label: group label :type label: str :return: (group, created) where group is the group (new or existing, in any case already stored) and created is a boolean saying :rtype: (:class:`aiida.orm.Group`, bool) """ if not label: raise ValueError('Group label must be provided') res = self.find(filters={'label': label}) if not res: return self.entity_type(label, backend=self.backend, **kwargs).store(), True if len(res) > 1: raise exceptions.MultipleObjectsError( 'More than one groups found in the database') return res[0], False
def get(self, **filters): """ Get the group matching the given filters :param filters: the attributes of the group to get :return: the group :rtype: :class:`aiida.orm.implementation.BackendGroup` """ results = self.query(**filters) if len(results) > 1: raise exceptions.MultipleObjectsError("Found multiple groups matching criteria '{}'".format(filters)) if not results: raise exceptions.NotExistent("No group bound matching criteria '{}'".format(filters)) return results[0]
def get(self, email): """ Get a user using the email address :param email: The user's email address :return: The corresponding user object :raises: :class:`aiida.common.exceptions.MultipleObjectsError`, :class:`aiida.common.exceptions.NotExistent` """ results = self.find(email=email) if not results: raise exceptions.NotExistent() else: if len(results) > 1: raise exceptions.MultipleObjectsError() else: return results[0]
def get_or_create(cls, *args, **kwargs): """ Try to retrieve a group from the DB with the given arguments; create (and store) a new group if such a group was not present yet. :return: (group, created) where group is the group (new or existing, in any case already stored) and created is a boolean saying """ res = cls.query(name=kwargs.get('name'), type_string=kwargs.get('type_string')) if not res: return cls.create(*args, **kwargs), True if len(res) > 1: raise exceptions.MultipleObjectsError('More than one groups found in the database') return res[0], False
def get_node_by_label(self, label): """Return the node from list for given label. :return: node that corresponds to the given label :raises aiida.common.NotExistent: if the label is not present among the link_triples """ matching_entry = None for entry in self.link_triples: if entry.link_label == label: if matching_entry is None: matching_entry = entry.node else: raise exceptions.MultipleObjectsError( f'more than one neighbor with the label {label} found' ) if matching_entry is None: raise exceptions.NotExistent(f'no neighbor with the label {label} found') return matching_entry
def get_or_create(self, label=None, **kwargs): """ Try to retrieve a group from the DB with the given arguments; create (and store) a new group if such a group was not present yet. :param label: group label :type label: str :return: (group, created) where group is the group (new or existing, in any case already stored) and created is a boolean saying :rtype: (:class:`aiida.orm.Group`, bool) """ if not label: raise ValueError('Group label must be provided') filters = {'label': label} if 'type_string' in kwargs: if not isinstance(kwargs['type_string'], six.string_types): raise exceptions.ValidationError( 'type_string must be {}, you provided an object of type ' '{}'.format(str, type(kwargs['type_string']))) filters['type_string'] = kwargs['type_string'] res = self.find(filters=filters) if not res: return Group(label, backend=self.backend, **kwargs).store(), True if len(res) > 1: raise exceptions.MultipleObjectsError( 'More than one groups found in the database') return res[0], False