SafeEyes/safeeyes/model.py

#!/usr/bin/env python
# Safe Eyes is a utility to remind you to take break frequently
# to protect your eyes from eye strain.

# Copyright (C) 2017  Gobinath

# 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/>.
"""
This module contains the entity classes used by Safe Eyes and its plugins.
"""

import logging
from distutils.version import LooseVersion
from enum import Enum

from safeeyes import utility


class Break:
    """
    An entity class which represents a break.
    """

    def __init__(self, break_type, name, time, duration, image, plugins):
        self.type = break_type
        self.name = name
        self.duration = duration
        self.image = image
        self.plugins = plugins
        self.time = time
        self.next = None

    def __str__(self):
        return 'Break: {{name: "{}", type: {}, duration: {}}}\n'.format(self.name, self.type, self.duration)

    def __repr__(self):
        return str(self)

    def is_long_break(self):
        """
        Check whether this break is a long break.
        """
        return self.type == BreakType.LONG_BREAK

    def is_short_break(self):
        """
        Check whether this break is a short break.
        """
        return self.type == BreakType.SHORT_BREAK

    def plugin_enabled(self, plugin_id, is_plugin_enabled):
        """
        Check whether this break supports the given plugin.
        """
        if self.plugins:
            return plugin_id in self.plugins
        else:
            return is_plugin_enabled


class BreakType(Enum):
    """
    Type of Safe Eyes breaks.
    """
    SHORT_BREAK = 1
    LONG_BREAK = 2


class BreakQueue:

    def __init__(self, config, context):
        self.context = context
        self.__current_break = None
        self.__first_break = None
        self.__short_break_time = config.get('short_break_interval')
        self.__long_break_time = config.get('long_break_interval')
        self.__short_pointer = self.__build_queue(BreakType.SHORT_BREAK,
                                                  config.get('short_breaks'),
                                                  self.__short_break_time,
                                                  config.get('short_break_duration'))
        self.__long_pointer = self.__build_queue(BreakType.LONG_BREAK,
                                                 config.get('long_breaks'),
                                                 self.__long_break_time,
                                                 config.get('long_break_duration'))
        self.__short_header = self.__short_pointer
        self.__long_header = self.__long_pointer

        # Restore the last break from session
        if not self.is_empty():
            last_break = context['session'].get('break')
            if last_break is not None:
                current_break = self.get_break()
                if last_break != current_break.name:
                    pointer = self.next()
                    while pointer != current_break and pointer.name != last_break:
                        pointer = self.next()

    def get_break(self):
        if self.__current_break is None:
            self.__current_break = self.next()
        return self.__current_break

    def is_long_break(self):
        return self.__current_break is not None and self.__current_break.type == BreakType.LONG_BREAK

    def next(self):
        if self.is_empty():
            return None
        break_obj = None
        if self.__short_pointer is None:
            # No short breaks
            break_obj = self.__long_pointer
            self.context['break_type'] = 'long'
            # Update the pointer to next
            self.__long_pointer = self.__long_pointer.next
        elif self.__long_pointer is None:
            # No long breaks
            break_obj = self.__short_pointer
            self.context['break_type'] = 'short'
            # Update the pointer to next
            self.__short_pointer = self.__short_pointer.next
        elif self.__long_pointer.time <= self.__short_pointer.time:
            # Time for a long break
            break_obj = self.__long_pointer
            self.context['break_type'] = 'long'
            # Update the pointer to next
            self.__long_pointer = self.__long_pointer.next
        else:
            # Time for a short break
            break_obj = self.__short_pointer
            self.context['break_type'] = 'short'
            # Reduce the break time from the next long break
            self.__long_pointer.time -= self.__short_pointer.time
            # Update the pointer to next
            self.__short_pointer = self.__short_pointer.next

        if self.__first_break is None:
            self.__first_break = break_obj
        self.context['new_cycle'] = self.__first_break == break_obj
        if self.__current_break is not None:
            # Reset the time of long breaks
            if self.__current_break.type == BreakType.LONG_BREAK:
                self.__current_break.time = self.__long_break_time

        self.__current_break = break_obj
        self.context['session']['break'] = self.__current_break.name

        return break_obj

    def reset(self):
        self.__short_pointer = self.__short_header
        self.__long_pointer = self.__long_header
        self.__first_break = None
        self.__current_break = None

        # Reset all break time
        short_pointer = self.__short_pointer
        long_pointer = self.__long_pointer
        short_pointer.time = self.__short_break_time
        long_pointer.time = self.__long_break_time
        short_pointer = short_pointer.next
        long_pointer = long_pointer.next

        while short_pointer != self.__short_header:
            short_pointer.time = self.__short_break_time
            short_pointer = short_pointer.next

        while long_pointer != self.__long_header:
            long_pointer.time = self.__long_break_time
            long_pointer = long_pointer.next


    def is_empty(self):
        return self.__short_pointer is None and self.__long_pointer is None

    def __build_queue(self, break_type, break_configs, break_time, break_duration):
        """
        Build a circular queue of breaks.
        """
        head = None
        tail = None
        for break_config in break_configs:
            name = _(break_config['name'])
            duration = break_config.get('duration', break_duration)
            image = break_config.get('image')
            plugins = break_config.get('plugins', None)
            interval = break_config.get('interval', break_time)

            # Validate time value
            if not isinstance(duration, int) or duration <= 0:
                logging.error('Invalid break duration in: ' +
                              str(break_config))
                continue

            break_obj = Break(break_type, name, interval,
                              duration, image, plugins)
            if head is None:
                head = break_obj
                tail = break_obj
            else:
                tail.next = break_obj
                tail = break_obj

        # Connect the tail to the head
        if tail is not None:
            tail.next = head
        return head


