def get_aiida_class(self): """ Return the corresponding aiida instance of class aiida.orm.Node or a appropriate subclass. """ from aiida.common.pluginloader import from_type_to_pluginclassname from aiida.orm.node import Node try: pluginclassname = from_type_to_pluginclassname(self.type) except DbContentError: raise DbContentError("The type name of node with pk= {} is " "not valid: '{}'".format(self.pk, self.type)) try: PluginClass = load_plugin(Node, 'aiida.orm', pluginclassname) except MissingPluginError: aiidalogger.error("Unable to find plugin for type '{}' (node= {}), " "will use base Node class".format(self.type, self.pk)) PluginClass = Node return PluginClass(dbnode=self)
def get_ormclass(self, cls, ormclasstype): """ Return the valid ormclass for the connections """ # Checks whether valid cls and ormclasstype are done before # If it is a class: if cls: # Nodes: if issubclass(cls, self.Node): # If something pass an ormclass node # Users wouldn't do that, by why not... ormclasstype = self.AiidaNode._plugin_type_string query_type_string = self.AiidaNode._query_type_string ormclass = cls elif issubclass(cls, self.AiidaNode): ormclasstype = cls._plugin_type_string query_type_string = cls._query_type_string ormclass = self.Node # Groups: elif issubclass(cls, self.Group): ormclasstype = 'group' query_type_string = None ormclass = cls elif issubclass(cls, self.AiidaGroup): ormclasstype = 'group' query_type_string = None ormclass = self.Group # Computers: elif issubclass(cls, self.Computer): ormclasstype = 'computer' query_type_string = None ormclass = cls elif issubclass(cls, self.AiidaComputer): ormclasstype = 'computer' query_type_string = None ormclass = self.Computer # Users elif issubclass(cls, self.User): ormclasstype = 'user' query_type_string = None ormclass = cls elif issubclass(cls, self.AiidaUser): ormclasstype = 'user' query_type_string = None ormclass = self.User else: raise InputValidationError( "\n\n\n" "I do not know what to do with {}" "\n\n\n".format(cls) ) # If it is not a class else: if ormclasstype.lower() == 'group': ormclasstype = ormclasstype.lower() query_type_string = None ormclass = self.Group elif ormclasstype.lower() == 'computer': ormclasstype = ormclasstype.lower() query_type_string = None ormclass = self.Computer elif ormclasstype.lower() == 'user': ormclasstype = ormclasstype.lower() query_type_string = None ormclass = self.User else: # At this point, it has to be a node. # The only valid string at this point is a string # that matches exactly the _plugin_type_string # of a node class from aiida.common.old_pluginloader import from_type_to_pluginclassname from aiida.common.pluginloader import load_plugin ormclass = self.Node try: pluginclassname = from_type_to_pluginclassname(ormclasstype) # I want to check at this point if that is a valid class, # so I use the load_plugin to load the plugin class # and use the classes _plugin_type_string attribute # In the future, assuming the user knows what he or she is doing # we could remove that check # The query_type_string we can get from # the aiida.common.old_pluginloader function get_query_type_string PluginClass = load_plugin(self.AiidaNode, 'aiida.orm', pluginclassname) except (DbContentError, MissingPluginError) as e: raise InputValidationError( "\nYou provide a vertice of the path with\n" "type={}\n" "But that string is not a valid type string\n" "Exception raise during check\n" "{}".format(ormclasstype, e) ) ormclasstype = PluginClass._plugin_type_string query_type_string = PluginClass._query_type_string return ormclass, ormclasstype, query_type_string