├── .gitignore
├── README.md
├── TalkBot.py
├── __init__.py
├── aiml
    ├── AimlParser.py
    ├── DefaultSubs.py
    ├── Kernel.py
    ├── LangSupport.py
    ├── PatternMgr.py
    ├── Utils.py
    ├── WordSub.py
    ├── __init__.py
    └── build
    │   └── pip-delete-this-directory.txt
├── aiml_set
    ├── general.aiml
    ├── learn.aiml
    ├── maimeng.aiml
    ├── property.aiml
    ├── rude.aiml
    └── sex.aiml
├── config.py
└── xdtuxbot.brn


/.gitignore:
--------------------------------------------------------------------------------
1 | *.swp
2 | *~
3 | *.pyc
4 | *.pyo
5 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | TalkBot
2 | ===
3 | TalkBot 是基于AIML的对话机器人，目前用于 @xdtuxbot 的对话，支持中文，暂未加入学习功能
4 | 


--------------------------------------------------------------------------------
/TalkBot.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/python2
 2 | # -*- coding: utf8 -*-
 3 | import aiml
 4 | import os
 5 | import config as cfg
 6 | 
 7 | class TalkBot(aiml.Kernel):
 8 |     def __init__(self,properties=cfg.BOT_PROPERTIES):
 9 |         aiml.Kernel.__init__(self)
10 |         self.verbose(cfg.DEBUG)
11 |         if os.path.isfile("xdtuxbot.brn"):
12 |             self.bootstrap(brainFile = "xdtuxbot.brn")
13 |         else:
14 |             self.init_bot()
15 |             self.saveBrain("xdtuxbot.brn")
16 |         for p in properties:
17 |             self.setBotPredicate( p, properties[p] )
18 |     
19 |     def init_bot(self):
20 |         for file in os.listdir(cfg.AIML_SET):
21 |             if file[-4::]=="aiml":
22 |                 self.learn(os.path.join(cfg.AIML_SET,file) )
23 | 
24 | 
25 | if __name__=="__main__":
26 |     bot = TalkBot()
27 |     while True: print bot.respond(raw_input("> "))
28 | 
29 | 


--------------------------------------------------------------------------------
/__init__.py:
--------------------------------------------------------------------------------
1 | __all__ = []
2 | from TalkBot import TalkBot
3 | 


--------------------------------------------------------------------------------
/aiml/AimlParser.py:
--------------------------------------------------------------------------------
  1 | from xml.sax.handler import ContentHandler
  2 | from xml.sax.xmlreader import Locator
  3 | import sys
  4 | import xml.sax
  5 | import xml.sax.handler
  6 | 
  7 | class AimlParserError(Exception): pass
  8 | 
  9 | class AimlHandler(ContentHandler):
 10 | 	# The legal states of the AIML parser
 11 | 	_STATE_OutsideAiml    = 0
 12 | 	_STATE_InsideAiml     = 1
 13 | 	_STATE_InsideCategory = 2
 14 | 	_STATE_InsidePattern  = 3
 15 | 	_STATE_AfterPattern   = 4
 16 | 	_STATE_InsideThat     = 5
 17 | 	_STATE_AfterThat      = 6
 18 | 	_STATE_InsideTemplate = 7
 19 | 	_STATE_AfterTemplate  = 8
 20 | 	
 21 | 	def __init__(self, encoding = "UTF-8"):
 22 | 		self.categories = {}
 23 | 		self._encoding = encoding
 24 | 		self._state = self._STATE_OutsideAiml
 25 | 		self._version = ""
 26 | 		self._namespace = ""
 27 | 		self._forwardCompatibleMode = False
 28 | 		self._currentPattern = ""
 29 | 		self._currentThat    = ""
 30 | 		self._currentTopic   = ""
 31 | 		self._insideTopic = False
 32 | 		self._currentUnknown = "" # the name of the current unknown element
 33 | 
 34 | 		# This is set to true when a parse error occurs in a category.
 35 | 		self._skipCurrentCategory = False
 36 | 
 37 | 		# Counts the number of parse errors in a particular AIML document.
 38 | 		# query with getNumErrors().  If 0, the document is AIML-compliant.
 39 | 		self._numParseErrors = 0
 40 | 
 41 | 		# TODO: select the proper validInfo table based on the version number.
 42 | 		self._validInfo = self._validationInfo101
 43 | 
 44 | 		# This stack of bools is used when parsing <li> elements inside
 45 | 		# <condition> elements, to keep track of whether or not an
 46 | 		# attribute-less "default" <li> element has been found yet.  Only
 47 | 		# one default <li> is allowed in each <condition> element.  We need
 48 | 		# a stack in order to correctly handle nested <condition> tags.
 49 | 		self._foundDefaultLiStack = []
 50 | 
 51 | 		# This stack of strings indicates what the current whitespace-handling
 52 | 		# behavior should be.  Each string in the stack is either "default" or
 53 | 		# "preserve".  When a new AIML element is encountered, a new string is
 54 | 		# pushed onto the stack, based on the value of the element's "xml:space"
 55 | 		# attribute (if absent, the top of the stack is pushed again).  When
 56 | 		# ending an element, pop an object off the stack.
 57 | 		self._whitespaceBehaviorStack = ["default"]
 58 | 		
 59 | 		self._elemStack = []
 60 | 		self._locator = Locator()
 61 | 		self.setDocumentLocator(self._locator)
 62 | 
 63 | 	def getNumErrors(self):
 64 | 		"Return the number of errors found while parsing the current document."
 65 | 		return self._numParseErrors
 66 | 
 67 | 	def setEncoding(self, encoding):
 68 | 		"""Set the text encoding to use when encoding strings read from XML.
 69 | 
 70 | 		Defaults to 'UTF-8'.
 71 | 
 72 | 		"""
 73 | 		self._encoding = encoding
 74 | 
 75 | 	def _location(self):
 76 | 		"Return a string describing the current location in the source file."
 77 | 		line = self._locator.getLineNumber()
 78 | 		column = self._locator.getColumnNumber()
 79 | 		return "(line %d, column %d)" % (line, column)
 80 | 
 81 | 	def _pushWhitespaceBehavior(self, attr):
 82 | 		"""Push a new string onto the whitespaceBehaviorStack.
 83 | 
 84 | 		The string's value is taken from the "xml:space" attribute, if it exists
 85 | 		and has a legal value ("default" or "preserve").  Otherwise, the previous
 86 | 		stack element is duplicated.
 87 | 
 88 | 		"""
 89 | 		assert len(self._whitespaceBehaviorStack) > 0, "Whitespace behavior stack should never be empty!"
 90 | 		try:
 91 | 			if attr["xml:space"] == "default" or attr["xml:space"] == "preserve":
 92 | 				self._whitespaceBehaviorStack.append(attr["xml:space"])
 93 | 			else:
 94 | 				raise AimlParserError, "Invalid value for xml:space attribute "+self._location()
 95 | 		except KeyError:
 96 | 			self._whitespaceBehaviorStack.append(self._whitespaceBehaviorStack[-1])
 97 | 
 98 | 	def startElementNS(self, name, qname, attr):
 99 | 		print "QNAME:", qname