class State(Enum):
    """
    Possible states of Safe Eyes.
    """
    START = 0,
    WAITING = 1,
    PRE_BREAK = 2,
    BREAK = 3,
    STOPPED = 4,
    QUIT = 5


class EventHook:
    """
    Hook to attach and detach listeners to system events.
    """

    def __init__(self):
        self.__handlers = []

    def __iadd__(self, handler):
        self.__handlers.append(handler)
        return self

    def __isub__(self, handler):
        self.__handlers.remove(handler)
        return self

    def fire(self, *args, **keywargs):
        """
        Fire all listeners attached with.
        """
        for handler in self.__handlers:
            if not handler(*args, **keywargs):
                return False
        return True


class Config:
    """
    The configuration of Safe Eyes.
    """

    def __init__(self, init=True):
        # Read the config files
        self.__user_config = utility.load_json(utility.CONFIG_FILE_PATH)
        self.__system_config = utility.load_json(
            utility.SYSTEM_CONFIG_FILE_PATH)
        self.__force_upgrade = ['long_breaks', 'short_breaks']

        if init:
            if self.__user_config is None:
                utility.initialize_safeeyes()
                self.__user_config = self.__system_config
                self.save()
            else:
                system_config_version = self.__system_config['meta']['config_version']
                meta_obj = self.__user_config.get('meta', None)
                if meta_obj is None:
                    # Corrupted user config
                    self.__user_config = self.__system_config
                else:
                    user_config_version = str(
                        meta_obj.get('config_version', '0.0.0'))
                    if LooseVersion(user_config_version) != LooseVersion(system_config_version):
                        # Update the user config
                        self.__merge_dictionary(
                            self.__user_config, self.__system_config)
                        self.__user_config = self.__system_config
                        # Update the style sheet
                        utility.replace_style_sheet()

            utility.merge_plugins(self.__user_config)
            self.save()

    def __merge_dictionary(self, old_dict, new_dict):
        """
        Merge the dictionaries.
        """
        for key in new_dict:
            if key == "meta" or key in self.__force_upgrade:
                continue
            if key in old_dict:
                new_value = new_dict[key]
                old_value = old_dict[key]
                if type(new_value) is type(old_value):
                    # Both properties have same type
                    if isinstance(new_value, dict):
                        self.__merge_dictionary(old_value, new_value)
                    else:
                        new_dict[key] = old_value

    def clone(self):
        config = Config(init=False)
        return config

    def save(self):
        """
        Save the configuration to file.
        """
        utility.write_json(utility.CONFIG_FILE_PATH, self.__user_config)

    def get(self, key, default_value=None):
        """
        Get the value.
        """
        value = self.__user_config.get(key, default_value)
        if value is None:
            value = self.__system_config.get(key, None)
        return value

    def set(self, key, value):
        """
        Set the value.
        """
        self.__user_config[key] = value

    def __eq__(self, config):
        return self.__user_config == config.__user_config

    def __ne__(self, config):
        return self.__user_config != config.__user_config


class TrayAction:
    """
    Data object wrapping name, icon and action.
    """

    def __init__(self, name, icon, action, system_icon):
        self.name = name
        self.__icon = icon
        self.action = action
        self.system_icon = system_icon
        self.__toolbar_buttons = []

    def get_icon(self):
        if self.system_icon:
            return self.__icon
        else:
            image = utility.load_and_scale_image(self.__icon, 16, 16)
            image.show()
            return image

    def add_toolbar_button(self, button):
        self.__toolbar_buttons.append(button)

    def reset(self):
        for button in self.__toolbar_buttons:
            button.hide()
        self.__toolbar_buttons.clear()

    @classmethod
    def build(cls, name, icon_path, icon_id, action):
        image = utility.load_and_scale_image(icon_path, 12, 12)
        if image is None:
            return TrayAction(name, icon_id, action, True)
        else:
            return TrayAction(name, icon_path, action, False)