moved protobuf files to new repo

restructure in client server model
loads of work still missing

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "protobuf"]
+	path = protobuf
+	url = git@github.com:LED-Freaks/LedD-protobuf.git

README.md

@@ -1,6 +1,6 @@
 # LedD
 
-[![][codeclimate img]][codeclimate] [![][license img]][license]
+[![][cq img]][cq] [![][license img]][license]
 
 LedD is a daemon for interfacing LED stripes written in python3. It provides an abstract interface for effects to control any kind of LED stripe through an controller, although it is intented to be used with the PCA9685 chip. An Android application can connect and natively change any settings for the effects and stripes.
 
@@ -18,6 +18,15 @@ LedD is a daemon for interfacing LED stripes written in python3. It provides an
     - PCA9685
 - __Note__: Plugins can have different permission requirements
 
+## Installation
+
+Make sure your i2c devices are available (modprobe i2c-dev) before you follow these steps.
+
+1. `apt-get install python3-dev python3-pip python3-cffi python3-docopt python3-nose python3-sqlalchemy python-smbus libffi-dev`
+2. `pip3 install -U cffi` (fixes a bug where smbus-cffi can't install)
+3. `pip3 install coloredlogs spectra json-rpc smbus-cffi`
+4. `adduser $USER i2c`
+
 ### Plugins & Effects
 
 Plugin functionality is planned as we provide APIs for effects and plugins to use. Here are some we are going to provide when they are finished.
@@ -43,5 +52,5 @@ This project is licensed under the conditions of the GNU GPL 3.0.
 
 [license]:LICENSE
 [license img]:https://img.shields.io/github/license/led-freaks/ledd.svg?style=flat-square
-[codeclimate]:https://codeclimate.com/github/LED-Freaks/LedD
-[codeclimate img]:https://img.shields.io/codeclimate/github/LED-Freaks/LedD.svg?style=flat-square
+[cq]:https://www.codacy.com/app/chefeificationful/LedD
+[cq img]:https://img.shields.io/codacy/bb2de4e1587f48358141cd7465d2ea89.svg?style=flat-square

ledd.py

@@ -1,3 +1,5 @@
+#!/usr/bin/python3
+
 # LEDD Project
 # Copyright (C) 2015 LEDD Team
 #
@@ -17,53 +19,26 @@
 """LedD Daemon
 
 Usage:
-  ledd.py [--daemon] [-d | --debug] [-v | --verbose]
+  ledd.py [--detach] [-d | --debug] [-v | --verbose]
   ledd.py -h | --help
   ledd.py --version
 
 Options:
   -h --help         Show this screen.
   --version         Show version.
-  -d --debug        Show debug output. (not recommended for daily use)
+  -d --debug        Show debug output. (not recommended)
   -v --verbose      Be verbose.
-  --daemon          Run in daemon mode.
+  --detach          Detach after start.
 """
 
 import logging
-import sys
 import os
-from pkgutil import iter_modules
+import sys
 
 from docopt import docopt
 
-import ledd.daemon
 import ledd
-
-if "smbus" not in (name for loader, name, ispkg in iter_modules()):
-    print("smbus not found, installing replacement")
-
-
-    class SMBus:
-        def __init__(self, i2c_address):
-            self.i2c_address = i2c_address
-            self.channels = {}
-
-        def write_word_data(self, addr, cmd, val):
-            if (cmd - 6) % 4 == 0:
-                self.channels[(cmd - 6) // 4] = val
-
-        def read_word_data(self, addr, cmd):
-            if (cmd - 8) // 4 not in self.channels:
-                self.channels[(cmd - 8) // 4] = 0
-            return self.channels[(cmd - 8) // 4]
-
-
-    class SMBusModule:
-        SMBus = SMBus
-
-
-    sys.modules['smbus'] = SMBusModule
-    sys.modules['smbus'].SMBus = SMBus
+import ledd.daemon
 
 
 def pid_exists(processid):
@@ -89,9 +64,6 @@ if __name__ == "__main__":
     if arguments['--debug']:
         lvl = logging.DEBUG
 
-    logging.basicConfig(level=lvl,
-                        format="[%(asctime)s] %(levelname)s [%(name)s.%(funcName)s:%(lineno)d] %(message)s",
-                        datefmt="%H:%M:%S")
     log = logging.getLogger(__name__)
 
     try:
@@ -106,7 +78,7 @@ if __name__ == "__main__":
     except FileNotFoundError:
         pass
 
-    if arguments['--daemon']:
+    if arguments['--detach']:
         wdir = os.path.dirname(os.path.realpath(__file__))
         try:
             pid = os.fork()
@@ -118,7 +90,7 @@ if __name__ == "__main__":
                     os.chdir(wdir)
                     with open("ledd.pid", 'w') as pidf:
                         pidf.write(str(os.getpid()) + '\n')
-                    daemon = ledd.daemon.Daemon()
+                    ledd.daemon.run()
                 else:
                     sys.exit()
             else:
@@ -126,4 +98,4 @@ if __name__ == "__main__":
         except OSError as e:
             log.fatal("Start failed: %s", e)
     else:
-        daemon = ledd.daemon.Daemon()
+        ledd.daemon.run()

ledd/__init__.py

@@ -14,4 +14,4 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-VERSION = "0.1"
+VERSION = "0.2"

ledd/client.py

@@ -0,0 +1,62 @@
+import asyncio
+import socket
+
+from ledd import VERSION
+from ledd.protobuf import client_pb2
+from ledd.protobuf.ledd_pb2 import WrapperMsg, LedD
+
+
+class LedDClientProtocol(asyncio.Protocol):
+    def connection_made(self, transport):
+        print("Connected to client!")
+
+    def data_received(self, data):
+        print('Data received: {!r}'.format(data.decode()))
+
+    def connection_lost(self, exc):
+        print('The client closed the connection')
+
+
+class Client:
+    def __init__(self):
+        super().__init__()
+
+        self.msg = client_pb2.Client()
+        self.proto = None
+        self.transport = None
+
+    def init_from_db(self, row):
+        self.msg.name = row['name']
+        self.msg.addr = row['addr']
+        self.msg.id = row['id']
+        self.msg.options = row['options']
+        self.msg.resolution = row['reso']
+        self.msg.port = row['port']
+
+    def init_from_msg(self, msg):
+        client = client_pb2.Client()
+        self.msg = client.ParseFromString(msg)
+
+    def connect(self):
+        ledd = LedD()
+        ledd.version = VERSION
+        ledd.hostname = socket.gethostname()
+
+        wrapper = WrapperMsg()
+        wrapper.type = WrapperMsg.Type.DISCOVER
+        wrapper.ledd = ledd
+
+        loop = asyncio.get_event_loop()
+        coro = loop.create_connection(LedDClientProtocol, self.msg.addr, self.msg.port)
+        loop.run_until_complete(coro)
+        self.transport = coro[0]
+        self.proto = coro[1]
+
+        self.send_to_client(wrapper.SerializeToString())
+
+    def is_connected(self):
+        return not self.transport.is_closing()
+
+    def send_to_client(self, data):
+        if self.is_connected() and data:
+            self.transport.write(data)

ledd/controller.py

@@ -1,167 +0,0 @@
-# LEDD Project
-# Copyright (C) 2015 LEDD Team
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-from json import JSONEncoder
-import logging
-import time
-
-import smbus
-
-from ledd.stripe import Stripe
-
-PCA9685_SUBADR1 = 0x2
-PCA9685_SUBADR2 = 0x3
-PCA9685_SUBADR3 = 0x4
-
-PCA9685_MODE1 = 0x00
-PCA9685_MODE2 = 0x01
-PCA9685_PRESCALE = 0xFE
-
-LED0_ON_L = 0x06
-LED0_ON_H = 0x07
-LED0_OFF_L = 0x08
-LED0_OFF_H = 0x09
-
-ALLLED_ON_L = 0xFA
-ALLLED_ON_H = 0xFB
-ALLLED_OFF_L = 0xFC
-ALLLED_OFF_H = 0xFD
-
-
-class Controller:
-    """
-    A controller controls a number of stripes.
-    """
-
-    @classmethod
-    def from_row(cls, db, row):
-        # load from db
-        return cls(db, pwm_freq=row["pwm_freq"], channels=row["channels"], i2c_device=row["i2c_device"],
-                   address=row["address"], cid=row["id"], from_db=True)
-
-    @staticmethod
-    def from_db(db):
-        l = []
-        cur = db.cursor()
-        for row in cur.execute("select * from controller"):
-            c = Controller.from_row(db, row)
-            l.append(c)
-        cur.close()
-        return l
-
-    def save_to_db(self):
-        cur = self.db.cursor()
-        if self.id == -1:
-            cur.execute("INSERT INTO controller (pwm_freq, channels, i2c_device, address) VALUES (?,?,?,?)",
-                        (self._pwm_freq, self.channels, self.i2c_device, self.address))
-            self.id = cur.lastrowid
-        else:
-            cur.execute("UPDATE controller SET pwm_freq=?, channels=?, i2c_device=?, address=? WHERE id = ?",
-                        (self._pwm_freq, self.channels, self.i2c_device, self.address, self.id))
-        cur.close()
-        self.db.commit()
-
-    def __init__(self, db, channels, i2c_device, address, pwm_freq=1526, cid=-1, from_db=False):
-        self._mode = None
-        self.channels = channels
-        self.i2c_device = i2c_device
-        self.bus = smbus.SMBus(i2c_device)
-        self.address = address
-        self._address = int(address, 16)
-        self.id = cid
-        self.db = db
-        self.stripes = []
-        self._pwm_freq = None
-        self.pwm_freq = pwm_freq
-        if not from_db:
-            self.save_to_db()
-        self.load_stripes()
-
-    def load_stripes(self):
-        cur = self.db.cursor()
-        for stripe in cur.execute("select * from stripes where controller_id = ?", (self.id,)):
-            self.stripes.append(Stripe.from_db(self, stripe))
-        logging.getLogger(__name__).debug("Loaded %s stripes for controller %s", len(self.stripes), self.id)
-        cur.close()
-
-    def __repr__(self):
-        return "<Controller stripes={} cid={}>".format(len(self.stripes), self.id)
-
-    def set_channel(self, channel, val):
-        self.bus.write_word_data(self._address, LED0_OFF_L + 4 * channel, int(val * 4095))
-        self.bus.write_word_data(self._address, LED0_ON_L + 4 * channel, 0)
-
-    def get_channel(self, channel):
-        return self.bus.read_word_data(self._address, LED0_OFF_L + 4 * channel) / 4095
-
-    def add_stripe(self, stripe):
-        self.stripes.append(stripe)
-
-    def reset(self):
-        self.mode = int("0b00100001", 2)  # MODE1 -> 0b00000001
-        time.sleep(0.015)
-        self.mode = int("0b10100001", 2)
-
-    @property
-    def mode(self):
-        self._mode = self.bus.read_byte_data(self._address, PCA9685_MODE1)
-        logging.getLogger(__name__).debug("Controller mode: %s", bin(self._mode))
-        return self._mode
-
-    @mode.setter
-    def mode(self, mode):
-        self.bus.write_byte_data(self._address, PCA9685_MODE1, mode)
-        self._mode = mode
-        logging.getLogger(__name__).debug("Controller mode: %s", bin(self._mode))
-
-    @property
-    def pwm_freq(self):
-        self._pwm_freq = (self.bus.read_byte_data(self._address, PCA9685_PRESCALE) + 1) / 4096 * 25000000
-        return self._pwm_freq
-
-    @pwm_freq.setter
-    def pwm_freq(self, value):
-        if value < 24 or value > 1526:
-            raise ValueError("PWM frequency must be 24Hz <= pwm_freq <= 1526Hz: {}".format(value))
-        prescal = round((25000000.0 / (4096.0 * value))) - 1
-        logging.getLogger(__name__).debug("Presacle value: %s", prescal)
-
-        self.mode = int("0b00110001", 2)
-        self.bus.write_byte_data(self._address, PCA9685_PRESCALE, prescal)
-        self.reset()
-        self._pwm_freq = value
-
-
-class ControllerEncoder(JSONEncoder):
-    def default(self, o):
-        if isinstance(o, Controller):
-            return {
-                'id': o.id,
-                'pwm_freq': o.pwm_freq,
-                'channel': o.channels,
-                'address': o.address,
-                'stripes': o.stripes,
-                'cstripes': len(o.stripes),
-                'i2c_device': o.i2c_device,
-                'mode': o.mode
-            }
-        elif isinstance(o, Stripe):
-            return {
-                'id': o.id,
-                'name': o.name,
-                'rgb': o.rgb,
-                'channel': o.channels
-            }

ledd/daemon.py

@@ -14,378 +14,339 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-import logging
-import configparser
-import json
-import sqlite3
-import os
-import sys
-import traceback
 import asyncio
+import configparser
+import errno
+import logging
+import os
 import signal
+import sqlite3
+import sys
 
 import spectra
+from sqlalchemy.orm.exc import NoResultFound
 
-from ledd import controller, VERSION
-from ledd.decorators import ledd_protocol
-from ledd.effectstack import EffectStack
-from ledd.stripe import Stripe
+from ledd import VERSION
+from ledd.db_helper import check_db
+from ledd.effect.effectstack import EffectStack
+from ledd.led.rgb_stripe import RGBStripe
+from ledd.protobuf.ledd_pb2 import WrapperMsg
 
 log = logging.getLogger(__name__)
 
+daemonSection = 'daemon'
+databaseSection = 'db'
+""" :type : asyncio.BaseEventLoop """
+effects = []
+leds = []
+clients = []
+conn = None
+loop = None
+server = None
 
-class Daemon:
-    daemonSection = 'daemon'
-    databaseSection = 'db'
-    instance = None
-    """:type : Daemon """
-    loop = None
-    """ :type : asyncio.BaseEventLoop """
-    protocol = {}
-    effects = []
-
-    def __init__(self):
-        Daemon.instance = self
 
+def run():
+    try:
+        # read config
+        config = configparser.ConfigParser()
         try:
-            # read config
-            self.config = configparser.ConfigParser()
-            try:
-                with open('ledd.config', 'w+') as f:
-                    self.config.read_file(f)
-            except FileNotFoundError:
-                log.info("No config file found!")
-                pass
+            with open('ledd.config', 'w+') as f:
+                config.read_file(f)
+        except FileNotFoundError:
+            log.info("No config file found!")
 
-            # SQL init
-            self.sqldb = sqlite3.connect(self.config.get(self.databaseSection, 'name', fallback='ledd.sqlite'))
-            self.sqldb.row_factory = sqlite3.Row
+        # SQL init
+        global conn
+        conn = sqlite3.connect(config.get(databaseSection, 'name', fallback='ledd.sqlite'))
+        conn.row_factory = sqlite3.Row
+        check_db(conn)
 
-            if not self.check_db():
-                self.init_db()
+        logging.getLogger("asyncio").setLevel(log.getEffectiveLevel())
 
-            self.sqldb.commit()
+        # sigterm handler
+        def sigterm_handler():
+            raise SystemExit
 
-            # init controllers from db
-            self.controllers = controller.Controller.from_db(self.sqldb)
-            log.debug(self.controllers)
-            logging.getLogger("asyncio").setLevel(log.getEffectiveLevel())
+        signal.signal(signal.SIGTERM, sigterm_handler)
 
-            # sigterm handler
-            def sigterm_handler(_signo, _stack_frame):
-                sys.exit(0)
+        # init plugins
+        # TODO: check all plugins for existing hooks
 
-            signal.signal(signal.SIGTERM, sigterm_handler)
+        # init clients
 
-            # main loop
-            self.loop = asyncio.get_event_loop()
-            coro = self.loop.create_server(LedDProtocol,
-                                           self.config.get(self.daemonSection, 'host', fallback='0.0.0.0'),
-                                           self.config.get(self.daemonSection, 'port', fallback=1425))
-            self.server = self.loop.run_until_complete(coro)
-            self.loop.run_forever()
-        except (KeyboardInterrupt, SystemExit):
-            log.info("Exiting")
-            try:
-                os.remove("ledd.pid")
-            except FileNotFoundError:
-                pass
-            self.sqldb.close()
-            self.server.close()
-            self.loop.run_until_complete(self.server.wait_closed())
-            self.loop.close()
-            sys.exit(0)
 
-    def check_db(self):
-        """
-        Checks database version
-        :return: database validity
-        :rtype: bool
-        """
-        c = self.sqldb.cursor()
-        try:
-            c.execute("SELECT value FROM meta WHERE option = 'db_version'")
-            db_version = c.fetchone()
+        # main loop
+        global loop, server
+        loop = asyncio.get_event_loop()
+        coro = loop.create_server(LedDProtocol,
+                                  config.get(daemonSection, 'host', fallback='0.0.0.0'),
+                                  config.get(daemonSection, 'port', fallback=1425))
+        server = loop.run_until_complete(coro)
+        log.info("Start phase finished; starting main loop")
+        loop.run_forever()
+    except (KeyboardInterrupt, SystemExit):
+        log.info("Exiting")
+
+        for c in clients:
             c.close()
 
-            if db_version is not None:
-                log.info("DB connection established; db-version=%s", db_version[0])
-                return True
-            else:
-                return False
-        except sqlite3.OperationalError:
-            c.close()
-            return False
-
-    def init_db(self):
-        self.sqldb.close()
-        if os.path.exists("ledd.sqlite"):
-            os.remove("ledd.sqlite")
-        self.sqldb = sqlite3.connect(self.config.get(self.databaseSection, 'name', fallback='ledd.sqlite'))
-        self.sqldb.row_factory = sqlite3.Row
-        with open("ledd/sql/ledd.sql", "r") as sqlfile:
-            c = self.sqldb.cursor()
-            c.executescript(sqlfile.read())
-            c.close()
-        self.check_db()
-
-    @ledd_protocol(protocol)
-    def start_effect(self, req_json):
-        """
-        Part of the Color API. Used to start a specific effect.
-        Required JSON parameters: stripe IDs: sids; effect id: eid, effect options: eopt
-        :param req_json: dict of request json
-        """
-        log.debug("recieved action: %s", req_json['action'])
-
-        stripes = []
-
-        if "sids" in req_json:
-            for sid in req_json['sids']:
-                found_s = self.find_stripe(sid)
-
-                if found_s is not None:
-                    stripes.append(found_s)
-
-        if len(stripes) > 0:
-            # TODO: add anything required to start effect with req_json['eid']
-            # on stripes[] with options in req_json['eopt']
-            effect = EffectStack()
-            self.effects.append(effect)
-            effect.stripes.append(self.controllers[0].stripes[0])
-            effect.start()
-
-            # asyncio.ensure_future(asyncio.get_event_loop().run_in_executor(self.executor, effect.execute))
-
-            rjson = {
-                'success': True,
-                'eident': None,  # unique effect identifier that identifies excatly this effect started on this set of
-                # stripes, used to stop them later and to give informations about running effects
-                'ref': req_json['ref']
-            }
-
-            return json.dumps(rjson)
-        else:
-            rjson = {
-                'success': False,
-                'message': "No stripe with this id found",
-                'ref': req_json['ref']
-            }
-
-            return json.dumps(rjson)
-
-    @ledd_protocol(protocol)
-    def stop_effect(self, req_json):
-        """
-        Part of the Color API. Used to stop a specific effect.
-        Required JSON parameters: effect identifier: eident
-        :param req_json: dict of request json
-        """
-        log.debug("recieved action: %s", req_json['action'])
-
-        # TODO: add stop effect by eident logic
-
-    @ledd_protocol(protocol)
-    def get_effects(self, req_json):
-        """
-        Part of the Color API. Used to show all available and running effects.
-        Required JSON parameters: -
-        :param req_json: dict of request json
-        """
-        log.debug("recieved action: %s", req_json['action'])
-
-        # TODO: list all effects here and on which stripes they run atm
-        # TODO: all effects get runtime only ids, "eid"'s. They are shown here for the client to start effects.
-        # TODO: All options that an effect may have need to be transmitted here too with "eopt".
-
-    @ledd_protocol(protocol)
-    def set_color(self, req_json):
-        """
-        Part of the Color API. Used to set color of a stripe.
-        Required JSON parameters: stripe ID: sid; HSV values hsv: h,s,v, controller id: cid
-        :param req_json: dict of request json
-        """
-        log.debug("recieved action: %s", req_json['action'])
-
-        found_s = self.find_stripe(req_json['sid'])
-
-        if found_s is None:
-            log.warning("Stripe not found: id=%s", req_json['sid'])
-        else:
-            found_s.set_color(spectra.hsv(req_json['hsv']['h'], req_json['hsv']['s'], req_json['hsv']['v']))
-
-    def find_stripe(self, sid):
-        """
-        Finds a given stripeid in the currently known controllers
-        :param sid stripe id
-        :return: stripe if found or none
-        :rtype: ledd.Stripe | None
-        """
-        for c in self.controllers:
-            for s in c.stripes:
-                if s.id == sid:
-                    return s
-
-        return None
-
-    @ledd_protocol(protocol)
-    def add_controller(self, req_json):
-        """
-        Part of the Color API. Used to add a controller.
-        Required JSON parameters: channels; i2c_dev: number of i2c device (e.g. /dev/i2c-1 would be i2c_dev = 1);
-                                  address: hexdecimal address of controller on i2c bus, e.g. 0x40
-        :param req_json: dict of request json
-        """
-        log.debug("recieved action: %s", req_json['action'])
         try:
-            ncontroller = controller.Controller(Daemon.instance.sqldb, req_json['channels'],
-                                                req_json['i2c_dev'], req_json['address'])
+            os.remove("ledd.pid")
+        except FileNotFoundError:
+            pass
+        conn.commit()
+        conn.close()
+        if server is not None:
+            server.close()
+        if loop is not None:
+            loop.run_until_complete(server.wait_closed())
+            loop.close()
+        sys.exit(0)
+
+
+def start_effect(**kwargs):
+    """
+    Part of the Color API. Used to start a specific effect.
+    Required parameters: stripe IDs: sids; effect id: eid, effect options: eopt
+    :param kwargs:
+    """
+
+    for stripe in RGBStripe.query.filter(RGBStripe.id.in_(kwargs['sids'])):
+        # TODO: add anything required to start effect with req_json['eid']
+        # on stripes[] with options in req_json['eopt']
+        effect = EffectStack()
+        effects.append(effect)
+        effect.stripes.append(stripe)
+        effect.start()
+
+        # asyncio.ensure_future(asyncio.get_event_loop().run_in_executor(executor, effect.execute))
+
+        rjson = {
+            'eident': None,  # unique effect identifier that identifies excatly this effect started on this set of
+            # stripes, used to stop them later and to give informations about running effect
+        }
+
+        return rjson
+
+        # return JSONRPCError(-1003, "Stripeid not found")
+
+
+def stop_effect(**kwargs):
+    """
+    Part of the Color API. Used to stop a specific effect.
+    Required parameters: effect identifier: eident
+    """
+
+    # TODO: add stop effect by eident logic
+
+
+def get_effects(**kwargs):
+    """
+    Part of the Color API. Used to show all available and running effect.
+    Required parameters: -
+    """
+
+    # TODO: list all effect here and on which stripes they run atm
+    # TODO: all effect get runtime only ids, "eid"'s. They are shown here for the client to start effect.
+    # TODO: All options that an effect may have need to be transmitted here too with "eopt".
+
+
+def set_color(**kwargs):
+    """
+    Part of the Color API. Used to set color of a stripe.
+    Required parameters: stripe ID: sid; HSV values hsv: h,s,v, controller id: cid
+    """
+
+    # if "sid" not in kwargs or "hsv" not in kwargs:
+    #    return JSONRPCInvalidParams()
+
+    stripe = get_stripe(kwargs['sid'])
+
+    if stripe:
+        try:
+            stripe.set_color(spectra.hsv(kwargs['hsv']['h'], kwargs['hsv']['s'], kwargs['hsv']['v']))
         except OSError as e:
-            log.error("Error opening i2c device: %s (%s)", req_json['i2c_dev'], os.strerror(int(str(e))))
-            rjson = {
-                'success': False,
-                'message': "Error while opening i2c device",
-                'message_detail': os.strerror(int(str(e))),
-                'ref': req_json['ref']
-            }
-            return json.dumps(rjson)
+            if int(e) == errno.ECOMM:
+                log.warning("Communication error on I2C Bus")
+                return e
+            else:
+                raise
+    else:
+        log.warning("Stripe not found: id=%s", kwargs['sid'])
+        # return JSONRPCError(-1003, "Stripeid not found")
 
-        self.controllers.append(ncontroller)
 
-        rjson = {
-            'success': True,
-            'cid': ncontroller.id,
-            'ref': req_json['ref']
-        }
+def set_color_all(**kwargs):
+    """
+    Part of the Color API. Used to set brightness of all stripes a controller owns.
+    Required parameters: controller id: cid, value: v
+    """
 
-        return json.dumps(rjson)
+    # if "cid" not in kwargs or "v" not in kwargs:
+    #    return JSONRPCInvalidParams()
 
-    @ledd_protocol(protocol)
-    def get_color(self, req_json):
-        """
-        Part of the Color API. Used to get the current color of an stripe.
-        Required JSON parameters: stripes
-        :param req_json: dict of request json
-        """
-        log.debug("recieved action: %s", req_json['action'])
+    try:
+        c = get_controller(kwargs['cid'])
+        """ :type c: ledd.controller.Controller """
 
-        found_s = self.find_stripe(req_json['sid'])
+        c.set_all_channel(kwargs['v'])
+    except NoResultFound:
+        log.warning("Controller not found: id=%s", kwargs['cid'])
+        # return JSONRPCError(-1002, "Controller not found")
 
-        if found_s is None:
-            log.warning("Stripe not found: id=%s", req_json['sid'])
-            return {
-                'success': False,
-                'message': "Stripe not found",
-                'ref': req_json['ref']
-            }
+    return ""
 
-        rjson = {
-            'success': True,
-            'color': found_s.color.values,
-            'ref': req_json['ref']
-        }
 
-        return json.dumps(rjson)
+def add_client(**kwargs):
+    """
+    Part of the ledd protocol. Used to add a client.
+    """
 
-    @ledd_protocol(protocol)
-    def add_stripe(self, req_json):
-        """
-        Part of the Color API. Used to add stripes.
-        Required JSON parameters: name; rgb: bool; map: r: r-channel, g: g-channel, b: b-channel, cid
-        :param req_json: dict of request json
-        """
-        log.debug("recieved action: %s", req_json['action'])
+    # if "i2c_dev" not in kwargs or "channels" not in kwargs or "address" not in kwargs:
+    #    return JSONRPCInvalidParams()
 
-        if "stripe" in req_json:
-            stripe = req_json['stripe']
-            c = next((x for x in self.controllers if x.id == stripe['cid']), None)
-            """ :type c: ledd.controller.Controller """
+    try:
+        pass
+        # ncontroller = Controller(channels=int(kwargs['channels']), i2c_device=int(kwargs['i2c_dev']),
+        #                          address=kwargs['address'], _pwm_freq=1526)
+    except OSError as e:
+        log.error("Error opening i2c device: %s (%s)", kwargs['i2c_dev'], e)
+        # return JSONRPCError(-1004, "Error while opening i2c device", e)
 
-            if c is None:
-                return {
-                    'success': False,
-                    'message': "Controller not found",
-                    'ref': stripe['ref']
-                }
+        # session = Session()
+        # session.add(ncontroller)
+        # session.commit()
 
-            s = Stripe(c, stripe['name'], stripe['rgb'],
-                       (stripe['map']['r'], stripe['map']['g'], stripe['map']['b']))
+        # clients.append(ncontroller)
 
-            c.stripes.append(s)
-            log.debug("Added stripe %s to controller %s; new len %s", c.id, s.id, len(c.stripes))
+        # return {'cid': ncontroller.id}
 
-            rjson = {
-                'success': True,
-                'sid': s.id,
-                'ref': req_json['ref']
-            }
 
-            return json.dumps(rjson)
+def get_color(**kwargs):
+    """
+    Part of the Color API. Used to get the current color of an stripe.
+    Required parameters: sid
+    """
 
-    @ledd_protocol(protocol)
-    def get_stripes(self, req_json):
-        """
-        Part of the Color API. Used to get all registered stripes known to the daemon.
-        Required JSON parameters: none
-        :param req_json: dict of request json
-        """
-        log.debug("recieved action: %s", req_json['action'])
+    # if "sid" not in kwargs:
+    #    return JSONRPCInvalidParams()
 
-        rjson = {
-            'success': True,
-            'ccount': len(Daemon.instance.controllers),
-            'controller': Daemon.instance.controllers,
-            'ref': req_json['ref']
-        }
+    stripe = get_stripe(kwargs['sid'])
 
-        return json.dumps(rjson, cls=controller.ControllerEncoder)
+    if not stripe:
+        log.warning("Stripe not found: id=%s", kwargs['sid'])
+        # return JSONRPCError(-1003, "Stripeid not found")
 
-    @ledd_protocol(protocol)
-    def test_channel(self, req_json):
-        """
-        Part of the Color API. Used to test a channel on a specified controller.
-        Required JSON parameters: controller id: cid, channel, value
-        :param req_json: dict of request json
-        """
-        log.debug("recieved action: %s", req_json['action'])
+    if stripe.color:
+        return {'color': stripe.color.values}
+    else:
+        log.warning("Stripe has no color: id=%s", kwargs['sid'])
+        # return JSONRPCError(-1009, "Internal Error")
 
-        result = next(filter(lambda x: x.id == req_json['cid'], self.controllers), None)
-        """ :type : ledd.controller.Controller """
 
-        if result is not None:
-            result.set_channel(req_json['channel'], req_json['value'])
+def add_led(**kwargs):
+    """
+    Part of the Color API. Used to add stripes.
+    Required  parameters: name; rgb: bool; map: r: r-channel, g: g-channel, b: b-channel, cid
+    """
 
-        rjson = {
-            'success': True,
-            'ref': req_json['ref']
-        }
+    # if "name" not in kwargs or "rgb" not in kwargs or "map" not in kwargs or "cid" not in kwargs:
+    #    return JSONRPCInvalidParams()
 
-        return json.dumps(rjson)
+    c = get_controller(kwargs['cid'])
+    """ :type c: ledd.controller.Controller """
 
-    @ledd_protocol(protocol)
-    def discover(self, req_json):
-        """
-        Part of the Color API. Used by mobile applications to find the controller.
-        Required JSON parameters: none
-        :param req_json: dict of request json
-        """
-        log.debug("recieved action: %s", req_json['action'])
+    if c is None:
+        log.warning("Controller not found: id=%s", kwargs['cid'])
+        # return JSONRPCError(-1002, "Controller not found")
 
-        rjson = {
-            'success': True,
-            'ref': req_json['ref'],
-            'version': VERSION
-        }
+    s = RGBStripe(name=kwargs['name'], rgb=bool(kwargs['rgb']),
+                  channel_r=kwargs['map']['r'], channel_g=kwargs['map']['g'], channel_b=kwargs['map']['b'])
+    s.controller = c
+    log.debug("Added stripe %s to controller %s; new len %s", s.id, c.id, len(c.stripes))
 
-        return json.dumps(rjson)
+    # session = Session()
+    # session.add(s)
+    # session.commit()
+    leds.append(s)
 
-    def no_action_found(self, req_json):
-        rjson = {
-            'success': False,
-            'message': "No action found",
-            'ref': req_json['ref']
-        }
-        return json.dumps(rjson)
+    return {'sid': s.id}
+
+
+def get_leds(**kwargs):
+    """
+    Part of the Color API. Used to get all registered stripes known to the daemon.
+    Required parameters: -
+    """
+
+    rjson = {
+        # 'ccount': len(controller),
+        # 'controller': controller
+    }
+
+    return rjson
+
+
+def test_channel(**kwargs):
+    """
+    Part of the Color API. Used to test a channel on a specified controller.
+    Required parameters: controller id: cid, channel, value
+    """
+
+    # if "cid" not in kwargs or "channel" not in kwargs or "value" not in kwargs:
+    #    return JSONRPCInvalidParams()
+
+    contr = get_controller(kwargs['cid'])
+    """ :type : ledd.controller.Controller """
+
+    if contr is not None:
+        try:
+            contr.set_channel(kwargs['channel'], kwargs['value'], 2.8)
+        except OSError as e:
+            pass
+            # return JSONRPCError(-1009, "Internal Error", e)
+    else:
+        pass
+        # return JSONRPCError(-1002, "Controller not found")
+
+
+def discover(**kwargs):
+    """
+    Part of the Color API. Used by mobile applications to find the controller.
+    Required parameters: -
+    """
+
+    return {'version': VERSION}
+
+
+def get_stripe(sid):
+    pass
+    # for s in stripes:
+    #    if s.id == sid:
+    #        return s
+
+
+def get_controller(cid):
+    pass
+    # for c in controller:
+    #    if c.id == cid:
+    #        return c
+
+
+function_mapping = {WrapperMsg.Type.LED_GET_ALL: get_leds,
+                    WrapperMsg.Type.LED_ADD: add_led,
+                    WrapperMsg.Type.CLIENT_ADD: add_client,
+                    # WrapperMsg.Type.LED_PERC_SET: ,
+                    # WrapperMsg.Type.LED_PERC_GET: ,
+                    # WrapperMsg.Type.CLIENT_LED_SET: ,
+                    # WrapperMsg.Type.CLIENT_GET: ,
+                    # WrapperMsg.Type.CLIENT_GET_LED_OPTIONS: ,
+                    # WrapperMsg.Type.CLIENT_SET_LOCAL_DIRECT: ,
+                    # WrapperMsg.Type.LEDGROUP_GET: ,
+                    # WrapperMsg.Type.LEDGROUP_GET_ALL: ,
+                    # WrapperMsg.Type.LEDGROUP_SET_COLOR: ,
+                    # WrapperMsg.Type.LEDGROUP_ADD: ,
+                    }
 
 
 class LedDProtocol(asyncio.Protocol):
@@ -397,36 +358,23 @@ class LedDProtocol(asyncio.Protocol):
 
     def data_received(self, data):
         try:
-            d_decoded = data.decode()
+            wrapper_msg = WrapperMsg()
+            wrapper_msg = wrapper_msg.ParseFromString(data)
         except UnicodeDecodeError:
             log.warning("Recieved undecodable data, ignoring")
         else:
-            log.debug("Received: %s from: %s", d_decoded, self.transport.get_extra_info("peername"))
-            self.select_task(d_decoded)
+            self.select_task(wrapper_msg)
 
     def select_task(self, data):
         if data:
-            try:
-                data_split = data.splitlines()
-                log.debug(data_split)
-                for line in data_split:
-                    if line:
-                        json_decoded = json.loads(line)
+            response = function_mapping[data.type](data)
 
-                        if "action" in json_decoded and "ref" in json_decoded:
-                            return_data = Daemon.instance.protocol.get(json_decoded['action'], Daemon.no_action_found)(
-                                Daemon.instance, json_decoded)
-
-                            if return_data is not None:
-                                self.transport.write("{}\n".format(return_data).encode())
-                        else:
-                            log.debug("no action or ref value found in JSON, ignoring")
-            except TypeError:
-                log.debug("No valid JSON found: %s", traceback.format_exc())
-            except ValueError:
-                log.debug("No valid JSON detected: %s", traceback.format_exc())
+            if response:
+                try:
+                    # noinspection PyUnresolvedReferences
+                    self.transport.write(response.SerializeToString())
+                except TypeError as te:
+                    log.warning("Can't send response: %s", te)
 
     def connection_lost(self, exc):
-        # The socket has been closed, stop the event loop
-        # Daemon.loop.stop()
         log.info("Lost connection to %s", self.transport.get_extra_info("peername"))

ledd/db_helper.py

@@ -0,0 +1,22 @@
+DB_VERSION = 1
+
+
+def check_db(conn):
+    cur = conn.cursor()
+
+    cur.execute("SELECT value FROM meta WHERE name='version'")
+
+    ver = cur.fetchone()
+    if ver:
+        ver = int(ver)
+
+        if ver < DB_VERSION:
+            upgrade_db(conn, ver, DB_VERSION)
+    else:
+        with open('sql/ledd.sql', 'r') as f:
+            cur.executescript(f.read())
+            conn.commit()
+
+
+def upgrade_db(conn, old, new):
+    pass

ledd/effect/baseeffect.py

@@ -17,7 +17,7 @@
 
 class BaseEffect(object):
     """
-    This class only defines default meta-data for effects.
+    This class only defines default meta-data for effect.
     """
     name = "BaseEffect"
     version = "0.1"

ledd/effect/effectstack.py

@@ -0,0 +1,39 @@
+# LEDD Project
+# Copyright (C) 2015 LEDD Team
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import asyncio
+
+from ledd.effect.fadeeffect import FadeEffect
+
+
+class EffectStack(object):
+    def __init__(self):
+        self.stripes = []
+        self.effect = FadeEffect()
+        # TODO
+        self.modifiers = []
+
+    def start(self):
+        asyncio.get_event_loop().call_soon(self.execute)
+
+    def execute(self):
+        color = self.effect.execute_internal()
+
+        for stripe in self.stripes:
+            stripe.set_color(color)
+
+        # schedule next execution
+        asyncio.get_event_loop().call_later(0.1, self.execute)

ledd/effect/fadeeffect.py

@@ -16,7 +16,7 @@
 
 import spectra
 
-from ledd.effects.generatoreffect import GeneratorEffect
+from ledd.effect.generatoreffect import GeneratorEffect
 
 
 class FadeEffect(GeneratorEffect):

ledd/effect/generatoreffect.py

@@ -16,12 +16,12 @@
 
 from spectra import Color
 
-from ledd.effects.baseeffect import BaseEffect
+from ledd.effect.baseeffect import BaseEffect
 
 
 class GeneratorEffect(BaseEffect):
     """
-    This is a base class for simple effects.
+    This is a base class for simple effect.
     It should yield a new color on each execution.
     """
 

ledd/effectstack.py

@@ -1,23 +0,0 @@
-import asyncio
-
-from ledd.effects.fadeeffect import FadeEffect
-
-
-class EffectStack(object):
-    def __init__(self):
-        self.stripes = []
-        self.effect = FadeEffect()
-        # TODO
-        self.modifiers = []
-
-    def start(self):
-        asyncio.get_event_loop().call_soon(self.execute)
-
-    def execute(self):
-        color = self.effect.execute_internal()
-
-        for stripe in self.stripes:
-            stripe.set_color(color)
-
-        # schedule next execution
-        asyncio.get_event_loop().call_later(0.1, self.execute)

ledd/led/rgb_stripe.py

@@ -0,0 +1,83 @@
+# LEDD Project
+# Copyright (C) 2015 LEDD Team
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from spectra import Color
+
+
+class RGBStripe:
+    """
+    A group of leds representing an common RGB stripe.
+    """
+    __tablename__ = "stripe"
+    id = Column(Integer, primary_key=True)
+    controller_id = Column(Integer, ForeignKey('controller.id'))
+    name = Column(String)
+    channel_r = Column(Integer)
+    channel_g = Column(Integer)
+    channel_b = Column(Integer)
+    channel_r_gamma = Column(Float, default=2.8)
+    channel_g_gamma = Column(Float, default=2.8)
+    channel_b_gamma = Column(Float, default=2.8)
+    rgb = Column(Boolean)
+
+    @property
+    def channels(self):
+        return self.channel_r, self.channel_g, self.channel_b
+
+    # TODO save channels to db
+
+    @channels.setter
+    def channels(self, t):
+        self.channel_r, self.channel_g, self.channel_b = t
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._color = None
+        self.gamma_correct = (self.channel_r_gamma, self.channel_g_gamma, self.channel_b_gamma)
+        self.read_color()
+
+    @reconstructor
+    def init_on_load(self):
+        self._color = None
+        self.gamma_correct = (self.channel_r_gamma, self.channel_g_gamma, self.channel_b_gamma)
+        self.read_color()
+
+    def read_color(self):
+        if self.controller:
+            rc = tuple([float(self.controller.get_channel(channel)) for channel in self.channels])
+            c = Color("rgb", rc[0], rc[1], rc[2])
+            self._color = c.to("hsv")
+
+    def __repr__(self):
+        return "<Stripe id={}>".format(self.id)
+
+    def set_color(self, c):
+        self._color = c
+        for channel, gamma_correct, value in zip(self.channels, self.gamma_correct, c.clamped_rgb):
+            self.controller.set_channel(channel, value, gamma_correct)
+
+    def get_color(self):
+        return self._color
+
+    def to_json(self):
+        return {
+            'id': self.id,
+            'name': self.name,
+            'rgb': self.rgb,
+            'channel': self.channels
+        }
+
+    color = property(get_color, set_color)

ledd/plugins/__init__.py

@@ -13,21 +13,3 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-def ledd_protocol(proto):
-    """
-    Decorator used to add functions to action dict
-    :param proto: dict to add to
-    :type proto: dict
-    """
-
-    def wrap(f):
-        proto[f.__name__] = f
-
-        def wrapped_f(*args):
-            f(*args)
-
-        return wrapped_f
-
-    return wrap

ledd/protobuf/client_pb2.py

@@ -0,0 +1,379 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: client.proto
+
+import sys
+
+_b = sys.version_info[0] < 3 and (lambda x: x) or (lambda x: x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+    name='client.proto',
+    package='ledd',
+    syntax='proto3',
+    serialized_pb=_b(
+        '\n\x0c\x63lient.proto\x12\x04ledd\"\xd3\x01\n\x06\x43lient\x12\n\n\x02id\x18\x01 \x01(\x05\x12\x0f\n\x07\x61\x64\x64ress\x18\x02 \x01(\t\x12\x0f\n\x07max_led\x18\x03 \x01(\x05\x12\x0c\n\x04name\x18\x04 \x01(\t\x12\x0f\n\x07version\x18\x05 \x01(\t\x12\x12\n\nresolution\x18\x06 \x01(\x05\x12\x0c\n\x04port\x18\x07 \x01(\x05\x12*\n\x07options\x18\n \x03(\x0b\x32\x19.ledd.Client.OptionsEntry\x1a.\n\x0cOptionsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"(\n\x07\x43lients\x12\x1d\n\x07\x63lients\x18\x01 \x03(\x0b\x32\x0c.ledd.Client\"?\n\x16\x43lientSetPercentageAll\x12\x12\n\npercentage\x18\x01 \x01(\x02\x12\x11\n\tclient_id\x18\x02 \x03(\x05\"<\n\x14\x43lientSetLocalDirect\x12\x10\n\x08local_id\x18\x01 \x01(\x05\x12\x12\n\npercentage\x18\x02 \x01(\x02\"x\n\x10\x43lientLEDOptions\x12\x34\n\x07options\x18\x01 \x03(\x0b\x32#.ledd.ClientLEDOptions.OptionsEntry\x1a.\n\x0cOptionsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\x62\x06proto3')
+)
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+_CLIENT_OPTIONSENTRY = _descriptor.Descriptor(
+    name='OptionsEntry',
+    full_name='ledd.Client.OptionsEntry',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='key', full_name='ledd.Client.OptionsEntry.key', index=0,
+            number=1, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='value', full_name='ledd.Client.OptionsEntry.value', index=1,
+            number=2, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=_descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001')),
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=188,
+    serialized_end=234,
+)
+
+_CLIENT = _descriptor.Descriptor(
+    name='Client',
+    full_name='ledd.Client',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='id', full_name='ledd.Client.id', index=0,
+            number=1, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='address', full_name='ledd.Client.address', index=1,
+            number=2, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='max_led', full_name='ledd.Client.max_led', index=2,
+            number=3, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='name', full_name='ledd.Client.name', index=3,
+            number=4, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='version', full_name='ledd.Client.version', index=4,
+            number=5, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='resolution', full_name='ledd.Client.resolution', index=5,
+            number=6, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='port', full_name='ledd.Client.port', index=6,
+            number=7, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='options', full_name='ledd.Client.options', index=7,
+            number=10, type=11, cpp_type=10, label=3,
+            has_default_value=False, default_value=[],
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[_CLIENT_OPTIONSENTRY, ],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=23,
+    serialized_end=234,
+)
+
+_CLIENTS = _descriptor.Descriptor(
+    name='Clients',
+    full_name='ledd.Clients',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='clients', full_name='ledd.Clients.clients', index=0,
+            number=1, type=11, cpp_type=10, label=3,
+            has_default_value=False, default_value=[],
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=236,
+    serialized_end=276,
+)
+
+_CLIENTSETPERCENTAGEALL = _descriptor.Descriptor(
+    name='ClientSetPercentageAll',
+    full_name='ledd.ClientSetPercentageAll',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='percentage', full_name='ledd.ClientSetPercentageAll.percentage', index=0,
+            number=1, type=2, cpp_type=6, label=1,
+            has_default_value=False, default_value=float(0),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='client_id', full_name='ledd.ClientSetPercentageAll.client_id', index=1,
+            number=2, type=5, cpp_type=1, label=3,
+            has_default_value=False, default_value=[],
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=278,
+    serialized_end=341,
+)
+
+_CLIENTSETLOCALDIRECT = _descriptor.Descriptor(
+    name='ClientSetLocalDirect',
+    full_name='ledd.ClientSetLocalDirect',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='local_id', full_name='ledd.ClientSetLocalDirect.local_id', index=0,
+            number=1, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='percentage', full_name='ledd.ClientSetLocalDirect.percentage', index=1,
+            number=2, type=2, cpp_type=6, label=1,
+            has_default_value=False, default_value=float(0),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=343,
+    serialized_end=403,
+)
+
+_CLIENTLEDOPTIONS_OPTIONSENTRY = _descriptor.Descriptor(
+    name='OptionsEntry',
+    full_name='ledd.ClientLEDOptions.OptionsEntry',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='key', full_name='ledd.ClientLEDOptions.OptionsEntry.key', index=0,
+            number=1, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='value', full_name='ledd.ClientLEDOptions.OptionsEntry.value', index=1,
+            number=2, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=_descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001')),
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=188,
+    serialized_end=234,
+)
+
+_CLIENTLEDOPTIONS = _descriptor.Descriptor(
+    name='ClientLEDOptions',
+    full_name='ledd.ClientLEDOptions',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='options', full_name='ledd.ClientLEDOptions.options', index=0,
+            number=1, type=11, cpp_type=10, label=3,
+            has_default_value=False, default_value=[],
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[_CLIENTLEDOPTIONS_OPTIONSENTRY, ],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=405,
+    serialized_end=525,
+)
+
+_CLIENT_OPTIONSENTRY.containing_type = _CLIENT
+_CLIENT.fields_by_name['options'].message_type = _CLIENT_OPTIONSENTRY
+_CLIENTS.fields_by_name['clients'].message_type = _CLIENT
+_CLIENTLEDOPTIONS_OPTIONSENTRY.containing_type = _CLIENTLEDOPTIONS
+_CLIENTLEDOPTIONS.fields_by_name['options'].message_type = _CLIENTLEDOPTIONS_OPTIONSENTRY
+DESCRIPTOR.message_types_by_name['Client'] = _CLIENT
+DESCRIPTOR.message_types_by_name['Clients'] = _CLIENTS
+DESCRIPTOR.message_types_by_name['ClientSetPercentageAll'] = _CLIENTSETPERCENTAGEALL
+DESCRIPTOR.message_types_by_name['ClientSetLocalDirect'] = _CLIENTSETLOCALDIRECT
+DESCRIPTOR.message_types_by_name['ClientLEDOptions'] = _CLIENTLEDOPTIONS
+
+Client = _reflection.GeneratedProtocolMessageType('Client', (_message.Message,), dict(
+
+    OptionsEntry=_reflection.GeneratedProtocolMessageType('OptionsEntry', (_message.Message,), dict(
+        DESCRIPTOR=_CLIENT_OPTIONSENTRY,
+        __module__='client_pb2'
+        # @@protoc_insertion_point(class_scope:ledd.Client.OptionsEntry)
+    ))
+    ,
+    DESCRIPTOR=_CLIENT,
+    __module__='client_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.Client)
+))
+_sym_db.RegisterMessage(Client)
+_sym_db.RegisterMessage(Client.OptionsEntry)
+
+Clients = _reflection.GeneratedProtocolMessageType('Clients', (_message.Message,), dict(
+    DESCRIPTOR=_CLIENTS,
+    __module__='client_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.Clients)
+))
+_sym_db.RegisterMessage(Clients)
+
+ClientSetPercentageAll = _reflection.GeneratedProtocolMessageType('ClientSetPercentageAll', (_message.Message,), dict(
+    DESCRIPTOR=_CLIENTSETPERCENTAGEALL,
+    __module__='client_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.ClientSetPercentageAll)
+))
+_sym_db.RegisterMessage(ClientSetPercentageAll)
+
+ClientSetLocalDirect = _reflection.GeneratedProtocolMessageType('ClientSetLocalDirect', (_message.Message,), dict(
+    DESCRIPTOR=_CLIENTSETLOCALDIRECT,
+    __module__='client_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.ClientSetLocalDirect)
+))
+_sym_db.RegisterMessage(ClientSetLocalDirect)
+
+ClientLEDOptions = _reflection.GeneratedProtocolMessageType('ClientLEDOptions', (_message.Message,), dict(
+
+    OptionsEntry=_reflection.GeneratedProtocolMessageType('OptionsEntry', (_message.Message,), dict(
+        DESCRIPTOR=_CLIENTLEDOPTIONS_OPTIONSENTRY,
+        __module__='client_pb2'
+        # @@protoc_insertion_point(class_scope:ledd.ClientLEDOptions.OptionsEntry)
+    ))
+    ,
+    DESCRIPTOR=_CLIENTLEDOPTIONS,
+    __module__='client_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.ClientLEDOptions)
+))
+_sym_db.RegisterMessage(ClientLEDOptions)
+_sym_db.RegisterMessage(ClientLEDOptions.OptionsEntry)
+
+_CLIENT_OPTIONSENTRY.has_options = True
+_CLIENT_OPTIONSENTRY._options = _descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001'))
+_CLIENTLEDOPTIONS_OPTIONSENTRY.has_options = True
+_CLIENTLEDOPTIONS_OPTIONSENTRY._options = _descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001'))
+# @@protoc_insertion_point(module_scope)

ledd/protobuf/hsv_pb2.py

@@ -0,0 +1,79 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: hsv.proto
+
+import sys
+
+_b = sys.version_info[0] < 3 and (lambda x: x) or (lambda x: x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+    name='hsv.proto',
+    package='ledd',
+    syntax='proto3',
+    serialized_pb=_b(
+        '\n\thsv.proto\x12\x04ledd\",\n\x03HSV\x12\x0b\n\x03hue\x18\x01 \x01(\x02\x12\x0b\n\x03sat\x18\x02 \x01(\x02\x12\x0b\n\x03val\x18\x03 \x01(\x02\x62\x06proto3')
+)
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+_HSV = _descriptor.Descriptor(
+    name='HSV',
+    full_name='ledd.HSV',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='hue', full_name='ledd.HSV.hue', index=0,
+            number=1, type=2, cpp_type=6, label=1,
+            has_default_value=False, default_value=float(0),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='sat', full_name='ledd.HSV.sat', index=1,
+            number=2, type=2, cpp_type=6, label=1,
+            has_default_value=False, default_value=float(0),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='val', full_name='ledd.HSV.val', index=2,
+            number=3, type=2, cpp_type=6, label=1,
+            has_default_value=False, default_value=float(0),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=19,
+    serialized_end=63,
+)
+
+DESCRIPTOR.message_types_by_name['HSV'] = _HSV
+
+HSV = _reflection.GeneratedProtocolMessageType('HSV', (_message.Message,), dict(
+    DESCRIPTOR=_HSV,
+    __module__='hsv_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.HSV)
+))
+_sym_db.RegisterMessage(HSV)
+
+
+# @@protoc_insertion_point(module_scope)

ledd/protobuf/led_pb2.py

@@ -0,0 +1,450 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: led.proto
+
+import sys
+
+_b = sys.version_info[0] < 3 and (lambda x: x) or (lambda x: x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf import descriptor_pb2
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+from . import hsv_pb2 as hsv__pb2
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+    name='led.proto',
+    package='ledd',
+    syntax='proto3',
+    serialized_pb=_b(
+        '\n\tled.proto\x12\x04ledd\x1a\thsv.proto\"\x9d\x01\n\x03LED\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\n\n\x02id\x18\x02 \x01(\x05\x12\x10\n\x08local_id\x18\x03 \x01(\x05\x12\x11\n\tclient_id\x18\x04 \x01(\x05\x12\'\n\x07options\x18\n \x03(\x0b\x32\x16.ledd.LED.OptionsEntry\x1a.\n\x0cOptionsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"\x8b\x01\n\x08LEDGroup\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\n\n\x02id\x18\x02 \x01(\x05\x12&\n\x04type\x18\x03 \x01(\x0e\x32\x18.ledd.LEDGroup.GroupType\x12\x0c\n\x04size\x18\x04 \x01(\x05\x12\x0f\n\x07led_ids\x18\n \x03(\x05\"\x1e\n\tGroupType\x12\x07\n\x03RGB\x10\x00\x12\x08\n\x04USER\x10\x01\"\x1f\n\x04LEDs\x12\x17\n\x04leds\x18\x01 \x03(\x0b\x32\t.ledd.LED\"/\n\tLEDGroups\x12\"\n\nled_groups\x18\x01 \x03(\x0b\x32\x0e.ledd.LEDGroup\"0\n\rLEDPercentage\x12\x0b\n\x03led\x18\x01 \x01(\x05\x12\x12\n\npercentage\x18\x02 \x01(\x02\"8\n\rLEDGroupColor\x12\r\n\x05group\x18\x01 \x01(\x05\x12\x18\n\x05\x63olor\x18\x02 \x01(\x0b\x32\t.ledd.HSV\"1\n\x12LEDGroupPercentage\x12\r\n\x05group\x18\x01 \x01(\x05\x12\x0c\n\x04perc\x18\x02 \x01(\x02\x62\x06proto3')
+    ,
+    dependencies=[hsv__pb2.DESCRIPTOR, ])
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+_LEDGROUP_GROUPTYPE = _descriptor.EnumDescriptor(
+    name='GroupType',
+    full_name='ledd.LEDGroup.GroupType',
+    filename=None,
+    file=DESCRIPTOR,
+    values=[
+        _descriptor.EnumValueDescriptor(
+            name='RGB', index=0, number=0,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='USER', index=1, number=1,
+            options=None,
+            type=None),
+    ],
+    containing_type=None,
+    options=None,
+    serialized_start=300,
+    serialized_end=330,
+)
+_sym_db.RegisterEnumDescriptor(_LEDGROUP_GROUPTYPE)
+
+_LED_OPTIONSENTRY = _descriptor.Descriptor(
+    name='OptionsEntry',
+    full_name='ledd.LED.OptionsEntry',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='key', full_name='ledd.LED.OptionsEntry.key', index=0,
+            number=1, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='value', full_name='ledd.LED.OptionsEntry.value', index=1,
+            number=2, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=_descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001')),
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=142,
+    serialized_end=188,
+)
+
+_LED = _descriptor.Descriptor(
+    name='LED',
+    full_name='ledd.LED',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='name', full_name='ledd.LED.name', index=0,
+            number=1, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='id', full_name='ledd.LED.id', index=1,
+            number=2, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='local_id', full_name='ledd.LED.local_id', index=2,
+            number=3, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='client_id', full_name='ledd.LED.client_id', index=3,
+            number=4, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='options', full_name='ledd.LED.options', index=4,
+            number=10, type=11, cpp_type=10, label=3,
+            has_default_value=False, default_value=[],
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[_LED_OPTIONSENTRY, ],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=31,
+    serialized_end=188,
+)
+
+_LEDGROUP = _descriptor.Descriptor(
+    name='LEDGroup',
+    full_name='ledd.LEDGroup',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='name', full_name='ledd.LEDGroup.name', index=0,
+            number=1, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='id', full_name='ledd.LEDGroup.id', index=1,
+            number=2, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='type', full_name='ledd.LEDGroup.type', index=2,
+            number=3, type=14, cpp_type=8, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='size', full_name='ledd.LEDGroup.size', index=3,
+            number=4, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='led_ids', full_name='ledd.LEDGroup.led_ids', index=4,
+            number=10, type=5, cpp_type=1, label=3,
+            has_default_value=False, default_value=[],
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+        _LEDGROUP_GROUPTYPE,
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=191,
+    serialized_end=330,
+)
+
+_LEDS = _descriptor.Descriptor(
+    name='LEDs',
+    full_name='ledd.LEDs',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='leds', full_name='ledd.LEDs.leds', index=0,
+            number=1, type=11, cpp_type=10, label=3,
+            has_default_value=False, default_value=[],
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=332,
+    serialized_end=363,
+)
+
+_LEDGROUPS = _descriptor.Descriptor(
+    name='LEDGroups',
+    full_name='ledd.LEDGroups',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='led_groups', full_name='ledd.LEDGroups.led_groups', index=0,
+            number=1, type=11, cpp_type=10, label=3,
+            has_default_value=False, default_value=[],
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=365,
+    serialized_end=412,
+)
+
+_LEDPERCENTAGE = _descriptor.Descriptor(
+    name='LEDPercentage',
+    full_name='ledd.LEDPercentage',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='led', full_name='ledd.LEDPercentage.led', index=0,
+            number=1, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='percentage', full_name='ledd.LEDPercentage.percentage', index=1,
+            number=2, type=2, cpp_type=6, label=1,
+            has_default_value=False, default_value=float(0),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=414,
+    serialized_end=462,
+)
+
+_LEDGROUPCOLOR = _descriptor.Descriptor(
+    name='LEDGroupColor',
+    full_name='ledd.LEDGroupColor',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='group', full_name='ledd.LEDGroupColor.group', index=0,
+            number=1, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='color', full_name='ledd.LEDGroupColor.color', index=1,
+            number=2, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=464,
+    serialized_end=520,
+)
+
+_LEDGROUPPERCENTAGE = _descriptor.Descriptor(
+    name='LEDGroupPercentage',
+    full_name='ledd.LEDGroupPercentage',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='group', full_name='ledd.LEDGroupPercentage.group', index=0,
+            number=1, type=5, cpp_type=1, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='perc', full_name='ledd.LEDGroupPercentage.perc', index=1,
+            number=2, type=2, cpp_type=6, label=1,
+            has_default_value=False, default_value=float(0),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=522,
+    serialized_end=571,
+)
+
+_LED_OPTIONSENTRY.containing_type = _LED
+_LED.fields_by_name['options'].message_type = _LED_OPTIONSENTRY
+_LEDGROUP.fields_by_name['type'].enum_type = _LEDGROUP_GROUPTYPE
+_LEDGROUP_GROUPTYPE.containing_type = _LEDGROUP
+_LEDS.fields_by_name['leds'].message_type = _LED
+_LEDGROUPS.fields_by_name['led_groups'].message_type = _LEDGROUP
+_LEDGROUPCOLOR.fields_by_name['color'].message_type = hsv__pb2._HSV
+DESCRIPTOR.message_types_by_name['LED'] = _LED
+DESCRIPTOR.message_types_by_name['LEDGroup'] = _LEDGROUP
+DESCRIPTOR.message_types_by_name['LEDs'] = _LEDS
+DESCRIPTOR.message_types_by_name['LEDGroups'] = _LEDGROUPS
+DESCRIPTOR.message_types_by_name['LEDPercentage'] = _LEDPERCENTAGE
+DESCRIPTOR.message_types_by_name['LEDGroupColor'] = _LEDGROUPCOLOR
+DESCRIPTOR.message_types_by_name['LEDGroupPercentage'] = _LEDGROUPPERCENTAGE
+
+LED = _reflection.GeneratedProtocolMessageType('LED', (_message.Message,), dict(
+
+    OptionsEntry=_reflection.GeneratedProtocolMessageType('OptionsEntry', (_message.Message,), dict(
+        DESCRIPTOR=_LED_OPTIONSENTRY,
+        __module__='led_pb2'
+        # @@protoc_insertion_point(class_scope:ledd.LED.OptionsEntry)
+    ))
+    ,
+    DESCRIPTOR=_LED,
+    __module__='led_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.LED)
+))
+_sym_db.RegisterMessage(LED)
+_sym_db.RegisterMessage(LED.OptionsEntry)
+
+LEDGroup = _reflection.GeneratedProtocolMessageType('LEDGroup', (_message.Message,), dict(
+    DESCRIPTOR=_LEDGROUP,
+    __module__='led_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.LEDGroup)
+))
+_sym_db.RegisterMessage(LEDGroup)
+
+LEDs = _reflection.GeneratedProtocolMessageType('LEDs', (_message.Message,), dict(
+    DESCRIPTOR=_LEDS,
+    __module__='led_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.LEDs)
+))
+_sym_db.RegisterMessage(LEDs)
+
+LEDGroups = _reflection.GeneratedProtocolMessageType('LEDGroups', (_message.Message,), dict(
+    DESCRIPTOR=_LEDGROUPS,
+    __module__='led_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.LEDGroups)
+))
+_sym_db.RegisterMessage(LEDGroups)
+
+LEDPercentage = _reflection.GeneratedProtocolMessageType('LEDPercentage', (_message.Message,), dict(
+    DESCRIPTOR=_LEDPERCENTAGE,
+    __module__='led_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.LEDPercentage)
+))
+_sym_db.RegisterMessage(LEDPercentage)
+
+LEDGroupColor = _reflection.GeneratedProtocolMessageType('LEDGroupColor', (_message.Message,), dict(
+    DESCRIPTOR=_LEDGROUPCOLOR,
+    __module__='led_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.LEDGroupColor)
+))
+_sym_db.RegisterMessage(LEDGroupColor)
+
+LEDGroupPercentage = _reflection.GeneratedProtocolMessageType('LEDGroupPercentage', (_message.Message,), dict(
+    DESCRIPTOR=_LEDGROUPPERCENTAGE,
+    __module__='led_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.LEDGroupPercentage)
+))
+_sym_db.RegisterMessage(LEDGroupPercentage)
+
+_LED_OPTIONSENTRY.has_options = True
+_LED_OPTIONSENTRY._options = _descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001'))
+# @@protoc_insertion_point(module_scope)

ledd/protobuf/ledd_pb2.py

@@ -0,0 +1,295 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: ledd.proto
+
+import sys
+
+_b = sys.version_info[0] < 3 and (lambda x: x) or (lambda x: x.encode('latin1'))
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+from . import led_pb2 as led__pb2
+from . import client_pb2 as client__pb2
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+    name='ledd.proto',
+    package='ledd',
+    syntax='proto3',
+    serialized_pb=_b(
+        '\n\nledd.proto\x12\x04ledd\x1a\tled.proto\x1a\x0c\x63lient.proto\")\n\x04LedD\x12\x10\n\x08hostname\x18\x01 \x01(\t\x12\x0f\n\x07version\x18\x02 \x01(\t\"\xe1\x06\n\nWrapperMsg\x12#\n\x04type\x18\x01 \x01(\x0e\x32\x15.ledd.WrapperMsg.Type\x12\x16\n\x03led\x18\x02 \x01(\x0b\x32\t.ledd.LED\x12\x18\n\x04leds\x18\x03 \x01(\x0b\x32\n.ledd.LEDs\x12!\n\tled_group\x18\x04 \x01(\x0b\x32\x0e.ledd.LEDGroup\x12#\n\nled_groups\x18\x05 \x01(\x0b\x32\x0f.ledd.LEDGroups\x12%\n\x08led_perc\x18\x06 \x01(\x0b\x32\x13.ledd.LEDPercentage\x12,\n\x0fled_group_color\x18\x07 \x01(\x0b\x32\x13.ledd.LEDGroupColor\x12\x18\n\x04ledd\x18\x08 \x01(\x0b\x32\n.ledd.LedD\x12\x1c\n\x06\x63lient\x18\t \x01(\x0b\x32\x0c.ledd.Client\x12\x1e\n\x07\x63lients\x18\n \x01(\x0b\x32\r.ledd.Clients\x12\x35\n\x11\x63lient_set_direct\x18\x0b \x01(\x0b\x32\x1a.ledd.ClientSetLocalDirect\x12\x32\n\x12\x63lient_led_options\x18\x0c \x01(\x0b\x32\x16.ledd.ClientLEDOptions\x12\x39\n\x13\x63lient_set_perc_all\x18\r \x01(\x0b\x32\x1c.ledd.ClientSetPercentageAll\x12\x30\n\x0eled_group_perc\x18\x0e \x01(\x0b\x32\x18.ledd.LEDGroupPercentage\"\xae\x02\n\x04Type\x12\x0f\n\x0bLED_GET_ALL\x10\x00\x12\x0b\n\x07LED_ADD\x10\x01\x12\x0e\n\nCLIENT_ADD\x10\x02\x12\x17\n\x13\x43LIENT_SET_PERC_ALL\x10\x03\x12\x10\n\x0cLED_PERC_SET\x10\x04\x12\x10\n\x0cLED_PERC_GET\x10\x05\x12\x12\n\x0e\x43LIENT_LED_SET\x10\x06\x12\x0c\n\x08\x44ISCOVER\x10\x07\x12\x0e\n\nCLIENT_GET\x10\x08\x12\x1a\n\x16\x43LIENT_GET_LED_OPTIONS\x10\t\x12\x1b\n\x17\x43LIENT_SET_LOCAL_DIRECT\x10\n\x12\x10\n\x0cLEDGROUP_GET\x10\x0b\x12\x14\n\x10LEDGROUP_GET_ALL\x10\x0c\x12\x16\n\x12LEDGROUP_SET_COLOR\x10\r\x12\x10\n\x0cLEDGROUP_ADD\x10\x0e\x62\x06proto3')
+    ,
+    dependencies=[led__pb2.DESCRIPTOR, client__pb2.DESCRIPTOR, ])
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+_WRAPPERMSG_TYPE = _descriptor.EnumDescriptor(
+    name='Type',
+    full_name='ledd.WrapperMsg.Type',
+    filename=None,
+    file=DESCRIPTOR,
+    values=[
+        _descriptor.EnumValueDescriptor(
+            name='LED_GET_ALL', index=0, number=0,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='LED_ADD', index=1, number=1,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='CLIENT_ADD', index=2, number=2,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='CLIENT_SET_PERC_ALL', index=3, number=3,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='LED_PERC_SET', index=4, number=4,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='LED_PERC_GET', index=5, number=5,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='CLIENT_LED_SET', index=6, number=6,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='DISCOVER', index=7, number=7,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='CLIENT_GET', index=8, number=8,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='CLIENT_GET_LED_OPTIONS', index=9, number=9,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='CLIENT_SET_LOCAL_DIRECT', index=10, number=10,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='LEDGROUP_GET', index=11, number=11,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='LEDGROUP_GET_ALL', index=12, number=12,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='LEDGROUP_SET_COLOR', index=13, number=13,
+            options=None,
+            type=None),
+        _descriptor.EnumValueDescriptor(
+            name='LEDGROUP_ADD', index=14, number=14,
+            options=None,
+            type=None),
+    ],
+    containing_type=None,
+    options=None,
+    serialized_start=652,
+    serialized_end=954,
+)
+_sym_db.RegisterEnumDescriptor(_WRAPPERMSG_TYPE)
+
+_LEDD = _descriptor.Descriptor(
+    name='LedD',
+    full_name='ledd.LedD',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='hostname', full_name='ledd.LedD.hostname', index=0,
+            number=1, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='version', full_name='ledd.LedD.version', index=1,
+            number=2, type=9, cpp_type=9, label=1,
+            has_default_value=False, default_value=_b("").decode('utf-8'),
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=45,
+    serialized_end=86,
+)
+
+_WRAPPERMSG = _descriptor.Descriptor(
+    name='WrapperMsg',
+    full_name='ledd.WrapperMsg',
+    filename=None,
+    file=DESCRIPTOR,
+    containing_type=None,
+    fields=[
+        _descriptor.FieldDescriptor(
+            name='type', full_name='ledd.WrapperMsg.type', index=0,
+            number=1, type=14, cpp_type=8, label=1,
+            has_default_value=False, default_value=0,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='led', full_name='ledd.WrapperMsg.led', index=1,
+            number=2, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='leds', full_name='ledd.WrapperMsg.leds', index=2,
+            number=3, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='led_group', full_name='ledd.WrapperMsg.led_group', index=3,
+            number=4, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='led_groups', full_name='ledd.WrapperMsg.led_groups', index=4,
+            number=5, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='led_perc', full_name='ledd.WrapperMsg.led_perc', index=5,
+            number=6, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='led_group_color', full_name='ledd.WrapperMsg.led_group_color', index=6,
+            number=7, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='ledd', full_name='ledd.WrapperMsg.ledd', index=7,
+            number=8, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='client', full_name='ledd.WrapperMsg.client', index=8,
+            number=9, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='clients', full_name='ledd.WrapperMsg.clients', index=9,
+            number=10, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='client_set_direct', full_name='ledd.WrapperMsg.client_set_direct', index=10,
+            number=11, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='client_led_options', full_name='ledd.WrapperMsg.client_led_options', index=11,
+            number=12, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='client_set_perc_all', full_name='ledd.WrapperMsg.client_set_perc_all', index=12,
+            number=13, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+        _descriptor.FieldDescriptor(
+            name='led_group_perc', full_name='ledd.WrapperMsg.led_group_perc', index=13,
+            number=14, type=11, cpp_type=10, label=1,
+            has_default_value=False, default_value=None,
+            message_type=None, enum_type=None, containing_type=None,
+            is_extension=False, extension_scope=None,
+            options=None),
+    ],
+    extensions=[
+    ],
+    nested_types=[],
+    enum_types=[
+        _WRAPPERMSG_TYPE,
+    ],
+    options=None,
+    is_extendable=False,
+    syntax='proto3',
+    extension_ranges=[],
+    oneofs=[
+    ],
+    serialized_start=89,
+    serialized_end=954,
+)
+
+_WRAPPERMSG.fields_by_name['type'].enum_type = _WRAPPERMSG_TYPE
+_WRAPPERMSG.fields_by_name['led'].message_type = led__pb2._LED
+_WRAPPERMSG.fields_by_name['leds'].message_type = led__pb2._LEDS
+_WRAPPERMSG.fields_by_name['led_group'].message_type = led__pb2._LEDGROUP
+_WRAPPERMSG.fields_by_name['led_groups'].message_type = led__pb2._LEDGROUPS
+_WRAPPERMSG.fields_by_name['led_perc'].message_type = led__pb2._LEDPERCENTAGE
+_WRAPPERMSG.fields_by_name['led_group_color'].message_type = led__pb2._LEDGROUPCOLOR
+_WRAPPERMSG.fields_by_name['ledd'].message_type = _LEDD
+_WRAPPERMSG.fields_by_name['client'].message_type = client__pb2._CLIENT
+_WRAPPERMSG.fields_by_name['clients'].message_type = client__pb2._CLIENTS
+_WRAPPERMSG.fields_by_name['client_set_direct'].message_type = client__pb2._CLIENTSETLOCALDIRECT
+_WRAPPERMSG.fields_by_name['client_led_options'].message_type = client__pb2._CLIENTLEDOPTIONS
+_WRAPPERMSG.fields_by_name['client_set_perc_all'].message_type = client__pb2._CLIENTSETPERCENTAGEALL
+_WRAPPERMSG.fields_by_name['led_group_perc'].message_type = led__pb2._LEDGROUPPERCENTAGE
+_WRAPPERMSG_TYPE.containing_type = _WRAPPERMSG
+DESCRIPTOR.message_types_by_name['LedD'] = _LEDD
+DESCRIPTOR.message_types_by_name['WrapperMsg'] = _WRAPPERMSG
+
+LedD = _reflection.GeneratedProtocolMessageType('LedD', (_message.Message,), dict(
+    DESCRIPTOR=_LEDD,
+    __module__='ledd_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.LedD)
+))
+_sym_db.RegisterMessage(LedD)
+
+WrapperMsg = _reflection.GeneratedProtocolMessageType('WrapperMsg', (_message.Message,), dict(
+    DESCRIPTOR=_WRAPPERMSG,
+    __module__='ledd_pb2'
+    # @@protoc_insertion_point(class_scope:ledd.WrapperMsg)
+))
+_sym_db.RegisterMessage(WrapperMsg)
+
+
+# @@protoc_insertion_point(module_scope)

ledd/sql/ledd.sql

@@ -1,21 +0,0 @@
-CREATE TABLE `stripes` (
-	`id`	INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,
-	`name`	TEXT,
-	`rgb`	INTEGER,
-	`controller_id`	INTEGER,
-	`channel_r`	INTEGER,
-	`channel_g`	INTEGER,
-	`channel_b`	INTEGER
-);
-CREATE TABLE "meta" (
-	`option`	TEXT,
-	`value`	TEXT
-);
-INSERT INTO `meta` VALUES ('db_version','1');
-CREATE TABLE "controller" (
-	`id`	INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE,
-	`address`	TEXT,
-	`i2c_device`	INTEGER,
-	`channels`	INTEGER,
-	`pwm_freq`	INTEGER
-);

ledd/stripe.py

@@ -1,68 +0,0 @@
-# LEDD Project
-# Copyright (C) 2015 LEDD Team
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-from spectra import Color
-
-
-class Stripe:
-    """
-    A stripe is the smallest controllable unit.
-    """
-
-    def __init__(self, controller, name, rgb, channels, sid=-1, from_db=False):
-        self.controller = controller
-        self.name = name
-        self.rgb = bool(rgb)
-        self.channels = channels
-        self.id = sid
-        self._color = None
-        self.gamma_correct = (2.8, 2.8, 2.8)  # TODO: add to DB
-        self.read_color()
-        if not from_db:
-            self.save_to_db()
-
-    def save_to_db(self):
-        cur = self.controller.db.cursor()
-        if self.id == -1:
-            cur.execute("INSERT INTO stripes DEFAULT VALUES")
-            self.id = cur.lastrowid
-        cur.execute(
-            "UPDATE stripes SET channel_r = ?, channel_g = ?, channel_b = ?,controller_id = ?, name = ? WHERE id = ?",
-            self.channels + (self.controller.id, self.name, self.id))
-        cur.close()
-        self.controller.db.commit()
-
-    def read_color(self):
-        rc = tuple([float(self.controller.get_channel(channel)) for channel in self.channels])
-        c = Color("rgb", rc[0], rc[1], rc[2])
-        self._color = c.to("hsv")
-
-    def __repr__(self):
-        return "<Stripe id={}>".format(self.id)
-
-    @classmethod
-    def from_db(cls, controller, row):
-        return cls(controller, name=row["name"], rgb=row["rgb"],
-                   channels=(row["channel_r"], row["channel_g"], row["channel_b"]), sid=row["id"], from_db=True)
-
-    def set_color(self, c):
-        self._color = c
-        for channel, gamma_correct, value in zip(self.channels, self.gamma_correct, c.clamped_rgb):
-            self.controller.set_channel(channel, value)
-
-    def get_color(self):
-        return self._color
-
-    color = property(get_color, set_color)

setup.py

@@ -25,6 +25,10 @@ setup(name='LedD',
       license='GPLv3',
       packages=['ledd'],
       install_requires=[
-            'nose', 'spectra', 'docopt',
+          'nose', 'spectra', 'docopt',
       ],
+      extras_require={
+          'systemd_logging': ["python-systemd"],
+          'colored_logging': ["coloreddlogs"]
+      },
       zip_safe=False)

sql/ledd.sql

@@ -0,0 +1,62 @@
+CREATE TABLE `meta` (
+  `id`    INTEGER PRIMARY KEY AUTOINCREMENT,
+  `name`  TEXT NOT NULL,
+  `value` TEXT NOT NULL
+);
+
+CREATE TABLE `client` (
+  `id`           INTEGER PRIMARY KEY AUTOINCREMENT,
+  `connect_type` INT  NOT NULL,
+  `addr`         TEXT NOT NULL,
+  `reso`         INT  NULL,
+  `name`         TEXT NOT NULL,
+  `options`      TEXT NULL,
+  `port`         INT  NOT NULL
+);
+
+CREATE TABLE `led` (
+  `id`        INTEGER PRIMARY KEY AUTOINCREMENT,
+  `name`      TEXT NULL,
+  `options`   TEXT NULL,
+  `local_id`  INT  NULL,
+  `client_id` INT  NOT NULL,
+  CONSTRAINT `fk_led_client`
+  FOREIGN KEY (`client_id`)
+  REFERENCES `client` (`id`)
+  ON DELETE NO ACTION
+  ON UPDATE NO ACTION
+);
+
+CREATE INDEX `fk_led_client_idx`
+  ON `led` (`client_id` ASC);
+
+CREATE TABLE IF NOT EXISTS `group` (
+  `id`   INTEGER PRIMARY KEY AUTOINCREMENT,
+  `name` TEXT NOT NULL,
+  `type` INT  NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS `led_has_group` (
+  `led_id`   INT NOT NULL,
+  `group_id` INT NOT NULL,
+  PRIMARY KEY (`led_id`, `group_id`),
+  CONSTRAINT `fk_led_has_group_led1`
+  FOREIGN KEY (`led_id`)
+  REFERENCES `led` (`id`)
+  ON DELETE NO ACTION
+  ON UPDATE NO ACTION,
+  CONSTRAINT `fk_led_has_group_group1`
+  FOREIGN KEY (`group_id`)
+  REFERENCES `group` (`id`)
+  ON DELETE NO ACTION
+  ON UPDATE NO ACTION
+);
+
+CREATE INDEX `fk_led_has_group_group1_idx`
+  ON `led_has_group` (`group_id` ASC);
+
+CREATE INDEX `fk_led_has_group_led1_idx`
+  ON `led_has_group` (`led_id` ASC);
+
+
+INSERT INTO meta ("name", "value") VALUES ("version", "1");