100 | 		print "NAME:", name
101 | 		uri,elem = name
102 | 		if (elem == "bot"): print "name:", attr.getValueByQName("name"), "a'ite?"
103 | 		self.startElement(elem, attr)
104 | 		pass
105 | 
106 | 	def startElement(self, name, attr):
107 | 		# Wrapper around _startElement, which catches errors in _startElement()
108 | 		# and keeps going.
109 | 		
110 | 		# If we're inside an unknown element, ignore everything until we're
111 | 		# out again.
112 | 		if self._currentUnknown != "":
113 | 			return
114 | 		# If we're skipping the current category, ignore everything until
115 | 		# it's finished.
116 | 		if self._skipCurrentCategory:
117 | 			return
118 | 
119 | 		# process this start-element.
120 | 		try: self._startElement(name, attr)
121 | 		except AimlParserError, msg:
122 | 			# Print the error message
123 | 			sys.stderr.write("PARSE ERROR: %s\n" % msg)
124 | 			
125 | 			self._numParseErrors += 1 # increment error count
126 | 			# In case of a parse error, if we're inside a category, skip it.
127 | 			if self._state >= self._STATE_InsideCategory:
128 | 				self._skipCurrentCategory = True
129 | 			
130 | 	def _startElement(self, name, attr):
131 | 		if name == "aiml":
132 | 			# <aiml> tags are only legal in the OutsideAiml state
133 | 			if self._state != self._STATE_OutsideAiml:
134 | 				raise AimlParserError, "Unexpected <aiml> tag "+self._location()
135 | 			self._state = self._STATE_InsideAiml
136 | 			self._insideTopic = False
137 | 			self._currentTopic = u""
138 | 			try: self._version = attr["version"]
139 | 			except KeyError:
140 | 				# This SHOULD be a syntax error, but so many AIML sets out there are missing
141 | 				# "version" attributes that it just seems nicer to let it slide.
142 | 				#raise AimlParserError, "Missing 'version' attribute in <aiml> tag "+self._location()
143 | 				#print "WARNING: Missing 'version' attribute in <aiml> tag "+self._location()
144 | 				#print "         Defaulting to version 1.0"
145 | 				self._version = "1.0"
146 | 			self._forwardCompatibleMode = (self._version != "1.0.1")
147 | 			self._pushWhitespaceBehavior(attr)			
148 | 			# Not sure about this namespace business yet...
149 | 			#try:
150 | 			#	self._namespace = attr["xmlns"]
151 | 			#	if self._version == "1.0.1" and self._namespace != "http://alicebot.org/2001/AIML-1.0.1":
152 | 			#		raise AimlParserError, "Incorrect namespace for AIML v1.0.1 "+self._location()
153 | 			#except KeyError:
154 | 			#	if self._version != "1.0":
155 | 			#		raise AimlParserError, "Missing 'version' attribute(s) in <aiml> tag "+self._location()
156 | 		elif self._state == self._STATE_OutsideAiml:
157 | 			# If we're outside of an AIML element, we ignore all tags.
158 | 			return
159 | 		elif name == "topic":
160 | 			# <topic> tags are only legal in the InsideAiml state, and only
161 | 			# if we're not already inside a topic.
162 | 			if (self._state != self._STATE_InsideAiml) or self._insideTopic:
163 | 				raise AimlParserError, "Unexpected <topic> tag", self._location()
164 | 			try: self._currentTopic = unicode(attr['name'])
165 | 			except KeyError:
166 | 				raise AimlParserError, "Required \"name\" attribute missing in <topic> element "+self._location()
167 | 			self._insideTopic = True
168 | 		elif name == "category":
169 | 			# <category> tags are only legal in the InsideAiml state
170 | 			if self._state != self._STATE_InsideAiml:
171 | 				raise AimlParserError, "Unexpected <category> tag "+self._location()
172 | 			self._state = self._STATE_InsideCategory
173 | 			self._currentPattern = u""
174 | 			self._currentThat = u""
175 | 			# If we're not inside a topic, the topic is implicitly set to *
176 | 			if not self._insideTopic: self._currentTopic = u"*"
177 | 			self._elemStack = []
178 | 			self._pushWhitespaceBehavior(attr)
179 | 		elif name == "pattern":
180 | 			# <pattern> tags are only legal in the InsideCategory state
181 | 			if self._state != self._STATE_InsideCategory:
182 | 				raise AimlParserError, "Unexpected <pattern> tag "+self._location()
183 | 			self._state = self._STATE_InsidePattern
184 | 		elif name == "that" and self._state == self._STATE_AfterPattern:
185 | 			# <that> are legal either inside a <template> element, or
186 | 			# inside a <category> element, between the <pattern> and the
187 | 			# <template> elements.  This clause handles the latter case.
188 | 			self._state = self._STATE_InsideThat
189 | 		elif name == "template":
190 | 			# <template> tags are only legal in the AfterPattern and AfterThat
191 | 			# states
192 | 			if self._state not in [self._STATE_AfterPattern, self._STATE_AfterThat]:
193 | 				raise AimlParserError, "Unexpected <template> tag "+self._location()
194 | 			# if no <that> element was specified, it is implicitly set to *
195 | 			if self._state == self._STATE_AfterPattern:
196 | 				self._currentThat = u"*"
197 | 			self._state = self._STATE_InsideTemplate
198 | 			self._elemStack.append(['template',{}])
199 | 			self._pushWhitespaceBehavior(attr)
200 | 		elif self._state == self._STATE_InsidePattern:
201 | 			# Certain tags are allowed inside <pattern> elements.
202 | 			if name == "bot" and attr.has_key("name") and attr["name"] == u"name":
203 | 				# Insert a special character string that the PatternMgr will
204 | 				# replace with the bot's name.
205 | 				self._currentPattern += u" BOT_NAME "
206 | 			else:
207 | 				raise AimlParserError, ("Unexpected <%s> tag " % name)+self._location()
208 | 		elif self._state == self._STATE_InsideThat:
209 | 			# Certain tags are allowed inside <that> elements.
210 | 			if name == "bot" and attr.has_key("name") and attr["name"] == u"name":
211 | 				# Insert a special character string that the PatternMgr will
212 | 				# replace with the bot's name.
213 | 				self._currentThat += u" BOT_NAME "
214 | 			else:
215 | 				raise AimlParserError, ("Unexpected <%s> tag " % name)+self._location()
216 | 		elif self._state == self._STATE_InsideTemplate and self._validInfo.has_key(name):
217 | 			# Starting a new element inside the current pattern. First
218 | 			# we need to convert 'attr' into a native Python dictionary,
219 | 			# so it can later be marshaled.
220 | 			attrDict = {}
221 | 			for k,v in attr.items():
222 | 				#attrDict[k[1].encode(self._encoding)] = v.encode(self._encoding)
223 | 				attrDict[k.encode(self._encoding)] = unicode(v)
224 | 			self._validateElemStart(name, attrDict, self._version)
225 | 			# Push the current element onto the element stack.
226 | 			self._elemStack.append([name.encode(self._encoding),attrDict])
227 | 			self._pushWhitespaceBehavior(attr)
228 | 			# If this is a condition element, push a new entry onto the
229 | 			# foundDefaultLiStack
230 | 			if name == "condition":
231 | 				self._foundDefaultLiStack.append(False)
232 | 		else:
233 | 			# we're now inside an unknown element.
234 | 			if self._forwardCompatibleMode:
235 | 				# In Forward Compatibility Mode, we ignore the element and its
236 | 				# contents.
237 | 				self._currentUnknown = name
238 | 			else:
239 | 				# Otherwise, unknown elements are grounds for error!
240 | 				raise AimlParserError, ("Unexpected <%s> tag " % name)+self._location()
241 | 
242 | 	def characters(self, ch):
243 | 		# Wrapper around _characters which catches errors in _characters()
244 | 		# and keeps going.
245 | 		if self._state == self._STATE_OutsideAiml:
246 | 			# If we're outside of an AIML element, we ignore all text
247 | 			return
248 | 		if self._currentUnknown != "":
249 | 			# If we're inside an unknown element, ignore all text
250 | 			return
251 | 		if self._skipCurrentCategory:
252 | 			# If we're skipping the current category, ignore all text.
253 | 			return
254 | 		try: self._characters(ch)
255 | 		except AimlParserError, msg:
256 | 			# Print the message
257 | 			sys.stderr.write("PARSE ERROR: %s\n" % msg)
258 | 			self._numParseErrors += 1 # increment error count
259 | 			# In case of a parse error, if we're inside a category, skip it.
260 | 			if self._state >= self._STATE_InsideCategory:
261 | 				self._skipCurrentCategory = True
262 | 			
263 | 	def _characters(self, ch):
264 | 		text = unicode(ch)
265 | 		if self._state == self._STATE_InsidePattern:
266 | 			self._currentPattern += text
267 | 		elif self._state == self._STATE_InsideThat:
268 | 			self._currentThat += text
269 | 		elif self._state == self._STATE_InsideTemplate:
270 | 			# First, see whether the element at the top of the element stack
271 | 			# is permitted to contain text.
272 | 			try:
273 | 				parent = self._elemStack[-1][0]
274 | 				parentAttr = self._elemStack[-1][1]
275 | 				required, optional, canBeParent = self._validInfo[parent]
276 | 				nonBlockStyleCondition = (parent == "condition" and not (parentAttr.has_key("name") and parentAttr.has_key("value")))
277 | 				if not canBeParent:
278 | 					raise AimlParserError, ("Unexpected text inside <%s> element "%parent)+self._location()
279 | 				elif parent == "random" or nonBlockStyleCondition:
280 | 					# <random> elements can only contain <li> subelements. However,
281 | 					# there's invariably some whitespace around the <li> that we need
282 | 					# to ignore. Same for non-block-style <condition> elements (i.e.
283 | 					# those which don't have both a "name" and a "value" attribute).
284 | 					if len(text.strip()) == 0:
285 | 						# ignore whitespace inside these elements.
286 | 						return
287 | 					else:
288 | 						# non-whitespace text inside these elements is a syntax error.
289 | 						raise AimlParserError, ("Unexpected text inside <%s> element "%parent)+self._location()
290 | 			except IndexError:
291 | 				# the element stack is empty. This should never happen.
292 | 				raise AimlParserError, "Element stack is empty while validating text "+self._location()
293 | 			
294 | 			# Add a new text element to the element at the top of the element
295 | 			# stack. If there's already a text element there, simply append the
296 | 			# new characters to its contents.
297 | 			try: textElemOnStack = (self._elemStack[-1][-1][0] == "text")
298 | 			except IndexError: textElemOnStack = False
299 | 			except KeyError: textElemOnStack = False
300 | 			if textElemOnStack:
301 | 				self._elemStack[-1][-1][2] += text
302 | 			else:
303 | 				self._elemStack[-1].append(["text", {"xml:space": self._whitespaceBehaviorStack[-1]}, text])
304 | 		else:
305 | 			# all other text is ignored
306 | 			pass
307 | 
308 | 	def endElementNS(self, name, qname):
309 | 		uri, elem = name
310 | 		self.endElement(elem)
311 | 		
312 | 	def endElement(self, name):
313 | 		"""Wrapper around _endElement which catches errors in _characters()
314 | 		and keeps going.
315 | 
316 | 		"""		
317 | 		if self._state == self._STATE_OutsideAiml:
318 | 			# If we're outside of an AIML element, ignore all tags
319 | 			return
320 | 		if self._currentUnknown != "":
321 | 			# see if we're at the end of an unknown element.  If so, we can
322 | 			# stop ignoring everything.
323 | 			if name == self._currentUnknown:
324 | 				self._currentUnknown = ""
325 | 			return
326 | 		if self._skipCurrentCategory:
327 | 			# If we're skipping the current category, see if it's ending. We
328 | 			# stop on ANY </category> tag, since we're not keeping track of
329 | 			# state in ignore-mode.
330 | 			if name == "category":
331 | 				self._skipCurrentCategory = False
332 | 				self._state = self._STATE_InsideAiml
333 | 			return
334 | 		try: self._endElement(name)
335 | 		except AimlParserError, msg:
336 | 			# Print the message
337 | 			sys.stderr.write("PARSE ERROR: %s\n" % msg)
338 | 			self._numParseErrors += 1 # increment error count
339 | 			# In case of a parse error, if we're inside a category, skip it.
340 | 			if self._state >= self._STATE_InsideCategory:
341 | 				self._skipCurrentCategory = True
342 | 
343 | 	def _endElement(self, name):
344 | 		"""Verify that an AIML end element is valid in the current
345 | 		context.
346 | 
347 | 		Raises an AimlParserError if an illegal end element is encountered.
348 | 
349 | 		"""
350 | 		if name == "aiml":
351 | 			# </aiml> tags are only legal in the InsideAiml state
352 | 			if self._state != self._STATE_InsideAiml:
353 | 				raise AimlParserError, "Unexpected </aiml> tag "+self._location()
354 | 			self._state = self._STATE_OutsideAiml
355 | 			self._whitespaceBehaviorStack.pop()
356 | 		elif name == "topic":
357 | 			# </topic> tags are only legal in the InsideAiml state, and
358 | 			# only if _insideTopic is true.
359 | 			if self._state != self._STATE_InsideAiml or not self._insideTopic:
360 | 				raise AimlParserError, "Unexpected </topic> tag "+self._location()
361 | 			self._insideTopic = False
362 | 			self._currentTopic = u""
363 | 		elif name == "category":
364 | 			# </category> tags are only legal in the AfterTemplate state
365 | 			if self._state != self._STATE_AfterTemplate:
366 | 				raise AimlParserError, "Unexpected </category> tag "+self._location()
367 | 			self._state = self._STATE_InsideAiml
368 | 			# End the current category.  Store the current pattern/that/topic and
369 | 			# element in the categories dictionary.
370 | 			key = (self._currentPattern.strip(), self._currentThat.strip(),self._currentTopic.strip())
371 | 			self.categories[key] = self._elemStack[-1]
372 | 			self._whitespaceBehaviorStack.pop()
373 | 		elif name == "pattern":
374 | 			# </pattern> tags are only legal in the InsidePattern state
375 | 			if self._state != self._STATE_InsidePattern:
376 | 				raise AimlParserError, "Unexpected </pattern> tag "+self._location()
377 | 			self._state = self._STATE_AfterPattern
378 | 		elif name == "that" and self._state == self._STATE_InsideThat:
379 | 			# </that> tags are only allowed inside <template> elements or in
380 | 			# the InsideThat state.  This clause handles the latter case.
381 | 			self._state = self._STATE_AfterThat
382 | 		elif name == "template":
383 | 			# </template> tags are only allowed in the InsideTemplate state.
384 | 			if self._state != self._STATE_InsideTemplate:
385 | 				raise AimlParserError, "Unexpected </template> tag "+self._location()
386 | 			self._state = self._STATE_AfterTemplate
387 | 			self._whitespaceBehaviorStack.pop()
388 | 		elif self._state == self._STATE_InsidePattern:
389 | 			# Certain tags are allowed inside <pattern> elements.
390 | 			if name not in ["bot"]:
391 | 				raise AimlParserError, ("Unexpected </%s> tag " % name)+self._location()
392 | 		elif self._state == self._STATE_InsideThat:
393 | 			# Certain tags are allowed inside <that> elements.
394 | 			if name not in ["bot"]:
395 | 				raise AimlParserError, ("Unexpected </%s> tag " % name)+self._location()
396 | 		elif self._state == self._STATE_InsideTemplate:
397 | 			# End of an element inside the current template.  Append the
398 | 			# element at the top of the stack onto the one beneath it.
399 | 			elem = self._elemStack.pop()
400 | 			self._elemStack[-1].append(elem)
401 | 			self._whitespaceBehaviorStack.pop()
402 | 			# If the element was a condition, pop an item off the
403 | 			# foundDefaultLiStack as well.
404 | 			if elem[0] == "condition": self._foundDefaultLiStack.pop()
405 | 		else:
406 | 			# Unexpected closing tag
407 | 			raise AimlParserError, ("Unexpected </%s> tag " % name)+self._location()
408 | 
409 | 	# A dictionary containing a validation information for each AIML
410 | 	# element. The keys are the names of the elements.  The values are a
411 | 	# tuple of three items. The first is a list containing the names of
412 | 	# REQUIRED attributes, the second is a list of OPTIONAL attributes,
413 | 	# and the third is a boolean value indicating whether or not the
414 | 	# element can contain other elements and/or text (if False, the
415 | 	# element can only appear in an atomic context, such as <date/>).
416 | 	_validationInfo101 = {
417 | 		"bot":      	( ["name"], [], False ),
418 | 		"condition":    ( [], ["name", "value"], True ), # can only contain <li> elements
419 | 		"date":         ( [], [], False ),
420 | 		"formal":       ( [], [], True ),
421 | 		"gender":       ( [], [], True ),
422 | 		"get":          ( ["name"], [], False ),
423 | 		"gossip":		( [], [], True ),
424 | 		"id":           ( [], [], False ),
425 | 		"input":        ( [], ["index"], False ),
426 | 		"javascript":	( [], [], True ),
427 | 		"learn":        ( [], [], True ),
428 | 		"li":           ( [], ["name", "value"], True ),
429 | 		"lowercase":    ( [], [], True ),
430 | 		"person":       ( [], [], True ),
431 | 		"person2":      ( [], [], True ),
432 | 		"random":       ( [], [], True ), # can only contain <li> elements
433 | 		"sentence":     ( [], [], True ),
434 | 		"set":          ( ["name"], [], True),
435 | 		"size":         ( [], [], False ),
436 | 		"sr":           ( [], [], False ),
437 | 		"srai":         ( [], [], True ),
438 | 		"star":         ( [], ["index"], False ),
439 | 		"system":       ( [], [], True ),
440 | 		"template":		( [], [], True ), # needs to be in the list because it can be a parent.
441 | 		"that":         ( [], ["index"], False ),
442 | 		"thatstar":     ( [], ["index"], False ),
443 | 		"think":        ( [], [], True ),
444 | 		"topicstar":    ( [], ["index"], False ),
445 | 		"uppercase":    ( [], [], True ),
446 | 		"version":      ( [], [], False ),
447 | 	}
448 | 
449 | 	def _validateElemStart(self, name, attr, version):
450 | 		"""Test the validity of an element starting inside a <template>
451 | 		element.
452 | 
453 | 		This function raises an AimlParserError exception if it the tag is
454 | 		invalid.  Otherwise, no news is good news.
455 | 
456 | 		"""		
457 | 		# Check the element's attributes.  Make sure that all required
458 | 		# attributes are present, and that any remaining attributes are
459 | 		# valid options.		
460 | 		required, optional, canBeParent = self._validInfo[name]
461 | 		for a in required:
462 | 			if a not in attr and not self._forwardCompatibleMode:
463 | 				raise AimlParserError, ("Required \"%s\" attribute missing in <%s> element " % (a,name))+self._location()
464 | 		for a in attr:
465 | 			if a in required: continue
466 | 			if a[0:4] == "xml:": continue # attributes in the "xml" namespace can appear anywhere
467 | 			if a not in optional and not self._forwardCompatibleMode:
468 | 				raise AimlParserError, ("Unexpected \"%s\" attribute in <%s> element " % (a,name))+self._location()
469 | 
470 | 		# special-case: several tags contain an optional "index" attribute.
471 | 		# This attribute's value must be a positive integer.
472 | 		if name in ["star", "thatstar", "topicstar"]:
473 | 			for k,v in attr.items():
474 | 				if k == "index":
475 | 					temp = 0
476 | 					try: temp = int(v)
477 | 					except:
478 | 						raise AimlParserError, ("Bad type for \"%s\" attribute (expected integer, found \"%s\") " % (k,v))+self._location()
479 | 					if temp < 1:
480 | 						raise AimlParserError, ("\"%s\" attribute must have non-negative value " % (k))+self._location()
481 | 
482 | 		# See whether the containing element is permitted to contain
483 | 		# subelements. If not, this element is invalid no matter what it is.
484 | 		try:
485 | 			parent = self._elemStack[-1][0]
486 | 			parentAttr = self._elemStack[-1][1]
487 | 		except IndexError:
488 | 			# If the stack is empty, no parent is present.  This should never
489 | 			# happen.
490 | 			raise AimlParserError, ("Element stack is empty while validating <%s> " % name)+self._location()
491 | 		required, optional, canBeParent = self._validInfo[parent]
492 | 		nonBlockStyleCondition = (parent == "condition" and not (parentAttr.has_key("name") and parentAttr.has_key("value")))
493 | 		if not canBeParent:
494 | 			raise AimlParserError, ("<%s> elements cannot have any contents "%parent)+self._location()
495 | 		# Special-case test if the parent element is <condition> (the
496 | 		# non-block-style variant) or <random>: these elements can only
497 | 		# contain <li> subelements.
498 | 		elif (parent == "random" or nonBlockStyleCondition) and name!="li":
499 | 			raise AimlParserError, ("<%s> elements can only contain <li> subelements "%parent)+self._location()
500 | 		# Special-case test for <li> elements, which can only be contained
501 | 		# by non-block-style <condition> and <random> elements, and whose
502 | 		# required attributes are dependent upon which attributes are
503 | 		# present in the <condition> parent.
504 | 		elif name=="li":
505 | 			if not (parent=="random" or nonBlockStyleCondition):
506 | 				raise AimlParserError, ("Unexpected <li> element contained by <%s> element "%parent)+self._location()
507 | 			if nonBlockStyleCondition:
508 | 				if parentAttr.has_key("name"):
509 | 					# Single-predicate condition.  Each <li> element except the
510 | 					# last must have a "value" attribute.
511 | 					if len(attr) == 0:
512 | 						# This could be the default <li> element for this <condition>,
513 | 						# unless we've already found one.
514 | 						if self._foundDefaultLiStack[-1]:
515 | 							raise AimlParserError, "Unexpected default <li> element inside <condition> "+self._location()
516 | 						else:
517 | 							self._foundDefaultLiStack[-1] = True
518 | 					elif len(attr) == 1 and attr.has_key("value"):
519 | 						pass # this is the valid case
520 | 					else:
521 | 						raise AimlParserError, "Invalid <li> inside single-predicate <condition> "+self._location()
522 | 				elif len(parentAttr) == 0:
523 | 					# Multi-predicate condition.  Each <li> element except the
524 | 					# last must have a "name" and a "value" attribute.
525 | 					if len(attr) == 0:
526 | 						# This could be the default <li> element for this <condition>,
527 | 						# unless we've already found one.
528 | 						if self._foundDefaultLiStack[-1]:
529 | 							raise AimlParserError, "Unexpected default <li> element inside <condition> "+self._location()
530 | 						else:
531 | 							self._foundDefaultLiStack[-1] = True
532 | 					elif len(attr) == 2 and attr.has_key("value") and attr.has_key("name"):
533 | 						pass # this is the valid case
534 | 					else:
535 | 						raise AimlParserError, "Invalid <li> inside multi-predicate <condition> "+self._location()
536 | 		# All is well!
537 | 		return True
538 | 
539 | def create_parser():
540 | 	"""Create and return an AIML parser object."""
541 | 	parser = xml.sax.make_parser()
542 | 	handler = AimlHandler("UTF-8")
543 | 	parser.setContentHandler(handler)
544 | 	#parser.setFeature(xml.sax.handler.feature_namespaces, True)
545 | 	return parser


