first step of pype's reorganization

pype/modules/idle_manager/__init__.py

@@ -0,0 +1,5 @@
+from .idle_manager import IdleManager
+
+
+def tray_init(tray_widget, main_widget):
+    return IdleManager()

pype/modules/idle_manager/idle_manager.py

@@ -0,0 +1,144 @@
+import time
+import collections
+from Qt import QtCore
+from pynput import mouse, keyboard
+from pype.api import Logger
+
+
+class IdleManager(QtCore.QThread):
+    """ Measure user's idle time in seconds.
+    Idle time resets on keyboard/mouse input.
+    Is able to emit signals at specific time idle.
+    """
+    time_signals = collections.defaultdict(list)
+    idle_time = 0
+    signal_reset_timer = QtCore.Signal()
+
+    def __init__(self):
+        super(IdleManager, self).__init__()
+        self.log = Logger().get_logger(self.__class__.__name__)
+        self.signal_reset_timer.connect(self._reset_time)
+        self.qaction = None
+        self.failed_icon = None
+        self._is_running = False
+
+    def set_qaction(self, qaction, failed_icon):
+        self.qaction = qaction
+        self.failed_icon = failed_icon
+
+    def tray_start(self):
+        self.start()
+
+    def tray_exit(self):
+        self.stop()
+        try:
+            self.time_signals = {}
+        except Exception:
+            pass
+
+    def add_time_signal(self, emit_time, signal):
+        """ If any module want to use IdleManager, need to use add_time_signal
+        :param emit_time: time when signal will be emitted
+        :type emit_time: int
+        :param signal: signal that will be emitted (without objects)
+        :type signal: QtCore.Signal
+        """
+        self.time_signals[emit_time].append(signal)
+
+    @property
+    def is_running(self):
+        return self._is_running
+
+    def _reset_time(self):
+        self.idle_time = 0
+
+    def stop(self):
+        self._is_running = False
+
+    def run(self):
+        self.log.info('IdleManager has started')
+        self._is_running = True
+        thread_mouse = MouseThread(self.signal_reset_timer)
+        thread_mouse.start()
+        thread_keyboard = KeyboardThread(self.signal_reset_timer)
+        thread_keyboard.start()
+        try:
+            while self.is_running:
+                self.idle_time += 1
+                if self.idle_time in self.time_signals:
+                    for signal in self.time_signals[self.idle_time]:
+                        signal.emit()
+                time.sleep(1)
+        except Exception:
+            self.log.warning(
+                'Idle Manager service has failed', exc_info=True
+            )
+
+        if self.qaction and self.failed_icon:
+            self.qaction.setIcon(self.failed_icon)
+
+        # Threads don't have their attrs when Qt application already finished
+        try:
+            thread_mouse.signal_stop.emit()
+            thread_mouse.terminate()
+            thread_mouse.wait()
+        except AttributeError:
+            pass
+
+        try:
+            thread_keyboard.signal_stop.emit()
+            thread_keyboard.terminate()
+            thread_keyboard.wait()
+        except AttributeError:
+            pass
+
+        self._is_running = False
+        self.log.info('IdleManager has stopped')
+
+
+class MouseThread(QtCore.QThread):
+    """Listens user's mouse movement
+    """
+    signal_stop = QtCore.Signal()
+
+    def __init__(self, signal):
+        super(MouseThread, self).__init__()
+        self.signal_stop.connect(self.stop)
+        self.m_listener = None
+
+        self.signal_reset_timer = signal
+
+    def stop(self):
+        if self.m_listener is not None:
+            self.m_listener.stop()
+
+    def on_move(self, posx, posy):
+        self.signal_reset_timer.emit()
+
+    def run(self):
+        self.m_listener = mouse.Listener(on_move=self.on_move)
+        self.m_listener.start()
+
+
+class KeyboardThread(QtCore.QThread):
+    """Listens user's keyboard input
+    """
+    signal_stop = QtCore.Signal()
+
+    def __init__(self, signal):
+        super(KeyboardThread, self).__init__()
+        self.signal_stop.connect(self.stop)
+        self.k_listener = None
+
+        self.signal_reset_timer = signal
+
+    def stop(self):
+        if self.k_listener is not None:
+            self.k_listener.stop()
+
+    def on_press(self, key):
+        self.signal_reset_timer.emit()
+
+    def run(self):
+        self.k_listener = keyboard.Listener(on_press=self.on_press)
+        self.k_listener.start()