rename scr to src

src/API.py

@@ -0,0 +1,210 @@
+'''
+Created on 24.10.2013
+
+@author: Philipp Rauch
+@version: 0.6
+'''
+
+from datetime   import datetime
+from flask      import Flask, jsonify, abort, make_response, request
+from socket     import gethostname
+from config     import Config
+import ems
+
+### LOAD CONFIG ###
+c = Config()
+conf = c.readConf()
+
+api_host = gethostname() if conf['flask_server'] == '0.0.0.0' else conf['flask_server']
+api_url = 'http://%s:%s' % (api_host, conf['flask_port'])
+
+#### BUFFER ####
+class Buffer(object):
+    device = {
+             'battery' : {
+                    'id': 1,
+                    'voltage' : 400.11,
+                    'current' : 20.264,
+                    'power' : 53.465,
+                    'capacity' : 80.34,
+                    'isCharging' : False,
+                    'isMaster' : True,
+                    'dyn' : None },
+               'ac_grid' : {
+                    'id': 2,
+                    'voltage' : 400.23,
+                    'current' : 10.423,
+                    'power' : 23.35,
+                    'isOn' : True,
+                    'isFeed' : True,
+                    'isMaster' : False,
+                    'dyn' : None }
+              }
+    error = {
+                'db_error' : {
+                    'id' : 1,
+                    'content' : None }
+             }
+    dc_labor = {
+                'device' : device,
+                'error' : error
+                }
+
+    dc_grid = {
+                'device' : 'device',
+                'error' : 'error'
+                }
+
+    ac_grid = {
+                'device' : 'device',
+                'error' : 'error'
+                }
+
+    system = {
+              '00_config' : conf,
+              'dc_labor' : dc_labor,
+              'dc_grid' : dc_grid,
+              'ac_grid' : ac_grid,
+              'request' : None
+              }
+
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        # http://stackoverflow.com/questions/42558/python-and-the-singleton-pattern
+        if not cls._instance:
+            cls._instance = super(Buffer, cls).__new__(
+                                cls, *args, **kwargs)
+        return cls._instance
+
+    def gen_start_url(self, l):
+        '''
+        generate a URL form a list
+        @param l: list of aspacts of the URL
+        @return: URL
+        '''
+        url = api_url
+        for i in l:
+            url = '%s/%s' % (url, i)
+        return url
+
+    def get_level(self, l):
+        '''
+        iterating over a dictionary on a given path
+        @param l: items witch tell the path to the value
+        @return: dictionary with the key and value of the last item in the list
+        '''
+        level = l.pop(0)
+        for i in l:
+            if isinstance(level, dict) and i in level:
+                level = level.get(i)
+            else:
+                abort(404)
+        self.set_href(level, self.gen_start_url(l))        #set all links above
+        return {l[-1] : level}
+
+    def generate_links(self, dic, url, postfix):
+        '''
+        generats a link to dic if dic is a dictionary
+        @param dic: variable that is being tested on a dictionary
+        @param url: previous url
+        @param postfix: appendix to the given url
+        '''
+        if isinstance(dic, dict):
+            url = '%s/%s' % (url, postfix)
+            self.set_href(dic, url)
+        else:
+            return
+
+    def set_href(self, dic, url):
+        '''
+        set the ref link if dic is a dictionary
+        @param dic: variable that is being tested on a dictionary
+        @param url: url to the first dictionary
+        '''
+        if isinstance(dic, dict):
+            for i in dic.keys():
+                self.generate_links(dic.get(i), url, i)
+            dic.update({'000_href': url})
+            dic.update({'000_timestamp' : str(datetime.now())})
+
+    def foo(self, l, args):
+        '''
+        @param l: list
+        @param args: arguments from the reqest
+        @return: Dictionary
+        '''
+        del l[-1]
+        dic = self.get_level(l).get(l[-1])
+        if isinstance(dic, dict) and 'dyn' in dic:
+            message = 'generating view for %s' % (l[-1])
+        else:
+            abort(404)
+        return { l[-1] : message, 'args' : args.to_dict(flat=False)}
+
+    def update_buffer(self):
+        #ToDo
+        None
+
+    def init_buffer(self):
+        #ToDo
+        None
+
+class API(object):
+
+    def __init__(self):
+        self.app = Flask(__name__)
+
+        ### ADD URL RULES ###
+        self.app.error_handler_spec[None][400] = bad_reqest
+        self.app.error_handler_spec[None][404] = not_found
+        self.app.error_handler_spec[None][405] = not_allowed
+        self.app.add_url_rule('/', 'get_root', get_root, methods = ['GET'])
+        self.app.add_url_rule('/<path:path>', 'get_catch_all',
+                              get_catch_all, methods = ['GET'])
+
+buf = Buffer()
+
+########## ERROR Handler ##########
+def not_allowed(error):
+    return make_response(jsonify( { 'error': '405 Not Allowed' } ), 405)
+
+def not_found(error):
+    return make_response(jsonify( { 'error': '404 Not Found' } ), 404)
+
+def bad_reqest(error):
+    return make_response(jsonify( { 'error': '400 Bad Reqest' } ), 400)
+
+##########  GET Handler  ##########
+def get_root():
+    buf.set_href(Buffer.system, api_url)
+    return jsonify( { 'system' : Buffer.system } )
+
+def get_catch_all(path):
+    l = path.split('/')
+    l.insert(0, Buffer.system)
+    if '' == l[-1]:                     # if last element of list is empty
+        del l[-1]                       # remove it
+        out = buf.get_level(l)
+    elif 'dyn' == l[-1]:
+        args = request.args             # returns a dictionary with a list of values for each key
+                                        # each value and each key is represented as a string
+                                        # to convert it to a dictionary use to_dict(flat=False)
+                                        # to_dict(flat=True) returns the key and the first item of the value list.
+        out = buf.foo(l, args)
+    else:
+        out = buf.get_level(l)
+    return jsonify( out )
+
+def start():
+    api = API()
+    api.app.run(host = conf['flask_server'],
+                port = int(conf['flask_port']),
+                debug = conf['flask_debug'])
+
+EMS = ems.ems(buf)
+emsthread = EMS.start()
+if conf['config_debug']:
+    print 'EMS-Thread:\t', EMS
+    print '\tAPI-BUFFER:\t', buf
+start()