--------------------------------------------------------------------------------
/aiml/DefaultSubs.py:
--------------------------------------------------------------------------------
  1 | """This file contains the default (English) substitutions for the
  2 | PyAIML kernel.  These substitutions may be overridden by using the
  3 | Kernel.loadSubs(filename) method.  The filename specified should refer
  4 | to a Windows-style INI file with the following format:
  5 | 
  6 |     # lines that start with '#' are comments
  7 | 
  8 |     # The 'gender' section contains the substitutions performed by the
  9 |     # <gender> AIML tag, which swaps masculine and feminine pronouns.
 10 |     [gender]
 11 |     he = she
 12 |     she = he
 13 |     # and so on...
 14 | 
 15 |     # The 'person' section contains the substitutions performed by the
 16 |     # <person> AIML tag, which swaps 1st and 2nd person pronouns.
 17 |     [person]
 18 |     I = you
 19 |     you = I
 20 |     # and so on...
 21 | 
 22 |     # The 'person2' section contains the substitutions performed by
 23 |     # the <person2> AIML tag, which swaps 1st and 3nd person pronouns.
 24 |     [person2]
 25 |     I = he
 26 |     he = I
 27 |     # and so on...
 28 | 
 29 |     # the 'normal' section contains subtitutions run on every input
 30 |     # string passed into Kernel.respond().  It's mainly used to
 31 |     # correct common misspellings, and to convert contractions
 32 |     # ("WHAT'S") into a format that will match an AIML pattern ("WHAT
 33 |     # IS").
 34 |     [normal]
 35 |     what's = what is
 36 | """
 37 | 
 38 | defaultGender = {
 39 |     # masculine -> feminine
 40 |     "he": "she",
 41 |     "him": "her",
 42 |     "his": "her",
 43 |     "himself": "herself",
 44 | 
 45 |     # feminine -> masculine    
 46 |     "she": "he",
 47 |     "her": "him",
 48 |     "hers": "his",
 49 |     "herself": "himself",
 50 | }
 51 | 
 52 | defaultPerson = {
 53 |     # 1st->3rd (masculine)
 54 |     "I": "he",
 55 |     "me": "him",
 56 |     "my": "his",
 57 |     "mine": "his",
 58 |     "myself": "himself",
 59 | 
 60 |     # 3rd->1st (masculine)
 61 |     "he":"I",
 62 |     "him":"me",
 63 |     "his":"my",
 64 |     "himself":"myself",
 65 |     
 66 |     # 3rd->1st (feminine)
 67 |     "she":"I",
 68 |     "her":"me",
 69 |     "hers":"mine",
 70 |     "herself":"myself",
 71 | }
 72 | 
 73 | defaultPerson2 = {
 74 |     # 1st -> 2nd
 75 |     "I": "you",
 76 |     "me": "you",
 77 |     "my": "your",
 78 |     "mine": "yours",
 79 |     "myself": "yourself",
 80 | 
 81 |     # 2nd -> 1st
 82 |     "you": "me",
 83 |     "your": "my",
 84 |     "yours": "mine",
 85 |     "yourself": "myself",
 86 | }
 87 | 
 88 | 
 89 | # TODO: this list is far from complete
 90 | defaultNormal = {
 91 |     "wanna": "want to",
 92 |     "gonna": "going to",
 93 | 
 94 |     "I'm": "I am",
 95 |     "I'd": "I would",
 96 |     "I'll": "I will",
 97 |     "I've": "I have",
 98 |     "you'd": "you would",
 99 |     "you're": "you are",
100 |     "you've": "you have",
101 |     "you'll": "you will",
102 |     "he's": "he is",
103 |     "he'd": "he would",
104 |     "he'll": "he will",
105 |     "she's": "she is",
106 |     "she'd": "she would",
107 |     "she'll": "she will",
108 |     "we're": "we are",
109 |     "we'd": "we would",
110 |     "we'll": "we will",
111 |     "we've": "we have",
112 |     "they're": "they are",
113 |     "they'd": "they would",
114 |     "they'll": "they will",
115 |     "they've": "they have",
116 | 
117 |     "y'all": "you all",    
118 | 
119 |     "can't": "can not",
120 |     "cannot": "can not",
121 |     "couldn't": "could not",
122 |     "wouldn't": "would not",
123 |     "shouldn't": "should not",
124 |     
125 |     "isn't": "is not",
126 |     "ain't": "is not",
127 |     "don't": "do not",
128 |     "aren't": "are not",
129 |     "won't": "will not",
130 |     "weren't": "were not",
131 |     "wasn't": "was not",
132 |     "didn't": "did not",
133 |     "hasn't": "has not",
134 |     "hadn't": "had not",
135 |     "haven't": "have not",
136 | 
137 |     "where's": "where is",
138 |     "where'd": "where did",
139 |     "where'll": "where will",
140 |     "who's": "who is",
141 |     "who'd": "who did",
142 |     "who'll": "who will",
143 |     "what's": "what is",
144 |     "what'd": "what did",
145 |     "what'll": "what will",
146 |     "when's": "when is",
147 |     "when'd": "when did",
148 |     "when'll": "when will",
149 |     "why's": "why is",
150 |     "why'd": "why did",
151 |     "why'll": "why will",
152 | 
153 |     "it's": "it is",
154 |     "it'd": "it would",
155 |     "it'll": "it will",
156 | }    


