def run_concept_iter_method(self, concept_id,
grpc_concept_iter_method_req):
return Iterator(
self._communicator,
RequestBuilder.start_iterating_concept_method(
concept_id, grpc_concept_iter_method_req),
lambda res: res.conceptMethod_iter_res.response)
def query(self, query: str, infer=True):
request = RequestBuilder.query(query, infer=infer)
# print("Query request: {0}".format(request))
response = self._communicator.send(request)
# convert `response` into a python iterator
return ResponseConverter.ResponseConverter.query(
self, response.query_iter)
def __init__(self, communicator, iter_req, resp_converter):
self._communicator = communicator
self._iter_req = iter_req
self._response_iterator = self._communicator.iteration_request(
RequestBuilder.iter_req_to_tx_req(self._iter_req), end_of_batch)
self._done = False
self._resp_converter = resp_converter
def get_attributes_by_value(self, attribute_value,
data_type: enums.DataType):
request = RequestBuilder.get_attributes_by_value(
attribute_value, data_type)
response = self._communicator.send(request)
return ResponseConverter.ResponseConverter.get_attributes_by_value(
self, response.getAttributes_iter)
def __init__(self, session_id, tx_type, transaction_endpoint):
self.session_id = session_id
self.tx_type = tx_type.value
self._communicator = Communicator(transaction_endpoint)
# open the transaction with an 'open' message
open_req = RequestBuilder.open_tx(session_id, tx_type)
self._communicator.single_request(open_req)
def __init__(self, keyspace, tx_type: enums.TxType, credentials, transaction_endpoint):
self.keyspace = keyspace
self.tx_type = tx_type.value
self.credentials = credentials
self._communicator = Communicator(transaction_endpoint)
# open the transaction with an 'open' message
open_req = RequestBuilder.open_tx(keyspace, tx_type, credentials)
self._communicator.send(open_req)
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 _request_next_batch(self, iter_id):
self._response_iterator = self._communicator.iteration_request(
RequestBuilder.iter_req_to_tx_req(
RequestBuilder.continue_iterating(iter_id,
self._iter_req.options)),
end_of_batch)
def close(self):
""" Close this keyspace session """
close_session_req = RequestBuilder.close_session(self.session_id)
self._stub.close(close_session_req)
self._closed = True
self._channel.close()
def explanation(self, explainable):
""" Retrieve the explanation of a Concept Map from the server """
tx_request = RequestBuilder.explanation(explainable)
response = self._communicator.single_request(tx_request)
return ResponseReader.ResponseReader.create_explanation(
self, response.explanation_res)
def put_role(self, label: str):
request = RequestBuilder.put_role(label)
response = self._communicator.send(request)
return ResponseConverter.ResponseConverter.put_role(
self, response.putRole_res)
def run_concept_method(self, concept_id, grpc_concept_method_req):
# wrap method_req into a transaction message
tx_request = RequestBuilder.concept_method_req_to_tx_req(
concept_id, grpc_concept_method_req)
response = self._communicator.single_request(tx_request)
return response.conceptMethod_res.response
def put_rule(self, label, when, then):
request = RequestBuilder.put_rule(label, when, then)
response = self._communicator.single_request(request)
return ResponseReader.ResponseReader.put_rule(self,
response.putRule_res)
def put_entity_type(self, label):
request = RequestBuilder.put_entity_type(label)
response = self._communicator.single_request(request)
return ResponseReader.ResponseReader.put_entity_type(
self, response.putEntityType_res)
def commit(self):
request = RequestBuilder.commit()
self._communicator.single_request(request)
def get_schema_concept(self, label):
request = RequestBuilder.get_schema_concept(label)
response = self._communicator.single_request(request)
return ResponseReader.ResponseReader.get_schema_concept(
self, response.getSchemaConcept_res)
def put_rule(self, label: str, when: str, then: str):
request = RequestBuilder.put_rule(label, when, then)
response = self._communicator.send(request)
return ResponseConverter.ResponseConverter.put_rule(
self, response.putRule_res)
def get_schema_concept(self, label: str):
request = RequestBuilder.get_schema_concept(label)
response = self._communicator.send(request)
return ResponseConverter.ResponseConverter.get_schema_concept(
self, response.getSchemaConcept_res)
def get_concept(self, concept_id: str):
request = RequestBuilder.get_concept(concept_id)
response = self._communicator.send(request)
return ResponseConverter.ResponseConverter.get_concept(
self, response.getConcept_res)
def commit(self):
request = RequestBuilder.commit()
self._communicator.send(request)
def iterate(self, iterator_id: int):
request = RequestBuilder.next_iter(iterator_id)
response = self._communicator.send(request)
return response.iterate_res
def query(self, query, infer, explain, batch_size):
return Iterator(
self._communicator,
RequestBuilder.start_iterating_query(query, infer, explain,
batch_size),
ResponseReader.ResponseReader.get_query_results(self))
def put_entity_type(self, label: str):
request = RequestBuilder.put_entity_type(label)
response = self._communicator.send(request)
return ResponseConverter.ResponseConverter.put_entity_type(
self, response.putEntityType_res)
def get_concept(self, concept_id):
request = RequestBuilder.get_concept(concept_id)
response = self._communicator.single_request(request)
return ResponseReader.ResponseReader.get_concept(
self, response.getConcept_res)
def put_relationship_type(self, label: str):
request = RequestBuilder.put_relationship_type(label)
response = self._communicator.send(request)
return ResponseConverter.ResponseConverter.put_relationship_type(
self, response.putRelationType_res)
def get_attributes_by_value(self, attribute_value, value_type):
request = RequestBuilder.start_iterating_get_attributes_by_value(
attribute_value, value_type)
return Iterator(
self._communicator, request,
ResponseReader.ResponseReader.get_attributes_by_value(self))
def put_attribute_type(self, label: str, data_type: enums.DataType):
request = RequestBuilder.put_attribute_type(label, data_type)
response = self._communicator.send(request)
return ResponseConverter.ResponseConverter.put_attribute_type(
self, response.putAttributeType_res)
def put_relation_type(self, label):
request = RequestBuilder.put_relation_type(label)
response = self._communicator.single_request(request)
return ResponseReader.ResponseReader.put_relation_type(
self, response.putRelationType_res)
def put_attribute_type(self, label, value_type):
request = RequestBuilder.put_attribute_type(label, value_type)
response = self._communicator.single_request(request)
return ResponseReader.ResponseReader.put_attribute_type(
self, response.putAttributeType_res)
