def test_do_exception(self):
from database import AbilityRecord,WordRecord
from body import Body,BodyException
b = Body()
with self.assertRaises(BodyException):
b.do([AbilityRecord("[0]")])
with self.assertRaises(BodyException):
self.b.do([AbilityRecord("[1]")])
class BodyTest(unittest.TestCase):
def setUp(self):
from body import Body
from database import AbilitiesDataBase
from abilities import a_test
ab_db = AbilitiesDataBase()
ab_db.addAbility(0,a_test.Test())
self.b = Body()
self.b.abilitiesDataBase(ab_db)
def test_abilitiesDataBase(self):
from database import AbilitiesDataBase
ab_db = AbilitiesDataBase()
self.b.abilitiesDataBase(ab_db)
def test_do_empty(self):
data = self.b.do([])
self.assertEqual(data,[])
def test_do(self):
from database import AbilityRecord,WordRecord
answer = self.b.do([AbilityRecord("[0]")])
for word in answer:
self.assertIsInstance(word,WordRecord)
answer = self.b.do([WordRecord("aaa"),WordRecord("bbb")])
self.assertIsInstance(answer[0],WordRecord)
self.assertIsInstance(answer[1],WordRecord)
self.assertEqual(answer[0],WordRecord("aaa"))
self.assertEqual(answer[1],WordRecord("bbb"))
def test_do_exception(self):
from database import AbilityRecord,WordRecord
from body import Body,BodyException
b = Body()
with self.assertRaises(BodyException):
b.do([AbilityRecord("[0]")])
with self.assertRaises(BodyException):
self.b.do([AbilityRecord("[1]")])
class Jarvis(object):
"""
Main Jarivs class
Attributes:
_brain - Brain object
_body - Body object
_word_db - Words database
_traning_db - Training database
_stop_event - Stop event
"""
def __init__(self):
from neural import LookUpTableBrain
from body import Body
from voice import Voice
from neural import InnerVoice
import threading
self._brain = LookUpTableBrain()
self._body = Body()
self._voice = Voice()
self._inner_voices = InnerVoice()
self._inner_voices.jarvis(self)
self._word_db = None
self._traning_db = None
self._stop_event = threading.Event()
def respond(self,request):
"""
This method responds to request
Input:
request - Request (string)
Returns:
answer
"""
from database import DataBaseException
from database import WordParser
from body import BodyException
from neural import BrainException
if self._word_db == None: raise JarvisException("Don't have dictionary.")
try:
request_coded = tuple(self._word_db.multipleWordId(WordParser(request).wordsList()))
except DataBaseException as error: raise JarvisException("Don't understand: " + request + " . Error: " + str(error))
try:
thought_coded = self._brain.think(request_coded)
except BrainException as error: raise JarvisException("Cannot replay to this request: " + request + " . Error: " + str(error))
try:
thought_tuple = self._word_db.multipleIdWord(thought_coded)
except DataBaseException as error: raise JarvisException("Cannot replay to this request: " + request + " . Error: " + str(error))
try:
answer_tuple = self._body.do(thought_tuple)
except BodyException as error: raise JarvisException("Cannot do this request: " + request + " . Error: " + str(error))
answer = " ".join([word.getValue() for word in answer_tuple])
self._voice.speak(answer)
return answer
def createWordsDataBase(self,builder):
"""
This method sets words database
Input:
builder - Word database builder
Returns:
Nothing
"""
self._word_db = builder.generateDataBase()
def createTrainingDataBase(self,builder):
"""
This method builds traning database
Input:
builder - Traning database builder
Returns:
Nothing
"""
self._traning_db = builder.generateDataBase()
def createInnerVoiceDatabase(self,builder):
"""
This method builds internal voice database
Input:
builder - Database builder
Returns:
Nothing
"""
self._inner_voices.innerVoices(builder.generateDataBase())
def createAbilitiesDataBase(self,builder):
"""
This method builds abilities database
Input:
builder - Abilities builder
Returns:
Nothing
"""
builder.jarvis(self)
self._body.abilitiesDataBase(builder.generateDataBase())
def train(self):
"""
Trains Jarvis brain
Input:
Nothing
Returns:
Nothing
"""
from trainer import Trainer
if self._word_db == None: raise JarvisException("Don't have dictionary.")
if self._traning_db == None: raise JarvisException("Don't have traning database.")
trainer = Trainer(self._word_db,self._traning_db)
trainer.train(self._brain)
def start(self):
"""
This method starts Jarvis internals
Input:
Nothing
Returns:
Nothing
"""
from neural import InnerVoiceException
try: self._inner_voices.start()
except InnerVoiceException as error: raise JarvisException(str(error))
self._stop_event.wait()
def stop(self):
"""
This method stops Jarvis internals
Input:
Nothing
Returns:
Nothing
"""
self._inner_voices.stop()
self._stop_event.set()
