Post New Code Cleanup

src/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+    Utils module
+"""

src/utils/endpoint_registry.py

@@ -0,0 +1,22 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+from .singleton import Singleton
+
+
+
+class EndpointRegistry(Singleton):
+    def __init__(self):
+        self._endpoints = {}
+
+    def register(self, rule, **options):
+        def decorator(f):
+            self._endpoints[rule] = f
+            return f
+
+        return decorator
+
+    def get_endpoints(self):
+        return self._endpoints

src/utils/event_system.py

@@ -0,0 +1,54 @@
+# Python imports
+from collections import defaultdict
+
+# Lib imports
+
+# Application imports
+from .singleton import Singleton
+
+
+
+class EventSystem(Singleton):
+    """ Create event system. """
+
+    def __init__(self):
+        self.subscribers = defaultdict(list)
+
+
+    def subscribe(self, event_type, fn):
+        self.subscribers[event_type].append(fn)
+
+    def unsubscribe(self, event_type, fn):
+        self.subscribers[event_type].remove(fn)
+
+    def unsubscribe_all(self, event_type):
+        self.subscribers.pop(event_type, None)
+
+    def emit(self, event_type, data = None):
+        if event_type in self.subscribers:
+            for fn in self.subscribers[event_type]:
+                if data:
+                    if hasattr(data, '__iter__') and not type(data) is str:
+                        fn(*data)
+                    else:
+                        fn(data)
+                else:
+                    fn()
+
+    def emit_and_await(self, event_type, data = None):
+        """ NOTE: Should be used when signal has only one listener and vis-a-vis """
+        if event_type in self.subscribers:
+            response = None
+            for fn in self.subscribers[event_type]:
+                if data:
+                    if hasattr(data, '__iter__') and not type(data) is str:
+                        response = fn(*data)
+                    else:
+                        response = fn(data)
+                else:
+                    response = fn()
+
+                if not response in (None, ''):
+                    break
+
+            return response

src/utils/ipc_server.py

@@ -0,0 +1,114 @@
+# Python imports
+import os
+import threading
+import time
+from multiprocessing.connection import Client
+from multiprocessing.connection import Listener
+
+# Lib imports
+
+# Application imports
+from .singleton import Singleton
+
+
+
+class IPCServer(Singleton):
+    """ Create a listener so that other {app_name} instances send requests back to existing instance. """
+    def __init__(self, ipc_address: str = '127.0.0.1', conn_type: str = "socket"):
+        self.is_ipc_alive     = False
+        self._ipc_port        = 4848
+        self._ipc_address     = ipc_address
+        self._conn_type       = conn_type
+        self._ipc_authkey     = b'' + bytes(f'{app_name}-ipc', 'utf-8')
+        self._ipc_timeout     = 15.0
+
+        if conn_type == "socket":
+            self._ipc_address = f'/tmp/{app_name}-ipc.sock'
+        elif conn_type == "full_network":
+            self._ipc_address = '0.0.0.0'
+        elif conn_type == "full_network_unsecured":
+            self._ipc_authkey = None
+            self._ipc_address = '0.0.0.0'
+        elif conn_type == "local_network_unsecured":
+            self._ipc_authkey = None
+
+        self._subscribe_to_events()
+
+    def _subscribe_to_events(self):
+        event_system.subscribe("post_file_to_ipc", self.send_ipc_message)
+
+
+    def create_ipc_listener(self) -> None:
+        if self._conn_type == "socket":
+            if os.path.exists(self._ipc_address) and settings.is_dirty_start():
+                os.unlink(self._ipc_address)
+
+            listener = Listener(address=self._ipc_address, family="AF_UNIX", authkey=self._ipc_authkey)
+        elif "unsecured" not in self._conn_type:
+            listener = Listener((self._ipc_address, self._ipc_port), authkey=self._ipc_authkey)
+        else:
+            listener = Listener((self._ipc_address, self._ipc_port))
+
+
+        self.is_ipc_alive = True
+        self._run_ipc_loop(listener)
+
+    @daemon_threaded
+    def _run_ipc_loop(self, listener) -> None:
+        # NOTE: Not thread safe if using with Gtk. Need to import GLib and use idle_add
+        while True:
+            try:
+                conn       = listener.accept()
+                start_time = time.perf_counter()
+                self._handle_ipc_message(conn, start_time)
+            except Exception as e:
+                ...
+
+        listener.close()
+
+    def _handle_ipc_message(self, conn, start_time) -> None:
+        while True:
+            msg = conn.recv()
+            if settings.is_debug():
+                print(msg)
+
+            if "FILE|" in msg:
+                file = msg.split("FILE|")[1].strip()
+                if file:
+                    event_system.emit("handle_file_from_ipc", file)
+
+            if "DIR|" in msg:
+                file = msg.split("DIR|")[1].strip()
+                if file:
+                    event_system.emit("handle_dir_from_ipc", file)
+
+                conn.close()
+                break
+
+
+            if msg in ['close connection', 'close server']:
+                conn.close()
+                break
+
+            # NOTE: Not perfect but insures we don't lock up the connection for too long.
+            end_time = time.perf_counter()
+            if (end_time - start_time) > self._ipc_timeout:
+                conn.close()
+                break
+
+
+    def send_ipc_message(self, message: str = "Empty Data...") -> None:
+        try:
+            if self._conn_type == "socket":
+                conn = Client(address=self._ipc_address, family="AF_UNIX", authkey=self._ipc_authkey)
+            elif "unsecured" not in self._conn_type:
+                conn = Client((self._ipc_address, self._ipc_port), authkey=self._ipc_authkey)
+            else:
+                conn = Client((self._ipc_address, self._ipc_port))
+
+            conn.send(message)
+            conn.close()
+        except ConnectionRefusedError as e:
+            print("Connection refused...")
+        except Exception as e:
+            print(repr(e))

src/utils/keybindings.py

@@ -0,0 +1,127 @@
+# Python imports
+import re
+
+# Lib imports
+import gi
+gi.require_version('Gdk', '3.0')
+from gi.repository import Gdk
+
+# Application imports
+from .singleton import Singleton
+
+
+
+def logger(log = ""):
+    print(log)
+
+
+class KeymapError(Exception):
+    """ Custom exception for errors in keybinding configurations """
+
+MODIFIER = re.compile('<([^<]+)>')
+class Keybindings(Singleton):
+    """ Class to handle loading and lookup of Terminator keybindings """
+
+    modifiers = {
+        'ctrl':     Gdk.ModifierType.CONTROL_MASK,
+        'control':  Gdk.ModifierType.CONTROL_MASK,
+        'primary':  Gdk.ModifierType.CONTROL_MASK,
+        'shift':    Gdk.ModifierType.SHIFT_MASK,
+        'alt':      Gdk.ModifierType.MOD1_MASK,
+        'super':    Gdk.ModifierType.SUPER_MASK,
+        'hyper':    Gdk.ModifierType.HYPER_MASK,
+        'mod2':	    Gdk.ModifierType.MOD2_MASK
+    }
+
+    empty   = {}
+    keys    = None
+    _masks  = None
+    _lookup = None
+
+    def __init__(self):
+        self.keymap = Gdk.Keymap.get_default()
+        self.configure({})
+
+    def configure(self, bindings):
+        """ Accept new bindings and reconfigure with them """
+        self.keys = bindings
+        self.reload()
+
+    def reload(self):
+        """ Parse bindings and mangle into an appropriate form """
+        self._lookup = {}
+        self._masks  = 0
+
+        for action, bindings in list(self.keys.items()):
+            if isinstance(bindings, list):
+                bindings = (*bindings,)
+            elif not isinstance(bindings, tuple):
+                bindings = (bindings,)
+
+
+            for binding in bindings:
+                if not binding or binding == "None":
+                    continue
+
+                try:
+                    keyval, mask = self._parsebinding(binding)
+                    # Does much the same, but with worse error handling.
+                    # keyval, mask = Gtk.accelerator_parse(binding)
+                except KeymapError as e:
+                  logger(f"Keybinding reload failed to parse binding '{binding}': {e}")
+                else:
+                    if mask & Gdk.ModifierType.SHIFT_MASK:
+                        if keyval == Gdk.KEY_Tab:
+                            keyval = Gdk.KEY_ISO_Left_Tab
+                            mask &= ~Gdk.ModifierType.SHIFT_MASK
+                        else:
+                            keyvals = Gdk.keyval_convert_case(keyval)
+                            if keyvals[0] != keyvals[1]:
+                                keyval = keyvals[1]
+                                mask &= ~Gdk.ModifierType.SHIFT_MASK
+                    else:
+                        keyval = Gdk.keyval_to_lower(keyval)
+
+                    self._lookup.setdefault(mask, {})
+                    self._lookup[mask][keyval] = action
+                    self._masks |= mask
+
+    def _parsebinding(self, binding):
+        """ Parse an individual binding using Gtk's binding function """
+        mask = 0
+        modifiers = re.findall(MODIFIER, binding)
+
+        if modifiers:
+            for modifier in modifiers:
+                mask |= self._lookup_modifier(modifier)
+
+        key = re.sub(MODIFIER, '', binding)
+        if key == '':
+            raise KeymapError('No key found!')
+
+        keyval = Gdk.keyval_from_name(key)
+
+        if keyval == 0:
+            raise KeymapError(f"Key '{key}' is unrecognised...")
+        return (keyval, mask)
+
+    def _lookup_modifier(self, modifier):
+        """ Map modifier names to gtk values """
+        try:
+            return self.modifiers[modifier.lower()]
+        except KeyError:
+            raise KeymapError(f"Unhandled modifier '<{modifier}>'")
+
+    def lookup(self, event):
+        """ Translate a keyboard event into a mapped key """
+        try:
+            _found, keyval, _egp, _lvl, consumed = self.keymap.translate_keyboard_state(
+                                              event.hardware_keycode,
+                                              Gdk.ModifierType(event.get_state() & ~Gdk.ModifierType.LOCK_MASK),
+                                              event.group)
+        except TypeError:
+            logger(f"Keybinding lookup failed to translate keyboard event: {dir(event)}")
+            return None
+
+        mask = (event.get_state() & ~consumed) & self._masks
+        return self._lookup.get(mask, self.empty).get(keyval, None)

