smartmetertx2mongo 1.2.0__tar.gz

smartmetertx2mongo-1.2.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: smartmetertx2mongo
+Version: 1.2.0
+Summary: Implementation of smartmetertx to save records to mongodb with config driven via YAML.
+Home-page: https://markizano.net/
+Author: Markizano Draconus
+Author-email: markizano@markizano.net
+License: GNU

smartmetertx2mongo-1.2.0/README.md

@@ -0,0 +1,46 @@
+# Original Class Object
+https://github.com/cmulk/python_smartmetertx
+
+# python-smartmetertx
+SmartMeterTX/SmartMeter Texas Python class provides a JSON interface to the electricity usage data available at https://www.smartmetertexas.com.
+You must have an account established at the site.
+
+Additions done by [@Markizano](http://github.com/markizano) to support updates since JAN 2024.
+API seems to be the same.
+
+More details can be found: https://github.com/mrand/smart_meter_texas
+
+Depends on a MongoDB server to be running in the environment of sorts.
+
+Will have to later build support for sqlite3 for local DB setup installs
+that require no further software than this package.
+
+More documentation in [doc](./doc).
+
+Notable files below:
+
+# bin/fetchMeterReads.cron.py
+Run this on a CRON to collect meter reads at least once a day to store data offline from the
+SmartMeterTexas.com site.
+
+# bin/smtx-server.py
+Run this to start up the local server.
+Configure with `~/.config/smartmetertx/config.yml`.
+Starts on port 7689 by default.
+
+Passwords are encrypted using gpg. You can store the PGP armored message block in your configuration
+file and this app will attempt to decrypt using your key (pending you manage the password/key/chain requirements beyond this app).
+
+Encrypt the password using:
+
+    $ echo -en "my-secret-password" | gpg -aer 0x0000
+
+Where `0x0000` is the key you want to use for this encryption.
+In this way, sensitive credentials are not stored in plain text in files.
+
+Loads a simple web page that can be used to visualize the data you want.
+
+Extend as you please from here :)
+
+# Screenshots
+![smtx-sample-page](https://markizano.net/assets/images/smtx-home-page.png)

smartmetertx2mongo-1.2.0/bin/fetchMeterReads.cron.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+
+import sys
+from smartmetertx.smtx2mongo import main
+
+if __name__ == '__main__':
+  sys.exit( main() )

smartmetertx2mongo-1.2.0/bin/smtx-server.py

@@ -0,0 +1,7 @@
+#!/usr/bin/env python3
+
+import sys
+from smartmetertx.server import main
+
+if __name__ == '__main__':
+  sys.exit( main() )

smartmetertx2mongo-1.2.0/lib/smartmetertx/__init__.py

@@ -0,0 +1,4 @@
+from kizano import Config
+Config.APP_NAME = 'smartmetertx'
+from smartmetertx.api import MeterReader
+from smartmetertx.smtx2mongo import Smtx2Mongo

smartmetertx2mongo-1.2.0/lib/smartmetertx/api.py

@@ -0,0 +1,108 @@
+import os
+import json
+import requests
+
+from pprint import pformat
+from kizano import getLogger
+
+# BEGIN: #StackOverflow
+# @Source: https://stackoverflow.com/a/16630836/2769671
+# These two lines enable debugging at httplib level (requests->urllib3->http.client)
+# You will see the REQUEST, including HEADERS and DATA, and RESPONSE with HEADERS but without DATA.
+# The only thing missing will be the response.body which is not logged.
+if os.getenv('DEBUG', False):
+    requests_log = getLogger("requests.urllib3", 10)
+    requests_log.propagate = True
+# END: #StackOverflow
+
+
+class MeterReader:
+    HOSTNAME = 'www.smartmetertexas.com'
+    HOST = f'https://{HOSTNAME}'
+    USER_AGENT = 'API Calls (python3; Linux x86_64) Track your own metrics with SmartMeterTX: https://github.com/markizano/smartmetertx'
+    TIMEOUT = 30
+
+    def __init__(self, timeout=10):
+        self.log = getLogger(__name__)
+        self.logged_in = False
+        self.session = requests.Session()
+        self.timeout = timeout
+        self.session.headers['Authority'] = MeterReader.HOSTNAME
+        self.session.headers['Origin'] = MeterReader.HOST
+        self.session.headers['Accept'] = 'application/json, text/plain, */*'
+        self.session.headers['Accept-Language'] = 'en-US,en;q=0.9'
+        self.session.headers['Content-Type'] = 'application/json; charset=UTF-8'
+        self.session.headers['dnt'] = '1'
+        self.session.headers['sec-ch-ua'] = '".Not/A)Brand";v="99", "Google Chrome";v="103", "Chromium";v="103"'
+        self.session.headers['sec-ch-ua-mobile'] = '?0'
+        self.session.headers['sec-ch-ua-platform'] = 'Linux'
+        self.session.headers['sec-fetch-dest'] = 'empty'
+        self.session.headers['sec-fetch-mode'] = 'cors'
+        self.session.headers['sec-fetch-site'] = 'same-origin'
+        self.session.headers['User-Agent'] = MeterReader.USER_AGENT
+
+    def api_call(self, url, json):
+        '''
+        Generic API call that can be made to the site for JSON results back.
+        @param url :string: Where to send POST request.
+        @param json :object: Data to send to the server.
+        @return :object: JSON response back or ERROR
+        '''
+        self.log.debug(f'MeterReader.api_call(url={url}, json={json})')
+        try:
+            return self.session.post(
+                url=url,
+                json=json,
+                timeout=self.timeout,
+                verify=False
+            )
+        except Exception as ex:
+            self.log.error(repr(ex))
+            raise ex
+
+    def login(self, username, password):
+        '''
+        Make API call to login and acquire a session token.
+        @param username :string: Username or email used to Login to the webpage.
+        @param password :string: Password used to login.
+        @return :string: The login token that will be used going forward.
+        '''
+        creds = {
+            "username": username,
+            "password": password
+        }
+        url = f"{MeterReader.HOST}/commonapi/user/authenticate"
+        r = self.api_call(url, json=creds)
+        if r.status_code != 200:
+            self.log.error("Login failed.")
+            self.log.debug(pformat(r.headers.__dict__))
+            self.log.debug(r.text)
+            self.log.debug(self.session.cookies.__dict__)
+            return False
+        else:
+            self.token = r.json()['token']
+            self.log.info("Login successful!")
+            self.log.debug(f"Got \x1b[33m{self.token}\x1b[0m as token.")
+            self.session.headers["Authorization"] = f"Bearer {self.token}"
+            self.logged_in = True
+            return self.token
+
+    def get_daily_read(self, esiid, start_date, end_date):
+        if self.logged_in == False:
+            self.log.error("You must login first.")
+            return False
+
+        json = {
+            "esiid": esiid,
+            "endDate": end_date,
+            "startDate": start_date,
+        }
+        url = f"{MeterReader.HOST}/api/usage/daily"
+        r = self.api_call(url, json=json)
+        if r.status_code != 200 or "error" in r.text.lower():
+            self.log.warning("Failed fetching daily read!")
+            self.log.debug(r.text)
+            self.log.debug(pformat(r.headers.__dict__))
+            return False
+        else:
+            return r.json()

smartmetertx2mongo-1.2.0/lib/smartmetertx/controller.py

@@ -0,0 +1,121 @@
+
+import os
+import json
+import cherrypy
+import traceback as tb
+
+class SmartMeterController(object):
+    '''
+    Base Controller abstract.
+    If a method is common among all controllers it goes here.
+    If a method should be implemented by all controllers, it could be included
+    here for all controllers to enjoy.
+    '''
+    ERRORS = {
+        'request-method': 'Request method not allowed.',
+        'accept-json': 'Accept header must be application/json.',
+        'not-json': 'Content-Type must be application/json.',
+        'content-length': 'Content-Length header required.',
+        'empty-body': 'Empty request body.',
+        'invalid-json': 'Invalid JSON: %s',
+    }
+
+    def isValidJSONRequest(self, request, body):
+        '''
+        Collection of validations against the client request to this server.
+        request: cherrypy.request object
+        body: The result to attempt to parse as a string.
+
+        400: bad request
+        405: method not allowed
+        406: not acceptable
+        411: content-length required
+        415: unsupported media type
+        417: expectation failed
+        422: Unprocessable entity
+
+        Usage:
+
+            isValid, errMesgs = self.isValidJSONRequest(request, payload)
+            if not isValid:
+                return { 'result': False, 'messages': errMesgs }
+        '''
+        result = True
+        mesgs = []
+        if request.get('REQUEST_METHOD', '') not in ['GET', 'POST', 'PUT']:
+            result = False
+            mesgs.append(SmartMeterController.ERRORS['request-method'])
+            cherrypy.response.status = 405
+        if request.get('REQUEST_URI', '').startswith('/api'):
+            accept = request.get('HTTP_ACCEPT', '')
+            if ('application/json' not in accept) and ('*/*' not in accept):
+                result = False
+                mesgs.append(SmartMeterController.ERRORS['accept-json'])
+                cherrypy.response.status = 415
+            if request['REQUEST_METHOD'] == 'POST':
+                if 'application/json' not in request.get('CONTENT_TYPE', ''):
+                    result = False
+                    mesgs.append(SmartMeterController.ERRORS['not-json'])
+                    cherrypy.response.status = 400
+                cl = request.get('CONTENT_LENGTH', 0)
+                if not cl or int(cl) < 1:
+                    result = False
+                    mesgs.append(SmartMeterController.ERRORS['content-length'])
+                    cherrypy.response.status = 411
+                if not body:
+                    result = False
+                    mesgs.append(SmartMeterController.ERRORS['empty-body'])
+                    cherrypy.response.status = 411
+                else:
+                    try:
+                        j = json.loads(body)
+                    except ValueError as e:
+                        result = False
+                        mesgs.append(SmartMeterController.ERRORS['invalid-json'] % e)
+                        cherrypy.response.status = 417
+        return result, mesgs
+
+    def returnError(self, err, mesgs):
+        '''
+        Return a [err] http response code and send the status message as an object.
+        Usage:
+
+          return self.returnError(500, ['no such file or directory'])
+        '''
+        kwargs = {}
+        if not cherrypy.response.status or ( cherrypy.response.status >= 200 and cherrypy.response.status <= 299 ):
+            cherrypy.response.status = int(err.get('status', 500))
+        if isinstance(mesgs, str):
+            mesgs = [mesgs]
+        result = {
+          'error': True,
+          'mesgs': err.get('mesgs', mesgs),
+          'value': None,
+        }
+        if 'DEBUG' in os.environ:
+            kwargs['indent'] = 2
+            kwargs['sort_keys'] = True
+            if err.has_key('e'):
+                result['exception'] = tb.format_exc(err['e'])
+        return json.dumps(result, **kwargs) + "\n"
+
+    def returnValue(self, result, value):
+        '''
+        Returns the value of the result you desire.
+        result: Boolean to return as a result of the operation.
+        value: object to return describing the result.
+        @returns :string: JSON dump of a wrapped object of the input params.
+        '''
+        if not cherrypy.response.status:
+            cherrypy.response.status = 200
+        kwargs = {}
+        if 'DEBUG' in os.environ:
+            kwargs['indent'] = 2
+            kwargs['sort_keys'] = True
+        return {
+            'error': False,
+            'status': 200,
+            'value': value,
+            'return': result,
+        }
+

smartmetertx2mongo-1.2.0/lib/smartmetertx/server.py

@@ -0,0 +1,176 @@
+
+import os, sys
+import cherrypy
+import jinja2
+import json
+from datetime import datetime
+
+from kizano import getLogger, getConfig, Config
+log = getLogger('smartmetertx.server', log_format='json')
+
+from .utils import getMongoConnection
+from .controller import SmartMeterController
+
+DEFAULT_UI_PATH = os.path.join( sys.exec_prefix, 'share', 'smartmetertx' )
+
+class MeterServer(SmartMeterController):
+    mongo = None
+
+    def __init__(self, config: Config):
+        super(MeterServer, self)
+        self.config = config
+        self.db = getMongoConnection(config).get_database(config['mongo'].get('dbname', 'smartmetertx'))
+
+    def __del__(self):
+        self.close()
+
+    def close(self):
+        if self.mongo:
+            self.mongo.close()
+            self.mongo = None
+
+    @cherrypy.expose
+    def index(self):
+        '''
+        Home page!
+        '''
+        return self.returnValue(True, {'hello': 'world'})
+
+    @cherrypy.expose
+    @cherrypy.tools.json_out()
+    def meterRead(self, date: str = None):
+        '''
+        Return a meter read for a specified date.
+        Gets the full meter read from the DB.
+        '''
+        result = {}
+        if date is None:
+            return self.returnValue(False, 'No date specified.')
+        try:
+            import dateparser
+            queryDate = dateparser.parse(date)
+            timerange = {
+                '$gte': queryDate.replace( hour=max(0, queryDate.hour-1) ),
+                '$lt': queryDate.replace( hour=min(23, queryDate.hour+1) )
+            }
+            result = self.db.meterReads.find_one({'datetime': timerange })
+            if result is None:
+                return self.returnValue(False, f'No meter read found for {date}')
+            log.debug(result)
+            del result['_id']
+            result['datetime'] = result['datetime'].strftime('%F/%R:%S')
+            return self.returnValue(True, result)
+        except Exception as e:
+            import traceback as tb
+            log.error(f'Error getting meter read for {date}: {e}')
+            log.error(tb.format_exc())
+            return self.returnValue(False, 'uhm, well, this is embarassing :S')
+
+    @cherrypy.expose
+    @cherrypy.tools.json_out()
+    def meterReads(self, fdate: str = None, tdate: str = None):
+        '''
+        Return a list of meter reads for a specified date range.
+        Gets only the list of values paired with the date as an object/key-value pairing.
+        '''
+        result = []
+        if fdate is None:
+            return self.returnValue(False, 'No From Date Specified. Need `fdate`.')
+        if tdate is None:
+            return self.returnValue(False, 'No To Date Specified. Need `tdate`.')
+        import dateparser
+        fromDate = dateparser.parse(fdate)
+        toDate = dateparser.parse(tdate)
+        timerange = {
+            '$gte': fromDate,
+            '$lt': toDate
+        }
+        projection = { '_id': False, 'reading': True, 'datetime': True}
+        reads = list( self.db.meterReads.find({'datetime': timerange }, projection) )
+        for mRead in reads:
+            sdate = mRead['datetime'].strftime('%F')
+            result.append( [sdate, mRead['reading'] ] )
+        return self.returnValue(True, result)
+
+    @cherrypy.expose
+    def shutdown(self):
+        '''
+        Shutdown the server.
+        '''
+        log.info('Server shutting down...')
+        cherrypy.engine.exit()
+        log.info('CherryPy Server exit.')
+
+class GoogleGraphsFS(SmartMeterController):
+    def __init__(self, uiPath: str = None):
+        log.info(f'Serving files from {uiPath}')
+        fsloader = jinja2.FileSystemLoader( uiPath )
+        self.view = jinja2.Environment(loader=fsloader)
+        cherrypy.response.headers['Access-Control-Allow-Origin'] = '*'
+        cherrypy.response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'
+
+    @cherrypy.expose
+    def index(self, **kwargs):
+        return self.view.get_template('index.html').render(
+            page='<p>Index Page.</p>',
+            navigation='<li><a href="/user/login">Login</a></li>'
+        )
+
+def main():
+    '''
+    Main application/API entry point.
+    '''
+    cherrypy._cplogging.LogManager.time = lambda self: datetime.now().strftime('%F %T')
+    # Default access_log_format '{h} {l} {u} {t} "{r}" {s} {b} "{f}" "{a}"'
+    # h - remote.ip, l - "-", u - login (or "-"), t - time, r - request line, s - status, b - content length
+    # f - referer, a - User Agent, o - Host or -, i - request.unique_id, z - UtcTime
+    cherrypy._cplogging.LogManager.access_log_format = '{' + json.dumps({
+        'time': '{t}',
+        'from': '{h}',
+        'user': '{u}',
+        'host': '{o}',
+        'status': '{s}',
+        'bytes': '{b}',
+        'referer': '{f}',
+        'agent': '{a}'
+    }) + '}'
+    #'{t} from={h} user={u} host={o} status={s} bytes={b} referer="{f}" agent="{a}"'
+    config = getConfig()
+    ui_path = os.path.realpath( config.get('server', {}).get('ui.path', DEFAULT_UI_PATH) )
+    if not os.path.exists(ui_path):
+        possible_paths = [
+            os.path.join(os.getenv('HOME', '/home/markizano'), '.local', 'share', 'smartmetertx'),
+            os.path.join(sys.prefix, 'local', 'share', 'smartmetertx'),
+            os.path.join(sys.prefix, 'share', 'smartmetertx'),
+        ]
+        for ppath in possible_paths:
+            if os.path.exists(ppath):
+                ui_path = ppath
+                break
+            else:
+                log.debug(f'Could not find UI in path: {ppath}')
+        if not os.path.exists(ui_path):
+            log.error(f'Could not find UI path: {ui_path}')
+            return 1
+    apiConfig = {
+        'tools.trailing_slash.on': False,
+        'tools.json_in.on': True,
+        'tools.staticdir.on': False,
+    }
+    serverConfig = {
+        'tools.trailing_slash.on': False,
+        'tools.staticdir.on': True,
+        'tools.staticdir.dir': ui_path
+    }
+    log.info('Starting SmartMeterTX Server...')
+    log.debug(config)
+    smtx = MeterServer(config)
+    content = GoogleGraphsFS( serverConfig['tools.staticdir.dir'] )
+    log.debug(f'Got config: {config}')
+    cherrypy.config.update(config.get('daemon', {}).get('cherrypy', {}))
+    cherrypy.tree.mount(smtx, '/api', { '/': apiConfig } )
+    cherrypy.tree.mount(content, '/', {'/': serverConfig })
+    cherrypy.engine.start()
+    cherrypy.engine.block()
+    return 0
+

smartmetertx2mongo-1.2.0/lib/smartmetertx/smtx2mongo.py

@@ -0,0 +1,110 @@
+'''
+\x1b[31mModule-Level Documentation!\x1b[0m
+'''
+import os
+import dateparser
+import pymongo
+import gnupg
+import json
+from datetime import datetime
+
+from kizano import getConfig, getLogger
+from smartmetertx.api import MeterReader
+from smartmetertx.utils import getMongoConnection
+
+log = getLogger(__name__)
+HOME = os.getenv('HOME', '')
+SMTX_FROM   = dateparser.parse(os.environ.get('SMTX_FROM', 'day before yesterday'))
+SMTX_TO     = dateparser.parse(os.environ.get('SMTX_TO', 'today'))
+
+class Smtx2Mongo(object):
+    '''
+    SmartMeterTexas -> MongoDB
+    Model object to take the records we get from https://smartmetertexas.com and insert them into
+    a mongodb we control for data preservation and other analytics on our electric usage data we
+    would want to undertake.
+    '''
+
+    def __init__(self):
+        self.config = getConfig()
+        self.mongo = getMongoConnection(self.config)
+        self.db = self.mongo.get_database(self.config['mongo'].get('dbname', 'smartmetertx'))
+        self.getSMTX()
+        self.ensureIndexes()
+
+    def close(self):
+      if self.mongo:
+        self.mongo.close()
+        self.mongo = None
+
+    def ensureIndexes(self):
+        self.db.meterReads.create_index(
+            [('reading', 1)],
+            background=True
+        )
+        self.db.meterReads.create_index(
+            [('datetime', 1)],
+            background=True,
+            unique=True
+        )
+        return self
+
+    def getSMTX(self):
+        log.info('Connecting to SmartMeterTX...')
+        gpg = gnupg.GPG(gnupghome=os.path.join(os.getenv('HOME', '/home/markizano') , '.gnupg'), use_agent=True)
+        self.smtx = MeterReader()
+        smtx_user = self.config['smartmetertx']['user']
+        smtx_pass = gpg.decrypt(self.config['smartmetertx']['pass']).data.decode('utf-8').strip()
+        self.smtx.login(smtx_user, smtx_pass)
+        log.info('Success! Getting meter reads...')
+        return self.smtx
+
+    def getDailyReads(self):
+        # Get the meter reads and print the date in the format their API expects.
+        reads = self.smtx.get_daily_read(self.config['smartmetertx']['esiid'], SMTX_FROM.strftime('%m/%d/%Y'), SMTX_TO.strftime('%m/%d/%Y'))
+        if not reads:
+            log.warn('Failed to get records from meterReads()')
+        else:
+            log.info('Acquired %d meter reads! Inserting into DB...' % len(reads['dailyData']))
+        return reads
+
+    def filterDailyReads(self, dailyData):
+        results = []
+        log.debug(json.dumps(dailyData, indent=2))
+        for meterRead in dailyData:
+            meterRead['datetime'] = datetime.strptime('%(date)s %(starttime)s' % meterRead, '%m/%d/%Y %H:%M%p')
+            del meterRead['date'], meterRead['starttime']
+            meterRead['startreading'] = float(meterRead['startreading'])
+            meterRead['endreading'] = float(meterRead['endreading'])
+            results.append(meterRead)
+        return results
+
+    def insertDailyData(self, dailyData):
+        results = []
+        log.info('Inserting %d reads into the DB.' % len(dailyData))
+        try:
+            insertResult = self.db.meterReads.insert_many(dailyData)
+            log.debug(insertResult)
+            results.append(insertResult)
+        except pymongo.errors.BulkWriteError as e:
+            errs = list(filter( lambda x: x['code'] != 11000, e.details['writeErrors'] ))
+            if errs:
+                raise errs
+        log.info('Complete!')
+
+def main():
+    log.info('Gathering records from %s to %s' % ( SMTX_FROM.strftime('%F/%R'), SMTX_TO.strftime('%F/%R') ) )
+    smtx2mongo = Smtx2Mongo()
+    reads = smtx2mongo.getDailyReads()
+    if not reads:
+        log.error('Failed to read smartmetertexas API...')
+        return 2
+
+    dailyData = smtx2mongo.filterDailyReads(reads['dailyData'])
+    if dailyData:
+        smtx2mongo.insertDailyData(dailyData)
+    else:
+        log.warning('No records inserted!')
+    smtx2mongo.close()
+    return 0
+

smartmetertx2mongo-1.2.0/lib/smartmetertx/utils.py

@@ -0,0 +1,22 @@
+
+import os
+import pymongo
+import gnupg
+import kizano
+from urllib.parse import urlencode
+
+log = kizano.getLogger(__name__)
+
+def getMongoConnection(config: kizano.Config):
+    # Establish connections to various sources and targets.
+    log.info('Connecting to MongoDB...')
+    gpg = gnupg.GPG(gnupghome=os.path.join(os.environ['HOME'], '.gnupg'), use_agent=True)
+    mongo_user = config['mongo']['username']
+    mongo_pass = gpg.decrypt(config['mongo']['password']).data.decode('utf-8')
+    mongo_host = config['mongo']['host']
+    mongo_opts = urlencode(config['mongo']['opts'])
+    mongo_url = f'mongodb://{mongo_user}:{mongo_pass}@{mongo_host}/?{mongo_opts}'
+    db = pymongo.MongoClient(mongo_url)
+    log.info('Connected!')
+    return db
+

smartmetertx2mongo-1.2.0/lib/ui/index.css

@@ -0,0 +1,49 @@
+
+/* 
+If a designer wants to come make this look more pretty, you're more than welcome!
+Feel free to submit a PR!
+*/
+
+#mychart {
+    max-width: 1280px;
+    max-height: 800px;
+    margin: 0 auto;
+    min-height: 400px;
+}
+
+#mytable {
+    max-width: 1280px;
+    max-height: 800px;
+    margin: 0 auto;
+    border: 2px solid black;
+}
+
+#mytable thead {
+    font-size: 1.7rem;
+    font-weight: bold;
+    background-color: #f2f2f2;
+    padding: 0.5rem;
+}
+
+#mytable th {
+    padding: 0.5rem;
+}
+
+#mytable td {
+    font-size: 1.2rem;
+    padding: 0.3rem;
+    border-bottom: 1px solid black;
+    margin: 0;
+}
+
+.kwh input {
+    width: 75px;
+    height: 24px;
+    font-size: 20px;
+}
+.kwh::before {
+    content: '$';
+}
+.kwh::after {
+    content: '/kWh';
+}

