web2py-service/modules/readers/adeireader.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import datetime
import calendar
import urllib2 as urllib
import base64
from helper import csvparser, xmlparser, print_exc
import re
from itertools import groupby

DEBUG = 0
ADEI_Time_Format = '%d-%b-%y %H:%M:%S.%f'

def adei_timestamp(adeitimestr):
    timestamp = datetime.datetime.strptime(adeitimestr, ADEI_Time_Format)
    timestamp = calendar.timegm(timestamp.timetuple())
    return timestamp

def parse_csv(url, username=None, password=None):
    request = urllib.Request(url)
    base64string = base64.encodestring('%s:%s' % ( username, password ) )
    request.add_header("Authorization", "Basic %s" % base64string)
    fp = urllib.urlopen(request)
    resp = csvparser(fp)
    #stamps = map(adei_timestamp, resp[0][1:])
    #data = [dict(zip(('name', 'values'), [s[0], s[1:]])) for s in resp[1:]]
    return resp
    #return stamps, data

def parse_xml(url, username=None, password=None):
    request = urllib.Request(url)
    base64string = base64.encodestring('%s:%s' % ( username, password ) )
    request.add_header("Authorization", "Basic %s" % base64string)
    fp = urllib.urlopen(request)
    return xmlparser(fp)
    

class ADEIReader(object):
    
    def __init__(self, host, server, db):
        self.host = host + '/services/'
        self.server = server
        self.db = db
        # self._sensors = None
        self._sensors = self.get_sensor_list()
        # print 'ADEIReader initialized'

    def qurl(self, qtype, **kargs):
        url = self.host

        if qtype == 'get':
            url = url + 'getdata.php?'
        elif qtype == 'group':
            url = url + 'list.php?target=groups'
        elif qtype == 'sensor':
            url = url + 'list.php?target=items'

        kargs['db_server'] = self.server
        kargs['db_name'] = self.db
        kargs['window'] = kargs.get('window') or '-1'
        kargs['resample'] = kargs.get('resample') or '0'
        for k, v in kargs.iteritems():
            url += '&' + k + '=' + v
        return url

    def get_sensor_list(self):
        url = self.qurl('group')
        groups = [ v.get('db_group') for v in parse_xml(url) ]
        sensor_list = {}
        for g in groups:
            url = self.qurl('sensor', db_group=g)
            sensor_list[g] = { v['name']:v['value'] for v in  parse_xml(url) }
        return sensor_list

    def getdata(self, group, *sensors):
        ' Fetch data from ADEI server. '
        try:
            masks = map(int, sensors)
        except:  
            if not self._sensors:
                self._sensors = self.get_sensor_list()
            if group in self._sensors:
                masks = map(self._sensors.get(group).get, sensors)
            else:
                masks = []
        if masks:
            try:
                data = self.querydata(group, *masks)
                data[0] = ('timestamp', adei_timestamp(data[0][1]))
            except:
                data = []
        else:
            data = []
        return data

    def querydata(self, group, *masks):
        masks = ','.join(map(str, masks))
        url = self.qurl('get', db_group=group, db_mask=masks)
        return parse_csv(url)

    @property
    def sensors(self):
#        if not self._sensors:
#            print 'retrieve sensor list'
#            self._sensors = self.get_sensor_list()
        return self._sensors

###### Deprected #######       

    def query(self, qtype='get', **kargs):
        # parse args
        group = str(kargs.get('group', ''))
        sensor = kargs.get('sensor', [])
        window = kargs.get('window','-1')
        resample = kargs.get('resample','0')
        sensor_mask = ','.join(map(str, sensor))
        url = self.qurl('get', db_group=group, db_mask=sensor_mask, window=window, resample=resample)
        data = parse_csv(url)
        # build sensor list
        #sensorlist = [ group+'__'+s for s in sensorMaskList ]
        #sensorlist.insert(0, 'timestamp')
        # pack data
        sname = [d[0] for d in data]
        svalue = [list( d[1:] ) for d in data]
        print svalue, len(svalue)
        svalue[0]  = map(adei_timestamp, svalue[0])
        svalue = transpose_list(svalue)
        # resample data
        if resample != '0':
            res_value = [svalue[0]]
            t0 = svalue[0][0]
            for v in svalue:
                if v[0] - t0  >= resample:
                    res_value.append(v)
                    t0 = v[0]
            svalue = res_value
        # debug info
        if DEBUG == 1:
            #import pprint
            print '--------------------------------------------------'
            print url
            print 'data:', len(data), data[0]
            print 'sensor names', sname, len(sname)
            print 'sensor values', svalue, len(svalue[0])
            print 'sensor', len(sensor)
            print
        return svalue

     #def parse_sensors(self, *sensors):
        #'''
        #Args:
            #sensors (list): a list of sensor identifiers

        #Return:

        #Description:
            #sensor identifiers  can be one of the following two forms, 
                #1) <group name>.<sensor name>,
                #2) (<group name>, <sensor name 1>, [<sensor name 2>, [...]]).
        #'''
        #if self.sensor_list is None:
            #self.sensor_list = self.get_sensor_list()

        #parsed_sensors = []
        #for item in sensors:
            #try:
                #m = re.match('(\w+).(\w+)', item)
                #if m:
                    #grp, sns = m.group(1), (m.group(2),)
            #except TypeError:
                #grp, sns= item[0], item[1:]
            #parsed_sensors.append((grp, sns))

        #res = {}
        #for k, v in parsed_sensors:
            #try: 
                #res[k].extend(v)
            #except: 
                #res[k] = list(v)
        #for k, v in res.iteritems():
            #try:
                #res[k] = sorted([ int(self.sensor_list.get(k).get(s)) for s in v ])
            #except:
                #pass
        #return res

ADEI_QUERY_STRING = {
        'group': 'db_group',
        'sensor': 'db_mask'
}

def f(x):
    x = str(x)
    result = []
    try:
        for part in x.split(','):
            if '-' in part:
                a, b = part.split('-')
                a, b = int(a), int(b)
                result.extend(range(a, b + 1))
            else:
                a = int(part)
                result.append(a)
    except:
        pass
    return map(str, result )

def transpose_list(l):
    return map(list, zip(*l))


class ADEIError(Exception):
    pass