def __init__(self, backend, computer, user): """ Construct an SqlaAuthInfo :param computer: a Computer instance :param user: a User instance :return: an AuthInfo object associated with the given computer and user """ super(SqlaAuthInfo, self).__init__(backend) type_check(user, users.SqlaUser) self._dbauthinfo = utils.ModelWrapper(DbAuthInfo(dbcomputer=computer.dbcomputer, aiidauser=user.dbuser))
def __init__(self, **kwargs): super(Node, self).__init__() self._temp_folder = None dbnode = kwargs.pop('dbnode', None) # Set the internal parameters # Can be redefined in the subclasses self._init_internal_params() if dbnode is not None: type_check(dbnode, DbNode) if dbnode.id is None: raise ValueError("If cannot load an aiida.orm.Node instance " "from an unsaved DbNode object.") if kwargs: raise ValueError("If you pass a dbnode, you cannot pass any " "further parameter") # If I am loading, I cannot modify it self._to_be_stored = False self._dbnode = dbnode # If this is changed, fix also the importer self._repo_folder = RepositoryFolder(section=self._section_name, uuid=self.uuid) else: user = self._backend.users.get_automatic_user() if user is None: raise RuntimeError("Could not find a default user") self._dbnode = DbNode(user=user.dbuser, uuid=get_new_uuid(), type=self._plugin_type_string) self._to_be_stored = True # As creating the temp folder may require some time on slow # filesystems, we defer its creation self._temp_folder = None # Used only before the first save self._attrs_cache = {} # If this is changed, fix also the importer self._repo_folder = RepositoryFolder(section=self._section_name, uuid=self.uuid) # Automatically set all *other* attributes, if possible, otherwise # stop self._set_with_defaults(**kwargs)
def from_dbmodel(cls, dbmodel, backend): """ Create a DjangoUser from a dbmodel instance :param backend: The backend :type backend: :class:`DjangoUserCollection` :param dbmodel: The dbmodel instance :type dbmodel: :class:`aiida.backends.djsite.db.models.DbUser` :return: A DjangoUser instance :rtype: :class:`DjangoUser` """ type_check(dbmodel, DbUser) user = cls.__new__(cls) super(DjangoUser, user).__init__(backend) user._dbuser = utils.ModelWrapper(dbmodel) return user
def __init__(self, **kwargs): from aiida.backends.djsite.db.models import DbGroup from aiida.orm.backend import construct_backend self._backend = construct_backend() dbgroup = kwargs.pop('dbgroup', None) if dbgroup is not None: if kwargs: raise ValueError( "If you pass a dbgroups, you cannot pass any further parameter" ) if isinstance(dbgroup, (int, long)): try: dbgroup = DbGroup.objects.get(pk=dbgroup) except ObjectDoesNotExist: raise NotExistent( "Group with pk={} does not exist".format(dbgroup)) type_check(dbgroup, DbGroup) self._dbgroup = utils.ModelWrapper(dbgroup) else: name = kwargs.pop('name', None) if name is None: raise ValueError("You have to specify a group name") group_type = kwargs.pop('type_string', "") # By default, a user group # Get the user and extract dbuser instance user = kwargs.pop('user', self._backend.users.get_automatic_user()) description = kwargs.pop('description', "") self._dbgroup = utils.ModelWrapper( DbGroup(name=name, description=description, user=user.dbuser, type=group_type)) if kwargs: raise ValueError("Too many parameters passed to Group, the " "unknown parameters are: {}".format(", ".join( kwargs.keys())))
def user(self, new_user): type_check(new_user, users.SqlaUser) self._dbgroup.user = new_user.dbuser
def from_dbmodel(cls, dbmodel, backend): type_check(dbmodel, DbAuthInfo) authinfo = cls.__new__(cls) super(DjangoAuthInfo, authinfo).__init__(backend) authinfo._dbauthinfo = utils.ModelWrapper(dbmodel) return authinfo
def _add_dblink_from(self, src, label=None, link_type=LinkType.UNSPECIFIED): from aiida.backends.sqlalchemy import get_scoped_session from aiida.orm.querybuilder import QueryBuilder session = get_scoped_session() type_check(src, Node) if self.uuid == src.uuid: raise ValueError("Cannot link to itself") if not self.is_stored: raise ModificationNotAllowed( "Cannot call the internal _add_dblink_from if the " "destination node is not stored") if not src.is_stored: raise ModificationNotAllowed( "Cannot call the internal _add_dblink_from if the " "source node is not stored") # Check for cycles. This works if the transitive closure is enabled; if # it isn't, this test will never fail, but then having a circular link # is not meaningful but does not pose a huge threat # # I am linking src->self; a loop would be created if a DbPath exists # already in the TC table from self to src if link_type is LinkType.CREATE or link_type is LinkType.INPUT: if QueryBuilder().append( Node, filters={ 'id': self.pk }, tag='parent').append( Node, filters={ 'id': src.pk }, tag='child', descendant_of='parent').count() > 0: raise ValueError( "The link you are attempting to create would generate a loop" ) if label is None: autolabel_idx = 1 existing_from_autolabels = session.query(DbLink.label).filter( DbLink.output_id == self._dbnode.id, DbLink.label.like("link%")) while "link_{}".format(autolabel_idx) in existing_from_autolabels: autolabel_idx += 1 safety_counter = 0 while True: safety_counter += 1 if safety_counter > 100: # Well, if you have more than 100 concurrent addings # to the same node, you are clearly doing something wrong... raise InternalError( "Hey! We found more than 100 concurrent" " adds of links " "to the same nodes! Are you really doing that??") try: self._do_create_link(src, "link_{}".format(autolabel_idx), link_type) break except UniquenessError: # Retry loop until you find a new loop autolabel_idx += 1 else: self._do_create_link(src, label, link_type)
def set_user(self, user): type_check(user, users.SqlaUser) self._dbnode.user = user.dbuser
def from_dbmodel(cls, dbmodel, backend): type_check(dbmodel, DbUser) user = cls.__new__(cls) super(SqlaUser, user).__init__(backend) user._dbuser = utils.ModelWrapper(dbmodel) return user