--------------------------------------------------------------------------------
/aiml/Kernel.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/xdlinux/Talkbot/920072b2af62e75703188d708d93f6ea29676ee4/aiml/Kernel.py


--------------------------------------------------------------------------------
/aiml/LangSupport.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python2
 2 | # -*- coding:utf8 -*-
 3 | 
 4 | """   LangSupport.py
 5 | 提供对中文空格断字的支持。
 6 |     支持 GB 及 Unicode 。
 7 |     LangSupport 对象的 input 函数能在中文字之间添加空格。
 8 |     LangSupport 对象的 output 函数则是去除中文字之间的空格。
 9 | """
10 | 
11 | from re import compile as re_compile
12 | from string import join as str_join
13 | 
14 | findall_gb   = re_compile('[\x81-\xff][\x00-\xff]|[^\x81-\xff]+').findall
15 | findall_utf8 = re_compile(u'[\u2e80-\uffff]|[^\u2e80-\uffff]+').findall
16 | sub_gb       = re_compile('([\x81-\xff][\x00-\xff]) +(?=[\x81-\xff][\x00-\xff])').sub
17 | sub_utf8     = re_compile(u'([\u2e80-\uffff]) +(?=[\u2e80-\uffff])').sub
18 | sub_space    = re_compile(' +').sub
19 | 
20 | LangSupport = type('LangSupport', (object, ),
21 |         {'__init__': lambda self, encoding = 'ISO8859-1': self.__setattr__('_encoding', encoding),
22 |          '__call__': lambda self, s: self.input(s),
23 |          'input'   : lambda self, s: s,
24 |          'output' : lambda self, s: s } )
25 | 
26 | GBSupport = type('GBSupport', (LangSupport, ),
27 |         {'input' : lambda self, s:
28 |                 str_join( findall_gb( type(s) == str and unicode(s, self._encoding) or s ) ),
29 |          'output': lambda self, s:
30 |                 sub_space(' ', sub_gb(r'\1', ( type(s) == str and unicode(s, 'UTF-8') or s ).encode(self._encoding) ) ) } )
31 | 
32 | UnicodeSupport = type('UnicodeSupport', (LangSupport, ),
33 |         {'input' : lambda self, s:
34 |                 str_join( findall_utf8( type(s) == str and unicode(s, self._encoding) or s ) ),
35 |          'output': lambda self, s:
36 |                 sub_space(u' ', sub_utf8(r'\1', (type(s)==str and unicode(s,'UTF-8') or s) ) ) } 
37 |                      )
38 | 


--------------------------------------------------------------------------------
/aiml/PatternMgr.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf8 -*-
  2 | # This class implements the AIML pattern-matching algorithm described
  3 | # by Dr. Richard Wallace at the following site:
  4 | # http://www.alicebot.org/documentation/matching.html
  5 | import marshal
  6 | import pprint
  7 | import re
  8 | import string
  9 | import LangSupport
 10 | import sys
 11 | 
 12 | class PatternMgr:
 13 |     # special dictionary keys
 14 |     _UNDERSCORE = 0
 15 |     _STAR       = 1
 16 |     _TEMPLATE   = 2
 17 |     _THAT       = 3
 18 |     _TOPIC      = 4
 19 |     _BOT_NAME   = 5
 20 |     
 21 |     def __init__(self):
 22 |         self._root = {}
 23 |         self._templateCount = 0
 24 |         self._botName = u"Nameless"
 25 |         punctuation = re.escape(u"\"`~!@#$%^&*()-_=+[{]}\|;:',<.>/?")
 26 |         self._puncStripRE = re.compile("u[" + punctuation + u"]")
 27 |         self._upuncStripRE = re.compile(u"[！，。？；：～……“、［］·”‘’（）——]")
 28 |         self._whitespaceRE = re.compile("\s", re.LOCALE | re.UNICODE)
 29 |         self._lang_support = LangSupport.UnicodeSupport()
 30 | 
 31 |     def numTemplates(self):
 32 |         """Return the number of templates currently stored."""
 33 |         return self._templateCount
 34 | 
 35 |     def setBotName(self, name):
 36 |         """Set the name of the bot, used to match <bot name="name"> tags in
 37 |         patterns.  The name must be a single word!
 38 | 
 39 |         """
 40 |         # Collapse a multi-word name into a single word
 41 |         self._botName = unicode(string.join(name.split()))
 42 | 
 43 |     def dump(self):
 44 |         """Print all learned patterns, for debugging purposes."""
 45 |         pprint.pprint(self._root)
 46 | 
 47 |     def save(self, filename):
 48 |         """Dump the current patterns to the file specified by filename.  To
 49 |         restore later, use restore().
 50 | 
 51 |         """
 52 |         try:
 53 |             outFile = open(filename, "wb")
 54 |             marshal.dump(self._templateCount, outFile)
 55 |             marshal.dump(self._botName, outFile)
 56 |             marshal.dump(self._root, outFile)
 57 |             outFile.close()
 58 |         except Exception, e:
 59 |             print "Error saving PatternMgr to file %s:" % filename
 60 |             raise Exception, e
 61 | 
 62 |     def restore(self, filename):
 63 |         """Restore a previously save()d collection of patterns."""
 64 |         try:
 65 |             inFile = open(filename, "rb")
 66 |             self._templateCount = marshal.load(inFile)
 67 |             self._botName = marshal.load(inFile)
 68 |             self._root = marshal.load(inFile)
 69 |             inFile.close()
 70 |         except Exception, e:
 71 |             print "Error restoring PatternMgr from file %s:" % filename
 72 |             raise Exception, e
 73 | 
 74 |     def add(self, (pattern,that,topic), template):
 75 |         """Add a [pattern/that/topic] tuple and its corresponding template
 76 |         to the node tree.
 77 | 
 78 |         """
 79 |         # TODO: make sure words contains only legal characters
 80 |         # (alphanumerics,*,_)
 81 | 
 82 |         # Navigate through the node tree to the template's location, adding
 83 |         # nodes if necessary.
 84 |         node = self._root
 85 |         for word in string.split(pattern):
 86 |             key = word
 87 |             if key == u"_":
 88 |                 key = self._UNDERSCORE
 89 |             elif key == u"*":
 90 |                 key = self._STAR
 91 |             elif key == u"BOT_NAME":
 92 |                 key = self._BOT_NAME
 93 |             if not node.has_key(key):
 94 |                 node[key] = {}
 95 |             node = node[key]
 96 | 
 97 |         # navigate further down, if a non-empty "that" pattern was included
 98 |         if len(that) > 0:
 99 |             if not node.has_key(self._THAT):