src/utils/logger.py

@@ -0,0 +1,61 @@
+# Python imports
+import os
+import logging
+
+# Lib imports
+
+# Application imports
+from .singleton import Singleton
+
+
+
+class Logger(Singleton):
+    """
+        Create a new logging object and return it.
+        :note:
+            NOSET     # Don't know the actual log level of this... (defaulting or literally none?)
+            Log Levels (From least to most)
+                Type      Value
+                CRITICAL   50
+                ERROR      40
+                WARNING    30
+                INFO       20
+                DEBUG      10
+        :param loggerName: Sets the name of the logger object. (Used in log lines)
+        :param createFile: Whether we create a log file or just pump to terminal
+
+        :return: the logging object we created
+    """
+
+    def __init__(self, config_path: str, _ch_log_lvl = logging.CRITICAL,  _fh_log_lvl = logging.INFO):
+        self._CONFIG_PATH = config_path
+        self.global_lvl   = logging.DEBUG  # Keep this at highest so that handlers can filter to their desired levels
+        self.ch_log_lvl   = _ch_log_lvl    # Prety much the only one we ever change
+        self.fh_log_lvl   = _fh_log_lvl
+
+    def get_logger(self, loggerName: str = "NO_LOGGER_NAME_PASSED", createFile: bool = True) -> logging.Logger:
+        log          = logging.getLogger(loggerName)
+        log.setLevel(self.global_lvl)
+
+        # Set our log output styles
+        fFormatter   = logging.Formatter('[%(asctime)s] %(pathname)s:%(lineno)d %(levelname)s - %(message)s', '%m-%d %H:%M:%S')
+        cFormatter   = logging.Formatter('%(pathname)s:%(lineno)d] %(levelname)s - %(message)s')
+
+        ch = logging.StreamHandler()
+        ch.setLevel(level=self.ch_log_lvl)
+        ch.setFormatter(cFormatter)
+        log.addHandler(ch)
+
+        if createFile:
+            folder = self._CONFIG_PATH
+            file   = f"{folder}/application.log"
+
+            if not os.path.exists(folder):
+                os.mkdir(folder)
+
+            fh = logging.FileHandler(file)
+            fh.setLevel(level=self.fh_log_lvl)
+            fh.setFormatter(fFormatter)
+            log.addHandler(fh)
+
+        return log

