def test_influx_output():
loop = asyncio.get_event_loop()
s = ValueListSensor(1, value_stream)
p = SensorPub(s)
b = InfluxDBWriter(msg_format=Sensor(series_name='Sensor',
fields=['val', 'ts'],
tags=['sensor_id']),
generate_timestamp=False)
p.subscribe(b)
scheduler = Scheduler(loop)
scheduler.schedule_periodic(p, 0.2) # sample five times every second
scheduler.run_forever()
# Now play back
c = InfluxDBClient(database='antevents')
rs = c.query('SELECT * FROM Sensor;').get_points()
for d in rs:
print(d)
# Play back using a publisher
p = InfluxDBReader('SELECT * FROM Sensor;')
p.subscribe(CallableAsSubscriber(print))
scheduler = Scheduler(loop)
scheduler.schedule_periodic(p, 0.2) # sample five times every second
scheduler.run_forever()
print("That's all folks")
def test_mqtt(self):
loop = asyncio.get_event_loop()
s = Scheduler(loop)
sensor = make_test_publisher_from_vallist(1, sensor_data)
mqtt_writer = MQTTWriter('localhost', topics=[
('bogus/bogus', 0),
])
sensor.to_json().subscribe(mqtt_writer)
s.schedule_periodic(sensor, 0.5)
mqtt_reader = MQTTReader("localhost", topics=[
('bogus/bogus', 0),
])
vs = ValidationSubscriber(sensor_data, self)
mqtt_reader.take(5).select(mqtt_msg_to_unicode).from_json(constructor=SensorEvent) \
.output().subscribe(vs)
c = s.schedule_on_private_event_loop(mqtt_reader)
stop = StopLoopAfter(5, c)
mqtt_reader.subscribe(stop)
mqtt_reader.print_downstream()
sensor.print_downstream()
s.run_forever()
loop.stop()
self.assertTrue(vs.completed)
print("that's it")
def test(self):
scheduler = Scheduler(asyncio.get_event_loop())
sensor = make_test_publisher_from_vallist(1, values)
scheduler.schedule_periodic(sensor, 1)
blocking_subscriber = TestSubscriber(scheduler, values, self)
sensor.subscribe(blocking_subscriber)
scheduler.run_forever()
self.assertTrue(blocking_subscriber.completed)
class TestCase(unittest.TestCase):
def setUp(self):
# Creating a new event loop each test case does not seem to work.
# I think it is due to hbmqtt not cleaning up some state in the asyncio
# layer.
#self.loop = asyncio.new_event_loop()
self.loop = asyncio.get_event_loop()
self.sched = Scheduler(self.loop)
def tearDown(self):
pass
#self.loop.stop()
#self.loop.close()
def test_client_only(self):
SENSOR_ID = 'sensor-1'
TOPIC = get_topic_name(self)
sensor = SensorPub(ValueListSensor(SENSOR_ID, VALUES))
td = sensor.transduce(PeriodicMedianTransducer(period=3))
qw = QueueWriter(td, URL, TOPIC, self.sched)
qw.output()
self.sched.schedule_periodic(sensor, 0.5)
self.sched.run_forever()
self.assertFalse(
qw.has_pending_requests(),
"QueueWriter has pending requests: %s" % qw.dump_state())
print("test_client_only completed")
def send_and_recv_body(self, sleep_timeout):
SENSOR_ID = 'sensor-1'
TOPIC = get_topic_name(self)
sensor = SensorPub(ValueListSensor(SENSOR_ID, VALUES))
td = sensor.transduce(PeriodicMedianTransducer(period=3))
qw = QueueWriter(td, URL, TOPIC, self.sched)
qw.output()
qr = QueueReader(URL, TOPIC, self.sched, timeout=sleep_timeout)
self.sched.schedule_periodic(sensor, 0.5)
stop_qr = self.sched.schedule_on_main_event_loop(qr)
vs = ValidateAndStopSubscriber(EXPECTED, self, stop_qr)
qr.select(msg_to_event).subscribe(vs)
self.sched.run_forever()
self.assertFalse(
qw.has_pending_requests(),
"QueueWriter has pending requests: %s" % qw.dump_state())
self.assertEqual(qr.state, QueueReader.FINAL_STATE)
self.assertEqual(vs.next_idx, len(EXPECTED))
print("send_and_recv_bod(%s) completed" % sleep_timeout)
def test_short_timeout(self):
self.send_and_recv_body(0.1)
def test_long_timeout(self):
self.send_and_recv_body(3.0)
def test_bokeh_output():
loop = asyncio.get_event_loop()
s = ValueListSensor(1, value_stream)
p = SensorPub(s)
b = BokehStreamer([ SensorEvent(ts=0,val=10,sensor_id="temp" ) ], io_loop=loop)
p.subscribe(b)
scheduler = Scheduler(loop)
scheduler.schedule_periodic(p, 0.5) # sample twice every second
scheduler.run_forever()
self.assertTrue(vo.completed,
"Schedule exited before validation observer completed")
print("That's all folks")
def test_passthrough_as_a_method(self):
"""Verify that, when passthrough is used as a method, it can still take
thunks.
"""
scheduler = Scheduler(asyncio.get_event_loop())
luxpub = SensorPub(ValueListSensor('lux-2', lux_data))
vs1 = ValidationSubscriber([450, 600], self)
vs2 = ValidationSubscriber(lux_data, self)
luxpub.passthrough(compose(where(lambda evt: evt.val > 300),
vs1)).subscribe(vs2)
scheduler.schedule_periodic(luxpub, 0.5)
scheduler.run_forever()
self.assertTrue(vs1.completed)
self.assertTrue(vs2.completed)
def main_linear():
obs_stream = from_iterable(
iter([[[[1.0, 1.0], [2.0, 2.0]], [1.0, 2.0]],
[[[6.0, 6.0], [9.0, 9.0]], [6.0, 9.0]]]))
pred_stream = from_iterable(iter([[3.0, 3.0]]))
model = LinearRegressionModel()
obs_stream.subscribe(model, topic_mapping=('default', 'train'))
obs_stream.subscribe(print)
pred_stream.subscribe(model, topic_mapping=('default', 'observe'))
model.subscribe(print, topic_mapping=('predict', 'default'))
scheduler = Scheduler(asyncio.get_event_loop())
scheduler.schedule_periodic(obs_stream, 1)
scheduler.schedule_periodic(pred_stream, 5)
scheduler.run_forever()
def test_where(self):
s = make_test_publisher_from_vallist(1, value_stream)
w = s.where(predicate)
w.output()
vo = ValidationSubscriber(expected_stream, self)
w.subscribe(vo)
scheduler = Scheduler(asyncio.get_event_loop())
scheduler.schedule_periodic(s, 0.5) # sample twice every second
s.print_downstream()
scheduler.run_forever()
self.assertTrue(
vo.completed,
"Schedule exited before validation observer completed")
self.assertTrue(vo.completed)
print("That's all folks")
def test_case(self):
sensor = make_test_publisher(1, stop_after_events=10)
split = SplitPublisher()
sensor.subscribe(split)
split.subscribe(lambda x: print("above:%s" % x),
topic_mapping=('above', 'default'))
split.subscribe(lambda x: print("below:%s" % x),
topic_mapping=('below', 'default'))
split.subscribe(lambda x: print("within:%s" % x),
topic_mapping=('within', 'default'))
scheduler = Scheduler(asyncio.get_event_loop())
scheduler.schedule_periodic(sensor, 1)
sensor.print_downstream()
scheduler.run_forever()
print("that's all")
def test_where(self):
"""In this version, we create a publisher and use method chaining to
compose the filters"""
s = ValueListSensor(1, value_stream)
p = SensorPub(s)
w = p.where(predicate)
w.output()
vo = ValidationSubscriber(expected_stream, self.test_where)
w.subscribe(vo)
scheduler = Scheduler(asyncio.get_event_loop())
scheduler.schedule_periodic(p, 0.5) # sample twice every second
p.print_downstream()
scheduler.run_forever()
self.assertTrue(
vo.completed,
"Schedule exited before validation observer completed")
print("That's all folks")
def test_multiple_timeouts(self):
"""In this testcase, we pass two events, drop two events, etc.
We set the timeout to a bit longer than the event interval. The last
good value is supplied when the timeout expires. Thus, we should see
two good events, two repeats of the first event, two good events, etc.
"""
sensor = make_test_publisher_from_vallist(1, sensor_values)
drop = DropPeriodic(sensor, N=2)
scheduler = Scheduler(asyncio.get_event_loop())
vo = ValidationSubscriber(expected_values_multiple_timeouts, self)
drop.supply_event_when_timeout(EventWatcher(), scheduler,
1.1).output().subscribe(vo)
scheduler.schedule_periodic(sensor, 1)
sensor.print_downstream()
scheduler.run_forever()
self.assertTrue(
vo.completed,
"Schedule exited before validation observer completed")
def test_supplying_event_on_timeout(self):
"""In this testcase, we drop every other event.
We set the timeout to a bit longer than the event interval of
one second. It then supplies the previous event. The resulting
output stream will show every other value repeated twice.
"""
sensor = make_test_publisher_from_vallist(1, sensor_values)
drop = DropPeriodic(sensor)
scheduler = Scheduler(asyncio.get_event_loop())
vo = ValidationSubscriber(expected_values, self)
drop.supply_event_when_timeout(EventWatcher(), scheduler,
1.1).output().subscribe(vo)
scheduler.schedule_periodic(sensor, 1)
sensor.print_downstream()
scheduler.run_forever()
self.assertTrue(
vo.completed,
"Schedule exited before validation observer completed")
def run_example():
sensor = SensorPub(DummyTempSensor('temp-1', input_sequence))
sensor.output() # let us see the raw values
dispatcher = sensor.transduce(RunningAvg(4))\
.passthrough(lambda evt:
print("Running avg temp: %s" %
round(evt.val, 2))) \
.dispatch([(lambda v: v[2]>=T_high, 't_high'),
(lambda v: v[2]<=T_low, 't_low')])
controller = Controller()
dispatcher.subscribe(controller, topic_mapping=('t_high', 't_high'))
dispatcher.subscribe(controller, topic_mapping=('t_low', 't_low'))
dispatcher.subscribe(controller, topic_mapping=('default', 'between'))
controller.subscribe(BypassValveActuator())
sensor.print_downstream()
scheduler = Scheduler(asyncio.get_event_loop())
scheduler.schedule_periodic(sensor, 0.5)
scheduler.run_forever()
print("got to the end")
def test_bokeh_manager():
loop = asyncio.get_event_loop()
s1 = ValueListSensor(1, value_stream)
p1 = SensorPub(s1)
s2 = ValueListSensor(1, value_stream2)
p2 = SensorPub(s2)
bm = BokehPlotManager()
bplot1 = BokehPlot('Sensor1', y_axis_label='value')
bplot2 = BokehPlot('Sensor2', y_axis_label='value')
bm.register(bplot1)
bm.register(bplot2)
p1.map(lambda v: ('Sensor1', v) ).subscribe(bm)
p2.map(lambda v: ('Sensor2', v) ).subscribe(bm)
bm.start()
scheduler = Scheduler(loop)
scheduler.schedule_periodic(p1, 1.0) # sample every second
scheduler.schedule_periodic(p2, 0.5) # sample twice every second
scheduler.run_forever()
# self.assertTrue(vo.completed,
# "Schedule exited before validation observer completed")
print("That's all folks")
def main_kalman():
dim_x = 2
dim_u = 1
dim_z = 1
initial_state_mean = np.array([[1.0], [0.0]])
initial_state_covariance = 1000 * np.eye(dim_x)
F = np.array([[1., 1.], [0., 1.]])
B = np.zeros((2, 1))
Q = Q_discrete_white_noise(dim=2, dt=0.1, var=0.13)
H = np.array([[1., 0.]])
R = 5 * np.eye(1)
model = KalmanFilterModel(dim_x, dim_u, dim_z, initial_state_mean,
initial_state_covariance, F, B, Q, H, R)
measurement_stream = from_iterable(iter([[1.0], [0.0]]))
# measurement_stream = from_iterable(iter([ np.array([ [1.0, 1.0] ]) ]))
measurement_stream.subscribe(model, topic_mapping=('default', 'observe'))
model.subscribe(print, topic_mapping=('predict', 'default'))
scheduler = Scheduler(asyncio.get_event_loop())
scheduler.schedule_periodic(measurement_stream, 1)
scheduler.run_forever()
if self.events_since_last == self.period:
val = median(self.samples)
event = SensorEvent(sensor_id=v.sensor_id, ts=v.ts, val=val)
self.events_since_last = 0
return event
else:
self.last_event = v # save in case we complete before completing a period
return None
def complete(self):
if self.events_since_last > 0:
# if we have some partial state, we emit one final event that
# averages whatever we saw since the last emission.
return SensorEvent(sensor_id=self.last_event.sensor_id,
ts=self.last_event.ts,
val=median(
self.samples[0:self.events_since_last]))
SENSOR_ID = 'sensor-1'
scheduler = Scheduler(asyncio.get_event_loop())
sensor = SensorPub(
RandomSensor(SENSOR_ID, mean=10, stddev=5, stop_after_events=12))
sensor.csv_writer('raw_data.csv').subscribe(
lambda x: print("raw data: %s" % repr(x)))
sensor.transduce(PeriodicMedianTransducer()).mqtt_async_send(
URL, SENSOR_ID, scheduler).output()
scheduler.schedule_periodic(sensor, 0.5)
scheduler.run_forever()
print("that's all folks")
print("LED Completed")
def __str__(self):
return 'LED'
# instantiate an LED
led = LED()
# Now, build a pipeline to sample events returned from the sensor,
# convert to a boolean based on whether the value is greater than
# the mean, and output to the LED.
import antevents.linq.select
sensor.select(lambda evt: evt.val > MEAN).subscribe(led)
# If you want to see the raw value of each sensor, just add the output() element
import antevents.linq.output
sensor.output()
# Call a debug method on the base publisher class to see the element tree rooted
# at sensor.
sensor.print_downstream()
# Now, we need to schedule the sensor to be sampled
import asyncio
from antevents.base import Scheduler
scheduler = Scheduler(asyncio.get_event_loop())
scheduler.schedule_periodic(sensor, 1.0) # sample once a second
scheduler.run_forever() # run until all sensors complete
print("That's all folks!")
# Copyright 2016 by MPI-SWS and Data-Ken Research. # Licensed under the Apache 2.0 License. import asyncio from antevents.tcpstreamer import TcpStreamObserver from antevents.base import make_test_publisher, Scheduler loop = asyncio.get_event_loop() s = make_test_publisher(1, stop_after_events=10) t = TcpStreamObserver(loop, "localhost", 2991) s.subscribe(t) scheduler = Scheduler(loop) scheduler.schedule_periodic(s, 2) # sample once every 2 seconds scheduler.run_forever() scheduler.stop()