def __init__(self, N, food_size):
self.reaction_computed = Observable()
self.step_computed = Observable()
self.generation_computed = Observable()
self.expressions = Multiset(N)
self.tmp_removed_expressions = []
self.food_size = food_size
def __init__(self):
log = logging.getLogger(f"c.{__name__}.init")
log.info("Start init")
self.xpoint = 200
self.ypoint = 200
self.expX = Observable(1)
self.expY = Observable(1)
self.funcType = Observable("cos")
self.res = Observable(None)
class ZNBot(ZeroHello):
event = Observable()
class Error(Exception):
pass
def __init__(self):
super().__init__()
def updateSiteInfo(self):
def cb(obj):
self.siteInfo = obj
self.siteInfoUpdated()
self.send("siteInfo", [], cb)
def siteInfoUpdated(self):
if not self.siteInfo["cert_user_id"]:
raise self.Error("No certificate available")
self.event.trigger("siteInfoUpdated")
def on_open(self):
self.send("certSet", ["zeroid.bit"])
self.updateSiteInfo()
self.event.trigger("webSocketOpen")
def __init__(self, config):
"""
Instantiate a new emulator
:param config: config to use
:type config: configuration.config.EmulatorConfig
"""
self.logger = init_logger(__name__)
if not config.is_initialized():
self.logger.error(
'Config is not properly initialized, exiting emulator')
raise Exception('Config is not properly initialized')
self.config = config
self.text_scenarios = config.get_text_scenarios()
self.hex_scenarios = config.get_hex_scenarios()
self.overwritten_text_scenarios = dict()
self.overwritten_hex_scenarios = dict()
self.input = config.get_input()
self.output = config.get_output()
self.keys = list(self.text_scenarios.keys())
self.field_values = FieldValueList()
self.paused = False
self.stopped = False
self.status = 'initialized'
self.bit_error_random = Random(config.get_default_seed())
self.observable = Observable()
self.timed = self.config.get_timed()
self.stop_condition = self.config.get_stop_condition()
if self.timed:
self.event_queue = EventQueue(self)
def __init__(self):
self.phrases = Observable({})
self.db = MongoDbProxy("mongodb://localhost:27017/", "RepeatItDb",
"phrases")
data = self.db.get_all()
self.phrases.setData(data)
def test_off():
"""test obs.off method"""
obs = Observable()
nose.assert_false(obs.events)
@obs.on("on_test")
def on_test():
pass
nose.assert_equals(obs.events['on_test'], [on_test])
nose.assert_true(obs.trigger("on_test"))
obs.off("on_test", on_test)
nose.assert_equals(obs.events['on_test'],[])
obs.off()
nose.assert_false(obs.events)
@obs.on("more_than_one_event")
def func1():
pass
@obs.on("more_than_one_event")
def func2():
pass
@obs.on("more_than_one_event")
def func3():
pass
nose.assert_equals(obs.events["more_than_one_event"], [func1, func2, func3])
obs.off("more_than_one_event", func2)
nose.assert_equals(obs.events["more_than_one_event"], [func1, func3])
obs.off("more_than_one_event")
nose.assert_equals(obs.events["more_than_one_event"], [])
def test_no_event_for_trigger():
"""test exception raising for not existing events"""
obs = Observable()
nose.assert_false(obs.events)
nose.assert_false(obs.trigger("no_existing_event"))
nose.assert_raises(EventNotFound, obs.off, "no_existing_event")
def __init__(self, direction, puzzle, wordsToFind):
self.observable = Observable()
self.direction = direction
self.puzzle = puzzle
self.puzzleRows = len(puzzle)
self.puzzleColumns = len(puzzle[0])
self.wordsToFind = wordsToFind
def __init__(self, grid: Gtk.Grid, label_text: str, x: int, y: int):
super().__init__()
self._empty = True
self.state = Observable(ErrorType.ok)
label = create_status_label(label_text, self.state)
label.set_xalign(1)
grid.attach(label, x, y, 1, 1)
self.desired = NumberEntry()
self.desired.set_width_chars(4)
self.desired.set_max_length(4)
def on_enter(entry: Gtk.Entry):
val = int(entry.get_text())
entry.set_text(str(val))
self.emit('completed', val)
self.desired.connect('activate', on_enter)
grid.attach(self.desired, x + 1, y, 1, 1)
self.actual = Gtk.Entry()
self.actual.set_sensitive(False)
self.actual.set_width_chars(4)
grid.attach(self.actual, x + 2, y, 1, 1)
def test_no_event_for_trigger():
"""test exception raising for not existing events"""
obs = Observable()
assert not obs.trigger("no_existing_event")
with pytest.raises(EventNotFound):
obs.off("no_existing_event")
def test_on():
"""test event registering with the on method"""
obs = Observable()
def on_test():
pass
obs.on("on_test", on_test)
assert on_test in obs._events["on_test"]
def test_on_decorator():
"""test event registering with the on decorator"""
obs = Observable()
@obs.on("on_test")
def on_test():
pass
assert on_test in obs._events["on_test"]
def __init__(self):
self.title = Observable("Calculator")
self.window_position = (0, 0)
self.empty_formula = '0'
self.formula = ObservableString(self.empty_formula)
self.result = ObservableString("")
self.history = []
self.history_position = -1
self.max_history_length = 100
def test_trigger_arg():
"""test event triggering with arguments"""
obs = Observable()
@obs.on("some_test")
def some_test(some_data):
assert some_data == "some data"
assert obs.trigger("some_test", "some data")
def test_on_decorator():
"""test event registering with the on decorator"""
obs = Observable()
nose.assert_false(obs.events)
@obs.on("on_test")
def on_test():
pass
nose.assert_in(on_test, obs.events["on_test"])
def test_on():
"""test event registering with the on method"""
obs = Observable()
nose.assert_false(obs.events)
def on_test():
pass
obs.on("on_test", on_test)
nose.assert_in(on_test, obs.events["on_test"])
def test_trigger_arg():
"""test event triggering with arguments"""
obs = Observable()
nose.assert_false(obs.events)
@obs.on("some_test")
def some_test(some_data):
nose.assert_equals(some_data, "some data")
nose.assert_true(obs.trigger("some_test", "some data"))
def test_is_registered():
"""test is_registered() after registering an event"""
obs = Observable()
def some_test():
pass
assert not obs.is_registered("some_event", some_test)
obs.on("some_event", some_test)
assert obs.is_registered("some_event", some_test)
def test_trigger_kwargs():
"""test event triggering with keyword-arguments"""
obs = Observable()
@obs.on("some_test")
def some_test(some_data=True, some_other_data=False):
assert some_data is False
assert some_other_data is True
assert obs.trigger("some_test", some_other_data=True, some_data=False)
def test_trigger_args():
"""test event triggering with argument list"""
obs = Observable()
@obs.on("some_test")
def some_test(some_data, some_other_data):
assert some_data is True
assert some_other_data is False
assert obs.trigger("some_test", *[True, False])
def test_trigger_kwargs():
"""test event triggering with keyword-arguments"""
obs = Observable()
nose.assert_false(obs.events)
@obs.on("some_test")
def some_test(some_data=True, some_other_data=False):
nose.assert_false(some_data)
nose.assert_true(some_other_data)
nose.assert_true(obs.trigger("some_test", some_other_data=True, some_data=False))
def test_once_decorator():
"""test event registering with the once decorator"""
obs = Observable()
@obs.once("once_test")
def once_test():
pass
assert once_test in obs._events["once_test"]
assert obs.trigger("once_test")
assert once_test not in obs._events["once_test"]
def test_trigger_args():
"""test event triggering with argument list"""
obs = Observable()
nose.assert_false(obs.events)
@obs.on("some_test")
def some_test(some_data, some_other_data):
nose.assert_true(some_data)
nose.assert_false(some_other_data)
nose.assert_true(obs.trigger("some_test", *[True, False]))
def __init__(self, users):
self.users = users # Socket assigned to user object
file = open("config/rooms.json", "r")
self.rooms = json.loads(file.read())
self.packet = PacketManager(self.rooms)
self.obs = Observable()
self.plugins = PluginManager(self)
self.POLICY = "<cross-domain-policy><allow-access-from domain='*' to-ports='*' /></cross-domain-policy>"
def test_on_trigger():
"""test event triggering with event registered with on"""
obs = Observable()
nose.assert_equals(obs._events, {})
@obs.on("on_test")
def on_test():
pass
nose.assert_equals(obs._events, {"on_test": [on_test]})
nose.assert_true(obs.trigger("on_test"))
nose.assert_true(obs.trigger("on_test"))
def test_once_decorator():
"""test event registering with the once decorator"""
obs = Observable()
nose.assert_false(obs.events)
@obs.once("once_test")
def once_test():
pass
nose.assert_in(once_test, obs.events["once_test"])
nose.assert_true(obs.trigger("once_test"))
nose.assert_not_in(once_test, obs.events["once_test"])
def test_once():
"""test event registering with the once method"""
obs = Observable()
def once_test():
pass
obs.once("once_test", once_test)
assert len(obs._events["once_test"]) == 1
assert obs.trigger("once_test")
assert obs._events["once_test"] == []
def test_once():
"""test event registering with the once method"""
obs = Observable()
nose.assert_false(obs.events)
def once_test():
pass
obs.once("once_test", once_test)
nose.assert_equals(len(obs.events["once_test"]), 1)
nose.assert_true(obs.trigger("once_test"))
nose.assert_equals(obs.events["once_test"], [])
def test_on_trigger():
"""test event triggering with event registered with on"""
obs = Observable()
obj = threading.local()
obj.called = False
@obs.on("on_test")
def on_test(obj):
obj.called = True
assert obs._events == {"on_test": [on_test]}
assert obs.trigger("on_test", obj)
assert obj.called
def __init__(self):
self.bpm = 90
self.q = 1 / self.bpm * 60
self.started = False
self.lock = Lock()
self.obs = Observable()
self.interval = 0
self.base_note = 0
self.last_note = 0
self.arpeggio_speed = 1
self.arpeggio_length = 0
self.arpeggio_step = 0
self.arpeggio_repeat = True
self.lastTick = time.time()