smartmetertx2mongo-1.2.0/lib/ui/index.html

@@ -0,0 +1,37 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>SMT Mongo Metric Reader</title>
+    <link rel="stylesheet" type="text/css" href="index.css" />
+    <!-- jQuery Core -->
+    <script type="text/javascript" src="https://code.jquery.com/jquery-1.11.3.js"></script>
+
+    <!-- jQueryUI Dependency -->
+    <script type="text/javascript" src="https://code.jquery.com/ui/1.11.3/jquery-ui.js"></script>
+    <link rel="stylesheet" href="//code.jquery.com/ui/1.13.1/themes/base/jquery-ui.css">
+
+    <!-- Google Charts -->
+    <script type="text/javascript" src="https://www.gstatic.com/charts/loader.js"></script>
+
+    <!-- Main Entrypoint to Script for this page. -->
+    <script type="text/javascript" src="index.js"></script>
+  </head>
+  <body>
+    <div id="page">
+      <header>
+        <h2>SmartMeter Texas Meter Reader</h2>
+        <p>
+          This chart shows data collected from the SmartMeter reader stored in the configured mongodb.
+          This software allows the overlay of additional data to draw correlations from other related
+          data that can be overlayed on top of this line chart.
+        </p>
+      </header>
+      <controls>
+        From Date: <input type="text" id="fdate" />&nbsp;&nbsp;
+        To Date: <input type="text" id="tdate" /><br />
+      </controls>
+      <div id="mychart"></div>
+      <table id="mytable"></table>
+    </div>
+  </body>
+</html>

