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 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 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 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 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 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 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 sups(self):
""" Retrieve the all supertypes (direct and higher level) of this schema concept as an iterator """
sups_req = RequestBuilder.ConceptMethod.SchemaConcept.sups()
method_response = self._tx_service.run_concept_method(
self.id, sups_req)
return ResponseConverter.ResponseConverter.iter_res_to_iterator(
self._tx_service, method_response.schemaConcept_sups_iter.id,
lambda tx_serv, iter_res: ConceptFactory.create_concept(
tx_serv, iter_res.conceptMethod_iter_res.
schemaConcept_sups_iter_res.schemaConcept))
def role_players(self, *roles):
""" Retrieve role players filtered by roles """
role_players_req = RequestBuilder.ConceptMethod.Relation.role_players(roles)
method_response = self._tx_service.run_concept_method(self.id, role_players_req)
return ResponseReader.ResponseReader.iter_res_to_iterator(
self._tx_service,
method_response.relation_rolePlayers_iter.id,
lambda tx_service, iter_res:
ConceptFactory.create_concept(tx_service, iter_res.conceptMethod_iter_res.relation_rolePlayers_iter_res.thing)
)
def attributes(self):
""" Retrieve all attributes attached to this Type as an iterator """
attributes_req = RequestBuilder.ConceptMethod.Type.attributes()
method_response = self._tx_service.run_concept_method(
self.id, attributes_req)
return ResponseConverter.ResponseConverter.iter_res_to_iterator(
self._tx_service, method_response.type_attributes_iter.id,
lambda tx_serv, iter_res: ConceptFactory.create_concept(
tx_serv, iter_res.conceptMethod_iter_res.
type_attributes_iter_res.attributeType))
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 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 instances(self):
""" Retrieve all instances of this Type as an iterator """
instances_req = RequestBuilder.ConceptMethod.Type.instances()
method_response = self._tx_service.run_concept_method(
self.id, instances_req)
return ResponseConverter.ResponseConverter.iter_res_to_iterator(
self._tx_service, method_response.type_instances_iter.id,
lambda tx_serv, iter_res: ConceptFactory.create_concept(
tx_serv, iter_res.conceptMethod_iter_res.
type_instances_iter_res.thing))
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))
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 attributes(self, *attribute_types):
""" Retrieve iterator of this Thing's attributes, filtered by optionally provided attribute types """
attrs_req = RequestBuilder.ConceptMethod.Thing.attributes(attribute_types)
method_response = self._tx_service.run_concept_method(self.id, attrs_req)
return ResponseReader.ResponseReader.iter_res_to_iterator(
self._tx_service,
method_response.thing_attributes_iter.id,
lambda tx_service, iter_res:
ConceptFactory.create_concept(tx_service, iter_res.conceptMethod_iter_res.thing_attributes_iter_res.attribute)
)
def relationships(self):
""" Retrieve relationships that this role participates in, as an iterator """
# NOTE: relations vs relationships here
relations_req = RequestBuilder.ConceptMethod.Role.relations()
method_response = self._tx_service.run_concept_method(
self.id, relations_req)
return ResponseConverter.ResponseConverter.iter_res_to_iterator(
self._tx_service, method_response.role_relations_iter.id,
lambda tx_service, iter_res: ConceptFactory.create_concept(
tx_service, iter_res.conceptMethod_iter_res.
role_relations_iter_res.relationType))
def subs(self):
""" Retrieve the sub schema concepts of this schema concept, as an iterator """
subs_req = RequestBuilder.ConceptMethod.SchemaConcept.subs()
method_response = self._tx_service.run_concept_method(self.id, subs_req)
return ResponseReader.ResponseReader.iter_res_to_iterator(
self._tx_service,
method_response.schemaConcept_subs_iter.id,
lambda tx_serv, iter_res:
ConceptFactory.create_concept(tx_serv,
iter_res.conceptMethod_iter_res.schemaConcept_subs_iter_res.schemaConcept)
)
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)
query_pattern = grpc_concept_map_msg.pattern
has_explanation = grpc_concept_map_msg.hasExplanation
return ConceptMap(answer_map, query_pattern, has_explanation, tx_service)
def relationships(self, *roles):
""" Get iterator this Thing's relationships, filtered to the optionally provided roles """
# NOTE `relations` rather than `relationships`
relations_req = RequestBuilder.ConceptMethod.Thing.relations(roles)
method_response = self._tx_service.run_concept_method(
self.id, relations_req)
return ResponseConverter.ResponseConverter.iter_res_to_iterator(
self._tx_service, method_response.thing_relations_iter.id,
lambda tx_service, iter_res: ConceptFactory.create_concept(
tx_service, iter_res.conceptMethod_iter_res.
thing_relations_iter_res.relation))
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)
from grakn.service.Session.util import ResponseReader
from grakn.service.Session.Concept import ConceptFactory
return ResponseReader.ResponseReader.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 relations(self, *roles):
""" Get iterator this Thing's relations, filtered to the optionally provided roles """
relations_req = RequestBuilder.ConceptMethod.Thing.relations(roles)
method_response = self._tx_service.run_concept_method(
self.id, relations_req)
from grakn.service.Session.util import ResponseReader
from grakn.service.Session.Concept import ConceptFactory
return ResponseReader.ResponseReader.iter_res_to_iterator(
self._tx_service, method_response.thing_relations_iter.id,
lambda tx_service, iter_res: ConceptFactory.create_concept(
tx_service, iter_res.conceptMethod_iter_res.
thing_relations_iter_res.relation))
def relations(self):
""" Retrieve relations that this role participates in, as an iterator """
relations_req = RequestBuilder.ConceptMethod.Role.relations()
method_response = self._tx_service.run_concept_method(
self.id, relations_req)
from grakn.service.Session.util import ResponseReader
from grakn.service.Session.Concept import ConceptFactory
return ResponseReader.ResponseReader.iter_res_to_iterator(
self._tx_service, method_response.role_relations_iter.id,
lambda tx_service, iter_res: ConceptFactory.create_concept(
tx_service, iter_res.conceptMethod_iter_res.
role_relations_iter_res.relationType))
def roles(self):
""" Retrieve roles in this relation schema type """
get_roles = RequestBuilder.ConceptMethod.RelationType.roles()
method_response = self._tx_service.run_concept_method(
self.id, get_roles)
from grakn.service.Session.util import ResponseReader
from grakn.service.Session.Concept import ConceptFactory
return ResponseReader.ResponseReader.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 instances(self):
""" Retrieve all instances of this Type as an iterator """
instances_req = RequestBuilder.ConceptMethod.Type.instances()
method_response = self._tx_service.run_concept_method(
self.id, instances_req)
from grakn.service.Session.util import ResponseReader
from grakn.service.Session.Concept import ConceptFactory
return ResponseReader.ResponseReader.iter_res_to_iterator(
self._tx_service, method_response.type_instances_iter.id,
lambda tx_serv, iter_res: ConceptFactory.create_concept(
tx_serv, iter_res.conceptMethod_iter_res.
type_instances_iter_res.thing))
