def test_app_info(self, fix_registered):
"Test getting info for the app."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
app = c.get_app()
assert hasattr(app, 'id')
def test_user_name(self, fix_registered):
"Test get name attribute of User object for connected user."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
usr = c.get_user()
assert usr.name == fix_registered.testset1['userName']
def test_app_info(self, fix_registered):
"Test getting info for the app."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
app = c.get_app()
assert hasattr(app, 'id')
def test_list_all_publishers(self):
from relayr import Client
c = Client()
expected_attrs = set(["id", "name", "owner"])
for p in c.get_public_publishers():
assert expected_attrs.issubset(set(dir(p))) == True
def test_user_name(self, fix_registered):
"Test get name attribute of User object for connected user."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
usr = c.get_user()
assert usr.name == fix_registered.testset1['userName']
def test_get_user_bookmarked_devices(self, fix_registered):
"Test get user's bookmarked devices."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
user = c.get_user()
b_devs = user.get_bookmarked_devices()
assert type(list(b_devs)) == list
def test_get_appdev_token(self, fix_registered):
"Test get appdev token."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
app = c.get_app()
res = c.api.get_oauth2_appdev_token(app.id)
assert res['token'] == token
def test_get_appdev_token(self, fix_registered):
"Test get appdev token."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
app = c.get_app()
res = c.api.get_oauth2_appdev_token(app.id)
assert res['token'] == token
def test_get_user_bookmarked_devices(self, fix_registered):
"Test get user's bookmarked devices."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
user = c.get_user()
b_devs = user.get_bookmarked_devices()
assert type(list(b_devs)) == list
def test_get_wunderbar_devices(self, fix_registered):
"Test get user's registered wunderbar devices and master."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
usr = c.get_user()
items = list(usr.register_wunderbar())
assert len(items) == 7
def test_get_wunderbar_devices(self, fix_registered):
"Test get user's registered wunderbar devices and master."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
usr = c.get_user()
items = list(usr.register_wunderbar())
assert len(items) == 7
def test_public_resources(self, fix_registered):
"Get public resources."
from relayr import Client
from relayr.resources import App, Publisher, Device, DeviceModel
token = fix_registered.testset1['token']
c = Client(token=token)
assert next(c.get_public_apps()).__class__ == App
assert next(c.get_public_devices()).__class__ == Device
assert next(c.get_public_device_models()).__class__ == DeviceModel
assert next(c.get_public_publishers()).__class__ == Publisher
def relayr_configure(self):
from relayr import Client
from relayr.dataconnection import MqttStream
self.client = Client(token=self.relayr_config["token"])
self.devices = {
self.client.get_device(id=device['id']): device['name']
for device in self.relayr_config["devices"]
}
self.mqtt_stream = MqttStream(self.mqtt_callback, self.devices.keys())
def _x_user_parser(user, data):
client = Client(token=user.credentials.token)
usr = client.get_user()
user.name = usr.name
user.id = usr.id
user.email = usr.email
user.transmitters = list(usr.get_transmitters())
user.transmitters_devices = {}
for t in user.transmitters:
user.transmitters_devices[t.name] = client.api.get_transmitter_devices(t.id)
return user
def test_find_wunderbar_devices(self, fix_registered):
"Test get all devices on a Wunderbar."
from relayr import Client
from relayr.resources import Device, Transmitter
token = fix_registered.testset1['token']
c = Client(token=token)
usr = c.get_user()
assert usr.name == fix_registered.testset1['userName']
devs = usr.register_wunderbar()
for d in devs:
assert d.__class__ in (Device, Transmitter)
assert hasattr(d, 'id')
def test_users_resources(self, fix_registered):
"Test get user's resources."
from relayr import Client
from relayr.resources import User, Publisher, App, Device
token = fix_registered.testset1['token']
c = Client(token=token)
usr = c.get_user()
assert usr.__class__ == User
assert c.get_app().__class__ == App
assert next(usr.get_apps()).__class__ == App
assert next(usr.get_devices()).__class__ == Device
assert next(usr.get_publishers()).__class__ == Publisher
def test_users_resources(self, fix_registered):
"Test get user's resources."
from relayr import Client
from relayr.resources import User, Publisher, App, Device
token = fix_registered.testset1['token']
c = Client(token=token)
usr = c.get_user()
assert usr.__class__ == User
assert c.get_app().__class__ == App
assert next(usr.get_apps()).__class__ == App
assert next(usr.get_devices()).__class__ == Device
assert next(usr.get_publishers()).__class__ == Publisher
def test_find_wunderbar_devices(self, fix_registered):
"Test get all devices on a Wunderbar."
from relayr import Client
from relayr.resources import Device, Transmitter
token = fix_registered.testset1['token']
c = Client(token=token)
usr = c.get_user()
assert usr.name == fix_registered.testset1['userName']
devs = usr.register_wunderbar()
for d in devs:
assert d.__class__ in (Device, Transmitter)
assert hasattr(d, 'id')
def _x_user_parser(user, data):
client = Client(token=user.credentials.token)
usr = client.get_user()
user.name = usr.name
user.id = usr.id
user.email = usr.email
user.transmitters = list(usr.get_transmitters())
user.transmitters_devices = {}
for t in user.transmitters:
user.transmitters_devices[
t.name] = client.api.get_transmitter_devices(t.id)
return user
def main():
"Get some current sensor values from a prototype."
# Use token from your relayr API keys page.
# *** REPLACE WITH YOUR OWN! ***
c = Client(token='kKSWtiYvfFoTHD1RY-d7Lif4tPRhUKgU')
dev = c.get_device(id=creds['user'])
def mqtt_callback(topic, payload):
print json.loads(payload)['readings']
stream = MqttStream(mqtt_callback, [dev])
stream.start()
time.sleep(10)
stream.stop()
def test_app_update(self, fix_registered):
"Test update info for some app."
# This is actually done twice for making this an idempotent operation.
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
app = c.get_app()
initial_app_name = app.name
# update name to something silly
silly_name = 'HolyWhat?'
app.update(name=silly_name)
assert app.name == silly_name
# update name to previous name
app.update(name=initial_app_name)
assert app.name == initial_app_name
def test_app_update(self, fix_registered):
"Test update info for some app."
# This is actually done twice for making this an idempotent operation.
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
app = c.get_app()
initial_app_name = app.name
# update name to something silly
silly_name = 'HolyWhat?'
app.update(name=silly_name)
assert app.name == silly_name
# update name to previous name
app.update(name=initial_app_name)
assert app.name == initial_app_name
def test_read_mqtt_single_device(self, fix_registered):
"Test connect to a single device via MQTT and read data."
import time
from relayr import Client
from relayr.resources import Device
import paho.mqtt.client as mqtt
token = fix_registered.testset1['token']
c = Client(token=token)
deviceId = fix_registered.testset1['deviceID']
d = Device(id=deviceId, client=c)
creds = c.api.post_channel(d.id, 'mqtt')
print('full channel creds:', creds)
creds = creds['credentials']
self.topics = [creds['topic'].encode('utf-8')]
client = mqtt.Client(client_id=creds['clientId'])
client.on_connect = self.on_connect
client.on_message = self.on_message
client.on_subscribe = self.on_subscribe
client.username_pw_set(creds['user'], creds['password'])
null_file = '/dev/null' if platform.system() != 'Windows' else 'nul'
client.tls_set(ca_certs=null_file, cert_reqs=ssl.CERT_NONE)
client.tls_insecure_set(True)
client.connect('mqtt.relayr.io', port=8883, keepalive=60)
try:
client.loop_forever()
except KeyboardInterrupt:
print('')
def test_create_list_delete(self, fix_registered):
"Test create, list and delete channel credentials."
from relayr import Client
from relayr.exceptions import RelayrApiException
token = fix_registered.testset1['token']
c = Client(token=token)
deviceID = fix_registered.testset1['deviceID']
# create channel creds
creds = c.api.post_channel(deviceID, 'mqtt')
assert type(creds) == dict
assert set(['channelId', 'credentials']).issubset(set(creds.keys()))
channelId = creds['channelId']
# list channels for device
info = c.api.get_device_channels(deviceID)
assert info['deviceId'] == deviceID
assert channelId in [ch['channelId'] for ch in info['channels']]
# delete channel creds
res = c.api.delete_channel_id(channelId)
assert res == None
# try delete again
with pytest.raises(RelayrApiException) as excinfo:
res = c.api.delete_channel_id(channelId)
msg = 'Channel with id %s not found' % channelId
assert msg in str(excinfo.value)
def test_read_mqtt_multi_device_abstract(self, fix_registered):
"Test add/remove devices dynamically and read their data."
import time
from relayr import Client
from relayr.resources import Device
from relayr.dataconnection import MqttStream
fixture = fix_registered.testset1
c = Client(token=fixture['token'])
# create channel with one device (microphone)
mic = Device(id=fixture['deviceID'], client=c)
stream = MqttStream(self.receive, [mic])
stream.start()
time.sleep(5)
# add one device (temperature/humidity)
temphum = Device(id=fixture['deviceID2'], client=c)
stream.add_device(temphum)
time.sleep(5)
# remove one device (microphone)
stream.remove_device(mic)
time.sleep(5)
stream.stop()
class RelayrSensorApp(App):
def __init__(self, **kwargs):
super(RelayrSensorApp, self).__init__(**kwargs)
from kivy.storage.jsonstore import JsonStore
self.relayr_config = JsonStore('relayr_credentials.json')
self.relayr_configure()
def mqtt_callback(self, topic, payload):
self.root.update(topic, payload)
def relayr_configure(self):
from relayr import Client
from relayr.dataconnection import MqttStream
self.client = Client(token=self.relayr_config["token"])
self.devices = {self.client.get_device(id=device['id']): device['name'] for device in
self.relayr_config["devices"]}
self.mqtt_stream = MqttStream(self.mqtt_callback, self.devices.keys())
def on_start(self):
self.mqtt_stream.start()
def on_pause(self):
self.mqtt_stream.stop()
def on_resume(self):
self.mqtt_stream.start()
def on_stop(self):
self.mqtt_stream.stop()
def build(self):
from widgets import MainWidget
return MainWidget(self.devices)
def test_client_log(self, fix_registered):
"Test logging some messages."
token = fix_registered.testset1['token']
import datetime
from relayr import Client
c = Client(token=token)
now = datetime.datetime.now()
before = now - datetime.timedelta(minutes=25)
messages = [
{
"timestamp": before.isoformat(),
"message": "heavy rain shower",
"connection": {
"internet": True
}
},
{
"timestamp": now.isoformat(),
"message": "sunshine with rainbow",
"connection": {
"internet": True
}
},
]
res = c.api.post_client_log(messages)
assert res == None
def test_access_device(self, fix_registered):
"Test access a public device."
from relayr import Client
from relayr.resources import Device
token = fix_registered.testset1['token']
deviceID = fix_registered.testset1['deviceID']
c = Client(token=token)
dev = Device(id=deviceID)
def _test_update_user(self, fix_registered):
"Test update user attribute, here: name."
from relayr import Client
## TODO: check if a regular user can change his own attributes...
token = fix_registered.testset1['token']
c = Client(token=token)
info = c.api.get_oauth2_user_info()
c.api.patch_user(info['id'], name='dcg')
def test_exception_missing_creds(self):
"Test raising exception for missing credentials."
from relayr import Client
from relayr.exceptions import RelayrApiException
with pytest.raises(RelayrApiException) as excinfo:
info = Client().api.get_oauth2_user_info()
prefix = 'The supplied authentication is not authorized to access this resource.'
assert str(excinfo.value).startswith(prefix)
def relayr_configure(self):
from relayr import Client
from relayr.dataconnection import MqttStream
self.client = Client(token=self.relayr_config["token"])
self.devices = {self.client.get_device(id=device['id']): device['name'] for device in
self.relayr_config["devices"]}
self.mqtt_stream = MqttStream(self.mqtt_callback, self.devices.keys())
def test_connected_user(self, fix_registered):
"Test get info about the currently connected user."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
info = c.api.get_oauth2_user_info()
for key in 'name email id'.split():
assert key in info
def test_find_wunderbar_devices(self, fix_registered):
"Test get all devices on a Wunderbar."
from relayr import Client
from relayr.resources import Device, Transmitter
token = fix_registered.testset1['token']
c = Client(token=token)
usr = c.get_user()
assert usr.name == fix_registered.testset1['userName']
devs = list(usr.register_wunderbar())
for d in devs:
assert d.__class__ in (Device, Transmitter)
assert hasattr(d, 'id')
# now clean-up
for dev in [d for d in devs if d.__class__ == Device]:
dev.delete()
for t in [d for d in devs if d.__class__ == Transmitter]:
t.delete()
def test_connected_app(self, fix_registered):
"Test get info about the currently connected app."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
info = c.api.get_oauth2_app_info()
for key in 'name description id'.split():
assert key in info
def test_find_wunderbar_devices(self, fix_registered):
"Test get all devices on a Wunderbar."
from relayr import Client
from relayr.resources import Device, Transmitter
token = fix_registered.testset1['token']
c = Client(token=token)
usr = c.get_user()
assert usr.name == fix_registered.testset1['userName']
devs = list(usr.register_wunderbar())
for d in devs:
assert d.__class__ in (Device, Transmitter)
assert hasattr(d, 'id')
# now clean-up
for dev in [d for d in devs if d.__class__ == Device]:
dev.delete()
for t in [d for d in devs if d.__class__ == Transmitter]:
t.delete()
def test_apps_of_connected_user(self, fix_registered):
"Get apps of connected user."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
apps = c.api.get_user_apps(c.api.get_oauth2_user_info()['id'])
assert len(apps) > 0
assert type(apps[0]) == dict
def test_read_pubnub_device_10s(self, fix_registered):
"Test connect to a device via PubNub and read data for some time."
import time
from relayr import Client
from relayr.resources import Device
token = fix_registered.testset1['token']
deviceID = fix_registered.testset1['deviceID']
self.received_data = []
c = Client(token=token)
dev = Device(id=deviceID, client=c).get_info()
usr = c.get_user()
app = c.get_app()
conn = usr.connect_device(app, dev, self.receive)
conn.start()
time.sleep(10)
conn.stop()
assert len(self.received_data) > 0
for item in self.received_data:
assert 'ts' in item
def test1_get_token(self, fix_registered):
"Test get current token and compare with the one given to connect."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
app_id = c.api.get_oauth2_app_info()['id']
info = c.api.get_oauth2_appdev_token(app_id)
for key in 'token expiryDate'.split():
assert key in info
assert token == info['token']
def test_get_transmitters(self, fix_registered):
"Test get user's transmitters."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
user_info = c.api.get_oauth2_user_info()
trans_info = c.api.get_user_transmitters(user_info['id'])
for trans in trans_info:
for key in 'owner name id'.split(): # plus others...
assert key in trans
def test_send_command_device(self, fix_registered):
"Test send a command to a device."
from relayr import Client
from relayr.resources import Device
token = fix_registered.testset1['token']
c = Client(token=token)
deviceID = fix_registered.testset1['deviceID']
dev = Device(id=deviceID, client=c)
dev.get_info()
dev.switch_led_on(True)
def test_pub_get_apps(self, fix_registered):
"Test getting apps for some publisher."
from relayr import Client
from relayr.resources import Publisher
publisherID = fix_registered.testset1['publisherID']
pub = Publisher(id=publisherID, client=Client())
apps = pub.get_apps()
app_list = list(apps)
assert len(app_list) >= 1
assert hasattr(app_list[0], 'id')
def test_pub_get_apps_extended(self, fix_registered):
"Test getting extended apps for some publisher."
from relayr import Client
from relayr.resources import Publisher
token = fix_registered.testset1['token']
c = Client(token=token)
publisherID = fix_registered.testset1['publisherID']
pub = Publisher(id=publisherID, client=c)
apps = pub.get_apps(extended=True)
app_list = list(apps)
assert len(app_list) >= 1
assert hasattr(app_list[0], 'clientId')
def test_get_transmitter_devices(self, fix_registered):
"Test getting devices of a known transmitter."
from relayr import Client
from relayr.resources import Transmitter
token = fix_registered.testset1['token']
transmitterID = fix_registered.testset1['transmitterID']
c = Client(token=token)
t = Transmitter(id=transmitterID, client=c)
t.get_info()
assert t.name == fix_registered.testset1['transmitterName']
devs = t.get_connected_devices()
assert len(list(devs)) == 6
class RelayrService:
def __init__(self, token, deviceId):
# device 'fe4bb3e0-400f-48fa-aac0-0c2713a92827'
#token 'FvhcUVcNkTsHqg4qI1w3wVs-Gadryj8O'
self.client = Client(token=token)
self.device = self.client.get_device(id=deviceId)
def startStream(self, callback):
self.stream = MqttStream(callback, [self.device])
self.stream.start()
def stopStream(self):
self.stream.stop()
def test_add_list_remove_device_group_device(self, fix_registered):
"Test add, list, update and remove device to/from device group."
from relayr import Client
from relayr.exceptions import RelayrApiException
from relayr.resources import Group, Device
token = fix_registered.testset1['token']
c = Client(token=token)
# create test group
group_name = 'TestGroup'
g = Group(client=c).create(name=group_name)
g.get_info()
assert g.name == group_name
assert len(g.devices) == 0
# add two WunderBar devices
d1_id = fix_registered.testset1['deviceID']
d1 = Device(d1_id)
g.add_device(d1)
d2_id = fix_registered.testset1['deviceID2']
d2 = Device(d2_id)
g.add_device(d2)
# get test group, again
g = Group(id=g.id, client=c).get_info()
devices = g.devices
assert len(devices) == 2
assert devices[0].id == d1_id
assert devices[1].id == d2_id
# update last device's position in group to be first
g.update_device(devices[1], 0)
# get test group, again
g = Group(id=g.id, client=c).get_info()
devices = g.devices
assert len(devices) == 2
assert devices[0].id == d2_id
assert devices[1].id == d1_id
# remove first device in group
g.remove_device(devices[0])
# get test group, again
g = Group(id=g.id, client=c).get_info()
devices = g.devices
assert len(devices) == 1
assert devices[0].id == d1_id
# delete test group
g.delete()
def test4(self, fix_registered):
"Test get publishers for connected user."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
usr = c.get_user()
def test_post_user_devices_bookmarks(self, fix_registered):
"Test get user's bookmarked devices."
from relayr import Client
token = fix_registered.testset1['token']
c = Client(token=token)
user = c.get_user()
import time
from relayr import Client
from relayr.dataconnection import MqttStream
c = Client(token='<my_access_token>')
dev = c.get_device(id='<my_device_id>')
def mqtt_callback(topic, payload):
print('%s %s' % (topic, payload))
stream = MqttStream(mqtt_callback, [dev])
stream.start()
time.sleep(10)
stream.stop()
import plotly.tools as tls
from relayr import Client
from relayr.dataconnection import MqttStream
# read config filename
with open('config.yml', 'r') as f:
config = yaml.load(f)
print(config)
# how often to write to plot.ly in seconds
UPDATE_INTERVALL = config["update_intervall"]
# relayr auth and temperature sensor device
c = Client(token=config["relayr"]["token"])
dev = c.get_device(id=config["relayr"]["deviceid"])
# plot.ly auth
py.sign_in(config["plotly"]["user"], config["plotly"]["apikey"])
# one stream token per trace to be plotted
# https://plot.ly/settings/api
tls.set_credentials_file(stream_ids=config["plotly"]["stream_ids"])
stream_ids = tls.get_credentials_file()['stream_ids']
# plotly: Get first stream token from stream id list
stream_id = stream_ids[0]
# plotly: Make instance of stream id object
import datetime
import json
import sqlite3
from relayr import Client
from relayr.dataconnection import MqttStream
conn = sqlite3.connect('relayr_sensorsdb.sqlite3')
cur = conn.cursor()
#cur.execute('DROP TABLE IF EXISTS sensors')
cur.execute('CREATE TABLE IF NOT EXISTS sensors (x TEXT, door TEXT, hum TEXT, temp TEXT)')
# works most of the time but sometimes this gives error messages... still needs some fixing
while True:
stuff = list()
c = Client(token='<insert your relayr token here>')
dev = c.get_device(id='<insert your relayr device id here>')
def mqtt_callback(topic, payload):
payvar = '%s' % (payload)
stuff.append(payvar)
stream = MqttStream(mqtt_callback, [dev])
stream.start()
time.sleep(3)
x = datetime.datetime.now()
print x
#there is an erro with the stuff[0] from time to time. I thought the line commented below helped but error still occures occasionally
#if stuff[0] == None : break
payvar = stuff[0]
try: js = json.loads(payvar)
except: js = None
door = js["readings"][0]["value"]
import time
from relayr import Client
from relayr.dataconnection import MqttStream
try:
import json
except ImportError:
import simplejson as json
with open('apikeys.txt', 'r') as keyFile:
keyFile = open('apikeys.txt', 'r')
CLIENT_TOKEN = keyFile.readline().rstrip()
DEVICE_ID = keyFile.readline().rstrip()
keyFile.closed
c = Client(token=CLIENT_TOKEN)
dev = c.get_device(id=DEVICE_ID)
def mqtt_callback(topic, payload):
print('%s %s' % (topic, payload))
stream = MqttStream(mqtt_callback, [dev])
stream.start()
time.sleep(10)
stream.stop()
#example code where I scraped json to see how to do that
# sound = twitter.statuses.user_timeline.tweets(screen_name="amandapalmer", since_id = int(readData),
# exclude_replies = "true", include_rts = "false")
#
# #step through list of last tweets
