def to_pair(tx_service, iter_res): response = iter_res.conceptMethod_iter_res.relation_rolePlayersMap_iter_res from grakn.service.Session.Concept import ConceptFactory role = ConceptFactory.create_concept(tx_service, response.role) from grakn.service.Session.Concept import ConceptFactory player = ConceptFactory.create_concept(tx_service, response.player) return (role, player)
def create(self, value): """ Create an instance with this AttributeType """ self_data_type: enums.DataType = self.data_type() create_inst_req = RequestBuilder.ConceptMethod.AttributeType.create(value, self_data_type) method_response = self._tx_service.run_concept_method(self.id, create_inst_req) grpc_attribute_concept = method_response.attributeType_create_res.attribute return ConceptFactory.create_concept(self._tx_service, grpc_attribute_concept)
def type(self): """ Get the type (schema concept) of this Thing """ type_req = RequestBuilder.ConceptMethod.Thing.type() method_response = self._tx_service.run_concept_method( self.id, type_req) return ConceptFactory.create_concept( self._tx_service, method_response.thing_type_res.type)
def sup(self, super_concept=None): """ Get or set super schema concept. If used as a setter returns self """ if super_concept is None: # get direct super schema concept get_sup_req = RequestBuilder.ConceptMethod.SchemaConcept.get_sup() method_response = self._tx_service.run_concept_method( self.id, get_sup_req) get_sup_response = method_response.schemaConcept_getSup_res # check if received a Null or Concept whichone = get_sup_response.WhichOneof('res') if whichone == 'schemaConcept': grpc_schema_concept = get_sup_response.schemaConcept from grakn.service.Session.Concept import ConceptFactory concept = ConceptFactory.create_concept( self._tx_service, grpc_schema_concept) return concept elif whichone == 'null': return None else: raise GraknError( "Unknown response concent for getting super schema concept: {0}" .format(whichone)) else: # set direct super SchemaConcept of this SchemaConcept set_sup_req = RequestBuilder.ConceptMethod.SchemaConcept.set_sup( super_concept) method_response = self._tx_service.run_concept_method( self.id, set_sup_req) return self
def _create_answer_group(tx_service, grpc_answer_group): grpc_owner_concept = grpc_answer_group.owner owner_concept = ConceptFactory.create_concept(tx_service, grpc_owner_concept) grpc_answers = list(grpc_answer_group.answers) answer_list = [AnswerConverter.convert(tx_service, grpc_answer) for grpc_answer in grpc_answers] explanation = AnswerConverter._create_explanation(tx_service, grpc_answer_group.explanation) return AnswerGroup(owner_concept, answer_list, explanation)
def roles(self): """ Retrieve roles in this relation schema type """ get_roles = RequestBuilder.ConceptMethod.RelationType.roles() from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.relationType_roles_iter_res.role), self._tx_service.run_concept_iter_method(self.id, get_roles))
def keys(self): """ Retrieve an iterator of attribute types that this Type uses as keys """ keys_req = RequestBuilder.ConceptMethod.Type.keys() from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.type_keys_iter_res.attributeType), self._tx_service.run_concept_iter_method(self.id, keys_req))
def playing(self): """ Retrieve iterator of roles played by this type """ playing_req = RequestBuilder.ConceptMethod.Type.playing() from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.type_playing_iter_res.role), self._tx_service.run_concept_iter_method(self.id, playing_req))
def instances(self): """ Retrieve all instances of this Type as an iterator """ instances_req = RequestBuilder.ConceptMethod.Type.instances() from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.type_instances_iter_res.thing), self._tx_service.run_concept_iter_method(self.id, instances_req))
def players(self): """ Retrieve an iterator of entities that play this role """ players_req = RequestBuilder.ConceptMethod.Role.players() from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.role_players_iter_res.type), self._tx_service.run_concept_iter_method(self.id, players_req))
def relations(self, *roles): """ Get iterator this Thing's relations, filtered to the optionally provided roles """ relations_req = RequestBuilder.ConceptMethod.Thing.relations(roles) from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.thing_relations_iter_res.relation), self._tx_service.run_concept_iter_method(self.id, relations_req))
def owners(self): """ Retrieve entities that have this attribute value """ owners_req = RequestBuilder.ConceptMethod.Attribute.owners() from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.attribute_owners_iter_res.thing), self._tx_service.run_concept_iter_method(self.id, owners_req))
def create(self): """ Instantiate an entity of the given type and return it """ create_req = RequestBuilder.ConceptMethod.EntityType.create() method_response = self._tx_service.run_concept_method( self.id, create_req) grpc_entity_concept = method_response.entityType_create_res.entity return ConceptFactory.create_concept(self._tx_service, grpc_entity_concept)
def keys(self, *attribute_types): """ Retrieve iterator of keys (i.e. actual attributes) of this Thing, filtered by the optionally provided attribute types """ keys_req = RequestBuilder.ConceptMethod.Thing.keys(attribute_types) from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.thing_keys_iter_res.attribute), self._tx_service.run_concept_iter_method(self.id, keys_req))
def roles(self): """ Retrieve iterator of roles this Thing plays """ roles_req = RequestBuilder.ConceptMethod.Thing.roles() from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.thing_roles_iter_res.role), self._tx_service.run_concept_iter_method(self.id, roles_req))
def _create_answer_group(tx_service, grpc_answer_group): grpc_owner_concept = grpc_answer_group.owner owner_concept = ConceptFactory.create_local_concept(grpc_owner_concept) grpc_answers = list(grpc_answer_group.answers) answer_list = [ AnswerConverter.convert(tx_service, grpc_answer) for grpc_answer in grpc_answers ] return AnswerGroup(owner_concept, answer_list)
def create(self): """ Create an instance of a relationship with this type """ create_rel_inst_req = RequestBuilder.ConceptMethod.RelationType.create( ) method_response = self._tx_service.run_concept_method( self.id, create_rel_inst_req) grpc_relationship_concept = method_response.relationType_create_res.relation return ConceptFactory.create_concept(self._tx_service, grpc_relationship_concept)
def sups(self): """ Retrieve the all supertypes (direct and higher level) of this schema concept as an iterator """ sups_req = RequestBuilder.ConceptMethod.SchemaConcept.sups() from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.schemaConcept_sups_iter_res. schemaConcept), self._tx_service.run_concept_iter_method(self.id, sups_req))
def attributes(self): """ Retrieve all attributes attached to this Type as an iterator """ attributes_req = RequestBuilder.ConceptMethod.Type.attributes() from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.type_attributes_iter_res. attributeType), self._tx_service.run_concept_iter_method(self.id, attributes_req))
def relations(self): """ Retrieve relations that this role participates in, as an iterator """ relations_req = RequestBuilder.ConceptMethod.Role.relations() from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.role_relations_iter_res. relationType), self._tx_service.run_concept_iter_method(self.id, relations_req))
def get_schema_concept(tx_service, grpc_get_concept): which_one = grpc_get_concept.WhichOneof("res") if which_one == "schemaConcept": grpc_concept = grpc_get_concept.schemaConcept return ConceptFactory.create_concept(tx_service, grpc_concept) elif which_one == "null": return None else: raise GraknError("Unknown get_schema_concept response: {0}".format(which_one))
def subs(self): """ Retrieve the sub schema concepts of this schema concept, as an iterator """ subs_req = RequestBuilder.ConceptMethod.SchemaConcept.subs() from grakn.service.Session.Concept import ConceptFactory return map( lambda iter_res: ConceptFactory.create_remote_concept( self._tx_service, iter_res.schemaConcept_subs_iter_res. schemaConcept), self._tx_service.run_concept_iter_method(self.id, subs_req))
def roles(self): """ Retrieve roles in this relationship schema type """ get_roles = RequestBuilder.ConceptMethod.RelationType.roles() method_response = self._tx_service.run_concept_method( self.id, get_roles) return ResponseConverter.ResponseConverter.iter_res_to_iterator( self._tx_service, method_response.relationType_roles_iter.id, lambda tx_serv, iter_res: ConceptFactory.create_concept( tx_serv, iter_res.conceptMethod_iter_res. relationType_roles_iter_res.role))
def _create_concept_map(tx_service, grpc_concept_map_msg): """ Create a Concept Dictionary from the grpc response """ var_concept_map = grpc_concept_map_msg.map answer_map = {} for (variable, grpc_concept) in var_concept_map.items(): answer_map[variable] = ConceptFactory.create_concept(tx_service, grpc_concept) # build explanation explanation = AnswerConverter._create_explanation(tx_service, grpc_concept_map_msg.explanation) return ConceptMap(answer_map, explanation)
def owners(self): """ Retrieve entities that have this attribute value """ owners_req = RequestBuilder.ConceptMethod.Attribute.owners() method_response = self._tx_service.run_concept_method( self.id, owners_req) return ResponseConverter.ResponseConverter.iter_res_to_iterator( self._tx_service, method_response.attribute_owners_iter.id, lambda tx_service, iter_res: ConceptFactory.create_concept( tx_service, iter_res.conceptMethod_iter_res. attribute_owners_iter_res.thing))
def keys(self, *attribute_types): """ Retrieve iterator of keys (i.e. actual attributes) of this Thing, filtered by the optionally provided attribute types """ keys_req = RequestBuilder.ConceptMethod.Thing.keys(attribute_types) method_response = self._tx_service.run_concept_method( self.id, keys_req) return ResponseConverter.ResponseConverter.iter_res_to_iterator( self._tx_service, method_response.thing_keys_iter.id, lambda tx_service, iter_res: ConceptFactory.create_concept( tx_service, iter_res.conceptMethod_iter_res.thing_keys_iter_res .attribute))
def roles(self): """ Retrieve iterator of roles this Thing plays """ roles_req = RequestBuilder.ConceptMethod.Thing.roles() method_response = self._tx_service.run_concept_method( self.id, roles_req) return ResponseConverter.ResponseConverter.iter_res_to_iterator( self._tx_service, method_response.thing_roles_iter.id, lambda tx_service, iter_res: ConceptFactory.create_concept( tx_service, iter_res.conceptMethod_iter_res. thing_roles_iter_res.role))
def players(self): """ Retrieve an iterator of entities that play this role """ players_req = RequestBuilder.ConceptMethod.Role.players() method_response = self._tx_service.run_concept_method( self.id, players_req) return ResponseConverter.ResponseConverter.iter_res_to_iterator( self._tx_service, method_response.role_players_iter.id, lambda tx_service, iter_res: ConceptFactory.create_concept( tx_service, iter_res.conceptMethod_iter_res. role_players_iter_res.type))
def playing(self): """ Retrieve iterator of roles played by this type """ playing_req = RequestBuilder.ConceptMethod.Type.playing() method_response = self._tx_service.run_concept_method( self.id, playing_req) return ResponseConverter.ResponseConverter.iter_res_to_iterator( self._tx_service, method_response.type_playing_iter.id, lambda tx_serv, iter_res: ConceptFactory.create_concept( tx_serv, iter_res.conceptMethod_iter_res.type_playing_iter_res. role))
def keys(self): """ Retrieve an iterator of attribute types that this Type uses as keys """ keys_req = RequestBuilder.ConceptMethod.Type.keys() method_response = self._tx_service.run_concept_method( self.id, keys_req) return ResponseConverter.ResponseConverter.iter_res_to_iterator( self._tx_service, method_response.type_keys_iter.id, lambda tx_serv, iter_res: ConceptFactory.create_concept( tx_serv, iter_res.conceptMethod_iter_res.type_keys_iter_res. attributeType))