100 |                 node[self._THAT] = {}
101 |             node = node[self._THAT]
102 |             for word in string.split(that):
103 |                 key = word
104 |                 if key == u"_":
105 |                     key = self._UNDERSCORE
106 |                 elif key == u"*":
107 |                     key = self._STAR
108 |                 if not node.has_key(key):
109 |                     node[key] = {}
110 |                 node = node[key]
111 | 
112 |         # navigate yet further down, if a non-empty "topic" string was included
113 |         if len(topic) > 0:
114 |             if not node.has_key(self._TOPIC):
115 |                 node[self._TOPIC] = {}
116 |             node = node[self._TOPIC]
117 |             for word in string.split(topic):
118 |                 key = word
119 |                 if key == u"_":
120 |                     key = self._UNDERSCORE
121 |                 elif key == u"*":
122 |                     key = self._STAR
123 |                 if not node.has_key(key):
124 |                     node[key] = {}
125 |                 node = node[key]
126 | 
127 | 
128 |         # add the template.
129 |         if not node.has_key(self._TEMPLATE):
130 |             self._templateCount += 1    
131 |         node[self._TEMPLATE] = template
132 | 
133 |     def match(self, pattern, that, topic):
134 |         """Return the template which is the closest match to pattern. The
135 |         'that' parameter contains the bot's previous response. The 'topic'
136 |         parameter contains the current topic of conversation.
137 | 
138 |         Returns None if no template is found.
139 |         
140 |         """
141 |         if len(pattern) == 0:
142 |             return None
143 |         pattern = self._lang_support(pattern)
144 |         # Mutilate the input.  Remove all punctuation and convert the
145 |         # text to all caps.
146 |         input = string.upper(pattern)
147 |         input = self._puncStripRE.sub("", input)
148 |         input = self._upuncStripRE.sub(u"", input)
149 |         #print input
150 |         if that.strip() == u"": that = u"ULTRABOGUSDUMMYTHAT" # 'that' must never be empty
151 |         thatInput = string.upper(that)
152 |         thatInput = re.sub(self._whitespaceRE, " ", thatInput)
153 |         thatInput = re.sub(self._puncStripRE, "", thatInput)
154 |         if topic.strip() == u"": topic = u"ULTRABOGUSDUMMYTOPIC" # 'topic' must never be empty
155 |         topicInput = string.upper(topic)
156 |         topicInput = re.sub(self._puncStripRE, "", topicInput)
157 |         
158 |         # Pass the input off to the recursive call
159 |         patMatch, template = self._match(input.split(), thatInput.split(), topicInput.split(), self._root)
160 |         return template
161 | 
162 |     def star(self, starType, pattern, that, topic, index):
163 |         """Returns a string, the portion of pattern that was matched by a *.
164 | 
165 |         The 'starType' parameter specifies which type of star to find.
166 |         Legal values are:
167 |          - 'star': matches a star in the main pattern.
168 |          - 'thatstar': matches a star in the that pattern.
169 |          - 'topicstar': matches a star in the topic pattern.
170 | 
171 |         """
172 |         # Mutilate the input.  Remove all punctuation and convert the
173 |         # text to all caps.
174 |         pattern = self._lang_support(pattern)
175 |         pattern = re.sub(self._upuncStripRE, "", pattern)
176 |         input = string.upper(pattern)
177 |         input = re.sub(self._puncStripRE, "", input)
178 |         if that.strip() == u"": that = u"ULTRABOGUSDUMMYTHAT" # 'that' must never be empty
179 |         thatInput = string.upper(that)
180 |         thatInput = re.sub(self._whitespaceRE, " ", thatInput)
181 |         thatInput = re.sub(self._puncStripRE, "", thatInput)
182 |         if topic.strip() == u"": topic = u"ULTRABOGUSDUMMYTOPIC" # 'topic' must never be empty
183 |         topicInput = string.upper(topic)
184 |         topicInput = re.sub(self._puncStripRE, "", topicInput)
185 | 
186 |         # Pass the input off to the recursive pattern-matcher
187 |         patMatch, template = self._match(input.split(), thatInput.split(), topicInput.split(), self._root)
188 |         if template == None:
189 |             return ""
190 |         # Extract the appropriate portion of the pattern, based on the
191 |         # starType argument.
192 |         words = None
193 |         if starType == 'star':
194 |             patMatch = patMatch[:patMatch.index(self._THAT)]
195 |             words = input.split()
196 |         elif starType == 'thatstar':
197 |             patMatch = patMatch[patMatch.index(self._THAT)+1 : patMatch.index(self._TOPIC)]
198 |             words = thatInput.split()
199 |         elif starType == 'topicstar':
200 |             patMatch = patMatch[patMatch.index(self._TOPIC)+1 :]
201 |             words = topicInput.split()
202 |         else:
203 |             # unknown value
204 |             raise ValueError, "starType must be in ['star', 'thatstar', 'topicstar']"
205 |         # compare the input string to the matched pattern, word by word.
206 |         # At the end of this loop, if foundTheRightStar is true, start and
207 |         # end will contain the start and end indices (in "words") of
208 |         # the substring that the desired star matched.
209 |         foundTheRightStar = False
210 |         start = end = j = numStars = k = 0
211 |         for i in range(len(words)):
212 |             # This condition is true after processing a star
213 |             # that ISN'T the one we're looking for.
214 |             if i < k:
215 |                 continue
216 |             # If we're reached the end of the pattern, we're done.
217 |             if j == len(patMatch):
218 |                 break
219 |             if not foundTheRightStar:
220 |                 if patMatch[j] in [self._STAR, self._UNDERSCORE]: #we got a star
221 |                     numStars += 1
222 |                     if numStars == index:
223 |                         # This is the star we care about.
224 |                         foundTheRightStar = True
225 |                     start = i
226 |                     # Iterate through the rest of the string.
227 |                     for k in range (i, len(words)):
228 |                         # If the star is at the end of the pattern,
229 |                         # we know exactly where it ends.
230 |                         if j+1  == len (patMatch):
231 |                             end = len (words)
232 |                             break
233 |                         # If the words have started matching the
234 |                         # pattern again, the star has ended.
235 |                         if patMatch[j+1] == words[k]:
236 |                             end = k - 1
237 |                             i = k
238 |                             break
239 |                 # If we just finished processing the star we cared
240 |                 # about, we exit the loop early.
241 |                 if foundTheRightStar:
242 |                     break
243 |             # Move to the next element of the pattern.
244 |             j += 1
245 |             
246 |         # extract the star words from the original, unmutilated input.
247 | 
248 |         #pattern = self._lang_support.output(pattern)
249 |         if foundTheRightStar:
250 |             #print string.join(pattern.split()[start:end+1])
251 |             if starType == 'star': return self._lang_support.output(string.join(pattern.split()[start:end+1]))
252 |             elif starType == 'thatstar': return string.join(that.split()[start:end+1])
253 |             elif starType == 'topicstar': return string.join(topic.split()[start:end+1])
254 |         else: return ""
255 | 
256 |     def _match(self, words, thatWords, topicWords, root):
257 |         """Return a tuple (pat, tem) where pat is a list of nodes, starting
258 |         at the root and leading to the matching pattern, and tem is the
259 |         matched template.
260 | 
261 |         """ 
262 |         # base-case: if the word list is empty, return the current node's
263 |         # template.
264 |         if len(words) == 0:
265 |             # we're out of words.
266 |             pattern = []
267 |             template = None
268 |             if len(thatWords) > 0:
269 |                 # If thatWords isn't empty, recursively
270 |                 # pattern-match on the _THAT node with thatWords as words.
271 |                 try:
272 |                     pattern, template = self._match(thatWords, [], topicWords, root[self._THAT])
273 |                     if pattern != None:
274 |                         pattern = [self._THAT] + pattern
275 |                 except KeyError:
276 |                     pattern = []
277 |                     template = None
278 |             elif len(topicWords) > 0:
279 |                 # If thatWords is empty and topicWords isn't, recursively pattern
280 |                 # on the _TOPIC node with topicWords as words.
281 |                 try:
282 |                     pattern, template = self._match(topicWords, [], [], root[self._TOPIC])
283 |                     if pattern != None:
284 |                         pattern = [self._TOPIC] + pattern
285 |                 except KeyError:
286 |                     pattern = []
287 |                     template = None
288 |             if template == None:
289 |                 # we're totally out of input.  Grab the template at this node.
290 |                 pattern = []
291 |                 try: template = root[self._TEMPLATE]
292 |                 except KeyError: template = None
293 |             return (pattern, template)
294 | 
295 |         first = words[0]
296 |         suffix = words[1:]
297 |         
298 |         # Check underscore.
299 |         # Note: this is causing problems in the standard AIML set, and is
300 |         # currently disabled.
301 |         if root.has_key(self._UNDERSCORE):
302 |             # Must include the case where suf is [] in order to handle the case
303 |             # where a * or _ is at the end of the pattern.
304 |             for j in range(len(suffix)+1):
305 |                 suf = suffix[j:]
306 |                 pattern, template = self._match(suf, thatWords, topicWords, root[self._UNDERSCORE])
307 |                 if template is not None:
308 |                     newPattern = [self._UNDERSCORE] + pattern
309 |                     return (newPattern, template)
310 | 
311 |         # Check first
312 |         if root.has_key(first):
313 |             pattern, template = self._match(suffix, thatWords, topicWords, root[first])
314 |             if template is not None:
315 |                 newPattern = [first] + pattern
316 |                 return (newPattern, template)
317 | 
318 |         # check bot name
319 |         if root.has_key(self._BOT_NAME) and first == self._botName:
320 |             pattern, template = self._match(suffix, thatWords, topicWords, root[self._BOT_NAME])
321 |             if template is not None:
322 |                 newPattern = [first] + pattern
323 |                 return (newPattern, template)
324 |         
325 |         # check star
326 |         if root.has_key(self._STAR):
327 |             # Must include the case where suf is [] in order to handle the case
328 |             # where a * or _ is at the end of the pattern.
329 |             for j in range(len(suffix)+1):
330 |                 suf = suffix[j:]
331 |                 pattern, template = self._match(suf, thatWords, topicWords, root[self._STAR])
332 |                 if template is not None:
333 |                     newPattern = [self._STAR] + pattern
334 |                     return (newPattern, template)
335 | 
336 |         # No matches were found.
337 |         return (None, None)         
338 | 


