def _fetch(self, request_id: str): try: return self._response_queues[request_id].get(block=False) except queue.Empty: pass # Keep taking responses until we get one that matches the request ID while True: try: response = next(self._response_iterator) except grpc.RpcError as e: self._transaction_was_closed = True grakn_exception = GraknClientException(e.details()) for response_queue in self._response_queues.values(): response_queue.put(grakn_exception) # noinspection PyUnresolvedReferences raise grakn_exception except StopIteration: raise GraknClientException( "The transaction has been closed and no further operation is allowed." ) if isinstance(response, GraknClientException): raise response elif response.id == request_id: return response else: response_queue = self._response_queues[response.id] if response_queue is None: raise GraknClientException( "Received a response with unknown request id '" + response.id + "'.") response_queue.put(response)
def __init__(self, transaction, iid: str): if not transaction: raise GraknClientException("Transaction must be set.") if not iid: raise GraknClientException("IID must be set.") self._transaction = transaction self._iid = iid self._hash = hash(iid)
def __init__(self, transaction, label: str, is_root: bool): if not transaction: raise GraknClientException("Transaction must be set.") if not label: raise GraknClientException("Label must be a non-empty string.") self._transaction = transaction self._label = label self._is_root = is_root self._hash = hash((self._transaction, label))
def __init__(self, label: str, when: str, then: str): if not label: raise GraknClientException("Label must be a non-empty string.") self._label = label self._when = when self._then = then self._hash = hash(label)
def all(self) -> List[str]: try: return list( self._grpc_stub.database_all( database_proto.Database.All.Req()).names) except RpcError as e: raise GraknClientException(e)
def delete(self, name: str) -> None: request = database_proto.Database.Delete.Req() request.name = _not_blank(name) try: self._grpc_stub.database_delete(request) except RpcError as e: raise GraknClientException(e)
def contains(self, name: str) -> bool: request = database_proto.Database.Contains.Req() request.name = _not_blank(name) try: return self._grpc_stub.database_contains(request).contains except RpcError as e: raise GraknClientException(e)
def __next__(self): if self._done: raise StopIteration() if self._current_iterator is not None: try: return next(self._current_iterator) except StopIteration: self._current_iterator = None res = self._transaction._fetch(self._request_id) res_case = res.WhichOneof("res") if res_case == Stream._CONTINUE: continue_req = transaction_proto.Transaction.Req() continue_req.id = self._request_id setattr(continue_req, "continue", True) self._transaction._request_iterator.put(continue_req) return next(self) elif res_case == Stream._DONE: self._done = True raise StopIteration() elif res_case is None: raise GraknClientException( "The required field 'res' of type 'transaction_proto.Transaction.Res' was not set." ) else: self._current_iterator = iter(self._transform_response(res)) return next(self)
def contains(self, name: str) -> bool: errors = [] for database_manager in self._database_managers.values(): try: return database_manager.contains(name) except GraknClientException as e: errors.append(e) raise GraknClientException("Attempted connecting to all cluster members, but the following errors occurred: " + str([str(e) for e in errors]))
def all(self) -> List[DatabaseCluster]: errors = [] for address in self._database_managers: try: res = self._client.grakn_cluster_grpc_stub(address).database_all(database_proto.Database.All.Req()) return [_DatabaseClusterRPC.of(db, self) for db in res.databases] except GraknClientException as e: errors.append(e) raise GraknClientException("Attempted connecting to all cluster members, but the following errors occurred: " + str([str(e) for e in errors]))
def thing_encoding(thing_): if thing_.is_entity(): return concept_proto.Thing.Encoding.Value("ENTITY") elif thing_.is_relation(): return concept_proto.Thing.Encoding.Value("RELATION") elif thing_.is_attribute(): return concept_proto.Thing.Encoding.Value("ATTRIBUTE") else: raise GraknClientException("Unrecognised thing encoding: " + str(thing_))
def _execute(self, request: transaction_proto.Transaction.Req): response_queue = queue.Queue() request_id = str(uuid.uuid4()) request.id = request_id if self._transaction_was_closed: raise GraknClientException( "The transaction has been closed and no further operation is allowed." ) self._response_queues[request_id] = response_queue self._request_iterator.put(request) return self._fetch(request_id)
def get(self, name: str) -> DatabaseCluster: errors = [] for address in self._database_managers: try: database_get_req = database_proto.Database.Get.Req() database_get_req.name = name res = self._client.grakn_cluster_grpc_stub(address).database_get(database_get_req) return _DatabaseClusterRPC.of(res.database, self) except GraknClientException as e: errors.append(e) raise GraknClientException("Attempted connecting to all cluster members, but the following errors occurred: " + str([str(e) for e in errors]))
def _of(numeric_proto: answer_proto.Numeric): numeric_case = numeric_proto.WhichOneof("value") if numeric_case == "long_value": return Numeric(numeric_proto.long_value, None) elif numeric_case == "double_value": return Numeric(None, numeric_proto.double_value) elif numeric_case == "nan": return Numeric(None, None) else: raise GraknClientException("The answer type '" + numeric_case + "' was not recognised.")
def close(self) -> None: if self._is_open: self._is_open = False self._pulse_thread_pool.shutdown(wait=False) req = session_proto.Session.Close.Req() req.session_id = self._session_id try: self._grpc_stub.session_close(req) except RpcError as e: raise GraknClientException(e) finally: self._channel.close()
def thing(thing_proto: concept_proto.Thing): if thing_proto.encoding == concept_proto.Thing.Encoding.Value("ENTITY"): return Entity._of(thing_proto) elif thing_proto.encoding == concept_proto.Thing.Encoding.Value( "RELATION"): return Relation._of(thing_proto) elif thing_proto.encoding == concept_proto.Thing.Encoding.Value( "ATTRIBUTE"): return attribute(thing_proto) else: raise GraknClientException("The encoding " + thing_proto.encoding + " was not recognised.")
def parse(address: str) -> "ServerAddress": s = address.split(",") if len(s) == 1: s1 = address.split(":") return ServerAddress(client_host=s1[0], client_port=int(s1[1]), server_host=s1[0], server_port=int(s1[1])) elif len(s) == 2: client_url = s[0].split(":") server_url = s[1].split(":") if len(client_url) != 2 or len(server_url) != 2: raise GraknClientException("Failed to parse server address: " + address) return ServerAddress(client_host=client_url[0], client_port=int(client_url[1]), server_host=server_url[0], server_port=int(server_url[1])) else: raise GraknClientException("Failed to parse server address: " + address)
def type_encoding(_type): if _type.is_entity_type(): return concept_proto.Type.Encoding.Value("ENTITY_TYPE") elif _type.is_relation_type(): return concept_proto.Type.Encoding.Value("RELATION_TYPE") elif _type.is_attribute_type(): return concept_proto.Type.Encoding.Value("ATTRIBUTE_TYPE") elif _type.is_role_type(): return concept_proto.Type.Encoding.Value("ROLE_TYPE") elif _type.is_thing_type(): return concept_proto.Type.Encoding.Value("THING_TYPE") else: raise GraknClientException("Unrecognised type encoding: " + str(_type))
def primary_replica(self) -> "_RPCSessionCluster.Replica": primaries = [ replica for replica in self._replicas.values() if replica.is_primary() ] if primaries: return max(primaries, key=lambda r: r.term) else: max_term = max( [replica.term() for replica in self._replicas.values()]) raise GraknClientException( "No replica has been marked as the primary replica for latest known term '%d'." % max_term)
def thing_type(type_proto: concept_proto.Type): if type_proto.encoding == concept_proto.Type.Encoding.Value("ENTITY_TYPE"): return EntityType._of(type_proto) elif type_proto.encoding == concept_proto.Type.Encoding.Value( "RELATION_TYPE"): return RelationType._of(type_proto) elif type_proto.encoding == concept_proto.Type.Encoding.Value( "ATTRIBUTE_TYPE"): return attribute_type(type_proto) elif type_proto.encoding == concept_proto.Type.Encoding.Value( "THING_TYPE"): return ThingType(type_proto.label, type_proto.root) else: raise GraknClientException("The encoding " + str(type_proto.encoding) + " was not recognised.")
def _stream( self, request: transaction_proto.Transaction.Req, transform_response: Callable[[transaction_proto.Transaction.Res], List] = None): response_queue = queue.Queue() request_id = str(uuid.uuid4()) request.id = request_id if self._transaction_was_closed: raise GraknClientException( "The transaction has been closed and no further operation is allowed." ) self._response_queues[request_id] = response_queue self._request_iterator.put(request) return Stream(self, request_id, transform_response)
def value_type(value_type_: ValueType): if value_type_ == ValueType.BOOLEAN: return concept_proto.AttributeType.ValueType.Value("BOOLEAN") elif value_type_ == ValueType.LONG: return concept_proto.AttributeType.ValueType.Value("LONG") elif value_type_ == ValueType.DOUBLE: return concept_proto.AttributeType.ValueType.Value("DOUBLE") elif value_type_ == ValueType.STRING: return concept_proto.AttributeType.ValueType.Value("STRING") elif value_type_ == ValueType.DATETIME: return concept_proto.AttributeType.ValueType.Value("DATETIME") elif value_type_ == ValueType.OBJECT: return concept_proto.AttributeType.ValueType.Value("OBJECT") else: raise GraknClientException("Unrecognised value type: " + str(value_type_))
def _discover_cluster(self, addresses: List[str]) -> Set[Address.Server]: for address in addresses: try: with _RPCGraknClient(address) as client: print("Performing cluster discovery to %s..." % address) grakn_cluster_stub = GraknClusterStub(client.channel()) res = grakn_cluster_stub.cluster_discover( cluster_proto.Cluster.Discover.Req()) members = set( [Address.Server.parse(srv) for srv in res.servers]) print("Discovered %s" % str(members)) return members except RpcError: print("Cluster discovery to %s failed." % address) raise GraknClientException( "Unable to connect to Grakn Cluster. Attempted connecting to the cluster members, but none are available: %s" % str(addresses))
def attribute(thing_proto: concept_proto.Thing): if thing_proto.value_type == concept_proto.AttributeType.ValueType.Value( "BOOLEAN"): return BooleanAttribute._of(thing_proto) elif thing_proto.value_type == concept_proto.AttributeType.ValueType.Value( "LONG"): return LongAttribute._of(thing_proto) elif thing_proto.value_type == concept_proto.AttributeType.ValueType.Value( "DOUBLE"): return DoubleAttribute._of(thing_proto) elif thing_proto.value_type == concept_proto.AttributeType.ValueType.Value( "STRING"): return StringAttribute._of(thing_proto) elif thing_proto.value_type == concept_proto.AttributeType.ValueType.Value( "DATETIME"): return DateTimeAttribute._of(thing_proto) else: raise GraknClientException("The value type " + str(thing_proto.value_type) + " was not recognised.")
def get_has(self, attribute_type=None, attribute_types: List = None, only_key=False): if [bool(attribute_type), bool(attribute_types), only_key].count(True) > 1: raise GraknClientException( "Only one filter can be applied at a time to get_has." "The possible filters are: [attribute_type, attribute_types, only_key]" ) if attribute_type: attribute_types = [attribute_type] method = concept_proto.Thing.Req() get_has_req = concept_proto.Thing.GetHas.Req() if only_key: get_has_req.keys_only = only_key elif attribute_types: get_has_req.attribute_types.extend( concept_proto_builder.types(attribute_types)) method.thing_get_has_req.CopyFrom(get_has_req) return self._thing_stream(method, lambda res: res.thing_get_has_res.attributes)
def get(self, name: str) -> Database: if self.contains(name): return _DatabaseRPC(self, name) else: raise GraknClientException("The database '%s' does not exist." % name)
def _not_blank(name: str) -> str: if name in [None, ""] or name.isspace(): raise GraknClientException("Database name must not be empty.") return name
def __init__(self, label: str, is_root: bool): if not label: raise GraknClientException("Label must be a non-empty string.") self._label = label self._is_root = is_root self._hash = hash(label)
def _cluster_not_available_exception(self) -> GraknClientException: addresses = str( [str(addr) for addr in self._cluster_client.cluster_members()]) return GraknClientException( "Unable to connect to Grakn Cluster. Attempted connecting to the cluster members, but none are available: '%s'" % addresses)
def rpc_call(request: Callable[[], Any]) -> Any: try: return request() except RpcError as e: raise GraknClientException(e)