First Version, written at a hackaton...

COPYRIGHT

+Copyright 2019 Christian Lölkes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LICENSE.md

+Copyright 2018 Christian Lölkes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

+# Gesetze im Internet
+
+ This package displays a list of the latest laws pusblished by the Federal Ministry of Justice and for Consumer Protection in Germany. In Germany, laws have to be published in the 'Bundesgesetzblatt', a formal publication by the German Government, to be applicable.
+
+ The package was created for the exhibition * Open Codes. Leben in Digitalen Welten * at the Federal Ministry of Justice and Consumer Protection in Berlin, Germany.
+
+**Note:** The content for this package is exclusivly in German.
+
+**Note:** This package allows the InfoBeamer node to access the internet.
+
+## Settings
+
+### Display rotation
+
+Control the rotation of the screen. Choose between 0° and 180°.
+
+**Note**: This package is currently not responsive and only works for 1920x1080 screens.
+
+### Background color
+
+Set the background color for the screen. Default is set to black, this setting applies to all content on the screen.
+
+### Font
+
+Select from the fonts in the package. Currently no additional fonts can be installed. This setting applies to all content on the screen.
+
+### Font color
+
+Set the font color. Default is set to white. This setting applies to all content on the screen.
+
+### Footer
+
+* **Show**. Tick if you want to show the footer. Default is ticked.
+* **Size**. Footer text height in pixels. Default is 20.
+* **Color** Footer text color. Default is white.
+
+#### Comment
+
+Can be used to give credit for software, data sources or show arbitrary information. This can be useful if you need to mention data sources or licence details.
+
+## Data sources
+* [Gesetze im Internet](http://www.gesetze-im-internet.de/)
+
+## Authors
+
+* **Christian Lölkes** - *Initial work* - [GitHub](https://github.com/loelkes)
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

config.json

+{
+  "__metadata": {
+    "api": "",
+    "device_id": 0,
+    "instance_id": 0,
+    "package_id": 0,
+    "scratch": "",
+    "secrets": {
+      "account": "",
+      "setup": ""
+    },
+    "setup_id": 0
+  },
+  "bg_color": {
+    "a": 1,
+    "b": 0,
+    "g": 0,
+    "hex": "000000",
+    "r": 0,
+    "rgba": [
+      0,
+      0,
+      0,
+      1
+    ]
+  },
+  "font": "Inconsolata-Bold.ttf",
+  "text_color": {
+    "a": 1,
+    "b": 1,
+    "g": 1,
+    "hex": "ffffff",
+    "r": 1,
+    "rgba": [
+      1,
+      1,
+      1,
+      1
+    ]
+  },
+  "title": "",
+  "project_name": "jhvn2019",
+  "created_after": "04/04/2019 20:00:00"
+}

hackdash.py

+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from http_API import API
+from toolbox import Util
+from hosted import node, device, log
+from datetime import datetime
+import time, json
+from collections import namedtuple
+
+
+class Hackdash(object):
+    def __init__(self, config):
+        self.util = Util()
+        self.hackdash_api = API(url="https://hackdash.org/api/v2/{}/projects".format(config['project_name']))
+        self.created_after = datetime.strptime(config['created_after'], '%d/%m/%Y %H:%M:%S')
+        self.lastRefresh = 0
+
+    def refresh(self):
+        self.hackdash_api.query()
+        projects = self.hackdash_api.response
+        for project_data in projects:
+            project = Project(project_data)
+            if project.created > self.created_after:
+                title = self.util.line(u'{} | {}'.format(project.title, project.status), height=50)
+                self.util.offset['y'] += 50
+                desc = self.util.line(u'{}...'.format(project.description[:120]), height=30)
+                self.util.offset['y'] += 80
+                self.util.lines.append(title)
+                self.util.lines.append(desc)
+
+    def update(self):
+        self.refresh()
+        self.util.updateFile()
+
+class Project:
+    def __init__(self, data):
+        self.__dict__.update(data)
+
+    @property
+    def created(self):
+        return datetime.strptime(self.created_at, '%Y-%m-%dT%H:%M:%S.%fZ')
+
+# "2019-04-06T13:18:42.163Z"

hosted.py

+#
+# Part of info-beamer hosted. You can find the latest version
+# of this file at:
+#
+# https://github.com/info-beamer/package-sdk
+#
+# Copyright (c) 2014,2015,2016,2017,2018 Florian Wesch <fw@info-beamer.com>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+#     Redistributions of source code must retain the above copyright
+#     notice, this list of conditions and the following disclaimer.
+#
+#     Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the
+#     distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+VERSION = "1.3"
+
+import os
+import sys
+import json
+import time
+import errno
+import socket
+import select
+import pyinotify
+import thread
+import threading
+import requests
+from tempfile import NamedTemporaryFile
+
+types = {}
+
+def init_types():
+    def type(fn):
+        types[fn.__name__] = fn
+        return fn
+
+    @type
+    def color(value):
+        return value
+
+    @type
+    def string(value):
+        return value
+
+    @type
+    def text(value):
+        return value
+
+    @type
+    def section(value):
+        return value
+
+    @type
+    def boolean(value):
+        return value
+
+    @type
+    def select(value):
+        return value
+
+    @type
+    def duration(value):
+        return value
+
+    @type
+    def integer(value):
+        return value
+
+    @type
+    def float(value):
+        return value
+
+    @type
+    def font(value):
+        return value
+
+    @type
+    def device(value):
+        return value
+
+    @type
+    def resource(value):
+        return value
+
+    @type
+    def json(value):
+        return value
+
+    @type
+    def custom(value):
+        return value
+
+    @type
+    def date(value):
+        return value
+
+init_types()
+
+def log(msg):
+    print >>sys.stderr, "[hosted.py] %s" % msg
+
+def abort_service(reason):
+    log("restarting service (%s)" % reason)
+    try:
+        thread.interrupt_main()
+    except:
+        pass
+    time.sleep(2)
+    os.kill(os.getpid(), 2)
+    time.sleep(2)
+    os.kill(os.getpid(), 15)
+    time.sleep(2)
+    os.kill(os.getpid(), 9)
+    time.sleep(100)
+
+class Configuration(object):
+    def __init__(self):
+        self._restart = False
+        self._options = []
+        self._config = {}
+        self._parsed = {}
+        self.parse_node_json(do_update=False)
+        self.parse_config_json()
+
+    def restart_on_update(self):
+        log("going to restart when config is updated")
+        self._restart = True
+
+    def parse_node_json(self, do_update=True):
+        with open("node.json") as f:
+            self._options = json.load(f).get('options', [])
+        if do_update:
+            self.update_config()
+
+    def parse_config_json(self, do_update=True):
+        with open("config.json") as f:
+            self._config = json.load(f)
+        if do_update:
+            self.update_config()
+
+    def update_config(self):
+        if self._restart:
+            return abort_service("restart_on_update set")
+
+        def parse_recursive(options, config, target):
+            # print 'parsing', config
+            for option in options:
+                if not 'name' in option:
+                    continue
+                if option['type'] == 'list':
+                    items = []
+                    for item in config[option['name']]:
+                        parsed = {}
+                        parse_recursive(option['items'], item, parsed)
+                        items.append(parsed)
+                    target[option['name']] = items
+                    continue
+                target[option['name']] = types[option['type']](config[option['name']])
+
+        parsed = {}
+        parse_recursive(self._options, self._config, parsed)
+        log("updated config")
+        self._parsed = parsed
+
+    @property
+    def raw(self):
+        return self._config
+
+    @property
+    def metadata(self):
+        return self._config['__metadata']
+
+    def __getitem__(self, key):
+        return self._parsed[key]
+
+    def __getattr__(self, key):
+        return self._parsed[key]
+
+def setup_inotify(configuration):
+    class EventHandler(pyinotify.ProcessEvent):
+        def process_default(self, event):
+            basename = os.path.basename(event.pathname)
+            if basename == 'node.json':
+                log("node.json changed")
+                configuration.parse_node_json()
+            elif basename == 'config.json':
+                log("config.json changed!")
+                configuration.parse_config_json()
+            elif basename.endswith('.py'):
+                abort_service("python file changed")
+
+    wm = pyinotify.WatchManager()
+
+    notifier = pyinotify.ThreadedNotifier(wm, EventHandler())
+    notifier.daemon = True
+    notifier.start()
+
+    wm.add_watch('.', pyinotify.IN_MOVED_TO)
+
+class Node(object):
+    def __init__(self, node):
+        self._node = node
+        self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+
+    def send_raw(self, raw):
+        log("sending %r" % (raw,))
+        self._sock.sendto(raw, ('127.0.0.1', 4444))
+
+    def send(self, data):
+        self.send_raw(self._node + data)
+
+    @property
+    def is_top_level(self):
+        return self._node == "root"
+
+    @property
+    def path(self):
+        return self._node
+
+    def write_file(self, filename, content):
+        f = NamedTemporaryFile(prefix='.hosted-py-tmp', dir=os.getcwd())
+        try:
+            f.write(content)
+        except:
+            traceback.print_exc()
+            f.close()
+            raise
+        else:
+            f.delete = False
+            f.close()
+            os.rename(f.name, filename)
+
+    def write_json(self, filename, data):
+        self.write_file(filename, json.dumps(
+            data,
+            ensure_ascii=False,
+            separators=(',',':'),
+        ).encode('utf8'))
+
+    class Sender(object):
+        def __init__(self, node, path):
+            self._node = node
+            self._path = path
+
+        def __call__(self, data):
+            if isinstance(data, (dict, list)):
+                raw = "%s:%s" % (self._path, json.dumps(
+                    data,
+                    ensure_ascii=False,
+                    separators=(',',':'),
+                ).encode('utf8'))
+            else:
+                raw = "%s:%s" % (self._path, data)
+            self._node.send_raw(raw)
+
+    def __getitem__(self, path):
+        return self.Sender(self, self._node + path)
+
+    def __call__(self, data):
+        return self.Sender(self, self._node)(data)
+
+    def scratch_cached(self, filename, generator):
+        cached = os.path.join(os.environ['SCRATCH'], filename)
+
+        if not os.path.exists(cached):
+            f = NamedTemporaryFile(prefix='scratch-cached-tmp', dir=os.environ['SCRATCH'])
+            try:
+                generator(f)
+            except:
+                raise
+            else:
+                f.delete = False
+                f.close()
+                os.rename(f.name, cached)
+
+        if os.path.exists(filename):
+            try:
+                os.unlink(filename)
+            except:
+                pass
+        os.symlink(cached, filename)
+
+class APIError(Exception):
+    pass
+
+class APIProxy(object):
+    def __init__(self, apis, api_name):
+        self._apis = apis
+        self._api_name = api_name
+
+    @property
+    def url(self):
+        index = self._apis.get_api_index()
+        if not self._api_name in index:
+            raise APIError("api '%s' not available" % (self._api_name,))
+        return index[self._api_name]['url']
+
+    def unwrap(self, r):
+        r.raise_for_status()
+        if r.status_code == 304:
+            return None
+        if r.headers['content-type'] == 'application/json':
+            resp = r.json()
+            if not resp['ok']:
+                raise APIError(u"api call failed: %s" % (
+                    resp.get('error', '<unknown error>'),
+                ))
+            return resp.get(self._api_name)
+        else:
+            return r.content
+
+    def add_defaults(self, kwargs):
+        if not 'timeout' in kwargs:
+            kwargs['timeout'] = 10
+
+    def get(self, **kwargs):
+        self.add_defaults(kwargs)
+        try:
+            return self.unwrap(self._apis.session.get(
+                url = self.url,
+                **kwargs
+            ))
+        except APIError:
+            raise
+        except Exception as err:
+            raise APIError(err)
+
+    def post(self, **kwargs):
+        self.add_defaults(kwargs)
+        try:
+            return self.unwrap(self._apis.session.post(
+                url = self.url,
+                **kwargs
+            ))
+        except APIError:
+            raise
+        except Exception as err:
+            raise APIError(err)
+
+class APIs(object):
+    def __init__(self, config):
+        self._config = config
+        self._index = None
+        self._valid_until = 0
+        self._lock = threading.Lock()
+        self._session = requests.Session()
+        self._session.headers.update({
+            'User-Agent': 'hosted.py version/%s' % (VERSION,)
+        })
+
+    def update_apis(self):
+        log("fetching api index")
+        r = self._session.get(
+            url = self._config.metadata['api'],
+            timeout = 5,
+        )
+        r.raise_for_status()
+        resp = r.json()
+        if not resp['ok']:
+            raise APIError("cannot retrieve api index")
+        self._index = resp['apis']
+        self._valid_until = resp['valid_until'] - 300
+
+    def get_api_index(self):
+        with self._lock:
+            now = time.time()
+            if now > self._valid_until:
+                self.update_apis()
+            return self._index
+
+    @property
+    def session(self):
+        return self._session
+
+    def list(self):
+        try:
+            index = self.get_api_index()
+            return sorted(index.keys())
+        except Exception as err:
+            raise APIError(err)
+
+    def __getitem__(self, api_name):
+        return APIProxy(self, api_name)
+
+    def __getattr__(self, api_name):
+        return APIProxy(self, api_name)
+
+class GPIO(object):
+    def __init__(self):
+        self._pin_fd = {}
+        self._state = {}
+        self._fd_2_pin = {}
+        self._poll = select.poll()
+        self._lock = threading.Lock()
+
+    def setup_pin(self, pin, direction="in", invert=False):
+        if not os.path.exists("/sys/class/gpio/gpio%d" % pin):
+            with open("/sys/class/gpio/export", "wb") as f:
+                f.write(str(pin))
+        # mdev is giving the newly create GPIO directory correct permissions.
+        for i in range(10):
+            try:
+                with open("/sys/class/gpio/gpio%d/active_low" % pin, "wb") as f:
+                    f.write("1" if invert else "0")
+                break
+            except IOError as err:
+                if err.errno != errno.EACCES:
+                    raise
+            time.sleep(0.1)
+            log("waiting for GPIO permissions")
+        else:
+            raise IOError(errno.EACCES, "Cannot access GPIO")
+        with open("/sys/class/gpio/gpio%d/direction" % pin, "wb") as f:
+            f.write(direction)
+
+    def set_pin_value(self, pin, high):
+        with open("/sys/class/gpio/gpio%d/value" % pin, "wb") as f:
+            f.write("1" if high else "0")
+
+    def monitor(self, pin, invert=False):
+        if pin in self._pin_fd:
+            return
+        self.setup_pin(pin, direction="in", invert=invert)
+        with open("/sys/class/gpio/gpio%d/edge" % pin, "wb") as f:
+            f.write("both")
+        fd = os.open("/sys/class/gpio/gpio%d/value" % pin, os.O_RDONLY)
+        self._state[pin] = bool(int(os.read(fd, 5)))
+        self._fd_2_pin[fd] = pin
+        self._pin_fd[pin] = fd
+        self._poll.register(fd, select.POLLPRI | select.POLLERR)
+
+    def poll(self, timeout=1000):
+        changes = []
+        for fd, evt in self._poll.poll(timeout):
+            os.lseek(fd, 0, 0)
+            state = bool(int(os.read(fd, 5)))
+            pin = self._fd_2_pin[fd]
+            with self._lock:
+                prev_state, self._state[pin] = self._state[pin], state
+            if state != prev_state:
+                changes.append((pin, state))
+        return changes
+
+    def poll_forever(self):
+        while 1:
+            for event in self.poll():