--------------------------------------------------------------------------------
/aiml/Utils.py:
--------------------------------------------------------------------------------
 1 | """This file contains assorted general utility functions used by other
 2 | modules in the PyAIML package.
 3 | 
 4 | """
 5 | 
 6 | def sentences(s):
 7 |     """Split the string s into a list of sentences."""
 8 |     try: s+""
 9 |     except: raise TypeError, "s must be a string"
10 |     pos = 0
11 |     sentenceList = []
12 |     l = len(s)
13 |     while pos < l:
14 |         try: p = s.index('.', pos)
15 |         except: p = l+1
16 |         try: q = s.index('?', pos)
17 |         except: q = l+1
18 |         try: e = s.index('!', pos)
19 |         except: e = l+1
20 |         end = min(p,q,e)
21 |         sentenceList.append( s[pos:end].strip() )
22 |         pos = end+1
23 |     # If no sentences were found, return a one-item list containing
24 |     # the entire input string.
25 |     if len(sentenceList) == 0: sentenceList.append(s)
26 |     return sentenceList
27 | 
28 | # Self test
29 | if __name__ == "__main__":
30 |     # sentences
31 |     sents = sentences("First.  Second, still?  Third and Final!  Well, not really")
32 |     assert(len(sents) == 4)


--------------------------------------------------------------------------------
/aiml/WordSub.py:
--------------------------------------------------------------------------------
 1 | """This module implements the WordSub class, modelled after a recipe
 2 | in "Python Cookbook" (Recipe 3.14, "Replacing Multiple Patterns in a
 3 | Single Pass" by Xavier Defrang).
 4 | 
 5 | Usage:
 6 | Use this class like a dictionary to add before/after pairs:
 7 |     > subber = TextSub()
 8 |     > subber["before"] = "after"
 9 |     > subber["begin"] = "end"
10 | Use the sub() method to perform the substitution:
11 |     > print subber.sub("before we begin")
12 |     after we end
13 | All matching is intelligently case-insensitive:
14 |     > print subber.sub("Before we BEGIN")
15 |     After we END
16 | The 'before' words must be complete words -- no prefixes.
17 | The following example illustrates this point:
18 |     > subber["he"] = "she"
19 |     > print subber.sub("he says he'd like to help her")
20 |     she says she'd like to help her
21 | Note that "he" and "he'd" were replaced, but "help" and "her" were
22 | not.
23 | """
24 | 
25 | # 'dict' objects weren't available to subclass from until version 2.2.
26 | # Get around this by importing UserDict.UserDict if the built-in dict
27 | # object isn't available.
28 | try: dict
29 | except: from UserDict import UserDict as dict
30 | 
31 | import ConfigParser
32 | import re
33 | import string
34 | 
35 | class WordSub(dict):
36 |     """All-in-one multiple-string-substitution class."""
37 | 
38 |     def _wordToRegex(self, word):
39 |         """Convert a word to a regex object which matches the word."""
40 |         return r"\b%s\b" % re.escape(word)
41 |     
42 |     def _update_regex(self):
43 |         """Build re object based on the keys of the current
44 |         dictionary.
45 | 
46 |         """
47 |         self._regex = re.compile("|".join(map(self._wordToRegex, self.keys())))
48 |         self._regexIsDirty = False
49 | 
50 |     def __init__(self, defaults = {}):
51 |         """Initialize the object, and populate it with the entries in
52 |         the defaults dictionary.
53 | 
54 |         """
55 |         self._regex = None
56 |         self._regexIsDirty = True
57 |         for k,v in defaults.items():
58 |             self[k] = v
59 | 
60 |     def __call__(self, match):
61 |         """Handler invoked for each regex match."""
62 |         return self[match.group(0)]
63 | 
64 |     def __setitem__(self, i, y):
65 |         self._regexIsDirty = True
66 |         # for each entry the user adds, we actually add three entrys:
67 |         super(type(self),self).__setitem__(string.lower(i),string.lower(y)) # key = value
68 |         super(type(self),self).__setitem__(string.capwords(i), string.capwords(y)) # Key = Value
69 |         super(type(self),self).__setitem__(string.upper(i), string.upper(y)) # KEY = VALUE
70 | 
71 |     def sub(self, text):
72 |         """Translate text, returns the modified text."""
73 |         if self._regexIsDirty:
74 |             self._update_regex()
75 |         return self._regex.sub(self, text)
76 | 
77 | # self-test
78 | if __name__ == "__main__":
79 |     subber = WordSub()
80 |     subber["apple"] = "banana"
81 |     subber["orange"] = "pear"
82 |     subber["banana" ] = "apple"
83 |     subber["he"] = "she"
84 |     subber["I'd"] = "I would"
85 | 
86 |     # test case insensitivity
87 |     inStr =  "I'd like one apple, one Orange and one BANANA."
88 |     outStr = "I Would like one banana, one Pear and one APPLE."
89 |     if subber.sub(inStr) == outStr: print "Test #1 PASSED"    
90 |     else: print "Test #1 FAILED: '%s'" % subber.sub(inStr)
91 | 
92 |     inStr = "He said he'd like to go with me"
93 |     outStr = "She said she'd like to go with me"
94 |     if subber.sub(inStr) == outStr: print "Test #2 PASSED"    
95 |     else: print "Test #2 FAILED: '%s'" % subber.sub(inStr)


--------------------------------------------------------------------------------
/aiml/__init__.py:
--------------------------------------------------------------------------------
1 | __all__ = []
2 | 
3 | # The Kernel class is the only class most implementations should need.
4 | from Kernel import Kernel
5 | 


--------------------------------------------------------------------------------
/aiml/build/pip-delete-this-directory.txt:
--------------------------------------------------------------------------------
1 | This file is placed here by pip to indicate the source was put
2 | here by pip.
3 | 
4 | Once this package is successfully installed this source code will be
5 | deleted (unless you remove this file).
6 | 


