def testConsistency(self):
slzr = serializer.StandardSerializer()
self.assertEqual('a', slzr.to_text(slzr.to_binary('a')))
self.assertEqual(' ', slzr.to_text(slzr.to_binary(' ')))
# greek letter \alpha (not working in current ascii serialization)
self.assertEqual(u"\u03B1", slzr.to_text(slzr.to_binary(u"\u03B1")))
def testOutputSerialization(self):
slzr = serializer.StandardSerializer()
oc = channels.OutputChannel(slzr)
test_string = 'my message'
serialized_test_string = slzr.to_binary(test_string)
oc.set_message(test_string)
for b in serialized_test_string:
self.assertEqual(b, oc.consume())
def task_messenger(task):
slzr = serializer.StandardSerializer()
scheduler = SingleTaskScheduler(task)
env = environment.Environment(slzr,
scheduler,
max_reward_per_task=float("inf"),
byte_mode=True)
return EnvironmentByteMessenger(env, slzr)
def init_env(self, task, success_threshold=2):
slzr = serializer.StandardSerializer()
scheduler = ConsecutiveTaskScheduler([task], success_threshold)
env = environment.Environment(slzr,
scheduler,
max_reward_per_task=float("inf"),
byte_mode=True)
messenger = EnvironmentByteMessenger(env, slzr)
return (scheduler, messenger)
def testInputSerialization(self):
slzr = serializer.StandardSerializer()
ic = channels.InputChannel(slzr)
test_string = 'my message'
serialized_test_string = slzr.to_binary(test_string)
def all_good(input_message):
self.assertEqual(test_string[:len(input_message)], input_message)
ic.message_updated.register(all_good)
for b in serialized_test_string:
ic.consume(b)
def testAllInputs(self):
env = environment.Environment(serializer.StandardSerializer(),
SingleTaskScheduler(NullTask()),
byte_mode=True)
learner = TryAllInputsLearner()
s = session.Session(env, learner)
def on_time_updated(t):
if t >= 600:
s.stop()
s.total_time_updated.register(on_time_updated)
s.run()
def testLimitReward(self):
env = environment.Environment(serializer.StandardSerializer(),
SingleTaskScheduler(NullTask()))
learner = LearnerMock()
s = session.Session(env, learner)
def on_time_updated(t):
if t >= 20:
s.stop()
s.total_time_updated.register(on_time_updated)
s.run()
self.assertLessEqual(s._total_reward, 10)
def testConsistency(self):
slzr = serializer.StandardSerializer()
ic = channels.InputChannel(slzr)
oc = channels.OutputChannel(slzr)
test_string = 'my message'
def all_good(input_message):
self.assertEqual(test_string[:len(input_message)], input_message)
oc.set_message(test_string)
ic.message_updated.register(all_good)
while not oc.is_empty():
b = oc.consume()
ic.consume(b)
def testIsSient(self):
slzr = serializer.StandardSerializer()
oc = channels.OutputChannel(slzr)
self.assertTrue(oc.is_silent())
oc.set_message(slzr.SILENCE_TOKEN)
self.assertTrue(oc.is_silent())
while not oc.is_empty():
oc.consume()
self.assertTrue(oc.is_silent())
oc.set_message('hello')
while not oc.is_empty():
oc.consume()
if not oc.is_empty():
self.assertFalse(oc.is_silent())
self.assertTrue(oc.is_silent())
def perform_setup(self, success_threshold=2):
slzr = serializer.StandardSerializer()
self.tasks = [
micro.Micro1Task(),
micro.Micro2Task(),
micro.Micro3Task(),
micro.Micro4Task(),
micro.Micro5Sub1Task()
]
self.scheduler = ConsecutiveTaskScheduler(self.tasks,
success_threshold)
self.env = environment.Environment(slzr,
self.scheduler,
max_reward_per_task=float("inf"),
byte_mode=True)
self.messenger = EnvironmentByteMessenger(self.env, slzr)
def testSilenceConsistency(self):
slzr = serializer.StandardSerializer()
ic = channels.InputChannel(slzr)
oc = channels.OutputChannel(slzr)
test_string = slzr.SILENCE_TOKEN * 10
something_read = [0]
def all_good(input_message):
something_read[0] = len(input_message)
self.assertEqual(test_string[:len(input_message)], input_message)
oc.set_message(test_string)
ic.message_updated.register(all_good)
while not oc.is_empty():
b = oc.consume()
ic.consume(b)
self.assertEqual(something_read[0], len(test_string))
def task_messenger(task_funct, world_funct=None):
'''
Returns an EnvironmentMessenger to interact with the created task.
Args:
task_func (functor): takes an environment (optionally a world) and
returns a task object.
world_func (functor): takes an environment and returns a world
object.
'''
slzr = serializer.StandardSerializer()
if world_funct:
world = world_funct()
task = task_funct(world)
else:
task = task_funct()
scheduler = SingleTaskScheduler(task)
env = environment.Environment(slzr, scheduler)
m = EnvironmentMessenger(env, slzr)
yield m
def testOverwrittingConsistency(self):
slzr = serializer.StandardSerializer()
ic = channels.InputChannel(slzr)
oc = channels.OutputChannel(slzr)
test_string = 'my message'
# array because Python's scoping rules are demented:
# http://stackoverflow.com/questions/4851463/python-closure-write-to-variable-in-parent-scope
something_read = [0]
def all_good(input_message):
something_read[0] = len(input_message)
self.assertEqual(test_string[:len(input_message)], input_message)
oc.set_message("this shouldn't matter")
oc.set_message(test_string)
ic.message_updated.register(all_good)
while not oc.is_empty():
b = oc.consume_bit()
ic.consume_bit(b)
self.assertEqual(something_read[0], len(test_string))
def testScramblingSerializerWrapper(self):
slzr = serializer.ScramblingSerializerWrapper(
serializer.StandardSerializer())
self.assertEqual(slzr.tokenize("a b"),
[("a", "WORD"), (" ", 'SILENCE'), ('b', 'WORD')])
self.assertEqual(slzr.tokenize("a b"),
[("a", "WORD"), (" ", 'SILENCE'), (" ", 'SILENCE'),
('b', 'WORD')])
self.assertEqual(slzr.tokenize("a b "),
[("a", "WORD"), (" ", 'SILENCE'), ('b', 'WORD'),
(' ', 'SILENCE')])
self.assertEqual(slzr.tokenize("a b, "), [("a", "WORD"),
(" ", 'SILENCE'),
('b', 'WORD'),
(',', 'PUNCT'),
(' ', 'SILENCE')])
self.assertEqual(slzr.tokenize("a b ."), [("a", "WORD"),
(" ", 'SILENCE'),
('b', 'WORD'),
(' ', 'SILENCE'),
('.', 'PUNCT')])