smartmetertx2mongo-1.2.0/lib/ui/index.js

@@ -0,0 +1,151 @@
+
+let MeterRender = {};
+(function(MeterRender){
+
+    /**
+     * Event handler for refreshing the table with the new kWh rate based on what's in the textbox.
+     * @param {Event} event The event that triggered the request.
+     * @returns {void}
+     */
+    MeterRender.onKwhChange = function onKwhChange(event) {
+        let kwh = $('#kwh').val();
+        let tbody = $('#mytable tbody');
+        let rows = tbody.find('tr');
+        rows.each((i, r) => {
+            let row = $(r);
+            let consumption = parseFloat(row.find('td').eq(2).text());
+            row.find('td').eq(3).text('$' + (consumption * kwh).toFixed(2));
+        });
+    };
+
+    /**
+     * Draw a table of the monthly aggregate of consumption from the meter reads.
+     * The meter reads will come with a day and a meter read. This function will
+     * group them by month and show the consumption in a monthly listing.
+     * @param {Object} meterReads Meter read data from server.
+     * @returns {void}
+     */
+    MeterRender.drawTable = function drawTable(meterReads) {
+        var table = $('#mytable');
+        table.empty();
+        let months = meterReads.value.reduce((m, x) => {
+            // get the month as 2 digits always
+            let d = ((d) => `${d.getFullYear()}-${('0'+d.getMonth()).slice(-2)}`)(new Date(x[0]));
+            console.log(d);
+            if ( typeof m[d] === "undefined" ) m[d] = 0;
+            if ( typeof x[1] !== "number")
+                console.log("!!!" + x[1]);
+            m[d] += x[1];
+            return m;
+        }, {});
+        let monthKeys = Object.keys(months);
+        monthKeys.sort();
+        var thead = $('<thead>');
+        var tr = $('<tr><th>Year</th><th>Month</th><th>Consumption</th></tr>')
+        var kwh = $('<input>')
+          .attr('type', 'number')
+          .attr('id', 'kwh')
+          .attr('name', 'kwh')
+          .attr('placeholder', 'kWh')
+          .attr('step', 0.01)
+          .val(0.13)
+          .on('change', MeterRender.onKwhChange);
+        var th = $('<th>').addClass('kwh').append(kwh);
+        tr.append(th);
+        thead.append(tr);
+        var tbody = $('<tbody>');
+        monthKeys.forEach((k) => {
+            let date = k.split('-');
+            let row = $('<tr>');
+            row.append($(`<td></td>`).text(date[0]));
+            row.append($(`<td></td>`).text(parseInt(date[1]) + 1));
+            row.append($(`<td></td>`).text(months[k].toFixed(2) + ' kWh'));
+            row.append($(`<td></td>`).text('$' + (months[k] * kwh.val()).toFixed(2)));
+            tbody.append(row);
+        });
+
+        table.append(thead);
+        table.append(tbody);
+        console.log('Done populating table of meter reads.')
+        console.log(meterReads);
+    }
+
+
+    /**
+     * Google handler for drawing the chart.
+     * @param {Object} meterReads Meter read data from server.
+     * @returns {void}
+     */
+    MeterRender.drawChart = function drawChart(meterReads) {
+        var data = new google.visualization.DataTable();
+        data.addColumn('number', 'Date');
+        data.addColumn('number', 'Reading');
+        let reads = [...meterReads.value];
+        reads.unshift(['Date', 'Reading']);
+        var data = google.visualization.arrayToDataTable(reads);
+        var options = {
+            title: 'SmartMeter Texas Meter Reads',
+            legend: { position: 'bottom' }
+        };
+        var chart = new google.visualization.LineChart(document.getElementById('mychart'));
+        chart.draw(data, options);
+    };
+
+    /**
+     * Request the meter reads from the server.
+     * Sample response from the server looks like:
+     * {
+     *      error: false,
+     *      status: 200,
+     *      value: [
+     *          [
+     *              "2022-01-01",
+     *              00.000
+     *          ]
+     *      }
+     *  }
+     * 
+     * @param {Event} event The event that triggered the request.
+     * @returns {void}
+     */
+    MeterRender.requestMetrics = function requestMetrics(event) {
+        let fdate = encodeURI( $('#fdate').val() ), tdate = encodeURI( $('#tdate').val() );
+        $.ajax({
+            url: `/api/meterReads?fdate=${fdate}&tdate=${tdate}`,
+        }).done(meterReads => {
+            MeterRender.drawChart(meterReads);
+            MeterRender.drawTable(meterReads);
+        });
+    };
+
+    /**
+     * On load event handler.
+     * @param {Event} event The event that triggered the request.
+     * @returns {void}
+     */
+    MeterRender.onLoad = function onLoad(event) {
+        let fdate = $('#fdate'), tdate = $('#tdate');
+        let sixmonths = new Date( Date.now() - (86400 * 1000 * 365) );
+        let yday = new Date(Date.now() - 86400000);
+        let dtopts = {
+            changeMonth: true,
+            changeYear: true,
+            dateFormat: "yy-mm-dd"
+        };
+        fdate.datepicker(dtopts);
+        tdate.datepicker(dtopts);
+
+        fdate.val(`${sixmonths.getFullYear()}-${sixmonths.getMonth()+1}-${sixmonths.getDate()}`);
+        tdate.val(`${yday.getFullYear()}-${yday.getMonth()+1}-${yday.getDate()}`);
+
+        fdate.change(MeterRender.requestMetrics)
+        tdate.change(MeterRender.requestMetrics)
+    };
+
+    google.charts.load('current', {'packages': ['corechart']});
+    google.charts.setOnLoadCallback(MeterRender.requestMetrics);
+    return MeterRender;
+})(MeterRender);
+window.MeterRenderer = MeterRender;
+
+$(document).ready(MeterRender.onLoad);

