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_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_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_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 _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_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 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

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 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_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()

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 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 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

 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()