src/utils/settings/__init__.py

@@ -0,0 +1,4 @@
+"""
+    Settings module
+"""
+from .settings import Settings

src/utils/settings/settings.py

@@ -0,0 +1,218 @@
+# Python imports
+import os
+import json
+import inspect
+import datetime
+
+# Lib imports
+import gi
+gi.require_version('Gdk', '3.0')
+from gi.repository import Gdk
+
+# Application imports
+from ..singleton import Singleton
+from .start_check_mixin import StartCheckMixin
+
+
+class MissingConfigError(Exception):
+    pass
+
+
+
+class Settings(StartCheckMixin, Singleton):
+    def __init__(self):
+        self._SCRIPT_PTH        = os.path.dirname(os.path.realpath(__file__))
+        self._USER_HOME         = os.path.expanduser('~')
+        self._USR_PATH          = f"/usr/share/{app_name.lower()}"
+
+        self._USR_CONFIG_FILE   = f"{self._USR_PATH}/settings.json"
+        self._HOME_CONFIG_PATH  = f"{self._USER_HOME}/.config/{app_name.lower()}"
+        self._SCREENSHOTS_DIR   = f"{self._USER_HOME}/.screenshots"
+        self._PLUGINS_PATH      = f"{self._HOME_CONFIG_PATH}/plugins"
+        self._DEFAULT_ICONS     = f"{self._HOME_CONFIG_PATH}/icons"
+        self._CONFIG_FILE       = f"{self._HOME_CONFIG_PATH}/settings.json"
+        self._GLADE_FILE        = f"{self._HOME_CONFIG_PATH}/Main_Window.glade"
+        self._CSS_FILE          = f"{self._HOME_CONFIG_PATH}/stylesheet.css"
+        self._KEY_BINDINGS_FILE = f"{self._HOME_CONFIG_PATH}/key-bindings.json"
+        self._PID_FILE          = f"{self._HOME_CONFIG_PATH}/{app_name.lower()}.pid"
+        self._UI_WIDEGTS_PATH   = f"{self._HOME_CONFIG_PATH}/ui_widgets"
+        self._CONTEXT_MENU      = f"{self._HOME_CONFIG_PATH}/contexct_menu.json"
+        self._WINDOW_ICON       = f"{self._DEFAULT_ICONS}/{app_name.lower()}.png"
+
+
+        if not os.path.exists(self._HOME_CONFIG_PATH):
+            os.mkdir(self._HOME_CONFIG_PATH)
+        if not os.path.exists(self._PLUGINS_PATH):
+            os.mkdir(self._PLUGINS_PATH)
+        if not os.path.isdir(self._SCREENSHOTS_DIR):
+            os.mkdir(self._SCREENSHOTS_DIR)
+
+        if not os.path.exists(self._CONFIG_FILE):
+            import shutil
+            try:
+                shutil.copyfile(self._USR_CONFIG_FILE, self._CONFIG_FILE)
+            except Exception as e:
+                raise
+
+        if not os.path.exists(self._DEFAULT_ICONS):
+            self._DEFAULT_ICONS = f"{self._USR_PATH}/icons"
+            if not os.path.exists(self._DEFAULT_ICONS):
+                raise MissingConfigError("Unable to find the application icons directory.")
+        if not os.path.exists(self._GLADE_FILE):
+            self._GLADE_FILE   = f"{self._USR_PATH}/Main_Window.glade"
+            if not os.path.exists(self._GLADE_FILE):
+                raise MissingConfigError("Unable to find the application Glade file.")
+        if not os.path.exists(self._KEY_BINDINGS_FILE):
+            self._KEY_BINDINGS_FILE = f"{self._USR_PATH}/key-bindings.json"
+            if not os.path.exists(self._KEY_BINDINGS_FILE):
+                raise MissingConfigError("Unable to find the application Keybindings file.")
+        if not os.path.exists(self._CSS_FILE):
+            self._CSS_FILE     = f"{self._USR_PATH}/stylesheet.css"
+            if not os.path.exists(self._CSS_FILE):
+                raise MissingConfigError("Unable to find the application Stylesheet file.")
+        if not os.path.exists(self._WINDOW_ICON):
+            self._WINDOW_ICON  = f"{self._USR_PATH}/icons/{app_name.lower()}.png"
+            if not os.path.exists(self._WINDOW_ICON):
+                raise MissingConfigError("Unable to find the application icon.")
+        if not os.path.exists(self._UI_WIDEGTS_PATH):
+            self._UI_WIDEGTS_PATH  = f"{self._USR_PATH}/ui_widgets"
+        if not os.path.exists(self._CONTEXT_MENU):
+            self._CONTEXT_MENU  = f"{self._USR_PATH}/contexct_menu.json"
+
+
+        try:
+            with open(self._KEY_BINDINGS_FILE) as file:
+                bindings = json.load(file)["keybindings"]
+                keybindings.configure(bindings)
+        except Exception as e:
+            print( f"Settings: {self._KEY_BINDINGS_FILE}\n\t\t{repr(e)}" )
+
+        try:
+            with open(self._CONTEXT_MENU) as file:
+                self._context_menu_data = json.load(file)
+        except Exception as e:
+            print( f"Settings: {self._CONTEXT_MENU}\n\t\t{repr(e)}" )
+
+
+        self._main_window   = None
+        self._main_window_w = 500
+        self._main_window_h = 310
+        self._builder       = None
+        self.PAINT_BG_COLOR = (0, 0, 0, 0.54)
+
+        self._trace_debug   = False
+        self._debug         = False
+        self._dirty_start   = False
+
+        self.load_settings()
+
+
+    def register_signals_to_builder(self, classes=None):
+        handlers = {}
+
+        for c in classes:
+            methods = None
+            try:
+                methods = inspect.getmembers(c, predicate=inspect.ismethod)
+                handlers.update(methods)
+            except Exception as e:
+                ...
+
+        self._builder.connect_signals(handlers)
+
+    def set_main_window(self, window): self._main_window  = window
+    def set_builder(self, builder) -> any:  self._builder = builder
+
+
+    def get_monitor_data(self) -> list:
+        screen = self._main_window.get_screen()
+        monitors = []
+        for m in range(screen.get_n_monitors()):
+            monitors.append(screen.get_monitor_geometry(m))
+            print("{}x{}+{}+{}".format(monitor.width, monitor.height, monitor.x, monitor.y))
+
+        return monitors
+
+    def get_main_window(self)        -> any: return self._main_window
+    def get_main_window_width(self)  -> any: return self._main_window_w
+    def get_main_window_height(self) -> any: return self._main_window_h
+    def get_builder(self)            -> any: return self._builder
+    def get_paint_bg_color(self)     -> any: return self.PAINT_BG_COLOR
+    def get_glade_file(self)         -> str: return self._GLADE_FILE
+    def get_ui_widgets_path(self)    -> str: return self._UI_WIDEGTS_PATH
+    def get_context_menu_data(self)  -> str: return self._context_menu_data
+
+    def get_screenshots_dir(self)  -> str:   return self._SCREENSHOTS_DIR
+    def get_plugins_path(self)     -> str:   return self._PLUGINS_PATH
+    def get_icon_theme(self)       -> str:   return self._ICON_THEME
+    def get_css_file(self)         -> str:   return self._CSS_FILE
+    def get_home_config_path(self) -> str:   return self._HOME_CONFIG_PATH
+    def get_window_icon(self)      -> str:   return self._WINDOW_ICON
+    def get_home_path(self)        -> str:   return self._USER_HOME
+
+    # Filter returns
+    def get_office_filter(self)    -> tuple: return tuple(self._settings["filters"]["office"])
+    def get_vids_filter(self)      -> tuple: return tuple(self._settings["filters"]["videos"])
+    def get_text_filter(self)      -> tuple: return tuple(self._settings["filters"]["text"])
+    def get_music_filter(self)     -> tuple: return tuple(self._settings["filters"]["music"])
+    def get_images_filter(self)    -> tuple: return tuple(self._settings["filters"]["images"])
+    def get_pdf_filter(self)       -> tuple: return tuple(self._settings["filters"]["pdf"])
+
+    def get_success_color(self)    -> str:   return self._theming["success_color"]
+    def get_warning_color(self)    -> str:   return self._theming["warning_color"]
+    def get_error_color(self)      -> str:   return self._theming["error_color"]
+
+    def is_trace_debug(self)       -> str:   return self._trace_debug
+    def is_debug(self)             -> str:   return self._debug
+
+    def get_ch_log_lvl(self)       -> str:   return self._settings["debugging"]["ch_log_lvl"]
+    def get_fh_log_lvl(self)       -> str:   return self._settings["debugging"]["fh_log_lvl"]
+
+    def set_trace_debug(self, trace_debug):
+        self._trace_debug = trace_debug
+
+    def set_debug(self, debug):
+        self._debug = debug
+
+
+    def load_settings(self):
+        with open(self._CONFIG_FILE) as f:
+            self._settings = json.load(f)
+            self._config   = self._settings["config"]
+            self._theming  = self._settings["theming"]
+
+    def save_settings(self):
+        with open(self._CONFIG_FILE, 'w') as outfile:
+            json.dump(self._settings, outfile, separators=(',', ':'), indent=4)
+
+
+    def get_monitor_data(self):
+        screen      = self.get_main_window().get_screen()
+        wdth        = screen.get_width()
+        hght        = screen.get_height()
+        mon0        = Gdk.Rectangle()
+        mon0.width  = wdth
+        mon0.height = hght
+        monitors    = []
+
+        monitors.append(mon0)
+        for m in range(screen.get_n_monitors()):
+            monitors.append(screen.get_monitor_geometry(m))
+
+        return monitors
+
+    def get_directory_list(self):
+        files = []
+
+        for file in os.listdir(self._SCREENSHOTS_DIR):
+            if os.path.isfile(os.path.join(self._SCREENSHOTS_DIR, file)):
+                files.append(file)
+
+        return files
+
+    def generate_screenshot_name(self):
+        return f"{self._SCREENSHOTS_DIR}/scrshot_{self.get_time()}.png"
+
+    def get_time(self):
+        now  = datetime.datetime.now()
+        return now.strftime("%Y-%m-%d %H:%M:%S")