smartmetertx2mongo-1.2.0/setup.cfg

@@ -0,0 +1,24 @@
+[options]
+include_package_data = True
+
+[tool:pytest]
+testpaths = tests
+python_files = tests/runtests.py
+
+[nosetests]
+detailed-errors = 1
+with-coverage = 1
+cover-package = smartmetertx
+cover-inclusive = 1
+cover-html = 1
+cover-html-dir = tests/coverage/
+debug = nose.loader
+pdb = 0
+pdb-failures = 0
+nocapture = 1
+tests = tests/runtests.py
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

smartmetertx2mongo-1.2.0/setup.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+
+import os, io
+import sys
+from glob import glob
+from pprint import pprint
+from setuptools import setup
+
+try:
+    import yaml
+except ImportError:
+    os.system('pip3 install PyYAML')
+    import yaml
+
+sys.path.insert(0, os.path.abspath('.'))
+
+try:
+    PATCH = io.open('.build-id').read().strip()
+except:
+    try:
+        pkginfo = yaml.safe_load(io.open('PKG-INFO').read())
+        PATCH = pkginfo['Version'].split('.').pop()
+    except Exception as e:
+        PATCH = '0'
+
+setup_opts = {
+    'name'                : 'smartmetertx2mongo',
+    # We change this default each time we tag a release.
+    'version'             : f'1.2.{PATCH}',
+    'description'         : 'Implementation of smartmetertx to save records to mongodb with config driven via YAML.',
+    'author'              : 'Markizano Draconus',
+    'author_email'        : 'markizano@markizano.net',
+    'url'                 : 'https://markizano.net/',
+    'license'             : 'GNU',
+    'tests_require'       : ['nose', 'mock', 'coverage'],
+    'install_requires'    : [
+        'dateparser',
+        'kizano',
+        'pymongo',
+        'requests',
+        'cherrypy',
+        'PyYAML',
+        'python-gnupg',
+        'jinja2',
+    ],
+    'package_dir'         : { 'smartmetertx': 'lib/smartmetertx' },
+    'packages'            : [
+      'smartmetertx',
+    ],
+    'scripts'             : glob('bin/*'),
+    'test_suite'          : 'tests',
+    'data_files'          : [
+        ('share/smartmetertx', glob('lib/ui/*')),
+    ]
+}
+
+try:
+    import argparse
+    HAS_ARGPARSE = True
+except:
+    HAS_ARGPARSE = False
+
+if not HAS_ARGPARSE: setup_opts['install_requires'].append('argparse')
+
+# I botch this too many times.
+if sys.argv[1] == 'test':
+    sys.argv[1] = 'nosetests'
+
+if 'DEBUG' in os.environ: pprint(setup_opts)
+
+setup(**setup_opts)
+
+if 'sdist' in sys.argv:
+    import gnupg, hashlib
+    gpg = gnupg.GPG()
+    for artifact in glob('dist/*.tar.gz'):
+        # Detach sign the artifact in dist/ folder.
+        fd = open(artifact, 'rb')
+        checksums = open('dist/CHECKSUMS.txt', 'w+b')
+        status = gpg.sign_file(fd, detach=True, output=f'{artifact}.asc')
+        print(f'Signed {artifact} with {status.fingerprint}')
+
+        # create a MD5, SHA1 and SHA256 hash of the artifact.
+        for hashname in ['md5', 'sha1', 'sha256']:
+            hasher = getattr(hashlib, hashname)()
+            fd.seek(0,0)
+            hasher.update(fd.read())
+            digest = hasher.hexdigest()
+            checksums.write(f'''{hashname.upper()}:
+{digest} {artifact}
+
+'''.encode('utf-8'))
+            print(f'Got {artifact}.{hashname} as {digest}')
+        checksums.seek(0, 0)
+        chk_status = gpg.sign_file(checksums, detach=True, output=f'dist/CHECKSUMS.txt.asc')
+        checksums.close()
+        fd.close()
+        print(f'Signed CHECKSUMS.txt with {chk_status.fingerprint}')
+

