def __init__(self,
channel: grpc.Channel,
session_id: str,
transaction_type: TransactionType,
options=GraknOptions()):
self._transaction_type = transaction_type
self._concept_manager = ConceptManager(self)
self._query_manager = QueryManager(self)
self._logic_manager = LogicManager(self)
self._response_queues = {}
self._grpc_stub = GraknStub(channel)
self._request_iterator = RequestIterator()
self._response_iterator = self._grpc_stub.transaction(
self._request_iterator)
self._transaction_was_closed = False
open_req = transaction_proto.Transaction.Open.Req()
open_req.session_id = session_id
open_req.type = Transaction._transaction_type_proto(transaction_type)
open_req.options.CopyFrom(grakn_proto_builder.options(options))
req = transaction_proto.Transaction.Req()
req.open_req.CopyFrom(open_req)
start_time = time.time() * 1000.0
res = self._execute(req)
end_time = time.time() * 1000.0
self._network_latency_millis = end_time - start_time - res.open_res.processing_time_millis
def __init__(self,
client,
database: str,
session_type: SessionType,
options: GraknOptions = None):
if not options:
options = GraknOptions.core()
self._address = client._address
self._channel = grpc.insecure_channel(client._address)
self._scheduler = sched.scheduler(time.time, time.sleep)
self._database = database
self._session_type = session_type
self._grpc_stub = GraknStub(self._channel)
open_req = session_proto.Session.Open.Req()
open_req.database = database
open_req.type = _session_type_proto(session_type)
open_req.options.CopyFrom(grakn_proto_builder.options(options))
self._session_id = self._grpc_stub.session_open(open_req).session_id
self._is_open = True
self._pulse_thread_pool = ThreadPoolExecutor(
thread_name_prefix='session_pulse_{}'.format(
self._session_id.hex()))
self._scheduler.enter(delay=self._PULSE_FREQUENCY_SECONDS,
priority=1,
action=self._transmit_pulse,
argument=())
self._pulse_thread_pool.submit(self._scheduler.run)
def session(self,
database: str,
session_type: SessionType,
options=None) -> Session:
if not options:
options = GraknOptions.core()
return _RPCSession(self, database, session_type, options)
def transaction(self,
transaction_type: TransactionType,
options=None) -> Transaction:
if not options:
options = GraknOptions.core()
return Transaction(self._address, self._session_id, transaction_type,
options)
def delete(self, query: str, options: GraknOptions = None):
if not options:
options = GraknOptions.core()
request = query_proto.Query.Req()
delete_req = query_proto.Query.Delete.Req()
delete_req.query = query
request.delete_req.CopyFrom(delete_req)
return self._iterate_query(request, lambda res: [], options)
def undefine(self, query: str, options: GraknOptions = None):
if not options:
options = GraknOptions.core()
request = query_proto.Query.Req()
undefine_req = query_proto.Query.Undefine.Req()
undefine_req.query = query
request.undefine_req.CopyFrom(undefine_req)
return self._iterate_query(request, lambda res: [], options)
def transaction(self,
transaction_type: TransactionType,
options: GraknClusterOptions = None) -> Transaction:
if not options:
options = GraknOptions.cluster()
return self._transaction_secondary_replica(
transaction_type, options
) if options.allow_secondary_replica else self._transaction_primary_replica(
transaction_type, options)
def match_aggregate(self, query: str, options: GraknOptions = None):
if not options:
options = GraknOptions.core()
request = query_proto.Query.Req()
match_aggregate_req = query_proto.Query.MatchAggregate.Req()
match_aggregate_req.query = query
request.match_aggregate_req.CopyFrom(match_aggregate_req)
return self._iterate_query(
request, lambda res:
[numeric._of(res.query_res.match_aggregate_res.answer)], options)
def insert(self, query: str, options: GraknOptions = None):
if not options:
options = GraknOptions.core()
request = query_proto.Query.Req()
insert_req = query_proto.Query.Insert.Req()
insert_req.query = query
request.insert_req.CopyFrom(insert_req)
return map(
lambda answer_proto: concept_map._of(answer_proto),
self._iterate_query(request,
lambda res: res.query_res.insert_res.answers,
options))
def match_group(self, query: str, options: GraknOptions = None):
if not options:
options = GraknOptions.core()
request = query_proto.Query.Req()
match_group_req = query_proto.Query.MatchGroup.Req()
match_group_req.query = query
request.match_group_req.CopyFrom(match_group_req)
return map(
lambda cmg_proto: concept_map_group._of(cmg_proto),
self._iterate_query(
request, lambda res: res.query_res.match_group_res.answers,
options))
def match_group_aggregate(self, query: str, options: GraknOptions = None):
if not options:
options = GraknOptions.core()
request = query_proto.Query.Req()
match_group_aggregate_req = query_proto.Query.MatchGroupAggregate.Req()
match_group_aggregate_req.query = query
request.match_group_aggregate_req.CopyFrom(match_group_aggregate_req)
return map(
lambda numeric_group_proto: numeric_group._of(numeric_group_proto),
self._iterate_query(
request,
lambda res: res.query_res.match_group_aggregate_res.answers,
options))
def __init__(self,
client,
database: str,
session_type: SessionType,
options=GraknOptions()):
self._channel = client._channel
self._scheduler = client._scheduler
self._database = database
self._session_type = session_type
self._grpc_stub = GraknStub(self._channel)
open_req = session_proto.Session.Open.Req()
open_req.database = database
open_req.type = Session._session_type_proto(session_type)
open_req.options.CopyFrom(grakn_proto_builder.options(options))
self._session_id = self._grpc_stub.session_open(open_req).session_id
self._is_open = True
self._pulse = self._scheduler.enter(5, 1, self._transmit_pulse, ())
def __init__(self, client, database: str, session_type: SessionType, options: GraknOptions = None):
if not options:
options = GraknOptions.core()
self._client = client
self._address = client._address
self._channel = grpc.aio.insecure_channel(client._address)
self._scheduler = sched.scheduler(time.time, time.sleep)
self._database = _DatabaseRPC(database_manager=client.databases(), name=database)
self._session_type = session_type
self._grpc_stub = GraknStub(self._channel)
self._lock = Lock()
open_req = session_proto.Session.Open.Req()
open_req.database = database
open_req.type = _session_type_proto(session_type)
open_req.options.CopyFrom(grakn_proto_builder.options(options))
self._session_id: bytes = self._grpc_stub.session_open(open_req).session_id
self._is_open = True
self._pulse = self._scheduler.enter(delay=self._PULSE_FREQUENCY_SECONDS, priority=1, action=self._transmit_pulse, argument=())
Thread(target=self._scheduler.run, name="session_pulse_{}".format(self._session_id.hex()), daemon=True).start()
def transaction(self,
transaction_type: TransactionType,
options=GraknOptions()):
return Transaction(self._channel, self._session_id, transaction_type,
options)
def session(self,
database: str,
session_type: SessionType,
options=GraknOptions()):
return _Session(self, database, session_type, options)
def undefine(self, query: str, options=GraknOptions()):
request = query_proto.Query.Req()
undefine_req = query_proto.Graql.Undefine.Req()
undefine_req.query = query
request.undefine_req.CopyFrom(undefine_req)
self._run_query(request, options)
def delete(self, query: str, options=GraknOptions()):
request = query_proto.Query.Req()
delete_req = query_proto.Graql.Delete.Req()
delete_req.query = query
request.delete_req.CopyFrom(delete_req)
self._run_query(request, options)
def match(self, query: str, options=GraknOptions()):
request = query_proto.Query.Req()
match_req = query_proto.Graql.Match.Req()
match_req.query = query
request.match_req.CopyFrom(match_req)
return map(lambda answer_proto: concept_map._of(answer_proto), self._iterate_query(request, lambda res: res.query_res.match_res.answers, options))
