diff --git a/pype/modules/idle_manager/__init__.py b/pype/modules/idle_manager/__init__.py index 4bc33c87c1..651f360c50 100644 --- a/pype/modules/idle_manager/__init__.py +++ b/pype/modules/idle_manager/__init__.py @@ -1,4 +1,4 @@ -from .idle_manager import ( +from .idle_module import ( IdleManager, IIdleManager ) diff --git a/pype/modules/idle_manager/idle_module.py b/pype/modules/idle_manager/idle_module.py new file mode 100644 index 0000000000..979e1b92ea --- /dev/null +++ b/pype/modules/idle_manager/idle_module.py @@ -0,0 +1,97 @@ +import collections +from abc import ABCMeta, abstractmethod + +import six + +from pype.modules import PypeModule, ITrayService + + +@six.add_metaclass(ABCMeta) +class IIdleManager: + """Other modules interface to return callbacks by idle time in seconds. + + Expected output is dictionary with seconds as keys and callback/s + as value, value may be callback of list of callbacks. + EXAMPLE: + ``` + { + 60: self.on_minute_idle + } + ``` + """ + idle_manager = None + + @abstractmethod + def callbacks_by_idle_time(self): + pass + + @property + def idle_time(self): + if self.idle_manager: + return self.idle_manager.idle_time + + +class IdleManager(PypeModule, ITrayService): + """ Measure user's idle time in seconds. + Idle time resets on keyboard/mouse input. + Is able to emit signals at specific time idle. + """ + label = "Idle Service" + name = "idle_manager" + + def initialize(self, module_settings): + idle_man_settings = module_settings[self.name] + self.enabled = idle_man_settings["enabled"] + + self.time_callbacks = collections.defaultdict(list) + self.idle_thread = None + + def tray_init(self): + return + + def tray_start(self): + self.start_thread() + + def tray_exit(self): + self.stop_thread() + try: + self.time_callbacks = {} + except Exception: + pass + + def connect_with_modules(self, enabled_modules): + for module in enabled_modules: + if not isinstance(module, IIdleManager): + continue + + module.idle_manager = self + callbacks_items = module.callbacks_by_idle_time() or {} + for emit_time, callbacks in callbacks_items.items(): + if not isinstance(callbacks, (tuple, list, set)): + callbacks = [callbacks] + self.time_callbacks[emit_time].extend(callbacks) + + @property + def idle_time(self): + if self.idle_thread and self.idle_thread.is_running: + return self.idle_thread.idle_time + + def _create_thread(self): + from .idle_threads import IdleManagerThread + + return IdleManagerThread(self) + + def start_thread(self): + if self.idle_thread: + self.idle_thread.stop() + self.idle_thread.join() + self.idle_thread = self._create_thread() + self.idle_thread.start() + + def stop_thread(self): + if self.idle_thread: + self.idle_thread.stop() + self.idle_thread.join() + + def on_thread_stop(self): + self.set_service_failed_icon() diff --git a/pype/modules/idle_manager/idle_manager.py b/pype/modules/idle_manager/idle_threads.py similarity index 50% rename from pype/modules/idle_manager/idle_manager.py rename to pype/modules/idle_manager/idle_threads.py index fa6d70d229..7cedf986e6 100644 --- a/pype/modules/idle_manager/idle_manager.py +++ b/pype/modules/idle_manager/idle_threads.py @@ -1,105 +1,38 @@ import time -import collections import threading -from abc import ABCMeta, abstractmethod -import six from pynput import mouse, keyboard from pype.lib import PypeLogger -from pype.modules import PypeModule, ITrayService -@six.add_metaclass(ABCMeta) -class IIdleManager: - """Other modules interface to return callbacks by idle time in seconds. +class MouseThread(mouse.Listener): + """Listens user's mouse movement.""" - Expected output is dictionary with seconds as keys and callback/s - as value, value may be callback of list of callbacks. - EXAMPLE: - ``` - { - 60: self.on_minute_idle - } - ``` - """ - idle_manager = None + def __init__(self, callback): + super(MouseThread, self).__init__(on_move=self.on_move) + self.callback = callback - @abstractmethod - def callbacks_by_idle_time(self): - pass - - @property - def idle_time(self): - if self.idle_manager: - return self.idle_manager.idle_time + def on_move(self, posx, posy): + self.callback() -class IdleManager(PypeModule, ITrayService): - """ Measure user's idle time in seconds. - Idle time resets on keyboard/mouse input. - Is able to emit signals at specific time idle. - """ - label = "Idle Service" - name = "idle_manager" +class KeyboardThread(keyboard.Listener): + """Listens user's keyboard input.""" - def initialize(self, module_settings): - idle_man_settings = module_settings[self.name] - self.enabled = idle_man_settings["enabled"] + def __init__(self, callback): + super(KeyboardThread, self).__init__(on_press=self.on_press) - self.time_callbacks = collections.defaultdict(list) - self.idle_thread = None + self.callback = callback - def tray_init(self): - return - - def tray_start(self): - self.start_thread() - - def tray_exit(self): - self.stop_thread() - try: - self.time_callbacks = {} - except Exception: - pass - - def connect_with_modules(self, enabled_modules): - for module in enabled_modules: - if not isinstance(module, IIdleManager): - continue - - module.idle_manager = self - callbacks_items = module.callbacks_by_idle_time() or {} - for emit_time, callbacks in callbacks_items.items(): - if not isinstance(callbacks, (tuple, list, set)): - callbacks = [callbacks] - self.time_callbacks[emit_time].extend(callbacks) - - @property - def idle_time(self): - if self.idle_thread and self.idle_thread.is_running: - return self.idle_thread.idle_time - - def start_thread(self): - if self.idle_thread: - self.idle_thread.stop() - self.idle_thread.join() - self.idle_thread = IdleManagerThread(self) - self.idle_thread.start() - - def stop_thread(self): - if self.idle_thread: - self.idle_thread.stop() - self.idle_thread.join() - - def on_thread_stop(self): - self.set_service_failed_icon() + def on_press(self, key): + self.callback() class IdleManagerThread(threading.Thread): def __init__(self, module, *args, **kwargs): super(IdleManagerThread, self).__init__(*args, **kwargs) - self.log = PypeLogger().get_logger(self.__class__.__name__) + self.log = PypeLogger.get_logger(self.__class__.__name__) self.module = module self.threads = [] self.is_running = False @@ -124,8 +57,8 @@ class IdleManagerThread(threading.Thread): self.log.info("IdleManagerThread has started") self.is_running = True thread_mouse = MouseThread(self.reset_time) - thread_mouse.start() thread_keyboard = KeyboardThread(self.reset_time) + thread_mouse.start() thread_keyboard.start() try: while self.is_running: @@ -162,26 +95,3 @@ class IdleManagerThread(threading.Thread): pass self.on_stop() - - -class MouseThread(mouse.Listener): - """Listens user's mouse movement.""" - - def __init__(self, callback): - super(MouseThread, self).__init__(on_move=self.on_move) - self.callback = callback - - def on_move(self, posx, posy): - self.callback() - - -class KeyboardThread(keyboard.Listener): - """Listens user's keyboard input.""" - - def __init__(self, callback): - super(KeyboardThread, self).__init__(on_press=self.on_press) - - self.callback = callback - - def on_press(self, key): - self.callback() diff --git a/pype/modules/timers_manager/timers_manager.py b/pype/modules/timers_manager/timers_manager.py index 68890640b3..b83f51f0ba 100644 --- a/pype/modules/timers_manager/timers_manager.py +++ b/pype/modules/timers_manager/timers_manager.py @@ -1,4 +1,5 @@ import os +import collections from abc import ABCMeta, abstractmethod import six from .. import PypeModule, ITrayService, IIdleManager, IWebServerRoutes @@ -159,26 +160,25 @@ class TimersManager(PypeModule, ITrayService, IIdleManager, IWebServerRoutes): def callbacks_by_idle_time(self): """Implementation of IIdleManager interface.""" # Time when message is shown - callbacks = { - self.time_show_message: lambda: self.time_callback(0) - } + callbacks = collections.defaultdict(list) + callbacks[self.time_show_message].append(lambda: self.time_callback(0)) # Times when idle is between show widget and stop timers show_to_stop_range = range( self.time_show_message - 1, self.time_stop_timer ) for num in show_to_stop_range: - callbacks[num] = lambda: self.time_callback(1) + callbacks[num].append(lambda: self.time_callback(1)) # Times when widget is already shown and user restart idle shown_and_moved_range = range( self.time_stop_timer - self.time_show_message ) for num in shown_and_moved_range: - callbacks[num] = lambda: self.time_callback(1) + callbacks[num].append(lambda: self.time_callback(1)) # Time when timers are stopped - callbacks[self.time_stop_timer] = lambda: self.time_callback(2) + callbacks[self.time_stop_timer].append(lambda: self.time_callback(2)) return callbacks diff --git a/pype/modules/timers_manager/widget_user_idle.py b/pype/modules/timers_manager/widget_user_idle.py index 5e47cdaddf..cbdb7fd30a 100644 --- a/pype/modules/timers_manager/widget_user_idle.py +++ b/pype/modules/timers_manager/widget_user_idle.py @@ -163,8 +163,9 @@ class SignalHandler(QtCore.QObject): signal_change_label = QtCore.Signal() signal_stop_timers = QtCore.Signal() - def __init__(self, cls): - super().__init__() - self.signal_show_message.connect(cls.show_message) - self.signal_change_label.connect(cls.change_label) - self.signal_stop_timers.connect(cls.stop_timers) + def __init__(self, module): + super(SignalHandler, self).__init__() + self.module = module + self.signal_show_message.connect(module.show_message) + self.signal_change_label.connect(module.change_label) + self.signal_stop_timers.connect(module.stop_timers)