NotiFrame/notiframe/Notiframe.py

#!/usr/bin/env python3
from collections import namedtuple
import uuid
import os
import toml
#from preserve import preservable, preserve, restore

mydir = os.path.dirname(os.path.abspath(__file__))


# Classes
#
class Manager():
    # Manager class to manage a notiframe session.
    def __init__(self):
        self.manager_id = gen_id()
        self.devices = []
        #widget class register list - updated with available widget classes

    def add_device(self, name, resolution):  # add parameters for Device class constructor
        self.devices.append(Device(name, resolution))

    def remove_device(self, dev_id):
        for dev in self.devices:
            if dev.device_id == dev_id:
                self.devices.remove(dev)
                break

    def import_config_file(self, path):
        # get toml config file, convert to named tuple
        # return named tuple containing all layouts
        config = toml.load(path)
        #config = convert(uni_config)
        self.devices = [Device.load(device_data) for device_data in config['devices']]

    def export_config_file(self, path):
        # take tuple containing all layouts and dump as toml
        preserved_data = [device.save() for device in self.devices]
        with open(path, "w+") as config_file:
            config_file.write(toml.dumps({'devices': preserved_data}))


    # def update_config(self, new_config_tuple):
    #    new_device_list = []
    #    for dev in devices:
    #         conf_dev = Conf_device(dev.name, dev.resolution, dev.device_id)
    #        new_device_list.append(conf_dev)
    #
    #
    #    self.export_config_file(new_config_tuple)
    #    #self.update_layout() update devices layouts that need to be updated

    def update_layout(self, new_layout, device):
        device.layout = new_layout

    def clear_layout(self, device):
        device.layout = {}


class Device():
    """
    Device class to contain a device's properties, layout and widgets
    """

    @staticmethod
    def load(saved_state):
        """
        """
        new_device = Device(
            name=saved_state['name'], resolution=saved_state['resolution'], device_id=saved_state['device_id'])
        for widget_state in saved_state['widgets']:
            new_device.add_widget(Widget.load(widget_state))
        return new_device
    
    def save(self):
        """
        Returns a dict with saved state of the device
        """
        return_state = {}
        return_state['name'] = self.name
        return_state['resolution'] = self.resolution
        return_state['device_id'] = self.device_id
        return_state['widgets'] = [widget.save() for widget in self.widgets]
        return return_state

    def __init__(self, name, resolution, device_id=None):
        # attributes
        self.name = name
        self.resolution = resolution
        if(device_id is None):
            self.device_id = gen_id()
        else:
            self.device_id = device_id

        # widgets container
        self.widgets = []

        # generated
        self.device_image = None

    def add_widget(self, widget):
        self.widgets.append(widget)

class Widget():
    """
    test
    """

    @staticmethod
    def load(saved_state):
        """
        test
        """
        widget_classes = {'Widget': Widget, 'BasicTextWidget': BasicTextWidget} # this list maintained in the module or manager...
        new_widget_class = widget_classes[saved_state['w_type']]
        new_widget = new_widget_class(
            position=saved_state['position'], dimensions=saved_state['dimensions'], widg_id=saved_state['widget_id'])
        return new_widget
    
    def save(self):
        """
        Returns a dict with saved state of the widget
        """
        return_state = {}
        return_state['w_type'] = 'Widget'
        return_state['position'] = self.position
        return_state['dimensions'] = self.dimensions
        return_state['widget_id'] = self.widget_id
        return return_state

    def render(self):
        """
        returns image of widget
        """
        pass

    def __init__(self, position, dimensions, widget_id=None):
        if(widget_id is None):
            self.widget_id = gen_id()
        else:
            self.widget_id = widget_id
        self.position = position  # xy grid space location to draw the top left corner in
        self.dimensions = dimensions  # xy in terms of grid spaces

class BasicTextWidget(Widget):
    """
    test
    """

    @staticmethod
    def load(saved_state):
        """
        test
        """
        new_widget = BasicTextWidget(
           position=saved_state['position'], dimensions=saved_state['dimensions'], widg_id=saved_state['widget_id'], text=saved_state['text'])
        return new_widget

    def save(self):
        return_state = super().save()
        return_state['text'] = self.text
        return_state['w_type'] = 'BasicTextWidget'
        return return_state

    def __init__(self, position, dimensions, widg_id, text):
        super().__init__(position, dimensions, widg_id)

        self.text = text

# Global Functions
#
def gen_id():
    return str(uuid.uuid4())