the7erm
commented
8 years ago I think I have an idea for this but I'd like to get some input.
For starters let's take the model of what happens with humans. Short term & long term memory.
Humans in general can hold about 5~6 items in their short term memory at a time.
We'll probably need to build a context dict, this will hold a small piece of info about what was said:
Context item
{
"skill": "wolfram_alpha",
# insert joke here about how your wife remembers everything ...
"scope": "public/private" # allow the developer of the skill
# to mark this information public or private
# if it's a public any other skill can read it
# if it's private no other skills can read it.
"ttl": None, # time to live if it's None ... never forget
"data": { # this is a dict that the skill sets so the skill author
# controls what is remembered.
"utterance": "Mycroft, who is Lebron James?",
"response": {
"said": "..."
},
"pronoun": {
"he": "Lebron James"
}
},
"timestamp": time.time()
}I'm not sure about the best structure for this one. The way python handles objects you can have the same object exist in all the dicts.
Context containers
# skill_context would contain both the public & private entries
# later on we can build an interface that uses a database EG the long term
# memory.
skill_context = {
"wolfram_alpha": [{...}, {...}],
"random_skil_name": [{...}]
}
# This would be a list that you'd .append() items to.
public_context = [{...}, {...}]What I have in mind
Here's what it'd look like when it's all put together ... I kinda think in code.
from mycroft_context import MycroftContext
mycroft_context = MycroftContext()
class MycroftSkill(object):
def __init__(self, name, emitter=None):
...
self.context = mycroft_context.get_context(self.name)class MySkill(MycroftSkill):
def handle_intent_example(self, message):
last_ten_items = self.context.recall()
utterance = message.metadata['utterance']
# TODO language_parser()
# language_parser would separate the sentence into
# nouns, pronouns, verbs, adverbs etc
# That's the hard part ... figuring out who "HE" is based
# on the response.
# That's going to require a ALOT of work because we'll have to have
# a whole dictionary.
# I recommend putting the language parser in an issue of it's own.
# or ... fake it and regex it and add a list of pronouns to choose
# from. The system wouldn't know gender, you could ask who is she
# and it'd still tell you.
self.context.store({
"utterance": utterance,
"sentence_components": language_parser(response)
})mycroft_context.py
from mycroft.skill_context import MycroftSkillContext
class MycroftContext(object):
"""
Holds all the contexts public & private
"""
skill_context = defaultdict(list)
public_context = []
contexts = {}
def __init__(self):
pass
def get_context(self, mycroft_skill_name):
context = self.contexts.get(mycroft_skill_name)
if context:
return context
context = MycroftSkillContext(mycroft_skill_name,
self.skill_context[mycroft_skill_name],
self.public_context)
self.contexts[mycroft_skill_name] = context
return context
def forget(self):
# garbage collection
for skill_name, context in self.context.items():
context.forget()
return selfmycroft.skill_context.py
class MycroftSkillContext(object):
"""
MycroftSkillContext is used to isolate what the skill is allowed to "know"
"""
def __init__(self, mycroft_skill_name, skill_context, public_context):
self.name = mycroft_skill_name
self.skill_context = skill_context
self.public_context = private_context
def store(self, data, ttl=None, scope="private"):
# todo perhaps add "+1 day" for expires.
data['ttl'] = ttl
data['timestamp'] = time.time()
self.skill_context.append(data)
if scope != "private":
self.public_context.append(data)
return self
def recall(self, limit=10):
if limit == -1:
result = self.skill_context + self.public_context
else:
result = self.skill_context[-limit:] +\
self.public_context[-limit:]
# TODO sort by timestamp, perhaps make it an iterator.
return result
def forget(self):
# garbage collection
remove_items = []
now = time.time()
for item in context.skill_context:
ttl = item.get("ttl")
if ttl is None:
continue
timestamp = context.get("timestamp")
if now >= timestamp + ttl:
remove_items.append(item)
for item in remove_items:
try:
context.skill_context.remove(item)
except ValueError:
pass
try:
context.public_context.remove(item)
except ValueError:
pass
return self
clusterfudge
BoatrightTBC
forslund
marksev1
aatchison
zachwelch
Mycroft should be able to know when someone is talking about a previous query, e.g.
User: Mycroft, who is Lebron James? ... User: Mycroft, how tall is he? Mycroft: 6 feet 8 inches.