solarlog.py

import os
import re
import sys
import logging
import datetime

logger = logging.getLogger('')

class SolarLog():
    
    def __init__(self):
        self._vars = {}
        self._arrays = {}
        self._read_base_vars()

        logger.debug('--------- vars')
        for var in self._vars.keys():
            logger.debug(' {0} = {1}'.format(var, self._vars[var]))
        logger.debug('--------- arrays')
        for key in self._arrays.keys():
            logger.debug(' {0} = {1}'.format(key, self._arrays[key]))

        #logger.debug('--------- min_day')
        #self._read_min_day()
        #logger.debug('--------- min_day from 01.03.2013')
        #self._read_min_day(datetime.date(2013, 3, 1))
        #logger.debug('--------- days')
        #self._read_days()
        #logger.debug('--------- days history')
        #self._read_days(True)
        #logger.debug('--------- months')
        #self._read_months()
        #logger.debug('--------- years')
        #self._read_years()
        #logger.debug('--------- min_cur')
        #self._refresh()
        #logger.debug('--------- vars')
        #for var in self._vars.keys():
        #    logger.debug(' {0} = {1}'.format(var, self._vars[var]))
        #logger.debug('--------- arrays')
        #for key in self._arrays.keys():
        #    logger.debug(' {0} = {1}'.format(key, self._arrays[key]))


    def _read_base_vars(self):
        self._read_javascript('base_vars.js')

    def _refresh(self):
        self._read_javascript('min_cur.js')

    def _read_javascript(self, filename):
        re_var = re.compile(r'^var\s+(?P<varname>\w+)\s*=\s*"?(?P<varvalue>[^"]+)"?;?')
        re_array = re.compile(r'^var\s+(?P<varname>\w+)\s*=\s*new\s*Array\s*\((?P<arrayvalues>.*)\)')
        re_array_1st_level = re.compile(r'\s*(?P<varname>\w+)\[(?P<idx1>[0-9]+)\]((\s*=\s*(?:new\s*Array)?\((?P<arrayvalues>.*)\))|(\s*=\s*(?P<arraystring>.*)))')
        re_array_2nd_level = re.compile(r'\s*(?P<varname>\w+)\[(?P<idx1>[0-9]+)\]\s*\[(?P<idx2>[0-9]+)\]\s*=\s*new\s*Array\s*\((?P<arrayvalues>.*)\)')
        
        f = self._read(filename)

        if f:
            for line in f.splitlines():
                matches = re_array.match(line)

                if matches:
                    name, value = matches.groups()

                    self._arrays[name] = []

                    if self._vars.has_key(value):
                        self._arrays[name] = [None] * int(self._vars[value])
                    else:
                        try:
                            self._arrays[name] = [None] * int(value)
                        except:
                            self._arrays[name] = [x.strip(' "') for x in value.split(',')]
                    continue
                
                matches = re_var.match(line)

                if matches:
                    name, value = matches.groups()
                    if self._vars.has_key(name):
                        logger.debug('key {0} already exists'.format(name))
                    else:
                        self._vars[name] = value
                    continue

                matches = re_array_1st_level.match(line)

                if matches:
                    name = matches.group('varname')
                    idx1 = int(matches.group('idx1'))

                    if self._arrays.has_key(name):
                        logger.debug('access array {0} on index {1}'.format(name, idx1))
                        values = matches.group('arrayvalues')
                        if not values:
                            values = matches.group('arraystring')
                        if ',' in values:
                            self._arrays[name][idx1] = [x.strip(' "') for x in values.split(',')]
                        else:
                            self._arrays[name][idx1] = values
                    continue

                matches = re_array_2nd_level.match(line)

                if matches:
                    name, idx1, idx2, value = matches.groups()

                    if self._arrays.has_key(name):
                        self._arrays[name][int(idx1)][int(idx2)] = [x.strip(' "') for x in value.split(',')]
                    continue




    def _read_years(self):
        pattern = r'ye\[yx\+\+\]=.(?P<day>\d{2})\.(?P<month>\d{2})\.(?P<year>\d{2})'
        
        count_inverter = int(self._vars['AnzahlWR'])

        for x in range(0, count_inverter):
            pattern += '\|(?P<out_{0}>[0-9]*)'.format(x)

        pattern += '\"'
        logger.debug(' use pattern: {0}'.format(pattern))
        re_entry = re.compile(pattern)

        years = self._read('years.js')

        if years:
            for line in years.splitlines():
                matches = re_entry.match(line)

                if matches:
                    logger.debug(matches.groups())

    def _read_months(self):
        pattern = r'mo\[mx\+\+\]=.(?P<day>\d{2})\.(?P<month>\d{2})\.(?P<year>\d{2})'
        
        count_inverter = int(self._vars['AnzahlWR'])

        for x in range(0, count_inverter):
            pattern += '\|(?P<out_{0}>[0-9]*)'.format(x)

        pattern += '\"'
        logger.debug(' use pattern: {0}'.format(pattern))
        re_entry = re.compile(pattern)

        months = self._read('months.js')

        if months:
            for line in months.splitlines():
                matches = re_entry.match(line)

                if matches:
                    logger.debug(matches.groups())

    def _read_days(self, history=False):
        pattern = r'da\[dx\+\+\]=.(?P<day>\d{2})\.(?P<month>\d{2})\.(?P<year>\d{2})'
        
        count_inverter = int(self._vars['AnzahlWR'])

        for x in range(0, count_inverter):
            pattern += '\|(?P<out_{0}>[0-9]*);(?P<pac_max_{0}>[0-9]*)'.format(x)

        pattern += '\"'
        logger.debug(' use pattern: {0}'.format(pattern))
        re_entry = re.compile(pattern)

        if history:
            days = self._read('days_hist.js')
        else:
            days = self._read('days.js')

        if days:
            for line in days.splitlines():
                matches = re_entry.match(line)

                if matches:
                    logger.debug(matches.groups())


    def _read_min_day(self, date=None):
        pattern = r'm\[mi\+\+\]=.(?P<day>\d{2})\.(?P<month>\d{2})\.(?P<year>\d{2})\s(?P<hour>\d{2})\:(?P<minute>\d{2})\:(?P<second>\d{2})'
        
        count_inverter = int(self._vars['AnzahlWR'])
        count_strings = []

        # TODO: add a pattern that matches sensor boxes
        # ATM only inverters and strings supported
        for x in range(0, count_inverter):
            count_strings.append(int(self._arrays['WRInfo'][x][5]))

            pattern += '\|(?P<pac_{0}>[0-9]*)'.format(x)

            for y in range(0, count_strings[x]):
                pattern += ';(?P<pdc_{0}_{1}>[0-9]*)'.format(x,y)

            pattern += ';(?P<cur_{0}>[0-9]*)'.format(x)

            for y in range(0, count_strings[x]):
                pattern += ';(?P<udc_{0}_{1}>[0-9]*)'.format(x,y)

            if len(self._arrays['WRInfo'][x]) > 12:
                if self._arrays['WRInfo'][x][12] == '1':
                    pattern += ';(?P<temp_{0}>[0-9]*)'.format(x)

        pattern += '\"'
        logger.debug(' use pattern: {0}'.format(pattern))
        re_entry = re.compile(pattern)

        if date:
            min_day = self._read('min{0}.js'.format(date.strftime('%y%m%d')))
        else:
            min_day = self._read('min_day.js')

        if min_day:
            for line in min_day.splitlines():
                matches = re_entry.match(line)

                if matches:
                    logger.debug(matches.groups())
                
    def _read(self, filename):
        fn = os.path.join(os.path.dirname(__file__), filename)
        logger.debug('read from file {0}'.format(fn))
        with open(fn, 'r') as f:
            return f.read()

if __name__ == '__main__':
    logger.setLevel(logging.DEBUG)
    ch = logging.StreamHandler()
    logger.addHandler(ch)
    sl = SolarLog()

Format description:
http://photonensammler.homedns.org/wiki/doku.php?id=solarlog_datenformat