d = {
'component': 'Time',
'label': 'Send makerspace time every minute',
'icon': 'clock-o',
'inports': [
{ 'id': 'start', 'type': 'bang' },
],
'outports': [
{ 'id': 'time', 'type': 'string' },
],
}
self.running = False
msgflo.Participant.__init__(self, d, role)
def process(self, inport, msg):
if self.running:
self.running = False
self.ack(msg)
return
self.running = True
gevent.Greenlet.spawn(self.loop)
self.ack(msg)
def loop(self):
while self.running == True:
self.send('time', datetime.datetime.now().isoformat())
gevent.sleep(60)
if __name__ == '__main__':
msgflo.main(Time)
}
class DetectCryptoParty(msgflo.Participant):
def __init__(self, role):
d = {
'component': 'c-flo/DetectCryptoParty',
'label': 'Detect a CryptoParty event',
'icon': 'unlock-alt ',
'inports': [{
'id': 'current',
'type': 'array'
}],
'outports': [
{
'id': 'palette',
'type': 'object'
},
],
}
msgflo.Participant.__init__(self, d, role)
def process(self, inport, msg):
if len(msg.data) and hasCryptoParty(msg.data):
self.send('palette', getColorsForDmx())
self.ack(msg)
if __name__ == '__main__':
msgflo.main(DetectCryptoParty)
#!/usr/bin/env python2
import sys, os, json, logging
sys.path.append(os.path.abspath("."))
import gevent
import msgflo
class Repeat(msgflo.Participant):
def __init__(self, role):
d = {
'component': 'PythonRepeat',
'label': 'Repeat input data without change',
'inports': [
{ 'id': 'in', 'type': 'any' },
],
'outports': [
{ 'id': 'out', 'type': 'any' },
],
}
msgflo.Participant.__init__(self, d, role)
def process(self, inport, msg):
self.send('out', msg.data)
self.ack(msg)
if __name__ == '__main__':
msgflo.main(Repeat)
def main():
role = os.environ.get('DISPLAY_PREFIX', 'display/X')
if len(sys.argv) >= 2:
role = sys.argv[1]
p = msgflo.main(Participant, role=role)
class ToggleLights(msgflo.Participant):
def __init__(self, role):
d = {
'component': 'c-flo/togglelights',
'label': 'Switch traffic light states on every packet',
'icon': 'toggle-on',
'inports': [
{ 'id': 'in', 'type': 'bang' },
],
'outports': [
{ 'id': 'out', 'type': 'object' },
],
}
self.state = {
'red': 0,
'yellow': 0,
'green': 1,
}
msgflo.Participant.__init__(self, d, role)
def process(self, inport, msg):
if (self.state['green']):
self.state['green'] = 0
else:
self.state['green'] = 1
self.send('out', self.state)
self.ack(msg)
if __name__ == '__main__':
msgflo.main(ToggleLights)
self.measurements = [None, 'pm10', 'o3', 'no2', 'so2', 'co']
msgflo.Participant.__init__(self, d, role)
def process(self, inport, msg):
if inport == 'station':
self.station = msg.data
self.ack(msg)
return
if self.station == None:
# No station configured, skip
self.ack(msg)
return
url = 'https://luft.jetzt/api/%s' % urllib.parse.quote(
self.station.encode('utf-8'))
response = urllib.request.urlopen(url)
data = json.loads(response.read())
for measurement in data:
port = self.measurements[measurement["data"]["pollutant"]]
if port == None:
continue
if measurement["data"]["date_time"] <= self.lastSeen[port]:
# Already got this data
continue
self.send(port, measurement["data"]["value"])
self.lastSeen[port] = measurement["data"]["date_time"]
self.ack(msg)
if __name__ == '__main__':
msgflo.main(GetLuftJetzt)
response = urllib.urlopen(url)
data = response.read()
soup = BeautifulSoup(data, "html.parser")
table = soup.find_all('table')[0]
tr_list = table.find_all("tr")
mate = tr_list[3].find_all("td")
berliner1 = tr_list[4].find_all("td")
berliner2 = tr_list[5].find_all("td")
flora_mate = tr_list[6].find_all("td")
premium_cola = tr_list[7].find_all("td")
spetzi = tr_list[8].find_all("td")
kraftmalz = tr_list[9].find_all("td")
dict = {
mate[0].text: available(mate[1].text.strip()),
berliner1[0].text: available(berliner1[1].text.strip()),
berliner2[0].text: available(berliner2[1].text.strip()),
flora_mate[0].text: available(flora_mate[1].text.strip()),
premium_cola[0].text: available(premium_cola[1].text.strip()),
spetzi[0].text: available(spetzi[1].text.strip()),
kraftmalz[0].text: available(kraftmalz[1].text.strip())
}
self.send('out', dict)
self.ack(msg)
if __name__ == '__main__':
msgflo.main(Replicator)
],
'outports': [
{
'id': 'out',
'type': 'string'
},
],
}
self.is_enabled = False
msgflo.Participant.__init__(self, d, role)
def loop(self):
while self.is_enabled == True:
timestamp = datetime.datetime.utcnow().replace(
tzinfo=datetime.timezone.utc).isoformat()
self.send('out', timestamp)
# Wait for a minute
gevent.sleep(60)
def process(self, inport, msg):
if inport == 'start':
self.is_enabled = True
gevent.Greenlet.spawn(self.loop)
elif inport == 'stop':
self.is_enabled = False
self.ack(msg)
if __name__ == '__main__':
msgflo.main(Clock)
'id': 'colors',
'type': 'object'
},
],
'outports': [
{
'id': 'palette',
'type': 'object'
},
],
}
self.palette = None
self.current_events = []
msgflo.Participant.__init__(self, d, role)
def process(self, inport, msg):
if inport == 'current':
self.current_events = msg.data
if self.palette:
self.send('palette', handleEvents(msg.data, self.palette))
self.ack(msg)
return
if inport == 'colors':
self.palette = msg.data
self.send('palette', handleEvents(self.current_events, msg.data))
self.ack(msg)
if __name__ == '__main__':
msgflo.main(EventColors)
if msg.data and msg.data['summary'] == 'circle':
print "Circle event ongoing"
self.is_circle = True
lights = {
'red': 1,
'yellow': 0,
'green': 0,
}
self.send('out', lights)
self.ack(msg)
return
self.is_circle = False
if self.previous_data:
# Let lights go to pre-circle state
self.send('out', self.previous_data)
self.ack(msg)
return
# Otherwise go green
lights = {
'red': 0,
'yellow': 0,
'green': 1,
}
self.send('out', lights)
self.ack(msg)
return
if __name__ == '__main__':
msgflo.main(DetectCircle)
def __init__(self, role):
d = {
'component': 'c-flo/IgniteMainhall',
'label': 'Send true if both inputs are true',
'icon': 'code-fork',
'inports': [
{ 'id': 'ignite', 'type': 'boolean' },
{ 'id': 'start', 'type': 'boolean' },
],
'outports': [
{ 'id': 'out', 'type': 'boolean' },
],
}
self.igniteState = False
self.startState = False
msgflo.Participant.__init__(self, d, role)
def process(self, inport, msg):
if inport == "ignite":
self.igniteState = msg.data
if inport == "start":
self.startState = msg.data
if self.igniteState and self.startState:
self.send("out", True)
else:
self.send("out", False)
self.ack(msg)
if __name__ == '__main__':
msgflo.main(IgniteMainhall)
import msgflo
class Repeat(msgflo.Participant):
def __init__(self, role):
d = {
'component': 'PythonRepeat',
'label': 'Repeat input data without change',
'inports': [
{
'id': 'in',
'type': 'any'
},
],
'outports': [
{
'id': 'out',
'type': 'any'
},
],
}
msgflo.Participant.__init__(self, d, role)
def process(self, inport, msg):
self.send('out', msg.data)
self.ack(msg)
if __name__ == '__main__':
msgflo.main(Repeat)
