def __init__(self):
self._verboseMode = True
self._version = "PyAIML 0.8.6"
self._brain = PatternMgr()
self._respondLock = threading.RLock()
self._textEncoding = "utf-8"
# set up the sessions
self._sessions = {}
self._addSession(self._globalSessionID)
self._currentPlugin = ""
self.plugins = {}
# Set up the bot predicates
self._botPredicates = {}
self.setBotPredicate("name", "Nameless")
# set up the word substitutors (subbers):
self._subbers = {}
self._subbers['gender'] = WordSub(DefaultSubs.defaultGender)
self._subbers['person'] = WordSub(DefaultSubs.defaultPerson)
self._subbers['person2'] = WordSub(DefaultSubs.defaultPerson2)
self._subbers['normal'] = WordSub(DefaultSubs.defaultNormal)
# set up the element processors
self._elementProcessors = {
"bot": self._processBot,
"condition": self._processCondition,
"date": self._processDate,
"formal": self._processFormal,
"gender": self._processGender,
"get": self._processGet,
"gossip": self._processGossip,
"id": self._processId,
"input": self._processInput,
"javascript": self._processJavascript,
"learn": self._processLearn,
"li": self._processLi,
"lowercase": self._processLowercase,
"person": self._processPerson,
"person2": self._processPerson2,
"plugin": self._processPlugin,
"random": self._processRandom,
"text": self._processText,
"sentence": self._processSentence,
"set": self._processSet,
"size": self._processSize,
"sr": self._processSr,
"srai": self._processSrai,
"star": self._processStar,
"system": self._processSystem,
"template": self._processTemplate,
"that": self._processThat,
"thatstar": self._processThatstar,
"think": self._processThink,
"topicstar": self._processTopicstar,
"uppercase": self._processUppercase,
"version": self._processVersion,
}
def __init__(self):
self._verboseMode = True
self._version = "python-aiml {}".format(VERSION)
self._brain = PatternMgr()
self._respondLock = threading.RLock()
self.setTextEncoding( None if PY3 else "utf-8" )
# 建立会话
self._sessions = {}
self._addSession(self._globalSessionID)
# 设置机器人谓词
self._botPredicates = {}
self.setBotPredicate("name", "Nameless")
# 设置单词替换器 (subbers)，来自WordSub文件:
self._subbers = {}
self._subbers['gender'] = WordSub(DefaultSubs.defaultGender)
self._subbers['person'] = WordSub(DefaultSubs.defaultPerson)
self._subbers['person2'] = WordSub(DefaultSubs.defaultPerson2)
self._subbers['normal'] = WordSub(DefaultSubs.defaultNormal)
# 设置元素处理器
self._elementProcessors = {
"bot": self._processBot,
"condition": self._processCondition,
"date": self._processDate,
"formal": self._processFormal,
"gender": self._processGender,
"get": self._processGet,
"gossip": self._processGossip,
"id": self._processId,
"input": self._processInput,
"javascript": self._processJavascript,
"learn": self._processLearn,
"li": self._processLi,
"lowercase": self._processLowercase,
"person": self._processPerson,
"person2": self._processPerson2,
"random": self._processRandom,
"text": self._processText,
"sentence": self._processSentence,
"set": self._processSet,
"size": self._processSize,
"sr": self._processSr,
"srai": self._processSrai,
"star": self._processStar,
"system": self._processSystem,
"template": self._processTemplate,
"that": self._processThat,
"thatstar": self._processThatstar,
"think": self._processThink,
"topicstar": self._processTopicstar,
"uppercase": self._processUppercase,
"version": self._processVersion,
}
def __init__(self):
self._verboseMode = True
self._version = "PyAIML 0.8.6"
self._brain = PatternMgr()
self._respondLock = threading.RLock()
self._textEncoding = "utf-8"
# set up the sessions
self._sessions = {}
self._addSession(self._globalSessionID)
# Set up the bot predicates
self._botPredicates = {}
#self.setBotPredicate("master", "alpha")
# set up the word substitutors (subbers):
self._subbers = {}
self.settings_costum("ai/static/aimldb/Settings.xml")
self.subs_costum("ai/static/aimldb/Substitutions.xml")
self._subbers['gender'] = WordSub(DefaultSubs.defaultGender)
self._subbers['person'] = WordSub(DefaultSubs.defaultPerson)
self._subbers['person2'] = WordSub(DefaultSubs.defaultPerson2)
self._subbers['normal'] = WordSub(DefaultSubs.defaultNormal)
# set up the element processors
self._elementProcessors = {
"bot": self._processBot,
"condition": self._processCondition,
"date": self._processDate,
"formal": self._processFormal,
"gender": self._processGender,
"get": self._processGet,
"gossip": self._processGossip,
"id": self._processId,
"input": self._processInput,
"javascript": self._processJavascript,
"learn": self._processLearn,
"li": self._processLi,
"lowercase": self._processLowercase,
"person": self._processPerson,
"person2": self._processPerson2,
"random": self._processRandom,
"text": self._processText,
"sentence": self._processSentence,
"set": self._processSet,
"size": self._processSize,
"sr": self._processSr,
"srai": self._processSrai,
"star": self._processStar,
"system": self._processSystem,
"template": self._processTemplate,
"that": self._processThat,
"thatstar": self._processThatstar,
"think": self._processThink,
"topicstar": self._processTopicstar,
"uppercase": self._processUppercase,
"version": self._processVersion,
}
class Kernel:
# module constants
_globalSessionID = "_global" # key of the global session (duh)
_maxHistorySize = 10 # maximum length of the _inputs and _responses lists
_maxRecursionDepth = 100 # maximum number of recursive <srai>/<sr> tags before the response is aborted.
# special predicate keys
_inputHistory = "_inputHistory" # keys to a queue (list) of recent user input
_outputHistory = "_outputHistory" # keys to a queue (list) of recent responses.
_inputStack = "_inputStack" # Should always be empty in between calls to respond()
def __init__(self):
self._verboseMode = True
self._version = "PyAIML 0.8.6"
self._brain = PatternMgr()
self._respondLock = threading.RLock()
self._textEncoding = "utf-8"
# set up the sessions
self._sessions = {}
self._addSession(self._globalSessionID)
# Set up the bot predicates
self._botPredicates = {}
self.setBotPredicate("name", "Nameless")
# set up the word substitutors (subbers):
self._subbers = {}
self._subbers['gender'] = WordSub(DefaultSubs.defaultGender)
self._subbers['person'] = WordSub(DefaultSubs.defaultPerson)
self._subbers['person2'] = WordSub(DefaultSubs.defaultPerson2)
self._subbers['normal'] = WordSub(DefaultSubs.defaultNormal)
# set up the element processors
self._elementProcessors = {
"bot": self._processBot,
"condition": self._processCondition,
"date": self._processDate,
"formal": self._processFormal,
"gender": self._processGender,
"get": self._processGet,
"gossip": self._processGossip,
"id": self._processId,
"input": self._processInput,
"javascript": self._processJavascript,
"learn": self._processLearn,
"li": self._processLi,
"lowercase": self._processLowercase,
"person": self._processPerson,
"person2": self._processPerson2,
"random": self._processRandom,
"text": self._processText,
"sentence": self._processSentence,
"set": self._processSet,
"size": self._processSize,
"sr": self._processSr,
"srai": self._processSrai,
"star": self._processStar,
"system": self._processSystem,
"template": self._processTemplate,
"that": self._processThat,
"thatstar": self._processThatstar,
"think": self._processThink,
"topicstar": self._processTopicstar,
"uppercase": self._processUppercase,
"version": self._processVersion,
}
def bootstrap(self, brainFile=None, learnFiles=[], commands=[]):
"""Prepare a Kernel object for use.
If a brainFile argument is provided, the Kernel attempts to
load the brain at the specified filename.
If learnFiles is provided, the Kernel attempts to load the
specified AIML files.
Finally, each of the input strings in the commands list is
passed to respond().
"""
start = time.clock()
if brainFile:
self.loadBrain(brainFile)
# learnFiles might be a string, in which case it should be
# turned into a single-element list.
learns = learnFiles
try:
learns = [learnFiles + ""]
except:
pass
for file in learns:
self.learn(file)
# ditto for commands
cmds = commands
try:
cmds = [commands + ""]
except:
pass
for cmd in cmds:
print self._respond(cmd, self._globalSessionID)
if self._verboseMode:
print "Kernel bootstrap completed in %.2f seconds" % (
time.clock() - start)
def verbose(self, isVerbose=True):
"""Enable/disable verbose output mode."""
self._verboseMode = isVerbose
def version(self):
"""Return the Kernel's version string."""
return self._version
def numCategories(self):
"""Return the number of categories the Kernel has learned."""
# there's a one-to-one mapping between templates and categories
return self._brain.numTemplates()
def resetBrain(self):
"""Reset the brain to its initial state.
This is essentially equivilant to:
del(kern)
kern = aiml.Kernel()
"""
del (self._brain)
self.__init__()
def loadBrain(self, filename):
"""Attempt to load a previously-saved 'brain' from the
specified filename.
NOTE: the current contents of the 'brain' will be discarded!
"""
if self._verboseMode: print "Loading brain from %s..." % filename,
start = time.clock()
self._brain.restore(filename)
if self._verboseMode:
end = time.clock() - start
print "done (%d categories in %.2f seconds)" % (
self._brain.numTemplates(), end)
def saveBrain(self, filename):
"""Dump the contents of the bot's brain to a file on disk."""
if self._verboseMode: print "Saving brain to %s..." % filename,
start = time.clock()
self._brain.save(filename)
if self._verboseMode:
print "done (%.2f seconds)" % (time.clock() - start)
def getPredicate(self, name, sessionID=_globalSessionID):
"""Retrieve the current value of the predicate 'name' from the
specified session.
If name is not a valid predicate in the session, the empty
string is returned.
"""
try:
return self._sessions[sessionID][name]
except KeyError:
return ""
def setPredicate(self, name, value, sessionID=_globalSessionID):
"""Set the value of the predicate 'name' in the specified
session.
If sessionID is not a valid session, it will be created. If
name is not a valid predicate in the session, it will be
created.
"""
self._addSession(
sessionID) # add the session, if it doesn't already exist.
self._sessions[sessionID][name] = value
def getBotPredicate(self, name):
"""Retrieve the value of the specified bot predicate.
If name is not a valid bot predicate, the empty string is returned.
"""
try:
return self._botPredicates[name]
except KeyError:
return ""
def setBotPredicate(self, name, value):
"""Set the value of the specified bot predicate.
If name is not a valid bot predicate, it will be created.
"""
self._botPredicates[name] = value
# Clumsy hack: if updating the bot name, we must update the
# name in the brain as well
if name == "name":
self._brain.setBotName(self.getBotPredicate("name"))
def setTextEncoding(self, encoding):
"""Set the text encoding used when loading AIML files (Latin-1, UTF-8, etc.)."""
self._textEncoding = encoding
def loadSubs(self, filename):
"""Load a substitutions file.
The file must be in the Windows-style INI format (see the
standard ConfigParser module docs for information on this
format). Each section of the file is loaded into its own
substituter.
"""
inFile = file(filename)
parser = ConfigParser()
parser.readfp(inFile, filename)
inFile.close()
for s in parser.sections():
# Add a new WordSub instance for this section. If one already
# exists, delete it.
if self._subbers.has_key(s):
del (self._subbers[s])
self._subbers[s] = WordSub()
# iterate over the key,value pairs and add them to the subber
for k, v in parser.items(s):
self._subbers[s][k] = v
def _addSession(self, sessionID):
"""Create a new session with the specified ID string."""
if self._sessions.has_key(sessionID):
return
# Create the session.
self._sessions[sessionID] = {
# Initialize the special reserved predicates
self._inputHistory: [],
self._outputHistory: [],
self._inputStack: []
}
def _deleteSession(self, sessionID):
"""Delete the specified session."""
if self._sessions.has_key(sessionID):
_sessions.pop(sessionID)
def getSessionData(self, sessionID=None):
"""Return a copy of the session data dictionary for the
specified session.
If no sessionID is specified, return a dictionary containing
*all* of the individual session dictionaries.
"""
s = None
if sessionID is not None:
try:
s = self._sessions[sessionID]
except KeyError:
s = {}
else:
s = self._sessions
return copy.deepcopy(s)
def learn(self, filename):
"""Load and learn the contents of the specified AIML file.
If filename includes wildcard characters, all matching files
will be loaded and learned.
"""
for f in glob.glob(filename):
if self._verboseMode: print "Loading %s..." % f,
start = time.clock()
# Load and parse the AIML file.
parser = AimlParser.create_parser()
handler = parser.getContentHandler()
handler.setEncoding(self._textEncoding)
try:
parser.parse(f)
except xml.sax.SAXParseException, msg:
err = "\nFATAL PARSE ERROR in file %s:\n%s\n" % (f, msg)
sys.stderr.write(err)
continue
# store the pattern/template pairs in the PatternMgr.
for key, tem in handler.categories.items():
self._brain.add(key, tem)
# Parsing was successful.
if self._verboseMode:
print "done (%.2f seconds)" % (time.clock() - start)
def __init__(self):
self._verboseMode = True
self._version = "PyAIML 0.8.6"
self._brain = PatternMgr()
self._respondLock = threading.RLock()
self._textEncoding = "utf-8"
# set up the sessions
self._sessions = {}
self._addSession(self._globalSessionID)
# Set up the bot predicates
self._botPredicates = {}
self.setBotPredicate("name", "Freezer")
self.setBotPredicate("botmaster", "Jose Quintero")
year_of_birth=2013
self.setBotPredicate("anyo_nacimiento", str(year_of_birth))
age=date.today().year-2013
self.setBotPredicate("edad", str(age))
# set up the word substitutors (subbers):
self._subbers = {}
self._subbers['gender'] = WordSub(DefaultSubs.defaultGender)
self._subbers['person'] = WordSub(DefaultSubs.defaultPerson)
self._subbers['person2'] = WordSub(DefaultSubs.defaultPerson2)
self._subbers['normal'] = WordSub(DefaultSubs.defaultNormal)
# set up the element processors
self._elementProcessors = {
"bot": self._processBot,
"condition": self._processCondition,
"date": self._processDate,
"formal": self._processFormal,
"gender": self._processGender,
"get": self._processGet,
"gossip": self._processGossip,
"id": self._processId,
"input": self._processInput,
"javascript": self._processJavascript,
"learn": self._processLearn,
"li": self._processLi,
"lowercase": self._processLowercase,
"person": self._processPerson,
"person2": self._processPerson2,
"random": self._processRandom,
"text": self._processText,
"sentence": self._processSentence,
"set": self._processSet,
"size": self._processSize,
"sr": self._processSr,
"srai": self._processSrai,
"star": self._processStar,
"system": self._processSystem,
"template": self._processTemplate,
"that": self._processThat,
"thatstar": self._processThatstar,
"think": self._processThink,
"topicstar": self._processTopicstar,
"uppercase": self._processUppercase,
"version": self._processVersion,
}
class Kernel:
# module constants
_globalSessionID = "_global" # key of the global session (duh)
_maxHistorySize = 10 # maximum length of the _inputs and _responses lists
_maxRecursionDepth = 1000 # maximum number of recursive <srai>/<sr> tags before the response is aborted.
# special predicate keys
_inputHistory = "_inputHistory" # keys to a queue (list) of recent user input
_outputHistory = "_outputHistory" # keys to a queue (list) of recent responses.
_inputStack = "_inputStack" # Should always be empty in between calls to respond()
def __init__(self):
self._verboseMode = True
self._version = "PyAIML 0.8.6"
self._brain = PatternMgr()
self._respondLock = threading.RLock()
self._textEncoding = "utf-8"
# set up the sessions
self._sessions = {}
self._addSession(self._globalSessionID)
# Set up the bot predicates
self._botPredicates = {}
self.setBotPredicate("name", "Freezer")
self.setBotPredicate("botmaster", "Jose Quintero")
year_of_birth=2013
self.setBotPredicate("anyo_nacimiento", str(year_of_birth))
age=date.today().year-2013
self.setBotPredicate("edad", str(age))
# set up the word substitutors (subbers):
self._subbers = {}
self._subbers['gender'] = WordSub(DefaultSubs.defaultGender)
self._subbers['person'] = WordSub(DefaultSubs.defaultPerson)
self._subbers['person2'] = WordSub(DefaultSubs.defaultPerson2)
self._subbers['normal'] = WordSub(DefaultSubs.defaultNormal)
# set up the element processors
self._elementProcessors = {
"bot": self._processBot,
"condition": self._processCondition,
"date": self._processDate,
"formal": self._processFormal,
"gender": self._processGender,
"get": self._processGet,
"gossip": self._processGossip,
"id": self._processId,
"input": self._processInput,
"javascript": self._processJavascript,
"learn": self._processLearn,
"li": self._processLi,
"lowercase": self._processLowercase,
"person": self._processPerson,
"person2": self._processPerson2,
"random": self._processRandom,
"text": self._processText,
"sentence": self._processSentence,
"set": self._processSet,
"size": self._processSize,
"sr": self._processSr,
"srai": self._processSrai,
"star": self._processStar,
"system": self._processSystem,
"template": self._processTemplate,
"that": self._processThat,
"thatstar": self._processThatstar,
"think": self._processThink,
"topicstar": self._processTopicstar,
"uppercase": self._processUppercase,
"version": self._processVersion,
}
def bootstrap(self, brainFile = None, learnFiles = [], commands = []):
"""Prepare a Kernel object for use.
If a brainFile argument is provided, the Kernel attempts to
load the brain at the specified filename.
If learnFiles is provided, the Kernel attempts to load the
specified AIML files.
Finally, each of the input strings in the commands list is
passed to respond().
"""
start = time.clock()
if brainFile:
self.loadBrain(brainFile)
# learnFiles might be a string, in which case it should be
# turned into a single-element list.
learns = learnFiles
try: learns = [ learnFiles + "" ]
except: pass
for file in learns:
self.learn(file)
# ditto for commands
cmds = commands
try: cmds = [ commands + "" ]
except: pass
for cmd in cmds:
print self._respond(cmd, self._globalSessionID)
if self._verboseMode:
print "Kernel bootstrap completed in %.2f seconds" % (time.clock() - start)
def verbose(self, isVerbose = True):
"""Enable/disable verbose output mode."""
self._verboseMode = isVerbose
def version(self):
"""Return the Kernel's version string."""
return self._version
def numCategories(self):
"""Return the number of categories the Kernel has learned."""
# there's a one-to-one mapping between templates and categories
return self._brain.numTemplates()
def resetBrain(self):
"""Reset the brain to its initial state.
This is essentially equivilant to:
del(kern)
kern = aiml.Kernel()
"""
del(self._brain)
self.__init__()
def loadBrain(self, filename):
"""Attempt to load a previously-saved 'brain' from the
specified filename.
NOTE: the current contents of the 'brain' will be discarded!
"""
if self._verboseMode: print "Loading brain from %s..." % filename,
start = time.clock()
self._brain.restore(filename)
if self._verboseMode:
end = time.clock() - start
print "done (%d categories in %.2f seconds)" % (self._brain.numTemplates(), end)
def saveBrain(self, filename):
"""Dump the contents of the bot's brain to a file on disk."""
if self._verboseMode: print "Saving brain to %s..." % filename,
start = time.clock()
self._brain.save(filename)
if self._verboseMode:
print "done (%.2f seconds)" % (time.clock() - start)
def getPredicate(self, name, sessionID = _globalSessionID):
"""Retrieve the current value of the predicate 'name' from the
specified session.
If name is not a valid predicate in the session, the empty
string is returned.
"""
try: return self._sessions[sessionID][name]
except KeyError: return ""
def setPredicate(self, name, value, sessionID = _globalSessionID):
"""Set the value of the predicate 'name' in the specified
session.
If sessionID is not a valid session, it will be created. If
name is not a valid predicate in the session, it will be
created.
"""
self._addSession(sessionID) # add the session, if it doesn't already exist.
self._sessions[sessionID][name] = value
def getBotPredicate(self, name):
"""Retrieve the value of the specified bot predicate.
If name is not a valid bot predicate, the empty string is returned.
"""
try: return self._botPredicates[name]
except KeyError: return ""
def setBotPredicate(self, name, value):
"""Set the value of the specified bot predicate.
If name is not a valid bot predicate, it will be created.
"""
self._botPredicates[name] = value
# Clumsy hack: if updating the bot name, we must update the
# name in the brain as well
if name == "name":
self._brain.setBotName(self.getBotPredicate("name"))
def setTextEncoding(self, encoding):
"""Set the text encoding used when loading AIML files (Latin-1, UTF-8, etc.)."""
self._textEncoding = encoding
def loadSubs(self, filename):
"""Load a substitutions file.
The file must be in the Windows-style INI format (see the
standard ConfigParser module docs for information on this
format). Each section of the file is loaded into its own
substituter.
"""
inFile = file(filename)
parser = ConfigParser()
parser.readfp(inFile, filename)
inFile.close()
for s in parser.sections():
# Add a new WordSub instance for this section. If one already
# exists, delete it.
if self._subbers.has_key(s):
del(self._subbers[s])
self._subbers[s] = WordSub()
# iterate over the key,value pairs and add them to the subber
for k,v in parser.items(s):
self._subbers[s][k] = v
def _addSession(self, sessionID):
"""Create a new session with the specified ID string."""
if self._sessions.has_key(sessionID):
return
# Create the session.
self._sessions[sessionID] = {
# Initialize the special reserved predicates
self._inputHistory: [],
self._outputHistory: [],
self._inputStack: []
}
def _deleteSession(self, sessionID):
"""Delete the specified session."""
if self._sessions.has_key(sessionID):
_sessions.pop(sessionID)
def getSessionData(self, sessionID = None):
"""Return a copy of the session data dictionary for the
specified session.
If no sessionID is specified, return a dictionary containing
*all* of the individual session dictionaries.
"""
s = None
if sessionID is not None:
try: s = self._sessions[sessionID]
except KeyError: s = {}
else:
s = self._sessions
return copy.deepcopy(s)
def learn(self, filename):
"""Load and learn the contents of the specified AIML file.
If filename includes wildcard characters, all matching files
will be loaded and learned.
"""
for f in glob.glob(filename):
if self._verboseMode: print "Loading %s..." % f,
start = time.clock()
# Load and parse the AIML file.
parser = AimlParser.create_parser()
handler = parser.getContentHandler()
handler.setEncoding(self._textEncoding)
try: parser.parse(f)
except xml.sax.SAXParseException, msg:
err = "\nFATAL PARSE ERROR in file %s:\n%s\n" % (f,msg)
sys.stderr.write(err)
continue
# store the pattern/template pairs in the PatternMgr.
for key,tem in handler.categories.items():
self._brain.add(key,tem)
# Parsing was successful.
if self._verboseMode:
print "done (%.2f seconds)" % (time.clock() - start)
class Kernel:
# module constants
_globalSessionID = "_global" # 全局会话的key (duh)
_maxHistorySize = 10 # _inputs 与 _responses列表的最大长度。能记忆最近多少个问答对。
_maxRecursionDepth = 100 # 在响应中止之前 <srai>/<sr> 标签允许的最大递归深度
# special predicate keys 特殊的谓词键
_inputHistory = "_inputHistory" # 最近用户输入queue (list) 的 keys
_outputHistory = "_outputHistory" # 最近响应 queue (list) 的 keys
_inputStack = "_inputStack" # 在两次调用 respond() 之间，应该经常为空
def __init__(self):
self._verboseMode = True
self._version = "python-aiml {}".format(VERSION)
self._brain = PatternMgr()
self._respondLock = threading.RLock()
self.setTextEncoding( None if PY3 else "utf-8" )
# 建立会话
self._sessions = {}
self._addSession(self._globalSessionID)
# 设置机器人谓词
self._botPredicates = {}
self.setBotPredicate("name", "Nameless")
# 设置单词替换器 (subbers)，来自WordSub文件:
self._subbers = {}
self._subbers['gender'] = WordSub(DefaultSubs.defaultGender)
self._subbers['person'] = WordSub(DefaultSubs.defaultPerson)
self._subbers['person2'] = WordSub(DefaultSubs.defaultPerson2)
self._subbers['normal'] = WordSub(DefaultSubs.defaultNormal)
# 设置元素处理器
self._elementProcessors = {
"bot": self._processBot,
"condition": self._processCondition,
"date": self._processDate,
"formal": self._processFormal,
"gender": self._processGender,
"get": self._processGet,
"gossip": self._processGossip,
"id": self._processId,
"input": self._processInput,
"javascript": self._processJavascript,
"learn": self._processLearn,
"li": self._processLi,
"lowercase": self._processLowercase,
"person": self._processPerson,
"person2": self._processPerson2,
"random": self._processRandom,
"text": self._processText,
"sentence": self._processSentence,
"set": self._processSet,
"size": self._processSize,
"sr": self._processSr,
"srai": self._processSrai,
"star": self._processStar,
"system": self._processSystem,
"template": self._processTemplate,
"that": self._processThat,
"thatstar": self._processThatstar,
"think": self._processThink,
"topicstar": self._processTopicstar,
"uppercase": self._processUppercase,
"version": self._processVersion,
}
def bootstrap(self, brainFile = None, learnFiles = [], commands = [],
chdir=None):
"""准备一个内核对象以供使用。
如果提供了brainFile参数，则内核尝试以指定的文件名加载大脑。
如果提供了learnFiles，则内核将尝试加载指定的AIML文件。
最后，命令列表中的每个输入字符串都被传递给respond（）。
在执行任何学习或命令执行之前（但是在loadBrain处理之后），`chdir`参数会使其更改为该目录。
返回后，当前目录将移回原来的位置。 """
start = time.clock()
if brainFile:
self.loadBrain(brainFile)
prev = os.getcwd()
try:
if chdir:
os.chdir( chdir )
# learnFiles可能是一个字符串，在这种情况下应该转换成成一个单一的元素列表。
if isinstance( learnFiles, (str,unicode) ):
learnFiles = (learnFiles,)
for file in learnFiles:
self.learn(file)
# commands 也一样
if isinstance( commands, (str,unicode) ):
commands = (commands,)
for cmd in commands:
print( self._respond(cmd, self._globalSessionID) )
finally:
if chdir:
os.chdir( prev )
if self._verboseMode:
print( "Kernel bootstrap completed in %.2f seconds" % (time.clock() - start) )
def verbose(self, isVerbose = True):
"""启用/禁用详细输出模式。"""
self._verboseMode = isVerbose
def version(self):
"""返回 Kernel's 版本字符串.."""
return self._version
def numCategories(self):
"""返回内核学到的类别数量。"""
#模板和类别templates and categories 之间有一对一的映射
return self._brain.numTemplates()
def resetBrain(self):
"""重置大脑到其初始状态。 这实质上相当于：
del(kern)
kern = aiml.Kernel() """
del(self._brain)
self.__init__()
def loadBrain(self, filename):
"""尝试从指定的文件名加载以前保存的“大脑”。
注意：“大脑”的当前内容将被丢弃！ """
if self._verboseMode: print( "Loading brain from %s..." % filename, end="" )
start = time.clock()
self._brain.restore(filename)
if self._verboseMode:
end = time.clock() - start
print( "done (%d categories in %.2f seconds)" % (self._brain.numTemplates(), end) )
def saveBrain(self, filename):
"""将bot的大脑内容转储到磁盘上的文件中。"""
if self._verboseMode: print( "Saving brain to %s..." % filename, end="")
start = time.clock()
self._brain.save(filename)
if self._verboseMode:
print( "done (%.2f seconds)" % (time.clock() - start) )
def getPredicate(self, name, sessionID = _globalSessionID):
"""从指定的会话中检索谓词“名称”的当前值。
如果名称在会话中不是有效的谓词，则返回空字符串。 """
try: return self._sessions[sessionID][name]
except KeyError: return ""
def setPredicate(self, name, value, sessionID = _globalSessionID):
"""在指定的会话中设置谓词“名称”的值。
如果sessionID不是有效的会话，它将被创建。 如果名称在会话中不是一个有效的谓词，它将被创建。 """
self._addSession(sessionID) # 如果不存在，则添加会话。
self._sessions[sessionID][name] = value
def getBotPredicate(self, name):
"""取回指定的bot谓词的值。 如果名称不是有效的bot谓词，则返回空字符串。 """
try: return self._botPredicates[name]
except KeyError: return ""
def setBotPredicate(self, name, value):
"""设置指定的bot谓词的值。 如果名称不是有效的bot谓词，将会创建。 """
self._botPredicates[name] = value
# Clumsy hack: 如果更新机器人名称，我们也必须更新大脑中的名称。
if name == "name":
self._brain.setBotName(self.getBotPredicate("name"))
def setTextEncoding(self, encoding ):
"""
设置想要的 I/O 文本编码。 从 AIML文件加载的所有内容都会转换成指定的编码形式。
respond() 方法 is expected to be passed strings encoded with it (str in Py2, bytes in Py3) ，而且也将返回 them.
如果为False, 那么 strings 被假定不需要解码, 也就是说，文本将是 unicode 字符串 (unicode in Py2, str in Py3)。
"""
self._textEncoding = encoding
self._cod = msg_encoder( encoding )
def loadSubs(self, filename):
""""加载替换文件。
该文件必须采用Windows风格的INI格式（有关此格式的信息，请参阅标准的ConfigParser模块文档）。
文件的每个部分都被加载到自己的替代者中。 """
parser = ConfigParser()
with open(filename) as f:
parser.read_file(f)
for s in parser.sections():
# 为此部分添加一个新的WordSub实例。 如果已经存在，请将其删除。
if s in self._subbers:
del(self._subbers[s])
self._subbers[s] = WordSub()
# 遍历键-值对，并将它们添加到subber 替换者
for k,v in parser.items(s):
self._subbers[s][k] = v
def _addSession(self, sessionID):
"""用指定的ID字符串创建一个新的会话."""
if sessionID in self._sessions:
return
# 创建会话
self._sessions[sessionID] = {
# 初始化特殊的保留谓词
self._inputHistory: [],
self._outputHistory: [],
self._inputStack: []
}
def _deleteSession(self, sessionID):
"""删除指定的会话."""
if sessionID in self._sessions:
self._sessions.pop(sessionID)
def getSessionData(self, sessionID = None):
"""返回指定会话的会话数据字典副本。
如果没有指定sessionID，则返回包含所有个体会话字典的字典。 """
s = None
if sessionID is not None:
try: s = self._sessions[sessionID]
except KeyError: s = {}
else:
s = self._sessions
return copy.deepcopy(s)
def learn(self, filename):
"""加载并学习指定的AIML文件的内容。
如果filename包含通配符，则所有匹配的文件都将被加载并学习。 """
for f in glob.glob(filename):
if self._verboseMode: print( "Loading %s..." % f, end="")
start = time.clock()
# 加载并解析 AIML 文件.
parser = create_parser()
handler = parser.getContentHandler()
handler.setEncoding(self._textEncoding)
try: parser.parse(f)
except xml.sax.SAXParseException as msg:
err = "\nFATAL PARSE ERROR in file %s:\n%s\n" % (f,msg)
sys.stderr.write(err)
continue
# 在PatternMgr 中保存 pattern/template 对 .
for key,tem in handler.categories.items():
self._brain.add(key,tem)
# 解析是成功的。
if self._verboseMode:
print( "done (%.2f seconds)" % (time.clock() - start) )
def respond(self, input_, sessionID = _globalSessionID):
"""返回内核对输入字符串的响应。"""
if len(input_) == 0:
return u""
# 确保输入是一个 unicode 字符串
try: input_ = self._cod.dec(input_)
except UnicodeError: pass
except AttributeError: pass
# 防止其他线程践踏我们。
self._respondLock.acquire()
try:
self._addSession(sessionID) # 如果会话不存在，添加会话
# ?????? discrete ???????
sentences = Utils.sentences(input_)
finalResponse = u""
for s in sentences:
# ???????????????????????<input />???????
inputHistory = self.getPredicate(self._inputHistory, sessionID)
inputHistory.append(s)
while len(inputHistory) > self._maxHistorySize:
inputHistory.pop(0)
self.setPredicate(self._inputHistory, inputHistory, sessionID)
response = self._respond(s, sessionID) # Fetch ??
# add the data from this exchange to ????
outputHistory = self.getPredicate(self._outputHistory, sessionID)
outputHistory.append(response)
while len(outputHistory) > self._maxHistorySize:
outputHistory.pop(0)
self.setPredicate(self._outputHistory, outputHistory, sessionID)
finalResponse += (response + u" ") # ???????? the final response.?
finalResponse = finalResponse.strip()
#print( "@ASSERT", self.getPredicate(self._inputStack, sessionID))
assert(len(self.getPredicate(self._inputStack, sessionID)) == 0)
return self._cod.enc(finalResponse) # ????, ???? ??? I/O encoding
finally: # 释放资源锁
self._respondLock.release()
# 这个版本的_respond()只是获取一些输入的响应。 它不会混淆输入和输出历史。
# 从<srai>标签产生的递归调用response()应该调用这个函数，而不是respond()。
def _respond(self, input_, sessionID):
""" respond() 的私有版本, does the real work."""
if len(input_) == 0:
return u""
# 警惕无限递归！
inputStack = self.getPredicate(self._inputStack, sessionID)
if len(inputStack) > self._maxRecursionDepth:
if self._verboseMode:
err = u"警告: 超过最大递归深度！ (input='%s')" % self._cod.enc(input_)
sys.stderr.write(err)
return u""
# 将输入压入输入栈
inputStack = self.getPredicate(self._inputStack, sessionID)
inputStack.append(input_)
self.setPredicate(self._inputStack, inputStack, sessionID)
# 通过“normal”的subber 运行输入，做一些替换
subbedInput = self._subbers['normal'].sub(input_)
# 获取机器人以前的响应，以“that”的形式传递给match（）函数。.
outputHistory = self.getPredicate(self._outputHistory, sessionID)
try: that = outputHistory[-1]
except IndexError: that = ""
subbedThat = self._subbers['normal'].sub(that)
# 获取当前的 topic
topic = self.getPredicate("topic", sessionID)
subbedTopic = self._subbers['normal'].sub(topic)
response = u"" # 确定最终的回应。
elem = self._brain.match(subbedInput, subbedThat, subbedTopic)
if elem is None:
if self._verboseMode:
err = "WARNING: No match found for input: %s\n" % self._cod.enc(input_)
sys.stderr.write(err)
else:
# 将元素处理为响应字符串。
response += self._processElement(elem, sessionID).strip()
response += u" "
response = response.strip()
# 从输入堆栈弹出顶部条目。
inputStack = self.getPredicate(self._inputStack, sessionID)
inputStack.pop()
self.setPredicate(self._inputStack, inputStack, sessionID)
return response
def _processElement(self,elem, sessionID):
"""处理一个 AIML 元素。
元素列表的第一项是元素的XML标签的名称。 第二项是包含传递给该标签的任何属性及其值的字典。
列表中的任何其他项目都是当前元素的开始和结束标记所包含的元素; 它们由每个元素的处理函数处理。 """
try:
handlerFunc = self._elementProcessors[elem[0]]
except:
# 糟糕 - 这个元素类型没有处理函数！
if self._verboseMode:
err = "WARNING: No handler found for <%s> element\n" % self._cod.enc(elem[0])
sys.stderr.write(err)
return u""
return handlerFunc(elem, sessionID)
######################################################
### 单独的元素处理函数如下 ###
######################################################
# <bot>
def _processBot(self, elem, sessionID):
""""处理一个 <bot> AIML 元素.
必需的元素属性：
name：要测试的谓词的名称。 value：测试谓词的值。
<condition>元素有三种口味。 每个都有不同的属性，每个属性的处理方式都不相同。
最简单的情况是当<condition>标签同时具有“名称”和“值”属性。 在这种情况下，如果谓词“名称”的值为“值”，则元素的内容将被处理并返回。
如果<condition>元素只有一个'name'属性，那么它的内容是一系列<li>元素，每个元素都有一个'value'属性。
从上到下扫描列表直到找到匹配。 可选地，最后一个<li>元素可以不具有“值”属性，在这种情况下，如果没有找到其他匹配，则处理它并返回。
如果<condition>元素既没有“name”也没有“value”属性，那么它的行为几乎和前面的情况一样，
除了每个<li>元素（除了可选的最后一个条目）现在都必须包含“name” 和“value”属性。 """
attrName = elem[1]['name']
return self.getBotPredicate(attrName)
# <condition>
def _processCondition(self, elem, sessionID):
"""处理一个 <condition> AIML 元素.
可选的元素属性：
name：要测试的谓词的名称。 value：测试谓词的值。
<condition>元素有三种口味。 每个都有不同的属性，每个属性的处理方式都不相同。
最简单的情况是当<condition>标签同时具有“名称”和“值”属性。 在这种情况下，如果谓词“名称”的值为“值”，则元素的内容将被处理并返回。
如果<condition>元素只有一个'name'属性，那么它的内容是一系列<li>元素，每个元素都有一个'value'属性。
从上到下扫描列表直到找到匹配。 可选地，最后一个<li>元素可以不具有“值”属性，在这种情况下，如果没有找到其他匹配，则处理它并返回。
如果<condition>元素既没有“name”也没有“value”属性，那么它的行为几乎和前面的情况一样，
除了每个<li>元素（除了可选的最后一个条目）现在都必须包含“name” 和“value”属性。 """
attr = None
response = ""
attr = elem[1]
# Case #1: test the value of a specific predicate for 测试一下 特定谓词的设置的特定值。
if 'name' in attr and 'value' in attr:
val = self.getPredicate(attr['name'], sessionID)
if val == attr['value']:
for e in elem[2:]:
response += self._processElement(e,sessionID)
return response
else:
# Case #2 and #3: 循环<li>内容，为每个内容测试名称和值对。
try:
name = attr.get('name',None)
# Get the list of <li> elemnents
listitems = []
for e in elem[2:]:
if e[0] == 'li':
listitems.append(e)
# 如果listitems为空，则返回空字符串
if len(listitems) == 0:
return ""
# 遍历列表寻找匹配的条件。
foundMatch = False
for li in listitems:
try:
liAttr = li[1]
# 如果这是最后一个列表项，则允许它没有属性。 我们现在就跳过它。
if len(liAttr) == 0 and li == listitems[-1]:
continue
# get the name of the predicate to test
liName = name
if liName == None:
liName = liAttr['name']
# get the value to check against
liValue = liAttr['value']
# do the test
if self.getPredicate(liName, sessionID) == liValue:
foundMatch = True
response += self._processElement(li,sessionID)
break
except:
# 没有属性，没有名称/值属性，没有这样的谓词/会话，或处理错误。
if self._verboseMode: print( "Something amiss -- skipping listitem", li )
raise
if not foundMatch:
# 检查listitems的最后一个元素。 如果它没有“名称”或“值”属性，则处理它。
try:
li = listitems[-1]
liAttr = li[1]
if not ('name' in liAttr or 'value' in liAttr):
response += self._processElement(li, sessionID)
except:
# listitems是空的，没有属性，缺少名称/值属性或处理错误。
if self._verboseMode: print( "error in default listitem" )
raise
except:
# 其他一些灾难性的灾难
if self._verboseMode: print( "catastrophic condition failure" )
raise
return response
# <date>
def _processDate(self, elem, sessionID):
"""处理 <date> AIML 元素.
<date> 元素 resolve to t当前日期和时间。
AIML 规格说明 没有对这一信息作出 任何特定格式 的要求, 所以就怎么简单怎么写。 """
return time.asctime()
# <formal>
def _processFormal(self, elem, sessionID):
"""Process a <formal> AIML element.
<formal> elements process their contents recursively, and then
capitalize the first letter of each word of the result.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
return string.capwords(response)
# <gender>
def _processGender(self,elem, sessionID):
"""Process a <gender> AIML element.
<gender> elements process their contents, and then swap the
gender of any third-person singular pronouns in the result.
This subsitution is handled by the aiml.WordSub module.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
return self._subbers['gender'].sub(response)
# <get>
def _processGet(self, elem, sessionID):
"""Process a <get> AIML element.
必要元素属性:
name: The name of the predicate whose value should be
retrieved from the specified session and returned. If the
predicate doesn't exist, the empty string is returned.
<get> elements return the value of a predicate from the
specified session.
"""
return self.getPredicate(elem[1]['name'], sessionID)
# <gossip>
def _processGossip(self, elem, sessionID):
"""Process a <gossip> AIML element.
<gossip> elements are used to capture and store user input in
an implementation-defined manner, theoretically allowing the
bot to learn from the people it chats with. I haven't
descided how to define my implementation, so right now
<gossip> behaves identically to <think>.
"""
return self._processThink(elem, sessionID)
# <id>
def _processId(self, elem, sessionID):
""" Process an <id> AIML element.
<id> elements return a unique "user id" for a specific
conversation. In PyAIML, the user id is the name of the
current session.
"""
return sessionID
# <input>
def _processInput(self, elem, sessionID):
"""处理<input> AIML 元素。
可选属性元素:
index: The index of the element from the history list to
return. 1 means the most recent item, 2 means the one
before that, and so on.
<input> elements return an entry from the input history for
the current session.
"""
inputHistory = self.getPredicate(self._inputHistory, sessionID)
try: index = int(elem[1]['index'])
except: index = 1
try: return inputHistory[-index]
except IndexError:
if self._verboseMode:
err = "No such index %d while processing <input> element.\n" % index
sys.stderr.write(err)
return ""
# <javascript>
def _processJavascript(self, elem, sessionID):
"""处理 <javascript> AIML 元素。
<javascript> elements process their contents recursively, and
then run the results through a server-side Javascript
interpreter to compute the final response. Implementations
are not required to provide an actual Javascript interpreter,
and right now PyAIML doesn't; <javascript> elements are behave
exactly like <think> elements.
"""
return self._processThink(elem, sessionID)
# <learn>
def _processLearn(self, elem, sessionID):
"""处理<learn> AIML 元素。.
<learn> elements process their contents recursively, and then
treat the result as an AIML file to open and learn.
"""
filename = ""
for e in elem[2:]:
filename += self._processElement(e, sessionID)
self.learn(filename)
return ""
# <li>
def _processLi(self,elem, sessionID):
"""Process an <li> AIML element.
可选属性元素:
name: the name of a predicate to query.
value: the value to check that predicate for.
<li> elements process their contents recursively and return
the results. They can only appear inside <condition> and
<random> elements. See _processCondition() and
_processRandom() for details of their usage.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
return response
# <lowercase>
def _processLowercase(self,elem, sessionID):
"""处理 <lowercase> AIML 元素。.
<lowercase> elements process their contents recursively, and
then convert the results to all-lowercase.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
return response.lower()
# <person>
def _processPerson(self,elem, sessionID):
"""处理 <person> AIML 元素。
<person> elements process their contents recursively, and then
convert all pronouns in the results from 1st person to 2nd
person, and vice versa. This subsitution is handled by the
aiml.WordSub module.
If the <person> tag is used atomically (e.g. <person/>), it is
a shortcut for <person><star/></person>.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
if len(elem[2:]) == 0: # atomic <person/> = <person><star/></person>
response = self._processElement(['star',{}], sessionID)
return self._subbers['person'].sub(response)
# <person2>
def _processPerson2(self,elem, sessionID):
"""处理 <person2> AIML 元素。
<person2> elements process their contents recursively, and then
convert all pronouns in the results from 1st person to 3rd
person, and vice versa. This subsitution is handled by the
aiml.WordSub module.
If the <person2> tag is used atomically (e.g. <person2/>), it is
a shortcut for <person2><star/></person2>.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
if len(elem[2:]) == 0: # atomic <person2/> = <person2><star/></person2>
response = self._processElement(['star',{}], sessionID)
return self._subbers['person2'].sub(response)
# <random>
def _processRandom(self, elem, sessionID):
"""处理 <random> AIML 元素。
<random> 元素包含0到多个 <li> 元素。 如果没有 , 回返回空字符串。
如果出现一个或多个 <li> 元素， 随机选取其中一个 processed recursively and have its results returned.
只有选定的 <li> 元素内容会被处理。 任何非-<li> 元素的内容都会被忽略。 """
listitems = []
for e in elem[2:]:
if e[0] == 'li':
listitems.append(e)
if len(listitems) == 0:
return ""
# select and process a random listitem.
random.shuffle(listitems)
return self._processElement(listitems[0], sessionID)
# <sentence>
def _processSentence(self,elem, sessionID):
"""Process a <sentence> AIML element.
<sentence> elements process their contents recursively, and
then capitalize the first letter of the results.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
try:
response = response.strip()
words = response.split(" ", 1)
words[0] = words[0].capitalize()
response = ' '.join(words)
return response
except IndexError: # response was empty
return ""
# <set>
def _processSet(self, elem, sessionID):
"""Process a <set> AIML element.
必要元素属性::
name: The name of the predicate to set.
<set> elements process their contents recursively, and assign the results to a predicate
(given by their 'name' attribute) in the current session. The contents of the element
are also returned.
"""
value = ""
for e in elem[2:]:
value += self._processElement(e, sessionID)
#print( "@ELEM", elem )
self.setPredicate(elem[1]['name'], value, sessionID)
return value
# <size>
def _processSize(self,elem, sessionID):
"""Process a <size> AIML element.
<size> elements return the number of AIML categories currently
in the bot's brain.
"""
return str(self.numCategories())
# <sr>
def _processSr(self,elem,sessionID):
"""Process an <sr> AIML element.
<sr> elements are shortcuts for <srai><star/></srai>.
"""
star = self._processElement(['star',{}], sessionID)
response = self._respond(star, sessionID)
return response
# <srai>
def _processSrai(self,elem, sessionID):
"""Process a <srai> AIML element.
<srai> elements recursively process their contents, and then
pass the results right back into the AIML interpreter as a new
piece of input. The results of this new input string are
returned.
"""
newInput = ""
for e in elem[2:]:
newInput += self._processElement(e, sessionID)
return self._respond(newInput, sessionID)
# <star>
def _processStar(self, elem, sessionID):
"""Process a <star> AIML element.
可选元素属性:
index: Which "*" character in the current pattern should
be matched?
<star> elements return the text fragment matched by the "*"
character in the current input pattern. For example, if the
input "Hello Tom Smith, how are you?" matched the pattern
"HELLO * HOW ARE YOU", then a <star> element in the template
would evaluate to "Tom Smith".
"""
try: index = int(elem[1]['index'])
except KeyError: index = 1
# fetch the user's last input
inputStack = self.getPredicate(self._inputStack, sessionID)
input_ = self._subbers['normal'].sub(inputStack[-1])
# fetch the Kernel's last response (for 'that' context)
outputHistory = self.getPredicate(self._outputHistory, sessionID)
try: that = self._subbers['normal'].sub(outputHistory[-1])
except: that = "" # there might not be any output yet
topic = self.getPredicate("topic", sessionID)
response = self._brain.star("star", input_, that, topic, index)
return response
# <system>
def _processSystem(self,elem, sessionID):
"""Process a <system> AIML element.
<system> elements process their contents recursively, and then
attempt to execute the results as a shell command on the
server. The AIML interpreter blocks until the command is
complete, and then returns the command's output.
For cross-platform compatibility, any file paths inside
<system> tags should use Unix-style forward slashes ("/") as a
directory separator.
"""
# build up the command string
command = ""
for e in elem[2:]:
command += self._processElement(e, sessionID)
# normalize the path to the command. Under Windows, this
# switches forward-slashes to back-slashes; all system
# elements should use unix-style paths for cross-platform
# compatibility.
#executable,args = command.split(" ", 1)
#executable = os.path.normpath(executable)
#command = executable + " " + args
command = os.path.normpath(command)
# execute the command.
response = ""
try:
out = os.popen(command)
except RuntimeError as msg:
if self._verboseMode:
err = "WARNING: RuntimeError while processing \"system\" element:\n%s\n" % self._cod.enc(msg)
sys.stderr.write(err)
return "There was an error while computing my response. Please inform my botmaster."
time.sleep(0.01) # I'm told this works around a potential IOError exception.
for line in out:
response += line + "\n"
response = ' '.join(response.splitlines()).strip()
return response
# <template>
def _processTemplate(self,elem, sessionID):
"""Process a <template> AIML element.
<template> elements recursively process their contents, and
return the results. <template> is the root node of any AIML
response tree.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
return response
# text
def _processText(self,elem, sessionID):
"""Process a raw text element.
Raw text elements aren't really AIML tags. Text elements cannot contain
other elements; instead, the third item of the 'elem' list is a text
string, which is immediately returned. They have a single attribute,
automatically inserted by the parser, which indicates whether whitespace
in the text should be preserved or not.
"""
try:
elem[2] + ""
except TypeError:
raise TypeError( "Text element contents are not text" )
# If the the whitespace behavior for this element is "default",
# we reduce all stretches of >1 whitespace characters to a single
# space. To improve performance, we do this only once for each
# text element encountered, and save the results for the future.
if elem[1]["xml:space"] == "default":
elem[2] = re.sub("\s+", " ", elem[2])
elem[1]["xml:space"] = "preserve"
return elem[2]
# <that>
def _processThat(self,elem, sessionID):
"""处理 <that> AIML 元素。
可选元素属性:
index: Specifies which element from the output history to
return. 1 is the most recent response, 2 is the next most
recent, and so on.
<that> elements (when they appear inside <template> elements)
are the output equivilant of <input> elements; they return one
of the Kernel's previous responses.
"""
outputHistory = self.getPredicate(self._outputHistory, sessionID)
index = 1
try:
# According to the AIML spec, the optional index attribute
# can either have the form "x" or "x,y". x refers to how
# far back in the output history to go. y refers to which
# sentence of the specified response to return.
index = int(elem[1]['index'].split(',')[0])
except:
pass
try: return outputHistory[-index]
except IndexError:
if self._verboseMode:
err = "No such index %d while processing <that> element.\n" % index
sys.stderr.write(err)
return ""
# <thatstar>
def _processThatstar(self, elem, sessionID):
"""处理 <thatstar> AIML 元素。
可选元素属性:
index: Specifies which "*" in the <that> pattern to match.
<thatstar> elements are similar to <star> elements, except
that where <star/> returns the portion of the input string
matched by a "*" character in the pattern, <thatstar/> returns
the portion of the previous input string that was matched by a
"*" in the current category's <that> pattern.
"""
try: index = int(elem[1]['index'])
except KeyError: index = 1
# fetch the user's last input
inputStack = self.getPredicate(self._inputStack, sessionID)
input_ = self._subbers['normal'].sub(inputStack[-1])
# fetch the Kernel's last response (for 'that' context)
outputHistory = self.getPredicate(self._outputHistory, sessionID)
try: that = self._subbers['normal'].sub(outputHistory[-1])
except: that = "" # there might not be any output yet
topic = self.getPredicate("topic", sessionID)
response = self._brain.star("thatstar", input_, that, topic, index)
return response
# <think>
def _processThink(self,elem, sessionID):
"""处理 <think> AIML 元素.
<think> 元素处理 their contents recursively, and then
discard the results and return the empty string. They're
useful for setting predicates and learning AIML files without
generating any output. """
for e in elem[2:]:
self._processElement(e, sessionID)
return ""
# <topicstar>
def _processTopicstar(self, elem, sessionID):
"""处理<topicstar> AIML 元素.
可选元素属性:
index: Specifies which "*" in the <topic> pattern to match.
<topicstar> 元素 similar to <star> 元素, except that where <star/> returns the portion of the input string
matched by a "*" character in the pattern, <topicstar/>
returns the portion of current topic string that was matched
by a "*" in 当前 category's <topic> 模式. """
try: index = int(elem[1]['index'])
except KeyError: index = 1
# fetch the user's last input
inputStack = self.getPredicate(self._inputStack, sessionID)
input_ = self._subbers['normal'].sub(inputStack[-1])
# fetch the Kernel's last response (for 'that' context)
outputHistory = self.getPredicate(self._outputHistory, sessionID)
try: that = self._subbers['normal'].sub(outputHistory[-1])
except: that = "" # there might not be any output yet
topic = self.getPredicate("topic", sessionID)
response = self._brain.star("topicstar", input_, that, topic, index)
return response
# <uppercase>
def _processUppercase(self,elem, sessionID):
"""处理 <uppercase> AIML 元素
<uppercase> 元素 process their contents recursively, and return the results with all lower-case characters converted to
upper-case.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
return response.upper()
# <version>
def _processVersion(self,elem, sessionID):
"""处理 <version> AIML 元素.
<version> 元素会返回 AIML 解释器的版本号 """
return self.version()
class Kernel:
# module constants
_globalSessionID = "_global" # key of the global session (duh)
_maxHistorySize = 10 # maximum length of the _inputs and _responses lists
_maxRecursionDepth = 100 # maximum number of recursive <srai>/<sr> tags before the response is aborted.
# special predicate keys
_inputHistory = "_inputHistory" # keys to a queue (list) of recent user input
_outputHistory = "_outputHistory" # keys to a queue (list) of recent responses.
_inputStack = "_inputStack" # Should always be empty in between calls to respond()
def __init__(self):
self._verboseMode = True
self._version = "PyAIML 0.8.6"
self._brain = PatternMgr()
self._respondLock = threading.RLock()
self._textEncoding = "utf-8"
# set up the sessions
self._sessions = {}
self._addSession(self._globalSessionID)
# Set up the bot predicates
self._botPredicates = {}
self.setBotPredicate("name", "Nameless")
# set up the word substitutors (subbers):
self._subbers = {}
self._subbers['gender'] = WordSub(DefaultSubs.defaultGender)
self._subbers['person'] = WordSub(DefaultSubs.defaultPerson)
self._subbers['person2'] = WordSub(DefaultSubs.defaultPerson2)
self._subbers['normal'] = WordSub(DefaultSubs.defaultNormal)
# set up the element processors
self._elementProcessors = {
"bot": self._processBot,
"condition": self._processCondition,
"date": self._processDate,
"formal": self._processFormal,
"gender": self._processGender,
"get": self._processGet,
"gossip": self._processGossip,
"id": self._processId,
"input": self._processInput,
"javascript": self._processJavascript,
"learn": self._processLearn,
"li": self._processLi,
"lowercase": self._processLowercase,
"person": self._processPerson,
"person2": self._processPerson2,
"random": self._processRandom,
"text": self._processText,
"sentence": self._processSentence,
"set": self._processSet,
"size": self._processSize,
"sr": self._processSr,
"srai": self._processSrai,
"star": self._processStar,
"system": self._processSystem,
"template": self._processTemplate,
"that": self._processThat,
"thatstar": self._processThatstar,
"think": self._processThink,
"topicstar": self._processTopicstar,
"uppercase": self._processUppercase,
"version": self._processVersion,
}
def bootstrap(self, brainFile = None, learnFiles = [], commands = []):
"""Prepare a Kernel object for use.
If a brainFile argument is provided, the Kernel attempts to
load the brain at the specified filename.
If learnFiles is provided, the Kernel attempts to load the
specified AIML files.
Finally, each of the input strings in the commands list is
passed to respond().
"""
start = time.clock()
if brainFile:
self.loadBrain(brainFile)
# learnFiles might be a string, in which case it should be
# turned into a single-element list.
learns = learnFiles
try: learns = [ learnFiles + "" ]
except: pass
for file in learns:
self.learn(file)
# ditto for commands
cmds = commands
try: cmds = [ commands + "" ]
except: pass
for cmd in cmds:
print(self._respond(cmd, self._globalSessionID))
if self._verboseMode:
print("Kernel bootstrap completed in %.2f seconds" % (time.clock() - start))
def verbose(self, isVerbose = True):
"""Enable/disable verbose output mode."""
self._verboseMode = isVerbose
def version(self):
"""Return the Kernel's version string."""
return self._version
def numCategories(self):
"""Return the number of categories the Kernel has learned."""
# there's a one-to-one mapping between templates and categories
return self._brain.numTemplates()
def resetBrain(self):
"""Reset the brain to its initial state.
This is essentially equivilant to:
del(kern)
kern = aiml.Kernel()
"""
del(self._brain)
self.__init__()
def loadBrain(self, filename):
"""Attempt to load a previously-saved 'brain' from the
specified filename.
NOTE: the current contents of the 'brain' will be discarded!
"""
if self._verboseMode: print("Loading brain from %s..." % filename, end=' ')
start = time.clock()
self._brain.restore(filename)
if self._verboseMode:
end = time.clock() - start
print("done (%d categories in %.2f seconds)" % (self._brain.numTemplates(), end))
def saveBrain(self, filename):
"""Dump the contents of the bot's brain to a file on disk."""
if self._verboseMode: print("Saving brain to %s..." % filename, end=' ')
start = time.clock()
self._brain.save(filename)
if self._verboseMode:
print("done (%.2f seconds)" % (time.clock() - start))
def getPredicate(self, name, sessionID = _globalSessionID):
"""Retrieve the current value of the predicate 'name' from the
specified session.
If name is not a valid predicate in the session, the empty
string is returned.
"""
try: return self._sessions[sessionID][name]
except KeyError: return ""
def setPredicate(self, name, value, sessionID = _globalSessionID):
"""Set the value of the predicate 'name' in the specified
session.
If sessionID is not a valid session, it will be created. If
name is not a valid predicate in the session, it will be
created.
"""
self._addSession(sessionID) # add the session, if it doesn't already exist.
self._sessions[sessionID][name] = value
def getBotPredicate(self, name):
"""Retrieve the value of the specified bot predicate.
If name is not a valid bot predicate, the empty string is returned.
"""
try: return self._botPredicates[name]
except KeyError: return ""
def setBotPredicate(self, name, value):
"""Set the value of the specified bot predicate.
If name is not a valid bot predicate, it will be created.
"""
self._botPredicates[name] = value
# Clumsy hack: if updating the bot name, we must update the
# name in the brain as well
if name == "name":
self._brain.setBotName(self.getBotPredicate("name"))
def setTextEncoding(self, encoding):
"""Set the text encoding used when loading AIML files (Latin-1, UTF-8, etc.)."""
self._textEncoding = encoding
def loadSubs(self, filename):
"""Load a substitutions file.
The file must be in the Windows-style INI format (see the
standard ConfigParser module docs for information on this
format). Each section of the file is loaded into its own
substituter.
"""
inFile = file(filename)
parser = ConfigParser()
parser.readfp(inFile, filename)
inFile.close()
for s in parser.sections():
# Add a new WordSub instance for this section. If one already
# exists, delete it.
if s in self._subbers:
del(self._subbers[s])
self._subbers[s] = WordSub()
# iterate over the key,value pairs and add them to the subber
for k,v in parser.items(s):
self._subbers[s][k] = v
def _addSession(self, sessionID):
"""Create a new session with the specified ID string."""
if sessionID in self._sessions:
return
# Create the session.
self._sessions[sessionID] = {
# Initialize the special reserved predicates
self._inputHistory: [],
self._outputHistory: [],
self._inputStack: []
}
def _deleteSession(self, sessionID):
"""Delete the specified session."""
if sessionID in self._sessions:
_sessions.pop(sessionID)
def getSessionData(self, sessionID = None):
"""Return a copy of the session data dictionary for the
specified session.
If no sessionID is specified, return a dictionary containing
*all* of the individual session dictionaries.
"""
s = None
if sessionID is not None:
try: s = self._sessions[sessionID]
except KeyError: s = {}
else:
s = self._sessions
return copy.deepcopy(s)
def learn(self, filename):
"""Load and learn the contents of the specified AIML file.
If filename includes wildcard characters, all matching files
will be loaded and learned.
"""
for f in glob.glob(filename):
if self._verboseMode: print("Loading %s..." % f, end=' ')
start = time.clock()
# Load and parse the AIML file.
parser = AimlParser.create_parser()
handler = parser.getContentHandler()
handler.setEncoding(self._textEncoding)
try: parser.parse(f)
except xml.sax.SAXParseException as msg:
err = "\nFATAL PARSE ERROR in file %s:\n%s\n" % (f,msg)
sys.stderr.write(err)
continue
# store the pattern/template pairs in the PatternMgr.
for key,tem in list(handler.categories.items()):
self._brain.add(key,tem)
# Parsing was successful.
if self._verboseMode:
print("done (%.2f seconds)" % (time.clock() - start))
def respond(self, input, sessionID = _globalSessionID):
"""Return the Kernel's response to the input string."""
if len(input) == 0:
return ""
#ensure that input is a unicode string
try: input = input.decode(self._textEncoding, 'replace')
except UnicodeError: pass
except AttributeError: pass
# prevent other threads from stomping all over us.
self._respondLock.acquire()
# Add the session, if it doesn't already exist
self._addSession(sessionID)
# split the input into discrete sentences
sentences = Utils.sentences(input)
finalResponse = ""
for s in sentences:
# Add the input to the history list before fetching the
# response, so that <input/> tags work properly.
inputHistory = self.getPredicate(self._inputHistory, sessionID)
inputHistory.append(s)
while len(inputHistory) > self._maxHistorySize:
inputHistory.pop(0)
self.setPredicate(self._inputHistory, inputHistory, sessionID)
# Fetch the response
response = self._respond(s, sessionID)
# add the data from this exchange to the history lists
outputHistory = self.getPredicate(self._outputHistory, sessionID)
outputHistory.append(response)
while len(outputHistory) > self._maxHistorySize:
outputHistory.pop(0)
self.setPredicate(self._outputHistory, outputHistory, sessionID)
# append this response to the final response.
finalResponse += (response + " ")
finalResponse = finalResponse.strip()
assert(len(self.getPredicate(self._inputStack, sessionID)) == 0)
# release the lock and return
self._respondLock.release()
return finalResponse
# This version of _respond() just fetches the response for some input.
# It does not mess with the input and output histories. Recursive calls
# to respond() spawned from tags like <srai> should call this function
# instead of respond().
def _respond(self, input, sessionID):
"""Private version of respond(), does the real work."""
if len(input) == 0:
return ""
# guard against infinite recursion
inputStack = self.getPredicate(self._inputStack, sessionID)
if len(inputStack) > self._maxRecursionDepth:
if self._verboseMode:
err = "WARNING: maximum recursion depth exceeded (input='%s')" % input
sys.stderr.write(err)
return ""
# push the input onto the input stack
inputStack = self.getPredicate(self._inputStack, sessionID)
inputStack.append(input)
self.setPredicate(self._inputStack, inputStack, sessionID)
# run the input through the 'normal' subber
subbedInput = self._subbers['normal'].sub(input)
# fetch the bot's previous response, to pass to the match()
# function as 'that'.
outputHistory = self.getPredicate(self._outputHistory, sessionID)
try: that = outputHistory[-1]
except IndexError: that = ""
subbedThat = self._subbers['normal'].sub(that)
# fetch the current topic
topic = self.getPredicate("topic", sessionID)
subbedTopic = self._subbers['normal'].sub(topic)
# Determine the final response.
response = ""
elem = self._brain.match(subbedInput, subbedThat, subbedTopic)
if elem is None:
if self._verboseMode:
err = "WARNING: No match found for input: %s\n" % input
sys.stderr.write(err)
else:
# Process the element into a response string.
response += self._processElement(elem, sessionID).strip()
response += " "
response = response.strip()
# pop the top entry off the input stack.
inputStack = self.getPredicate(self._inputStack, sessionID)
inputStack.pop()
self.setPredicate(self._inputStack, inputStack, sessionID)
return response
def _processElement(self,elem, sessionID):
"""Process an AIML element.
The first item of the elem list is the name of the element's
XML tag. The second item is a dictionary containing any
attributes passed to that tag, and their values. Any further
items in the list are the elements enclosed by the current
element's begin and end tags; they are handled by each
element's handler function.
"""
try:
handlerFunc = self._elementProcessors[elem[0]]
except:
# Oops -- there's no handler function for this element
# type!
if self._verboseMode:
err = "WARNING: No handler found for <%s> element\n" % elem[0]
sys.stderr.write(err)
return ""
return handlerFunc(elem, sessionID)
######################################################
### Individual element-processing functions follow ###
######################################################
# <bot>
def _processBot(self, elem, sessionID):
"""Process a <bot> AIML element.
Required element attributes:
name: The name of the bot predicate to retrieve.
<bot> elements are used to fetch the value of global,
read-only "bot predicates." These predicates cannot be set
from within AIML; you must use the setBotPredicate() function.
"""
attrName = elem[1]['name']
return self.getBotPredicate(attrName)
# <condition>
def _processCondition(self, elem, sessionID):
"""Process a <condition> AIML element.
Optional element attributes:
name: The name of a predicate to test.
value: The value to test the predicate for.
<condition> elements come in three flavors. Each has different
attributes, and each handles their contents differently.
The simplest case is when the <condition> tag has both a 'name'
and a 'value' attribute. In this case, if the predicate
'name' has the value 'value', then the contents of the element
are processed and returned.
If the <condition> element has only a 'name' attribute, then
its contents are a series of <li> elements, each of which has
a 'value' attribute. The list is scanned from top to bottom
until a match is found. Optionally, the last <li> element can
have no 'value' attribute, in which case it is processed and
returned if no other match is found.
If the <condition> element has neither a 'name' nor a 'value'
attribute, then it behaves almost exactly like the previous
case, except that each <li> subelement (except the optional
last entry) must now include both 'name' and 'value'
attributes.
"""
attr = None
response = ""
attr = elem[1]
# Case #1: test the value of a specific predicate for a
# specific value.
if 'name' in attr and 'value' in attr:
val = self.getPredicate(attr['name'], sessionID)
if val == attr['value']:
for e in elem[2:]:
response += self._processElement(e,sessionID)
return response
else:
# Case #2 and #3: Cycle through <li> contents, testing a
# name and value pair for each one.
try:
name = None
if 'name' in attr:
name = attr['name']
# Get the list of <li> elemnents
listitems = []
for e in elem[2:]:
if e[0] == 'li':
listitems.append(e)
# if listitems is empty, return the empty string
if len(listitems) == 0:
return ""
# iterate through the list looking for a condition that
# matches.
foundMatch = False
for li in listitems:
try:
liAttr = li[1]
# if this is the last list item, it's allowed
# to have no attributes. We just skip it for now.
if len(list(liAttr.keys())) == 0 and li == listitems[-1]:
continue
# get the name of the predicate to test
liName = name
if liName == None:
liName = liAttr['name']
# get the value to check against
liValue = liAttr['value']
# do the test
if self.getPredicate(liName, sessionID) == liValue:
foundMatch = True
response += self._processElement(li,sessionID)
break
except:
# No attributes, no name/value attributes, no
# such predicate/session, or processing error.
if self._verboseMode: print("Something amiss -- skipping listitem", li)
raise
if not foundMatch:
# Check the last element of listitems. If it has
# no 'name' or 'value' attribute, process it.
try:
li = listitems[-1]
liAttr = li[1]
if not ('name' in liAttr or 'value' in liAttr):
response += self._processElement(li, sessionID)
except:
# listitems was empty, no attributes, missing
# name/value attributes, or processing error.
if self._verboseMode: print("error in default listitem")
raise
except:
# Some other catastrophic cataclysm
if self._verboseMode: print("catastrophic condition failure")
raise
return response
# <date>
def _processDate(self, elem, sessionID):
"""Process a <date> AIML element.
<date> elements resolve to the current date and time. The
AIML specification doesn't require any particular format for
this information, so I go with whatever's simplest.
"""
return time.asctime()
# <formal>
def _processFormal(self, elem, sessionID):
"""Process a <formal> AIML element.
<formal> elements process their contents recursively, and then
capitalize the first letter of each word of the result.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
return string.capwords(response)
# <gender>
def _processGender(self,elem, sessionID):
"""Process a <gender> AIML element.
<gender> elements process their contents, and then swap the
gender of any third-person singular pronouns in the result.
This subsitution is handled by the aiml.WordSub module.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
return self._subbers['gender'].sub(response)
# <get>
def _processGet(self, elem, sessionID):
"""Process a <get> AIML element.
Required element attributes:
name: The name of the predicate whose value should be
retrieved from the specified session and returned. If the
predicate doesn't exist, the empty string is returned.
<get> elements return the value of a predicate from the
specified session.
"""
return self.getPredicate(elem[1]['name'], sessionID)
# <gossip>
def _processGossip(self, elem, sessionID):
"""Process a <gossip> AIML element.
<gossip> elements are used to capture and store user input in
an implementation-defined manner, theoretically allowing the
bot to learn from the people it chats with. I haven't
descided how to define my implementation, so right now
<gossip> behaves identically to <think>.
"""
return self._processThink(elem, sessionID)
# <id>
def _processId(self, elem, sessionID):
""" Process an <id> AIML element.
<id> elements return a unique "user id" for a specific
conversation. In PyAIML, the user id is the name of the
current session.
"""
return sessionID
# <input>
def _processInput(self, elem, sessionID):
"""Process an <input> AIML element.
Optional attribute elements:
index: The index of the element from the history list to
return. 1 means the most recent item, 2 means the one
before that, and so on.
<input> elements return an entry from the input history for
the current session.
"""
inputHistory = self.getPredicate(self._inputHistory, sessionID)
try: index = int(elem[1]['index'])
except: index = 1
try: return inputHistory[-index]
except IndexError:
if self._verboseMode:
err = "No such index %d while processing <input> element.\n" % index
sys.stderr.write(err)
return ""
# <javascript>
def _processJavascript(self, elem, sessionID):
"""Process a <javascript> AIML element.
<javascript> elements process their contents recursively, and
then run the results through a server-side Javascript
interpreter to compute the final response. Implementations
are not required to provide an actual Javascript interpreter,
and right now PyAIML doesn't; <javascript> elements are behave
exactly like <think> elements.
"""
return self._processThink(elem, sessionID)
# <learn>
def _processLearn(self, elem, sessionID):
"""Process a <learn> AIML element.
<learn> elements process their contents recursively, and then
treat the result as an AIML file to open and learn.
"""
filename = ""
for e in elem[2:]:
filename += self._processElement(e, sessionID)
self.learn(filename)
return ""
# <li>
def _processLi(self,elem, sessionID):
"""Process an <li> AIML element.
Optional attribute elements:
name: the name of a predicate to query.
value: the value to check that predicate for.
<li> elements process their contents recursively and return
the results. They can only appear inside <condition> and
<random> elements. See _processCondition() and
_processRandom() for details of their usage.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
return response
# <lowercase>
def _processLowercase(self,elem, sessionID):
"""Process a <lowercase> AIML element.
<lowercase> elements process their contents recursively, and
then convert the results to all-lowercase.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
return response.lower()
# <person>
def _processPerson(self,elem, sessionID):
"""Process a <person> AIML element.
<person> elements process their contents recursively, and then
convert all pronouns in the results from 1st person to 2nd
person, and vice versa. This subsitution is handled by the
aiml.WordSub module.
If the <person> tag is used atomically (e.g. <person/>), it is
a shortcut for <person><star/></person>.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
if len(elem[2:]) == 0: # atomic <person/> = <person><star/></person>
response = self._processElement(['star',{}], sessionID)
return self._subbers['person'].sub(response)
# <person2>
def _processPerson2(self,elem, sessionID):
"""Process a <person2> AIML element.
<person2> elements process their contents recursively, and then
convert all pronouns in the results from 1st person to 3rd
person, and vice versa. This subsitution is handled by the
aiml.WordSub module.
If the <person2> tag is used atomically (e.g. <person2/>), it is
a shortcut for <person2><star/></person2>.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
if len(elem[2:]) == 0: # atomic <person2/> = <person2><star/></person2>
response = self._processElement(['star',{}], sessionID)
return self._subbers['person2'].sub(response)
# <random>
def _processRandom(self, elem, sessionID):
"""Process a <random> AIML element.
<random> elements contain zero or more <li> elements. If
none, the empty string is returned. If one or more <li>
elements are present, one of them is selected randomly to be
processed recursively and have its results returned. Only the
chosen <li> element's contents are processed. Any non-<li> contents are
ignored.
"""
listitems = []
for e in elem[2:]:
if e[0] == 'li':
listitems.append(e)
if len(listitems) == 0:
return ""
# select and process a random listitem.
random.shuffle(listitems)
return self._processElement(listitems[0], sessionID)
# <sentence>
def _processSentence(self,elem, sessionID):
"""Process a <sentence> AIML element.
<sentence> elements process their contents recursively, and
then capitalize the first letter of the results.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
try:
response = response.strip()
words = response.split(" ", 1)
words[0] = words[0].capitalize()
response = words.join()
return response
except IndexError: # response was empty
return ""
# <set>
def _processSet(self, elem, sessionID):
"""Process a <set> AIML element.
Required element attributes:
name: The name of the predicate to set.
<set> elements process their contents recursively, and assign the results to a predicate
(given by their 'name' attribute) in the current session. The contents of the element
are also returned.
"""
value = ""
for e in elem[2:]:
value += self._processElement(e, sessionID)
self.setPredicate(elem[1]['name'], value, sessionID)
return value
# <size>
def _processSize(self,elem, sessionID):
"""Process a <size> AIML element.
<size> elements return the number of AIML categories currently
in the bot's brain.
"""
return str(self.numCategories())
# <sr>
def _processSr(self,elem,sessionID):
"""Process an <sr> AIML element.
<sr> elements are shortcuts for <srai><star/></srai>.
"""
star = self._processElement(['star',{}], sessionID)
response = self._respond(star, sessionID)
return response
# <srai>
def _processSrai(self,elem, sessionID):
"""Process a <srai> AIML element.
<srai> elements recursively process their contents, and then
pass the results right back into the AIML interpreter as a new
piece of input. The results of this new input string are
returned.
"""
newInput = ""
for e in elem[2:]:
newInput += self._processElement(e, sessionID)
return self._respond(newInput, sessionID)
# <star>
def _processStar(self, elem, sessionID):
"""Process a <star> AIML element.
Optional attribute elements:
index: Which "*" character in the current pattern should
be matched?
<star> elements return the text fragment matched by the "*"
character in the current input pattern. For example, if the
input "Hello Tom Smith, how are you?" matched the pattern
"HELLO * HOW ARE YOU", then a <star> element in the template
would evaluate to "Tom Smith".
"""
try: index = int(elem[1]['index'])
except KeyError: index = 1
# fetch the user's last input
inputStack = self.getPredicate(self._inputStack, sessionID)
input = self._subbers['normal'].sub(inputStack[-1])
# fetch the Kernel's last response (for 'that' context)
outputHistory = self.getPredicate(self._outputHistory, sessionID)
try: that = self._subbers['normal'].sub(outputHistory[-1])
except: that = "" # there might not be any output yet
topic = self.getPredicate("topic", sessionID)
response = self._brain.star("star", input, that, topic, index)
return response
# <system>
def _processSystem(self,elem, sessionID):
"""Process a <system> AIML element.
<system> elements process their contents recursively, and then
attempt to execute the results as a shell command on the
server. The AIML interpreter blocks until the command is
complete, and then returns the command's output.
For cross-platform compatibility, any file paths inside
<system> tags should use Unix-style forward slashes ("/") as a
directory separator.
"""
# build up the command string
command = ""
for e in elem[2:]:
command += self._processElement(e, sessionID)
# normalize the path to the command. Under Windows, this
# switches forward-slashes to back-slashes; all system
# elements should use unix-style paths for cross-platform
# compatibility.
#executable,args = command.split(" ", 1)
#executable = os.path.normpath(executable)
#command = executable + " " + args
command = os.path.normpath(command)
# execute the command.
response = ""
try:
out = os.popen(command)
except RuntimeError as msg:
if self._verboseMode:
err = "WARNING: RuntimeError while processing \"system\" element:\n%s\n" % msg
sys.stderr.write(err)
return "There was an error while computing my response. Please inform my botmaster."
time.sleep(0.01) # I'm told this works around a potential IOError exception.
for line in out:
response += line + "\n"
response = response.splitlines().join().strip()
return response
# <template>
def _processTemplate(self,elem, sessionID):
"""Process a <template> AIML element.
<template> elements recursively process their contents, and
return the results. <template> is the root node of any AIML
response tree.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
return response
# text
def _processText(self,elem, sessionID):
"""Process a raw text element.
Raw text elements aren't really AIML tags. Text elements cannot contain
other elements; instead, the third item of the 'elem' list is a text
string, which is immediately returned. They have a single attribute,
automatically inserted by the parser, which indicates whether whitespace
in the text should be preserved or not.
"""
try: elem[2] + ""
except TypeError: raise TypeError("Text element contents are not text")
# If the the whitespace behavior for this element is "default",
# we reduce all stretches of >1 whitespace characters to a single
# space. To improve performance, we do this only once for each
# text element encountered, and save the results for the future.
if elem[1]["xml:space"] == "default":
elem[2] = re.sub("\s+", " ", elem[2])
elem[1]["xml:space"] = "preserve"
return elem[2]
# <that>
def _processThat(self,elem, sessionID):
"""Process a <that> AIML element.
Optional element attributes:
index: Specifies which element from the output history to
return. 1 is the most recent response, 2 is the next most
recent, and so on.
<that> elements (when they appear inside <template> elements)
are the output equivilant of <input> elements; they return one
of the Kernel's previous responses.
"""
outputHistory = self.getPredicate(self._outputHistory, sessionID)
index = 1
try:
# According to the AIML spec, the optional index attribute
# can either have the form "x" or "x,y". x refers to how
# far back in the output history to go. y refers to which
# sentence of the specified response to return.
index = int(elem[1]['index'].split(',')[0])
except:
pass
try: return outputHistory[-index]
except IndexError:
if self._verboseMode:
err = "No such index %d while processing <that> element.\n" % index
sys.stderr.write(err)
return ""
# <thatstar>
def _processThatstar(self, elem, sessionID):
"""Process a <thatstar> AIML element.
Optional element attributes:
index: Specifies which "*" in the <that> pattern to match.
<thatstar> elements are similar to <star> elements, except
that where <star/> returns the portion of the input string
matched by a "*" character in the pattern, <thatstar/> returns
the portion of the previous input string that was matched by a
"*" in the current category's <that> pattern.
"""
try: index = int(elem[1]['index'])
except KeyError: index = 1
# fetch the user's last input
inputStack = self.getPredicate(self._inputStack, sessionID)
input = self._subbers['normal'].sub(inputStack[-1])
# fetch the Kernel's last response (for 'that' context)
outputHistory = self.getPredicate(self._outputHistory, sessionID)
try: that = self._subbers['normal'].sub(outputHistory[-1])
except: that = "" # there might not be any output yet
topic = self.getPredicate("topic", sessionID)
response = self._brain.star("thatstar", input, that, topic, index)
return response
# <think>
def _processThink(self,elem, sessionID):
"""Process a <think> AIML element.
<think> elements process their contents recursively, and then
discard the results and return the empty string. They're
useful for setting predicates and learning AIML files without
generating any output.
"""
for e in elem[2:]:
self._processElement(e, sessionID)
return ""
# <topicstar>
def _processTopicstar(self, elem, sessionID):
"""Process a <topicstar> AIML element.
Optional element attributes:
index: Specifies which "*" in the <topic> pattern to match.
<topicstar> elements are similar to <star> elements, except
that where <star/> returns the portion of the input string
matched by a "*" character in the pattern, <topicstar/>
returns the portion of current topic string that was matched
by a "*" in the current category's <topic> pattern.
"""
try: index = int(elem[1]['index'])
except KeyError: index = 1
# fetch the user's last input
inputStack = self.getPredicate(self._inputStack, sessionID)
input = self._subbers['normal'].sub(inputStack[-1])
# fetch the Kernel's last response (for 'that' context)
outputHistory = self.getPredicate(self._outputHistory, sessionID)
try: that = self._subbers['normal'].sub(outputHistory[-1])
except: that = "" # there might not be any output yet
topic = self.getPredicate("topic", sessionID)
response = self._brain.star("topicstar", input, that, topic, index)
return response
# <uppercase>
def _processUppercase(self,elem, sessionID):
"""Process an <uppercase> AIML element.
<uppercase> elements process their contents recursively, and
return the results with all lower-case characters converted to
upper-case.
"""
response = ""
for e in elem[2:]:
response += self._processElement(e, sessionID)
return response.upper()
# <version>
def _processVersion(self,elem, sessionID):
"""Process a <version> AIML element.
<version> elements return the version number of the AIML
interpreter.
"""
return self.version()
def __init__(self, sessionStore=None):
self._verboseMode = True
self._version = "PyAIML 0.8.6"
self._brain = PatternMgr()
self._respondLock = threading.RLock()
self._textEncoding = "utf-8"
#set up the logger
#author: ictar
self._logger = logging.getLogger(__name__)
self._logger.setLevel(logging.INFO)
self._handler = logging.FileHandler('XIXI_Kernel.log')
self._handler.setLevel(logging.INFO)
self._handler.setFormatter(
logging.Formatter(
'%(asctime)s - %(filename)s:%(lineno)d - %(levelname)s - %(message)s'
))
self._logger.addHandler(self._handler)
self._logger.info("begin to log")
# set up the sessions
if sessionStore is not None:
self._sessions = sessionStore
else:
self._sessions = {}
self._addSession(self._globalSessionID)
# Set up the bot predicates
self._botPredicates = {}
self.setBotPredicate("name", "Nameless")
# set up the word substitutors (subbers):
self._subbers = {}
self._subbers['gender'] = WordSub(DefaultSubs.defaultGender)
self._subbers['person'] = WordSub(DefaultSubs.defaultPerson)
self._subbers['person2'] = WordSub(DefaultSubs.defaultPerson2)
self._subbers['normal'] = WordSub(DefaultSubs.defaultNormal)
# set up the element processors
self._elementProcessors = {
"bot": self._processBot,
"condition": self._processCondition,
"date": self._processDate,
"formal": self._processFormal,
"gender": self._processGender,
"get": self._processGet,
"gossip": self._processGossip,
"id": self._processId,
"input": self._processInput,
"javascript": self._processJavascript,
"learn": self._processLearn,
"li": self._processLi,
"lowercase": self._processLowercase,
"person": self._processPerson,
"person2": self._processPerson2,
"random": self._processRandom,
"text": self._processText,
"sentence": self._processSentence,
"set": self._processSet,
"size": self._processSize,
"sr": self._processSr,
"srai": self._processSrai,
"star": self._processStar,
"system": self._processSystem,
"template": self._processTemplate,
"that": self._processThat,
"thatstar": self._processThatstar,
"think": self._processThink,
"topicstar": self._processTopicstar,
"uppercase": self._processUppercase,
"version": self._processVersion,
}
def __init__(self, sessionStore=None):
self._verboseMode = True
self._version = "PyAIML 0.8.6"
self._brain = PatternMgr()
self._respondLock = threading.RLock()
self._textEncoding = "utf-8"
# set up the logger
# author: ictar
self._logger = logging.getLogger(__name__)
self._logger.setLevel(logging.INFO)
self._handler = logging.FileHandler("XIXI_Kernel.log")
self._handler.setLevel(logging.INFO)
self._handler.setFormatter(
logging.Formatter("%(asctime)s - %(filename)s:%(lineno)d - %(levelname)s - %(message)s")
)
self._logger.addHandler(self._handler)
self._logger.info("begin to log")
# set up the sessions
if sessionStore is not None:
self._sessions = sessionStore
else:
self._sessions = {}
self._addSession(self._globalSessionID)
# Set up the bot predicates
self._botPredicates = {}
self.setBotPredicate("name", "Nameless")
# set up the word substitutors (subbers):
self._subbers = {}
self._subbers["gender"] = WordSub(DefaultSubs.defaultGender)
self._subbers["person"] = WordSub(DefaultSubs.defaultPerson)
self._subbers["person2"] = WordSub(DefaultSubs.defaultPerson2)
self._subbers["normal"] = WordSub(DefaultSubs.defaultNormal)
# set up the element processors
self._elementProcessors = {
"bot": self._processBot,
"condition": self._processCondition,
"date": self._processDate,
"formal": self._processFormal,
"gender": self._processGender,
"get": self._processGet,
"gossip": self._processGossip,
"id": self._processId,
"input": self._processInput,
"javascript": self._processJavascript,
"learn": self._processLearn,
"li": self._processLi,
"lowercase": self._processLowercase,
"person": self._processPerson,
"person2": self._processPerson2,
"random": self._processRandom,
"text": self._processText,
"sentence": self._processSentence,
"set": self._processSet,
"size": self._processSize,
"sr": self._processSr,
"srai": self._processSrai,
"star": self._processStar,
"system": self._processSystem,
"template": self._processTemplate,
"that": self._processThat,
"thatstar": self._processThatstar,
"think": self._processThink,
"topicstar": self._processTopicstar,
"uppercase": self._processUppercase,
"version": self._processVersion,
}
