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 get(self, var=None):
""" Get the indicated variable's Concept from the map or this ConceptMap """
if var is None:
return self
else:
if var not in self._concept_map:
# TODO specialize exception
raise GraknError("Variable {0} is not in the ConceptMap".format(var))
return self._concept_map[var]
""" Return ConceptMap """
return self
def get_then(self):
""" Retrieve the `then` clause for this rule """
then_req = RequestBuilder.ConceptMethod.Rule.then()
method_response = self._tx_service.run_concept_method(self.id, then_req)
response = method_response.rule_then_res
whichone = response.WhichOneof('res')
if whichone == 'pattern':
return response.pattern
elif whichone == 'null':
return None
else:
raise GraknError("Unknown field in get_then or `rule`: {0}".format(whichone))
def from_grpc_value_object(grpc_value_object):
whichone = grpc_value_object.WhichOneof('value')
# check the one is in the known datatypes
known_datatypes = [e.name.lower() for e in enums.DataType]
if whichone.lower() not in known_datatypes:
raise GraknError("Unknown value object value key: {0}, not in {1}".format(whichone, known_datatypes))
if whichone == 'string':
return grpc_value_object.string
elif whichone == 'boolean':
return grpc_value_object.boolean
elif whichone == 'integer':
return grpc_value_object.integer
elif whichone == 'long':
return grpc_value_object.long
elif whichone == 'float':
return grpc_value_object.float
elif whichone == 'double':
return grpc_value_object.double
elif whichone == 'date':
return grpc_value_object.date
else:
raise GraknError("Unknown datatype in enum but not handled in from_grpc_value_object")
def attribute(self, value):
""" Retrieve an attribute instance by value if it exists """
self_data_type = self.data_type()
get_attribute_req = RequestBuilder.ConceptMethod.AttributeType.attribute(value, self_data_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':
return ConceptFactory.create_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 __next__(self):
if self._done:
raise GraknError('Iterator was already iterated.')
try:
response = next(self._response_iterator)
except StopIteration:
raise GraknError(
'Internal client/protocol error,'
' did not receive an expected "done" or "iteratorId" message.'
'\n\n Please ensure client version is supported by server version.'
)
iter_res = response.iter_res
res_type = iter_res.WhichOneof('res')
if res_type == 'done':
self._done = True
raise StopIteration
elif res_type == 'iteratorId':
self._request_next_batch(iter_res.iteratorId)
return next(self)
else:
return self._resp_converter(iter_res)
def data_type(self):
""" Get the DataType enum (grakn.DataType) corresponding to the type of this attribute """
get_data_type_req = RequestBuilder.ConceptMethod.AttributeType.data_type(
)
method_response = self._tx_service.run_concept_method(
self.id, get_data_type_req)
response = method_response.attributeType_dataType_res
whichone = response.WhichOneof('res')
if whichone == 'dataType':
# iterate over enum DataType enum to find matching data type
for e in enums.DataType:
if e.value == response.dataType:
return e
else:
# loop exited normally
raise GraknError("Reported datatype NOT in enum: {0}".format(
response.dataType))
elif whichone == 'null':
return None
else:
raise GraknError(
"Unknown datatype response for AttributeType: {0}".format(
whichone))
def convert(tx_service, grpc_answer):
which_one = grpc_answer.WhichOneof('answer')
if which_one == 'conceptMap':
return AnswerConverter._create_concept_map(tx_service, grpc_answer.conceptMap)
elif which_one == 'answerGroup':
return AnswerConverter._create_answer_group(tx_service, grpc_answer.answerGroup)
elif which_one == 'conceptList':
return AnswerConverter._create_concept_list(tx_service, grpc_answer.conceptList)
elif which_one == 'conceptSet':
return AnswerConverter._create_concept_set(tx_service, grpc_answer.conceptSet)
elif which_one == 'conceptSetMeasure':
return AnswerConverter._create_concept_set_measure(tx_service, grpc_answer.conceptSetMeasure)
elif which_one == 'value':
return AnswerConverter._create_value(tx_service, grpc_answer.value)
else:
raise GraknError('Unknown gRPC Answer.answer message type: {0}'.format(which_one))
def transaction(self, tx_type):
""" Open a transaction to Grakn on this keyspace
Can be used as `with session.transaction(grakn.TxType.READ) as tx: ...`
Don't forget to commit within the `with`!
Alternatively you can still do `tx = session.transaction(...); ...; tx.close()`
:param grakn.TxType tx_type: The type of transaction to open as indicated by the tx_type enum
"""
if self._closed:
raise GraknError("Session is closed")
# create a transaction service which hides GRPC usage
transaction_service = TransactionService(self.keyspace, tx_type,
self.credentials,
self._stub.transaction)
return Transaction(transaction_service)
def __init__(self, uri, keyspace, channel, credentials):
if not isinstance(uri, str):
raise TypeError('expected string for uri')
if not isinstance(keyspace, str):
raise TypeError('expected string for keyspace')
self.keyspace = keyspace
self.uri = uri
self.credentials = credentials
self._stub = SessionServiceStub(channel)
self._closed = False
try:
open_session_response = self._stub.open(
RequestBuilder.open_session(keyspace, self.credentials))
self.session_id = open_session_response.sessionId
except Exception as e:
raise GraknError(
'Could not obtain sessionId for keyspace "{0}", stems from: {1}'
.format(keyspace, e))
def error_if_closed(self):
if self._closed:
raise GraknError("This connection is closed")
def explanation(self):
if self._has_explanation:
return self._tx_service.explanation(self)
else:
raise GraknError("Explanation not available on concept map: " +
str(self))
