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 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 setup(broker, threshold):
lux = SensorPub(LuxSensor())
lux.subscribe(print)
led = GpioPinOut()
actions = lux.map(lambda event: event.val > threshold)
actions.subscribe(led)
actions.subscribe(lambda v: print('ON' if v else 'OFF'))
lux.to_json().subscribe(MQTTWriter(broker, topics=[('bogus/bogus', 0)]))
lux.print_downstream()
return (lux, led)
def setup(threshold=25):
lux = SensorPub(LuxSensor())
lux.subscribe(print)
lux.csv_writer(os.path.expanduser('~/lux.csv'))
led = GpioPinOut()
actions = lux.map(lambda event: event.val > threshold)
actions.subscribe(led)
actions.subscribe(lambda v: print('ON' if v else 'OFF'))
lux.print_downstream()
return (lux, led)
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 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_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 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 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")
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")
if self.events_left > 0:
data = random.gauss(self.mean, self.stddev)
self.events_left -= 1
return data
else:
raise StopIteration
def __str__(self):
return "RandomSensor(%s, %s, %s)" % \
(self.sensor_id, self.mean, self.stddev)
# Instantiate our sensor
MEAN = 100
STDDEV = 10
sensor = SensorPub(RandomSensor(1, MEAN, STDDEV, stop_after=5))
# Now, we will define a pretend LED as a subscriber. Each time is it passed
# True, it will print 'On'. Each time it is passed False, it will print 'Off'.
from antevents.base import DefaultSubscriber
class LED(DefaultSubscriber):
def on_next(self, x):
if x:
print("On")
else:
print("Off")
def on_error(self, e):
print("Got an error: %s" % e)