src/utils/settings/start_check_mixin.py

@@ -0,0 +1,50 @@
+# Python imports
+import os
+import json
+import inspect
+
+# Lib imports
+
+# Application imports
+
+
+
+
+class StartCheckMixin:
+    def is_dirty_start(self) -> bool: return self._dirty_start
+    def clear_pid(self): self._clean_pid()
+
+    def do_dirty_start_check(self):
+        if not os.path.exists(self._PID_FILE):
+            self._write_new_pid()
+        else:
+            with open(self._PID_FILE, "r") as _pid:
+                pid = _pid.readline().strip()
+                if pid not in ("", None):
+                    self._check_alive_status(int(pid))
+                else:
+                    self._write_new_pid()
+
+    """ Check For the existence of a unix pid. """
+    def _check_alive_status(self, pid):
+        print(f"PID Found: {pid}")
+        try:
+            os.kill(pid, 0)
+        except OSError:
+            print(f"{app_name} is starting dirty...")
+            self._dirty_start = True
+            self._write_new_pid()
+            return
+
+        print("PID is alive... Let downstream errors (sans debug args) handle app closure propigation.")
+
+    def _write_new_pid(self):
+        pid = os.getpid()
+        self._write_pid(pid)
+
+    def _clean_pid(self):
+        os.unlink(self._PID_FILE)
+
+    def _write_pid(self, pid):
+        with open(self._PID_FILE, "w") as _pid:
+            _pid.write(f"{pid}")

src/utils/singleton.py

@@ -0,0 +1,24 @@
+# Python imports
+
+# Lib imports
+
+# Application imports
+
+
+
+class SingletonError(Exception):
+    pass
+
+
+
+class Singleton:
+    ccount = 0
+
+    def __new__(cls, *args, **kwargs):
+        obj        = super(Singleton, cls).__new__(cls)
+        cls.ccount += 1
+
+        if cls.ccount == 2:
+            raise SingletonError(f"Exceeded {cls.__name__} instantiation limit...")
+
+        return obj