def test_concat(self):
e1 = Event.sequence(array1, interval=0.02)
e2 = Event.sequence(array2, interval=0.02).delay(0.07)
event = e1.concat(e2)
self.assertEqual(
event.run(),
[0, 1, 2, 3, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109])
def test_async_map(self):
async def coro(x):
await asyncio.sleep(0.1)
return x * x
event = Event.sequence(array).map(coro)
self.assertEqual(event.run(), [i * i for i in array])
def test_star(self):
def f(i, j):
r.append((i, j))
r = []
event = Event.sequence(array).map(lambda i: (i, i)).star().connect(f)
self.assertEqual(event.run(), r)
def test_delay(self):
delay = 0.01
src = Event.sequence(array1, interval=0.01)
e1 = src.timestamp().pluck(0)
e2 = src.delay(delay).timestamp().pluck(0)
r = e1.zip(e2).map(lambda a, b: b - a).mean().run()
self.assertLess(abs(r[-1]), delay + 0.002)
def test_aiter(self):
async def coro():
return [v async for v in event]
a = list(range(0, 10))
event = Event.sequence(a)
result = run(coro())
self.assertEqual(result, a)
def test_throttle(self):
t0 = time.time()
a = list(range(500))
event = Event.sequence(a) \
.throttle(1000, 0.1, cost_func=lambda i: 10)
result = event.run()
self.assertEqual(result, a)
dt = time.time() - t0
self.assertLess(abs(dt - 0.5), 0.05)
def test_select(self):
event = Event.sequence(array).filter(lambda x: x % 2)
self.assertEqual(event.run(), [x for x in array if x % 2])
def test_merge(self):
e1 = Event.sequence(array1, interval=0.01)
e2 = Event.sequence(array2, interval=0.01).delay(0.001)
event = e1.merge(e2)
self.assertEqual(event.run(),
[i for j in zip(array1, array2) for i in j])
def test_switch(self):
e1 = Event.sequence(array1, interval=0.01)
e2 = Event.sequence(array2, interval=0.01).delay(0.001)
e3 = Event.sequence(array3, interval=0.01).delay(0.002)
event = e1.switch(e2, e3, e2)
self.assertEqual(event.run(), [0, 100] + array3)
def test_iterate(self):
event = Event.sequence(array).iterate([5, 4, 3, 2, 1])
self.assertEqual(event.run(), [5, 4, 3, 2, 1])
def test_mergemap2(self):
a = ['ABC', 'UVW', 'XYZ']
event = Event.range(3, interval=0.01) \
.mergemap(lambda v: Event.sequence(a[v], 0.05 * v))
self.assertEqual(event.run(),
['A', 'B', 'C', 'U', 'X', 'V', 'W', 'Y', 'Z'])
def test_zip_self(self):
e1 = Event.sequence(array1)
event = e1.zip(e1)
self.assertEqual(event.run(), list(zip(array1, array1)))
def test_last(self):
event = Event.sequence(array).last()
self.assertEqual(event.run(), [9])
def test_constant(self):
event = Event.sequence(array).constant(42)
self.assertEqual(event.run(), [42] * len(array))
def test_debounce_on_first(self):
event = Event.range(10, interval=0.05) \
.mergemap(lambda t: Event.sequence(array2, 0.001)) \
.debounce(0.02, on_first=True)
self.assertEqual(event.run(), [100] * 10)
def test_partial(self):
event = Event.sequence(array).partial(42)
self.assertEqual(event.run(), [(42, i) for i in array])
def test_partial_right(self):
event = Event.sequence(array).partial_right(42)
self.assertEqual(event.run(), [(i, 42) for i in array])
def test_timestamp(self):
interval = 0.002
event = Event.sequence(array, interval=interval).timestamp()
times = event.pluck(0).run()
std = np.std(np.diff(times) - interval)
self.assertLess(std, interval)
def test_enumerate(self):
s = 'abcdefghij'
event = Event.sequence(s).enumerate()
self.assertEqual(event.run(), list(enumerate(s)))
def test_count(self):
s = 'abcdefghij'
event = Event.sequence(s).count()
self.assertEqual(event.run(), array[:len(s)])
def test_chain(self):
e1 = Event.sequence(array1, interval=0.01)
e2 = Event.sequence(array2, interval=0.01).delay(0.001)
event = e1.chain(e2, e1)
self.assertEqual(event.run(), array1 + array2 + array1)
def test_unique(self):
array = [1, 1, 2, 1, 2, 2, 2, 3, 1, 4, 4]
event = Event.sequence(array).unique()
self.assertEqual(event.run(), [1, 2, 3, 4])
def test_zip(self):
e1 = Event.sequence(array1)
e2 = Event.sequence(array2).delay(0.001)
event = e1.zip(e2)
self.assertEqual(event.run(), list(zip(array1, array2)))
def test_sync_map(self):
event = Event.sequence(array).map(lambda x: x * x)
self.assertEqual(event.run(), [i * i for i in array])
def test_ziplatest(self):
e1 = Event.sequence([0, 1], interval=0.01)
e2 = Event.sequence([2, 3], interval=0.01).delay(0.001)
event = e1.ziplatest(e2)
self.assertEqual(event.run(), [(0, Event.NO_VALUE), (0, 2), (1, 2),
(1, 3)])
def test_sync_star_map(self):
event = Event.sequence(array)
event = event.map(lambda i: (i, i)).star().map(lambda x, y: x / 2 - y)
self.assertEqual(event.run(),
[x / 2 - y for x, y in zip(array, array)])
def test_pack(self):
event = Event.sequence(array).pack()
self.assertEqual(event.run(), [(i, ) for i in array])
def test_previous(self):
event = Event.sequence(array).previous(2)
self.assertEqual(event.run(), array[:-2])
def event():
return Event.sequence(data)
def test_changes(self):
array = [1, 1, 2, 1, 2, 2, 2, 3, 1, 4, 4]
event = Event.sequence(array).changes()
self.assertEqual(event.run(), [1, 2, 1, 2, 3, 1, 4])