def __init__(self, config):
super().__init__(config)
LOG.info('authenticating to neurio api')
LOG.debug('key = {client_id}, secret = {client_secret}'.format(
**(self.config)))
tp = neurio.TokenProvider(key=self.config['client_id'],
secret=self.config['client_secret'])
self.nc = neurio.Client(token_provider=tp)
def update(self):
"""Get the Neurio monitor data from the web service."""
import neurio
try:
neurio_tp = neurio.TokenProvider(
key=self.api_key, secret=self.api_secret)
neurio_client = neurio.Client(token_provider=neurio_tp)
sample = neurio_client.get_samples_live_last(
sensor_id=self.sensor_id)
self._state = sample['consumptionPower']
except (requests.exceptions.RequestException, ValueError):
_LOGGER.warning('Could not update status for %s', self.name)
def __init__(self, api_key, api_secret, sensor_id):
"""Initialize the data."""
self.api_key = api_key
self.api_secret = api_secret
self.sensor_id = sensor_id
self._daily_usage = None
self._active_power = None
self._state = None
neurio_tp = neurio.TokenProvider(key=api_key, secret=api_secret)
self.neurio_client = neurio.Client(token_provider=neurio_tp)
def __init__(self, secret_file_name):
config = ConfigParser.RawConfigParser()
config.read(secret_file_name)
tp = neurio.TokenProvider(key=config.get('auth','key'),
secret=config.get('auth','secret'))
sensor_id = config.get('device', 'id')
nc = neurio.Client(token_provider=tp)
# Wrap Neurio client with our Neurio class:
self.__class__ = type(nc.__class__.__name__,
(self.__class__, nc.__class__),
{})
self.__dict__ = nc.__dict__
self.sensor_id = sensor_id
def __init__(self, cfg, monitor_id, time_zone, activation_time):
logger.debug("Instantiating Neurio Client for monitor %s" % monitor_id)
self.monitorType = "neurio"
self.monitor_id = monitor_id
self.time_zone = time_zone
self.activation_time = activation_time
self.query_period = pd.Timedelta(31, 'D')
client_id = cfg.get(self.monitorType, "clientID")
secret = cfg.get(self.monitorType, "secret")
tp = neurio.TokenProvider(key=client_id, secret=secret)
self.client = neurio.Client(
token_provider=tp) # interface to remote data
def setup_neurio(config):
tp = neurio.TokenProvider(key=config['neurio']['client id'],
secret=config['neurio']['client secret'])
nc = neurio.Client(token_provider=tp)
user_info = nc.get_user_information()
pp = pprint.PrettyPrinter(indent=4)
ip_address = user_info['locations'][0]['sensors'][0]['ipAddress']
sample = nc.get_samples_live_last(sensor_id='0x0000C47F51019C5A')
pp.pprint(sample)
sample = nc.get_local_current_sample(ip_address)
pp.pprint(sample)
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Setup the Neurio sensor."""
name = config.get(CONF_NAME)
api_key = config.get(CONF_API_KEY)
api_secret = config.get(CONF_API_SECRET)
sensor_id = config.get(CONF_SENSOR_ID)
if not sensor_id:
import neurio
neurio_tp = neurio.TokenProvider(key=api_key, secret=api_secret)
neurio_client = neurio.Client(token_provider=neurio_tp)
user_info = neurio_client.get_user_information()
_LOGGER.warning('Sensor ID auto-detected, set api_sensor_id: "%s"',
user_info["locations"][0]["sensors"][0]["sensorId"])
sensor_id = user_info["locations"][0]["sensors"][0]["sensorId"]
add_devices([NeurioEnergy(api_key, api_secret, name, sensor_id)])
def __init__(self, api_key, api_secret, sensor_id):
"""Initialize the data."""
self.api_key = api_key
self.api_secret = api_secret
self.sensor_id = sensor_id
self._daily_usage = None
self._active_power = None
self._state = None
neurio_tp = neurio.TokenProvider(key=api_key, secret=api_secret)
self.neurio_client = neurio.Client(token_provider=neurio_tp)
if not self.sensor_id:
user_info = self.neurio_client.get_user_information()
_LOGGER.warning(
"Sensor ID auto-detected: %s",
user_info["locations"][0]["sensors"][0]["sensorId"],
)
self.sensor_id = user_info["locations"][0]["sensors"][0]["sensorId"]
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Setup the Neurio sensor."""
api_key = config.get("api_key")
api_secret = config.get("api_secret")
sensor_id = config.get("sensor_id")
if not api_key and not api_secret:
_LOGGER.error(
"Configuration Error"
"Please make sure you have configured your api key and api secret")
return None
if not sensor_id:
import neurio
neurio_tp = neurio.TokenProvider(key=api_key, secret=api_secret)
neurio_client = neurio.Client(token_provider=neurio_tp)
user_info = neurio_client.get_user_information()
_LOGGER.warning('Sensor ID auto-detected, set api_sensor_id: "%s"',
user_info["locations"][0]["sensors"][0]["sensorId"])
sensor_id = user_info["locations"][0]["sensors"][0]["sensorId"]
dev = []
dev.append(NeurioEnergy(api_key, api_secret, sensor_id))
add_devices(dev)
def main():
args = parse_args()
logging.basicConfig(level='INFO')
LOG.info('authenticating to neurio api')
tp = neurio.TokenProvider(key=args.client_id, secret=args.client_secret)
nc = neurio.Client(token_provider=tp)
LOG.info('connecting to mqtt broker')
mq = mqtt.Client()
mq.loop_start()
mq.connect(args.mqtt_server)
while True:
sample = nc.get_samples_live_last(args.sensor_id)
del sample['timestamp']
sample['sensor_id'] = args.sensor_id
sample['sensor_type'] = 'neurio'
LOG.info('sending sample %s', sample)
topic = '{}/neurio/{}'.format(args.topic, args.sensor_id)
msg = json.dumps(sample)
mq.publish(topic, msg)
time.sleep(args.interval)
#!/usr/bin/env python
"""
Copyright 2015, 2016 Jordan Husney <*****@*****.**>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import sys
sys.path.append("..")
import neurio
import example_keys
sensor_id = "0x0013A20040B65FAD"
tp = neurio.TokenProvider(key=example_keys.key, secret=example_keys.secret)
nc = neurio.Client(token_provider=tp)
sample = nc.get_samples_live_last(sensor_id=sensor_id)
print "Current power consumption: %d W" % (sample['consumptionPower'])
def test_token_provider_invalid_credentials(self):
tp = neurio.TokenProvider(key=example_keys.key,
secret=example_keys.secret)
with self.assertRaises(Exception):
tp.get_token()
def test_token_provider_get_token(self):
tp = neurio.TokenProvider(key=test_keys.key, secret=test_keys.secret)
self.assertIsNotNone(tp.get_token(), "unable to fetch token")
def test_token_provider_init(self):
tp = neurio.TokenProvider(key=test_keys.key, secret=test_keys.secret)
self.assertIsNotNone(tp)
def main(argv):
#make the keys available
global APIKEY
global SYSTEMID
entireDay = False
donation = False
getSensorId = False
ltz = dateutil.tz.tzlocal()
UTCtz = dateutil.tz.tzutc()
APIKEY = my_keys.APIKEY
SYSTEMID = my_keys.SYSTEMID
if my_keys.DONATION:
maxEntries = 100
else:
maxEntries = 30
try:
opts, args = getopt.getopt(argv, "sht:", ["hoursBack"])
except getopt.GetoptError:
print 'neurioToPvoutput -sh -t dHrs '
sys.exit(2)
for opt, arg in opts:
if opt in ("-s"):
getSensorId = True
if opt in ("-t"):
dHrs = int(arg)
entireDay = True
if opt in ("-h"):
print 'neurio_pvoutput -udh -t dHrs '
print '-s print sensor id'
print '-h print help info'
print '-t dHrs - dHrs = number of hours in the past go get the neurio data'
sys.exit(0)
# get the Neurio token
tp = neurio.TokenProvider(key=my_keys.key, secret=my_keys.secret)
nc = neurio.Client(token_provider=tp)
#read the sensor Id
if getSensorId:
user_info = nc.get_user_information()
locations = user_info.get("locations")
sensors = locations[0].get("sensors")
sensorId = sensors[0].get("sensorId")
print "Sensor Id = " + sensorId.encode("utf-8")
sys.exit(0)
#Neurio doesnt allow more than a days worth of data in a single request
#so limit the data to either now - 1day or input offset time + 1 day
if entireDay:
stime = datetime.datetime.now() - datetime.timedelta(hours=dHrs)
etime = stime + datetime.timedelta(days=1)
else:
stime = datetime.datetime.now() - datetime.timedelta(days=1)
etime = stime + datetime.timedelta(days=1)
etime = etime - datetime.timedelta(hours=1)
#nuerio uses UTC, so we need to convert localtime to UTC and
#format the strings that neurio expects
stime = stime.replace(tzinfo=ltz)
etime = etime.replace(tzinfo=ltz)
stimeString = stime.astimezone(UTCtz).strftime("%Y-%m-%dT%H:%M:%S")
etimeString = etime.astimezone(UTCtz).strftime("%Y-%m-%dT%H:%M:%S")
print etimeString
print stimeString
#read the data from neurio
current = nc.get_samples_live_last(my_keys.sensor_id)
print current
stats = nc.get_samples_stats(my_keys.sensor_id, stimeString, "minutes",
etimeString, 5, 500, 1)
#stats = nc.get_samples_stats(my_keys.sensor_id,stimeString,"hours",etimeString)
print stats
cnt = 0
batchString = ''
#build the string from the stats we read
for item in stats:
#read the time
time = dateutil.parser.parse(item.get("start")).astimezone(ltz)
print time
#Read in the Energy and convert it to power in the 5 minute time
#Energy is in WattSec, Pvoutput wants watts
#So WattSec/3600Sec/Hr*12(5minute periods/hour) = Watts in the 5minute period
cons = float(item.get("consumptionEnergy")) / 3600 * 12
gen = float(item.get("generationEnergy")) / 3600 * 12
#store the date,time,-1,,generatedPower,-1,consumedPower
batchString = batchString + time.strftime(
"%Y%m%d,%H:%M") + ',-1,' + str(int(gen + 0.5)) + ',-1,' + str(
int(cons + 0.5)) + ';'
cnt = cnt + 1
#We can't exceed the pvoutput limits so check if we have hit the limit for each batch upload
if cnt == maxEntries:
log_pvoutput(batchString)
cnt = 0
batchString = ''
#finally check to see if there are any left over entries to uplad
if cnt > 0:
log_pvoutput(batchString)
def setUp(self):
self.tp = neurio.TokenProvider(key=test_keys.key,
secret=test_keys.secret)
self.nc = neurio.Client(token_provider=self.tp)
from __future__ import print_function
import neurio
import os
# Setup authentication:
tp = neurio.TokenProvider(key=os.environ.get('NEURIO_KEY'),
secret=os.environ.get('NEURIO_SECRET'))
# Create client that can authenticate itself:
nc = neurio.Client(token_provider=tp)
# Get user information (including sensor ID and location ID)
user_info = nc.get_user_information()
print("Sensor ID %s, location ID %s" %
(user_info["locations"][0]["sensors"][0]["sensorId"],
user_info["locations"][0]["id"]))
# Fetch sample from the remote API (not the local device.):
sample = nc.get_samples_live_last(
sensor_id=user_info["locations"][0]["sensors"][0]["sensorId"])
print("Current power consumption: %d W" % (sample['consumptionPower']))