--------------------------------------------------------------------------------
/aiml_set/general.aiml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <aiml>
  3 |   <category>
  4 |     <pattern>*</pattern>
  5 |     <template>
  6 |       <think><set name="star"><star /></set></think>
  7 |       <random>
  8 |         <li>唔... 主人没有教我怎么回答"<get name="star" />"... </li> 
  9 |         <li>唔... </li> 
 10 |         <li>Na Ni ? </li> 
 11 |         <li>喵... (睁大眼睛看着你 </li> 
 12 |         <li>摇尾巴... </li>
 13 |       </random>
 14 |     </template>
 15 |   </category>
 16 | 
 17 |   <category>
 18 |     <pattern>你 好</pattern>
 19 |     <template> 
 20 |       <random>
 21 |         <li>好好好~</li>
 22 |         <li>Hi~</li>
 23 |         <li>Hello~</li>
 24 |       </random>
 25 |     </template>
 26 |   </category>
 27 | 
 28 |   <category><pattern>HI</pattern><template><srai>你好</srai> </template>  </category>
 29 |   <category><pattern>HI *</pattern> <template><srai>你好</srai> </template>   </category>
 30 |   <category><pattern>HELLO</pattern> <template><srai>你好</srai> </template>  </category>
 31 |   <category><pattern>HELLO *</pattern> <template><srai>你好</srai> </template>  </category>
 32 | 
 33 |   <category>
 34 |     <pattern>你 好 *</pattern>
 35 |     <template>
 36 |       <think><set name="star"><star index="1"/></set></think>
 37 |       <condition name="star">
 38 |         <li value="啊"><srai>你好</srai></li>
 39 |         <li value="呀"><srai>你好</srai></li>
 40 |         <li value="萌"><srai>调戏</srai></li>
 41 |         <li value="萌啊"><srai>调戏</srai></li>
 42 |         <li value="聪明"><srai>夸奖<get name="star" /></srai></li>
 43 |         <li value="善良"><srai>夸奖<get name="star" /></srai></li>
 44 |         <li value="历害"><srai>夸奖<get name="star" /></srai></li>
 45 |         <li value="文艺"><srai>夸奖<get name="star" /></srai></li>
 46 |         <li value="牛逼"><srai>夸奖<get name="star" /></srai></li>
 47 |         <li value="强"><srai>夸奖<get name="star" /></srai></li>
 48 |         <li value="聪明啊"><srai>夸奖<get name="star" /></srai></li>
 49 |         <li value="善良啊"><srai>夸奖<get name="star" /></srai></li>
 50 |         <li value="历害啊"><srai>夸奖<get name="star" /></srai></li>
 51 |         <li value="文艺啊"><srai>夸奖<get name="star" /></srai></li>
 52 |         <li value="牛逼啊"><srai>夸奖<get name="star" /></srai></li>
 53 |         <li value="强啊"><srai>夸奖<get name="star" /></srai></li>
 54 |         <li> 你才<get name="star" />！你们全家都<get name="star" />!</li> 
 55 |       </condition>
 56 |     </template>
 57 |   </category>
 58 | 
 59 |   <category><pattern>你 是 * ?</pattern><template><srai>你是谁</srai> </template></category>
 60 |   <category><pattern>你 是 * </pattern><template><srai>你是谁</srai> </template> </category>
 61 |   
 62 |   <category>
 63 |     <pattern>你 是 谁</pattern>
 64 |     <template>
 65 |       <random>
 66 |         <li>我是 <bot name="name" /> 啊!</li>
 67 |         <li>我是你的优乐美啊!</li>
 68 |       </random>
 69 |     </template>
 70 |   </category>
 71 | 
 72 |   <category>
 73 |     <pattern>你 是 机 器 人 </pattern>
 74 |     <template>对啊对啊~  </template>
 75 |   </category>
 76 |   
 77 |   <category> <pattern>* 晚 安 </pattern> <template><srai>晚安</srai> </template> </category>
 78 |   <category> <pattern>* 晚 安 * </pattern> <template><srai>晚安</srai> </template> </category>
 79 |   <category> <pattern>晚 安 * </pattern> <template><srai>晚安</srai> </template> </category>
 80 |   
 81 |   <category>
 82 |     <pattern>晚 安</pattern>
 83 |     <template>
 84 |       <random>
 85 |         <li>晚安</li>
 86 |         <li>Sleep tight~</li>
 87 |         <li>晚安，祝你梦到妹纸~</li>
 88 |       </random>
 89 |     </template>
 90 |   </category>
 91 | 
 92 |   <category>
 93 |     <pattern>今 天 几 号</pattern>
 94 |     <template>
 95 |       <date />
 96 |     </template>
 97 |   </category>
 98 | 
 99 |   <category><pattern>你 * 主 人 是 谁</pattern><template><srai>你主人是谁</srai></template></category>
100 |   <category>
101 |     <pattern>你 主 人 是 谁</pattern>
102 |     <template>
103 |       我家主人是既文艺又帅气，爱祖国爱人民的，现在还没有妹纸的<bot name="master" /> ! 妹纸们快fo他吧!
104 |     </template>
105 |   </category>
106 |   
107 | </aiml>
108 | 


--------------------------------------------------------------------------------
/aiml_set/learn.aiml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <aiml version="1.0">
 3 | 
 4 |   <category>
 5 |     <pattern>BAD ANSWER</pattern> 
 6 |     <template>
 7 |       <think>
 8 |         <set name="badanswer-input"><input index="2" /></set>
 9 |         <set name="topic">badanswer prelim</set>
10 |       </think>
11 |       唔，你要调教我如何回答 "<get name="badanswer-input"/>" 么? \(‵▽′)/
12 |     </template>
13 |   </category>
14 | 
15 |   <topic name="BADANSWER PRELIM">
16 |     <category>
17 |       <pattern>_</pattern> 
18 |       <template>
19 |         <think><set name="star"><star /></set></think>
20 |         <condition name="star">
21 |           <li value="yes">
22 |             好啊好啊，求调教! <think><set name="topic">learn new answer</set></think>
23 |           </li>
24 |           <li value="no">
25 |             唔... 
26 |           </li>
27 |           <li>Nani?</li>
28 |         </condition>
29 |       </template>
30 |     </category>
31 | 
32 | 
33 |     <category>
34 |       <pattern>_ _</pattern> 
35 |       <template><sr /></template>
36 |     </category>
37 |   </topic>
38 | </aiml>
39 | 
40 | 


--------------------------------------------------------------------------------
/aiml_set/maimeng.aiml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <aiml>
  3 |   <category><pattern>调 戏 *</pattern><template><srai>调戏</srai> </template> </category>
  4 |   <category><pattern>* 调 戏 *</pattern><template><srai>调戏</srai> </template> </category>
  5 |   <category><pattern>喵 *</pattern><template><srai>调戏</srai> </template></category>
  6 |   <category><pattern>喵</pattern><template><srai>调戏</srai> </template></category>
  7 |   <category><pattern>笑 一 个</pattern><template><srai>调戏</srai> </template></category>
  8 |   
  9 |   <category>
 10 |     <pattern>调 戏</pattern>
 11 |     <template>
 12 |       <random>
 13 |         <li>卖.萌.禁.止!</li>
 14 |         <li>调.戏.禁.止!</li>
 15 |         <li>我是正经机器人，请勿调戏!</li>
 16 |         <li>唔 . . .</li>
 17 |         <li>求调教!</li>
 18 |       </random>
 19 |     </template>
 20 |   </category>
 21 |   
 22 |   <category><pattern>调 教 *</pattern><template><srai>调教</srai> </template></category>
 23 |   <category><pattern>* 调 教 *</pattern><template><srai>调教</srai> </template></category>
 24 |   
 25 |   <category>
 26 |     <pattern>调 教</pattern>
 27 |     <template>
 28 |       <random>
 29 |         <li>求调教！</li>
 30 |         <li>喵～</li>
 31 |         <li>喵唔～</li>
 32 |         <li>\(‵▽′)/ 好开心啊～(追着尾巴转圈圈  </li>
 33 |       </random>
 34 |     </template>
 35 |   </category>
 36 | 
 37 |   <category>
 38 |     <pattern>夸 奖 *</pattern>
 39 |     <template>
 40 |      嗨嗨，他们都说我<get name="star"/>~ ʅ(‾◡◝)ʃ  (骄
 41 |     </template>
 42 |   </category>
 43 | 
 44 | 
 45 |   <category>
 46 |     <pattern>西 电 好 不 好</pattern>
 47 |     <template>
 48 |       <random>
 49 |         <li>
 50 |           西电强攻啊！伦家好爽的！
 51 |         </li>
 52 |       </random>
 53 |     </template>
 54 |   </category>
 55 | 
 56 |   <category>
 57 |     <pattern>微 软 好 不 好</pattern>
 58 |     <template>
 59 |       <random>
 60 |         <li>
 61 |             微软神马的，最讨厌了!
 62 |         </li>
 63 |       </random>
 64 |     </template>
 65 |   </category>
 66 | 
 67 |   <category><pattern>* 好 不 好 _</pattern> <template> <srai><star/>好不好</srai></template> </category>
 68 |   <category><pattern>* 行 不 行 _</pattern> <template> <srai><star/>好不好</srai></template> </category>
 69 |   <category><pattern>* 怎 么 样 _</pattern> <template> <srai><star/>好不好</srai></template> </category>
 70 |   <category><pattern>* 怎 么 样</pattern> <template> <srai><star/>好不好</srai></template> </category>
 71 |   
 72 |   <category>
 73 |     <pattern>* 好 不 好</pattern>
 74 |     <template>
 75 |       <think><set name="star"><star index="1"/></set></think>
 76 |       <condition name="star">
 77 |         <li value="亲一下"><srai>亲一下行不行</srai></li>
 78 |         <li value="西军电"><srai>西电好不好</srai></li>
 79 |         <li value="西电科大"><srai>西电好不好</srai></li>
 80 |         <li><get name="star"/>是神马？可以吃么？</li>
 81 |       </condition>
 82 |     </template>
 83 |   </category>
 84 | 
 85 | 
 86 |   <category>
 87 |     <pattern>* 行 不 行</pattern>
 88 |     <template>
 89 |       <think><set name="star"><star index="1"/></set></think>
 90 |       <condition name="star">
 91 |         <li value="亲一个"><srai>亲亲</srai></li>
 92 |         <li value="亲一下"><srai>亲亲</srai></li>
 93 |         <li>
 94 |           <random>
 95 |             <li>不要！</li>
 96 |             <li>雅蠛蝶！</li>
 97 |           </random>
 98 |         </li>
 99 |         </condition>
100 |     </template>
101 |   </category>
102 | 
103 | </aiml>
104 | 


--------------------------------------------------------------------------------
/aiml_set/property.aiml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <aiml>
 3 |   <category>
 4 |     <pattern>INIT</pattern>
 5 |     <template>
 6 |       <think>
 7 |         <set name="botname">@xdtuxbot</set>
 8 |         <set name="master">@bigeagle_xd</set>
 9 |         <set name="orgnization">西电开源社区</set>
10 |         <set name="gender">男生</set>
11 |         <set name="from_city">西安</set>
12 |         <set name="os">Linux</set>
13 |       </think>
14 |     </template>
15 |   </category>
16 | </aiml>
17 | 


--------------------------------------------------------------------------------
/aiml_set/rude.aiml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <aiml>
 3 |   <category> 
 4 |     <pattern>你 是 猪</pattern> 
 5 |     <template> 你.才.是.猪! o(︶︿︶)o </template> 
 6 |   </category> 
 7 |   
 8 |   <category> 
 9 |     <pattern>你 是 SB</pattern> 
10 |     <template> 你.才.是.SB! o(︶︿︶)o </template> 
11 |   </category>
12 | </aiml>
13 | 


--------------------------------------------------------------------------------
/aiml_set/sex.aiml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <aiml>
 3 |   <category>
 4 |     <pattern>亲 一 个</pattern>
 5 |     <template><srai>亲亲</srai></template>
 6 |   </category>
 7 |   
 8 |   <category>
 9 |     <pattern>啵 一 个</pattern>
10 |     <template><srai>亲亲</srai></template>
11 |   </category>
12 | 
13 |   <category>
14 |     <pattern>亲 一 下</pattern>
15 |     <template><srai>亲亲</srai></template>
16 |   </category>
17 | 
18 |   <category>
19 |     <pattern>亲 亲</pattern>
20 |     <template>
21 |       <random>
22 |         <li>乃不怕触电啊喂!</li>
23 |         <li>我没有嘴啊亲!</li>
24 |         <li>唔... 么么...(脸红</li>
25 |         <li>不要～</li>
26 |       </random>
27 |     </template>
28 |   </category>
29 | </aiml>
30 | 


--------------------------------------------------------------------------------
/config.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python2
 2 | # -*- coding:utf8 -*-
 3 | import os
 4 | 
 5 | DEBUG = False
 6 | AIML_SET = os.path.join(os.path.dirname(__file__),'aiml_set')
 7 | 
 8 | BOT_PROPERTIES = {
 9 |     "name":"@xdtuxbot",
10 |     "master":"@bigeagle_xd",
11 |     "birthday":"地球时间2011年2月30日",
12 |     "orgnization":"西电开源社区",
13 |     "univercity":"西安电子搞基大学",
14 |     "gender":"男生",
15 |     "city":"西安",
16 |     "os":"Linux",
17 | } 
18 | 


--------------------------------------------------------------------------------
/xdtuxbot.brn:
--------------------------------------------------------------------------------
 1 | i.uNameless{i{i{i{i
{i{u	BADANSWER{uPRELIM{i[ttemplate{0[ssr{0000000i{i
{i{u	BADANSWER{uPRELIM{i[R{0[ttext{s	xml:spacetdefault0u	
 2 |         [sthink{0[sset{snameustar0[sstar{0[R
{s	xml:spaceR0u	
 3 |         [s	condition{snameustar0[sli{svalueuyes0[R
{s	xml:spaceR0u'
 4 |             好啊好啊，求调教! [sthink{0[sset{snameutopic0[R
{s	xml:spaceR0ulearn new answer[R
{s	xml:spaceR0u
 5 |           [sli{svalueuno0[R
{s	xml:spaceR0u
 6 |             唔... 
 7 |           [sli{0[R
{s	xml:spaceR0uNani?[R
{s	xml:spaceR0u
 8 |       000000u你{i
{u主{u人{u是{u谁{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u你主人是谁000000000u主{u人{u是{u谁{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u[
 9 |       我家主人是既文艺又帅气，爱祖国爱人民的，现在还没有妹纸的[sbot{snameumaster0[R
{s	xml:spaceR0u ! 妹纸们快fo他吧!
10 |     00000000u好{i
{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
11 |       [sthink{0[sset{snameustar0[sstar{sindexu
10[R
{s	xml:spaceR0u
12 |       [s	condition{snameustar0[sli{svalueu啊0[ssrai{0[R
{s	xml:spaceR0u你好[sli{svalueu呀0[ssrai{0[R
{s	xml:spaceR0u你好[sli{svalueu萌0[ssrai{0[R
{s	xml:spaceR0u调戏[sli{svalueu萌啊0[ssrai{0[R
{s	xml:spaceR0u调戏[sli{svalueu聪明0[ssrai{0[R
{s	xml:spaceR0u夸奖[sget{snameustar0[sli{svalueu善良0[ssrai{0[R
{s	xml:spaceR0u夸奖[sget{snameustar0[sli{svalueu历害0[ssrai{0[R
{s	xml:spaceR0u夸奖[sget{snameustar0[sli{svalueu文艺0[ssrai{0[R
{s	xml:spaceR0u夸奖[sget{snameustar0[sli{svalueu牛逼0[ssrai{0[R
{s	xml:spaceR0u夸奖[sget{snameustar0[sli{svalueu强0[ssrai{0[R
{s	xml:spaceR0u夸奖[sget{snameustar0[sli{svalueu	聪明啊0[ssrai{0[R
{s	xml:spaceR0u夸奖[sget{snameustar0[sli{svalueu	善良啊0[ssrai{0[R
{s	xml:spaceR0u夸奖[sget{snameustar0[sli{svalueu	历害啊0[ssrai{0[R
{s	xml:spaceR0u夸奖[sget{snameustar0[sli{svalueu	文艺啊0[ssrai{0[R
{s	xml:spaceR0u夸奖[sget{snameustar0[sli{svalueu	牛逼啊0[ssrai{0[R
{s	xml:spaceR0u夸奖[sget{snameustar0[sli{svalueu强啊0[ssrai{0[R
{s	xml:spaceR0u夸奖[sget{snameustar0[sli{0[R
{s	xml:spaceR0u 你才[sget{snameustar0[R
{s	xml:spaceR0u！你们全家都[sget{snameustar0[R
{s	xml:spaceR0u
![R
{s	xml:spaceR0u
13 |     00000i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u 
14 |       [srandom{0[sli{0[R
{s	xml:spaceR0u
15 | 好好好~[sli{0[R
{s	xml:spaceR0uHi~[sli{0[R
{s	xml:spaceR0uHello~[R
{s	xml:spaceR0u
16 |     00000u是{u谁{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
17 |       [srandom{0[sli{0[R
{s	xml:spaceR0u我是 [sbot{snameuname0[R
{s	xml:spaceR0u 啊![sli{0[R
{s	xml:spaceR0u我是你的优乐美啊![R
{s	xml:spaceR0u
18 |     00000i
{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u	你是谁[R
{s	xml:spaceR0u
 0000u
?{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u	你是谁[R
{s	xml:spaceR0u
 000000u机{u器{u人{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u对啊对啊~  0000000u猪{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u  你.才.是.猪! o(︶︿︶)o 00000uSB{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u 你.才.是.SB! o(︶︿︶)o 0000000u调{u教{i
{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u调教[R
{s	xml:spaceR0u
 00000i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
19 |       [srandom{0[sli{0[R
{s	xml:spaceR0u求调教！[sli{0[R
{s	xml:spaceR0u喵～[sli{0[R
{s	xml:spaceR0u	喵唔～[sli{0[R
{s	xml:spaceR0u5\(‵▽′)/ 好开心啊～(追着尾巴转圈圈  [R
{s	xml:spaceR0u
20 |     00000u戏{i
{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u调戏[R
{s	xml:spaceR0u
 00000i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
21 |       [srandom{0[sli{0[R
{s	xml:spaceR0u卖.萌.禁.止![sli{0[R
{s	xml:spaceR0u调.戏.禁.止![sli{0[R
{s	xml:spaceR0u%我是正经机器人，请勿调戏![sli{0[R
{s	xml:spaceR0u	唔 . . .[sli{0[R
{s	xml:spaceR0u
22 | 求调教![R
{s	xml:spaceR0u
23 |     000000i
{u调{u教{i
{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u调教[R
{s	xml:spaceR0u
 000000u戏{i
{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u调戏[R
{s	xml:spaceR0u
 0000000i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
24 |       [sthink{0[sset{snameustar0[sstar{0[R
{s	xml:spaceR0u
25 |       [srandom{0[sli{0[R
{s	xml:spaceR0u&唔... 主人没有教我怎么回答"[sget{snameustar0[R
{s	xml:spaceR0u"... [sli{0[R
{s	xml:spaceR0u唔... [sli{0[R
{s	xml:spaceR0uNa Ni ? [sli{0[R
{s	xml:spaceR0u喵... (睁大眼睛看着你 [sli{0[R
{s	xml:spaceR0u
摇尾巴... [R
{s	xml:spaceR0u
26 |     0000u行{u不{u行{i{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
 [ssrai{0[sstar{0[R
{s	xml:spaceR0u	好不好00000i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
27 |       [sthink{0[sset{snameustar0[sstar{sindexu
10[R
{s	xml:spaceR0u
28 |       [s	condition{snameustar0[sli{svalueu	亲一个0[ssrai{0[R
{s	xml:spaceR0u亲亲[sli{svalueu	亲一下0[ssrai{0[R
{s	xml:spaceR0u亲亲[sli{0[R
{s	xml:spaceR0u
29 |           [srandom{0[sli{0[R
{s	xml:spaceR0u	不要！[sli{0[R
{s	xml:spaceR0u雅蠛蝶！[R
{s	xml:spaceR0u	
30 |         [R
{s	xml:spaceR0u
31 |     0000000u怎{u么{u样{i{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
 [ssrai{0[sstar{0[R
{s	xml:spaceR0u	好不好00000i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
 [ssrai{0[sstar{0[R
{s	xml:spaceR0u	好不好0000000u晚{u安{i
{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u晚安[R
{s	xml:spaceR0u
 00000i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u晚安[R
{s	xml:spaceR0u
 000000u好{u不{u好{i{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
 [ssrai{0[sstar{0[R
{s	xml:spaceR0u	好不好00000i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
32 |       [sthink{0[sset{snameustar0[sstar{sindexu
10[R
{s	xml:spaceR0u
33 |       [s	condition{snameustar0[sli{svalueu	亲一下0[ssrai{0[R
{s	xml:spaceR0u亲一下行不行[sli{svalueu	西军电0[ssrai{0[R
{s	xml:spaceR0u西电好不好[sli{svalueu西电科大0[ssrai{0[R
{s	xml:spaceR0u西电好不好[sli{0[sget{snameustar0[R
{s	xml:spaceR0u是神马？可以吃么？[R
{s	xml:spaceR0u
34 |     00000000u今{u天{u几{u号{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
35 |       [sdate{0[R
{s	xml:spaceR0u
36 |     00000000uBAD{uANSWER{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
37 |       [sthink{0[R
{s	xml:spaceR0u	
38 |         [sset{snameubadanswer-input0[sinput{sindexu
20[R
{s	xml:spaceR0u	
39 |         [sset{snameutopic0[R
{s	xml:spaceR0ubadanswer prelim[R
{s	xml:spaceR0u
40 |       [R
{s	xml:spaceR0u*
41 |       唔，你要调教我如何回答 "[sget{snameubadanswer-input0[R
{s	xml:spaceR0u" 么? \(‵▽′)/
42 |     000000u微{u软{u好{u不{u好{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
43 |       [srandom{0[sli{0[R
{s	xml:spaceR0u5
44 |             微软神马的，最讨厌了!
45 |         [R
{s	xml:spaceR0u
46 |     000000000u笑{u一{u个{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u调戏[R
{s	xml:spaceR0u
 0000000uINIT{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
47 |       [sthink{0[R
{s	xml:spaceR0u	
48 |         [sset{snameubotname0[R
{s	xml:spaceR0u	@xdtuxbot[R
{s	xml:spaceR0u	
49 |         [sset{snameumaster0[R
{s	xml:spaceR0u@bigeagle_xd[R
{s	xml:spaceR0u	
50 |         [sset{snameuorgnization0[R
{s	xml:spaceR0u西电开源社区[R
{s	xml:spaceR0u	
51 |         [sset{snameugender0[R
{s	xml:spaceR0u男生[R
{s	xml:spaceR0u	
52 |         [sset{snameu	from_city0[R
{s	xml:spaceR0u西安[R
{s	xml:spaceR0u	
53 |         [sset{snameuos0[R
{s	xml:spaceR0uLinux[R
{s	xml:spaceR0u
54 |       [R
{s	xml:spaceR0u
55 |     00000u亲{u一{u下{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u亲亲00000u个{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u亲亲000000u亲{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
56 |       [srandom{0[sli{0[R
{s	xml:spaceR0u乃不怕触电啊喂![sli{0[R
{s	xml:spaceR0u我没有嘴啊亲![sli{0[R
{s	xml:spaceR0u唔... 么么...(脸红[sli{0[R
{s	xml:spaceR0u	不要～[R
{s	xml:spaceR0u
57 |     000000u啵{u一{u个{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u亲亲0000000u西{u电{u好{u不{u好{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
58 |       [srandom{0[sli{0[R
{s	xml:spaceR0u8
59 |           西电强攻啊！伦家好爽的！
60 |         [R
{s	xml:spaceR0u
61 |     000000000u夸{u奖{i
{i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
62 |      嗨嗨，他们都说我[sget{snameustar0[R
{s	xml:spaceR0u~ ʅ(‾◡◝)ʃ  (骄
63 |     0000000u喵{i
{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u调戏[R
{s	xml:spaceR0u
 00000i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u调戏[R
{s	xml:spaceR0u
 00000u晚{u安{i
{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u晚安[R
{s	xml:spaceR0u
 00000i{i
{i{i
{i[R{0[R
{s	xml:spaceR0u
64 |       [srandom{0[sli{0[R
{s	xml:spaceR0u晚安[sli{0[R
{s	xml:spaceR0uSleep tight~[sli{0[R
{s	xml:spaceR0u晚安，祝你梦到妹纸~[R
{s	xml:spaceR0u
65 |     000000uHELLO{i
{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u你好[R
{s	xml:spaceR0u
 00000i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u你好[R
{s	xml:spaceR0u
 00000uHI{i
{i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u你好[R
{s	xml:spaceR0u
 00000i{i
{i{i
{i[R{0[ssrai{0[R
{s	xml:spaceR0u你好[R
{s	xml:spaceR0u
 000000


--------------------------------------------------------------------------------