smartmetertx2mongo-1.2.0/smartmetertx2mongo.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: smartmetertx2mongo
+Version: 1.2.0
+Summary: Implementation of smartmetertx to save records to mongodb with config driven via YAML.
+Home-page: https://markizano.net/
+Author: Markizano Draconus
+Author-email: markizano@markizano.net
+License: GNU

smartmetertx2mongo-1.2.0/smartmetertx2mongo.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+setup.cfg
+setup.py
+bin/fetchMeterReads.cron.py
+bin/smtx-server.py
+lib/smartmetertx/__init__.py
+lib/smartmetertx/api.py
+lib/smartmetertx/controller.py
+lib/smartmetertx/server.py
+lib/smartmetertx/smtx2mongo.py
+lib/smartmetertx/utils.py
+lib/ui/index.css
+lib/ui/index.html
+lib/ui/index.js
+smartmetertx2mongo.egg-info/PKG-INFO
+smartmetertx2mongo.egg-info/SOURCES.txt
+smartmetertx2mongo.egg-info/dependency_links.txt
+smartmetertx2mongo.egg-info/requires.txt
+smartmetertx2mongo.egg-info/top_level.txt

smartmetertx2mongo-1.2.0/smartmetertx2mongo.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

smartmetertx2mongo-1.2.0/smartmetertx2mongo.egg-info/requires.txt

@@ -0,0 +1,8 @@
+PyYAML
+cherrypy
+dateparser
+jinja2
+kizano
+pymongo
+python-gnupg
+requests

smartmetertx2mongo-1.2.0/smartmetertx2mongo.egg-info/top_level.txt

@@ -0,0 +1 @@
+smartmetertx