def to_pair(iter_res):
response = iter_res.relation_rolePlayersMap_iter_res
from grakn.service.Session.Concept import ConceptFactory
role = ConceptFactory.create_remote_concept(
tx_service, response.role)
from grakn.service.Session.Concept import ConceptFactory
player = ConceptFactory.create_remote_concept(
tx_service, response.player)
return (role, player)
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_remote_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 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 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 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 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 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 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 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)
from grakn.service.Session.Concept import ConceptFactory
return ConceptFactory.create_remote_concept(
self._tx_service, method_response.thing_type_res.type)
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 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 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 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
from grakn.service.Session.Concept import ConceptFactory
return ConceptFactory.create_remote_concept(self._tx_service,
grpc_entity_concept)
def create(self):
""" Create an instance of a relation 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_relation_concept = method_response.relationType_create_res.relation
from grakn.service.Session.Concept import ConceptFactory
return ConceptFactory.create_remote_concept(self._tx_service,
grpc_relation_concept)
def create(self, value):
""" Create an instance with this AttributeType """
self_value_type = self.value_type()
create_inst_req = RequestBuilder.ConceptMethod.AttributeType.create(
value, self_value_type)
method_response = self._tx_service.run_concept_method(
self.id, create_inst_req)
grpc_attribute_concept = method_response.attributeType_create_res.attribute
from grakn.service.Session.Concept import ConceptFactory
return ConceptFactory.create_remote_concept(self._tx_service,
grpc_attribute_concept)
def role_players(self, *roles):
""" Retrieve role players filtered by roles """
role_players_req = RequestBuilder.ConceptMethod.Relation.role_players(
roles)
from grakn.service.Session.Concept import ConceptFactory
return map(
lambda iter_res: ConceptFactory.create_remote_concept(
self._tx_service, iter_res.relation_rolePlayers_iter_res.thing
),
self._tx_service.run_concept_iter_method(self.id,
role_players_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_remote_concept(
tx_service, grpc_concept)
elif which_one == "null":
return None
else:
raise GraknError(
"Unknown get_schema_concept response: {0}".format(which_one))
def attribute(self, value):
""" Retrieve an attribute instance by value if it exists """
self_value_type = self.value_type()
get_attribute_req = RequestBuilder.ConceptMethod.AttributeType.attribute(
value, self_value_type)
method_response = self._tx_service.run_concept_method(
self.id, get_attribute_req)
response = method_response.attributeType_attribute_res
whichone = response.WhichOneof('res')
if whichone == 'attribute':
from grakn.service.Session.Concept import ConceptFactory
return ConceptFactory.create_remote_concept(
self._tx_service, response.attribute)
elif whichone == 'null':
return None
else:
raise GraknError(
"Unknown `res` key in AttributeType `attribute` response: {0}".
format(whichone))
def put_entity_type(tx_service, grpc_put_entity_type):
return ConceptFactory.create_remote_concept(
tx_service, grpc_put_entity_type.entityType)
def put_relation_type(tx_service, grpc_put_relation_type):
return ConceptFactory.create_remote_concept(
tx_service, grpc_put_relation_type.relationType)
def put_attribute_type(tx_service, grpc_put_attribute_type):
return ConceptFactory.create_remote_concept(
tx_service, grpc_put_attribute_type.attributeType)
def put_rule(tx_service, grpc_put_rule):
return ConceptFactory.create_remote_concept(tx_service,
grpc_put_rule.rule)
def get_attributes_by_value(tx_service):
return lambda iterate_res: ConceptFactory.create_remote_concept(
tx_service, iterate_res.getAttributes_iter_res.attribute)