def get_overlaps(self, utterance):
"""
Query and build overlaps with regards to the subject and object of the heard statement
Parameters
----------
utterance
Returns
-------
Overlaps containing shared information with the heard statement
"""
# Role as subject
query = read_query('thoughts/object_overlap') % (
utterance.triple.predicate_name, utterance.triple.object_name,
utterance.triple.subject_name)
response = self._submit_query(query)
if response[0]['types']['value'] != '':
object_overlap = [self._fill_overlap_(elem) for elem in response]
else:
object_overlap = []
# Role as object
query = read_query('thoughts/subject_overlap') % (
utterance.triple.predicate_name, utterance.triple.subject_name,
utterance.triple.object_name)
response = self._submit_query(query)
if response[0]['types']['value'] != '':
subject_overlap = [self._fill_overlap_(elem) for elem in response]
else:
subject_overlap = []
return Overlaps(subject_overlap, object_overlap)
def get_overlaps(self, capsule):
# Role as subject
query = read_query('object_overlap') % (capsule['predicate']['type'],
capsule['object']['label'],
capsule['subject']['label'])
response = self._submit_query(query)
if response:
object_overlap = [{
'subject': elem['slabel']['value'],
'author': elem['authorlabel']['value'],
'date': elem['date']['value'].split('/')[-1]
} for elem in response]
else:
object_overlap = []
# Role as object
query = read_query('subject_overlap') % (capsule['predicate']['type'],
capsule['subject']['label'],
capsule['object']['label'])
response = self._submit_query(query)
if response:
subject_overlap = [{
'object': elem['olabel']['value'],
'author': elem['authorlabel']['value'],
'date': elem['date']['value'].split('/')[-1]
} for elem in response]
else:
subject_overlap = []
return {'subject': subject_overlap, 'object': object_overlap}
def get_gaps_from_entity(self, entity):
# Role as subject
query = read_query('subject_gaps') % (entity['label'], entity['label'])
response = self._submit_query(query)
if response:
subject_gaps = [{
'predicate': elem['p']['value'].split('/')[-1],
'range': elem['type2']['value'].split('/')[-1]
} for elem in response if elem['p']['value'].split('/')[-1] not in
self._NOT_TO_ASK_PREDICATES]
else:
subject_gaps = []
# Role as object
query = read_query('object_gaps') % (entity['label'], entity['label'])
response = self._submit_query(query)
if response:
object_gaps = [{
'predicate': elem['p']['value'].split('/')[-1],
'domain': elem['type2']['value'].split('/')[-1]
} for elem in response if elem['p']['value'].split('/')[-1] not in
self._NOT_TO_ASK_PREDICATES]
else:
object_gaps = []
return {'subject': subject_gaps, 'object': object_gaps}
def get_negation_conflicts(self, utterance):
"""
Query and build negation conflicts, meaning conflicts because predicates are directly negated
Parameters
----------
utterance
Returns
-------
conflicts: List[NegationConflict]
List of Conflicts containing the predicate which creates the conflict, and their provenance
"""
query = read_query('thoughts/negation_conflicts') % (
utterance.triple.predicate_name, utterance.triple.subject_name,
utterance.triple.object_name)
response = self._submit_query(query)
if response[0] != {}:
conflicts = [
self._fill_negation_conflict_(elem) for elem in response
]
else:
conflicts = []
return conflicts
def get_object_cardinality_conflicts(self, utterance):
"""
Query and build cardinality conflicts, meaning conflicts because predicates should be one to one but have
multiple object values
Parameters
----------
utterance
Returns
-------
conflicts: List[CardinalityConflicts]
List of Conflicts containing the object which creates the conflict, and their provenance
"""
if str(utterance.triple.predicate_name
) not in self._ONE_TO_ONE_PREDICATES:
return []
query = read_query('thoughts/object_cardinality_conflicts') % (
utterance.triple.predicate_name, utterance.triple.subject_name,
utterance.triple.object_name)
response = self._submit_query(query)
if response[0] != {}:
conflicts = [
self._fill_cardinality_conflict_(elem) for elem in response
]
else:
conflicts = []
return conflicts
def _exact_match_wikidata(item):
"""
Query wikidata for information on this item to get it's semantic type and description.
:param item:
:return:
"""
url = 'https://query.wikidata.org/sparql'
# Gather combinations
combinations = [item.lower()]
for comb in combinations:
# Try exact matching query
query = read_query('typing/wikidata_type_and_description') % comb
try:
r = requests.get(url, params={'format': 'json', 'query': query}, timeout=3)
data = r.json() if r.status_code != 500 else None
except:
data = None
# break if we have a hit
if data:
break
if data is not None:
class_type = data[u'results'][u'bindings'][0][u'itemtypeLabel'][u'value'] \
if 'itemtypeLabel' in data[u'results'][u'bindings'][0].keys() else None
description = data[u'results'][u'bindings'][0][u'itemDescription'][u'value'] \
if 'itemDescription' in data[u'results'][u'bindings'][0].keys() else None
return class_type, description
else:
return None, None
def __init__(self, address=config.BRAIN_URL_LOCAL):
"""
Interact with Triple store
Parameters
----------
address: str
IP address and port of the Triple store
"""
self.address = address
self.namespaces = {}
self.ontology_paths = {}
self.format = 'trig'
self.dataset = Dataset()
self.query_prefixes = read_query('prefixes')
self._define_namespaces()
self._get_ontology_path()
self._bind_namespaces()
self.my_uri = None
self._log = logger.getChild(self.__class__.__name__)
self._log.debug("Booted")
self._brain_log = config.BRAIN_LOG_ROOT.format(
datetime.now().strftime('%Y-%m-%d-%H-%M'))
# Launch first query
self.count_statements()
def count_statements(self):
"""
Count statements or 'facts' in the brain
:return:
"""
query = read_query('count_statements')
response = self._submit_query(query)
return response[0]['count']['value']
def count_friends(self):
"""
Count number of people I have talked to
:return:
"""
query = read_query('count_friends')
response = self._submit_query(query)
return response[0]['count']['value']
def get_my_friends(self):
"""
Get names of people I have talked to
:return:
"""
query = read_query('my_friends')
response = self._submit_query(query)
return [elem['name']['value'].split('/')[-1] for elem in response]
def get_best_friends(self):
"""
Get names of the 5 people I have talked to the most
:return:
"""
query = read_query('best_friends')
response = self._submit_query(query)
return [elem['name']['value'] for elem in response]
def get_predicates(self):
"""
Get predicates in social ontology
:return:
"""
query = read_query('structure exploration/predicates')
response = self._submit_query(query)
return [elem['p']['value'].split('/')[-1] for elem in response]
def get_classes(self):
"""
Get classes or types in social ontology
:return:
"""
query = read_query('structure exploration/classes')
response = self._submit_query(query)
return [elem['c']['value'].split('/')[-1] for elem in response]
def get_type_of_instance(self, label):
"""
Get types of a certain instance identified by its label
:param label: label of instance
:return:
"""
query = read_query('content exploration/type_of_instance') % label
response = self._submit_query(query)
return [elem['type']['value'] for elem in response] if response else []
def when_last_chat_with(self, actor_label):
"""
Get time value for the last time I chatted with this person
:param actor_label: name of person
:return:
"""
query = read_query('when_last_chat_with') % (actor_label)
response = self._submit_query(query)
return response[0]['time']['value'].split('/')[-1]
def get_classes(self):
"""
Get classes in social ontology
:return:
"""
query = read_query('classes')
response = self._submit_query(query)
return [elem['o']['value'].split('/')[-1] for elem in response]
def get_instance_of_type(self, instance_type):
"""
Get isntances of a certain class type
:param instance_type: name of class in ontology
:return:
"""
query = read_query('instance_of_type') % (instance_type)
response = self._submit_query(query)
return [elem['name']['value'] for elem in response]
def get_last_chat_id(self):
"""
Get the id for the last interaction recorded
:return: id
"""
query = read_query('last_chat_id')
response = self._submit_query(query)
return int(response[0]['chatid']['value']) if response else 0
def get_triples_with_predicate(self, predicate):
"""
Get triples that contain this predicate
:param predicate:
:return:
"""
query = read_query('triples_with_predicate') % predicate
response = self._submit_query(query)
return [(elem['sname']['value'], elem['oname']['value'])
for elem in response]
def get_instance_of_type(self, instance_type):
"""
Get instances of a certain class type
:param instance_type: name of class in ontology
:return:
"""
query = read_query(
'content exploration/instance_of_type') % instance_type
response = self._submit_query(query)
return [elem['name']['value'] for elem in response] if response else []
def check_statement_existence(self, instance_url):
query = read_query('instance_existence') % (instance_url)
response = self._submit_query(query)
if response[0] != {}:
response = [{
'date': elem['date']['value'].split('/')[-1],
'authorlabel': elem['authorlabel']['value']
} for elem in response]
return response
def get_entity_gaps(self, entity, exclude=None):
"""
Query and build gaps with regards to the range and domain of the given entity and its predicates
Parameters
----------
entity: dict
Information regarding the entity
Returns
-------
Gaps object containing gaps related to range and domain information that could be learned
"""
# Role as subject
query = read_query('thoughts/subject_gaps') % (
entity.label, entity.label if exclude is None else exclude.label)
response = self._submit_query(query)
if response:
subject_gaps = [
self._fill_entity_gap_(elem) for elem in response if elem['p']
['value'].split('/')[-1] not in self._NOT_TO_ASK_PREDICATES
]
else:
subject_gaps = []
# Role as object
query = read_query('thoughts/object_gaps') % (
entity.label, entity.label if exclude is None else exclude.label)
response = self._submit_query(query)
if response:
object_gaps = [
self._fill_entity_gap_(elem) for elem in response if elem['p']
['value'].split('/')[-1] not in self._NOT_TO_ASK_PREDICATES
]
else:
object_gaps = []
return Gaps(subject_gaps, object_gaps)
def get_labels_and_classes(self):
"""
Get classes in social ontology
:return:
"""
query = read_query('labels_and_classes')
response = self._submit_query(query)
temp = dict()
for r in response:
temp[r['l']['value']] = r['o']['value'].split('/')[-1]
return temp
def _check_instance_novelty_(self, instance_url):
"""
Query if an instance (entity) has been heard about before
Parameters
----------
instance_url: str
URI of instance
Returns
-------
conflicts: List[StatementNovelty]
List of provenance for the instance
"""
query = read_query('thoughts/entity_novelty') % instance_url
response = self._submit_query(query, ask=True)
return response
def get_last_turn_id(self, chat_id):
"""
Get the id for the last turn in the given chat
:param chat_id: id for chat of interest
:return: id
"""
query = read_query('last_turn_id') % (chat_id)
response = self._submit_query(query)
last_turn = 0
for turn in response:
turn_uri = turn['s']['value']
turn_id = turn_uri.split('/')[-1][10:]
turn_id = int(turn_id)
if turn_id > last_turn:
last_turn = turn_id
return last_turn
def create_chat_id(self, actor, date):
"""
Determine chat id depending on my last conversation with this person
:param actor:
:param date:
:return:
"""
query = read_query('last_chat_with') % (actor)
response = self._submit_query(query)
if response and int(response[0]['day']['value']) == int(date.day) \
and int(response[0]['month']['value']) == int(date.month) \
and int(response[0]['year']['value']) == int(date.year):
# Chatted with this person today so same chat id
chat_id = int(response[0]['chatid']['value'])
else:
# Either have never chatted with this person, or I have but not today. Add one to latest chat
chat_id = self.get_last_chat_id() + 1
return chat_id
def get_conflicts_with_one_to_one_predicate(self, one_to_one_predicate):
query = read_query('one_to_one_conflicts') % one_to_one_predicate
response = self._submit_query(query)
conflicts = []
for item in response:
conflict = {
'subject': item['sname']['value'],
'predicate': one_to_one_predicate,
'objects': []
}
for x in item['pairs']['value'].split(';'):
[val, auth] = x.split(',')
option = {'value': val, 'author': auth}
conflict['objects'].append(option)
conflicts.append(conflict)
return conflicts
def get_object_cardinality_conflicts_with_statement(self, capsule):
# Case fold
capsule = casefold_capsule(capsule, format='triple')
if capsule['predicate']['type'] not in self._ONE_TO_ONE_PREDICATES:
return [{}]
query = read_query('object_cardinality_conflicts') % (
capsule['predicate']['type'], capsule['subject']['label'],
capsule['object']['label'])
response = self._submit_query(query)
if response[0] != {}:
response = [{
'date': elem['date']['value'].split('/')[-1],
'authorlabel': elem['authorlabel']['value'],
'oname': elem['oname']['value']
} for elem in response]
return response
def __init__(self, address=config.BRAIN_URL_LOCAL, clear_all=False):
# type: (str, bool) -> LongTermMemory
"""
Interact with Triple store
Parameters
----------
address: str
IP address and port of the Triple store
"""
super(LongTermMemory, self).__init__(address, clear_all)
self.myself = None
self.query_prefixes = read_query('prefixes') # USED ONLY WHEN QUERYING
self.thought_generator = ThoughtGenerator()
self.location_reasoner = LocationReasoner()
self.type_reasoner = TypeReasoner()
self.set_location_label = self.location_reasoner.set_location_label
self.reason_location = self.location_reasoner.reason_location
def _exact_match_dbpedia(self, item):
"""
Query dbpedia for information on this item to get it's semantic type and description.
:param item:
:return:
"""
# Gather combinations
combinations = [item, item.capitalize(), item.lower(), item.title()]
for comb in combinations:
# Try exact matching query
query = read_query('typing/dbpedia_type_and_description') % comb
response = self._submit_query(query)
# break if we have a hit
if response:
break
class_type = response[0]['label_type']['value'] if response else None
description = response[0]['description']['value'].split('.')[0] if response else None
return class_type, description
