Updates, additions, minor improvements

src/plugins/manifest.py

@@ -0,0 +1,63 @@
+# Python imports
+import os, json
+from os.path import join
+
+# Lib imports
+
+# Application imports
+
+
+
+
+class ManifestProcessor(Exception):
+    ...
+
+
+class Plugin:
+    path: str       = None
+    name: str       = None
+    author: str     = None
+    version: str    = None
+    support: str    = None
+    requests:{}     = None
+    reference: type = None
+
+
+class ManifestProcessor:
+    def __init__(self, path, builder):
+        manifest = join(path, "manifest.json")
+        if not os.path.exists(manifest):
+            raise Exception("Invalid Plugin Structure: Plugin doesn't have 'manifest.json'. Aboarting load...")
+
+        self._path    = path
+        self._builder = builder
+        with open(manifest) as f:
+            data           = json.load(f)
+            self._manifest = data["manifest"]
+            self._plugin   = self.collect_info()
+
+    def collect_info(self) -> Plugin:
+        plugin          = Plugin()
+        plugin.path     = self._path
+        plugin.name     = self._manifest["name"]
+        plugin.author   = self._manifest["author"]
+        plugin.version  = self._manifest["version"]
+        plugin.support  = self._manifest["support"]
+        plugin.requests = self._manifest["requests"]
+
+        return plugin
+
+    def get_loading_data(self):
+        loading_data = {}
+        requests     = self._plugin.requests
+        keys         = requests.keys()
+
+        if "pass_fm_events" in keys:
+            if requests["pass_fm_events"] in ["true"]:
+                loading_data["pass_fm_events"] = True
+
+        if "bind_keys" in keys:
+            if isinstance(requests["bind_keys"], list):
+                loading_data["bind_keys"] = requests["bind_keys"]
+
+        return self._plugin, loading_data

src/plugins/plugins.py

@@ -8,14 +8,13 @@ gi.require_version('Gtk', '3.0')
 from gi.repository import Gtk, Gio
 
 # Application imports
+from .manifest import Plugin, ManifestProcessor
 
 
-class Plugin:
-    name: str       = None
-    author: str     = None
-    version: str    = None
-    module: str     = None
-    reference: type = None
+
+
+class InvalidPluginException(Exception):
+    ...
 
 
 class Plugins:
@@ -25,6 +24,8 @@ class Plugins:
         self._settings            = settings
         self._builder             = self._settings.get_builder()
         self._plugins_path        = self._settings.get_plugins_path()
+        self._keybindings         = self._settings.get_keybindings()
+
         self._plugins_dir_watcher = None
         self._plugin_collection   = []
 
@@ -48,33 +49,48 @@ class Plugins:
         print(f"Loading plugins...")
         parent_path = os.getcwd()
 
-        for file in os.listdir(self._plugins_path):
+        for path, folder in [[join(self._plugins_path, item), item] if os.path.isdir(join(self._plugins_path, item)) else None for item in os.listdir(self._plugins_path)]:
             try:
-                path = join(self._plugins_path, file)
-                if isdir(path):
-                    os.chdir(path)
+                target   = join(path, "plugin.py")
+                manifest = ManifestProcessor(path, self._builder)
 
-                    sys.path.insert(0, path)
-                    spec          = importlib.util.spec_from_file_location(file, join(path, "__main__.py"))
-                    app           = importlib.util.module_from_spec(spec)
-                    spec.loader.exec_module(app)
+                if not os.path.exists(target):
+                    raise InvalidPluginException("Invalid Plugin Structure: Plugin doesn't have 'plugin.py'. Aboarting load...")
 
-                    plugin_reference     = app.Plugin(self._builder, event_system)
-                    plugin               = Plugin()
-                    plugin.name          = plugin_reference.get_plugin_name()
-                    plugin.author        = plugin_reference.get_plugin_author()
-                    plugin.version       = plugin_reference.get_plugin_version()
-
-                    plugin.module        = path
-                    plugin.reference     = plugin_reference
-
-                    self._plugin_collection.append(plugin)
+                plugin, loading_data = manifest.get_loading_data()
+                module               = self.load_plugin_module(path, folder, target)
+                self.execute_plugin(module, plugin, loading_data)
             except Exception as e:
-                print("Malformed plugin! Not loading!")
+                print(f"Malformed Plugin: Not loading -->: '{folder}' !")
                 traceback.print_exc()
 
         os.chdir(parent_path)
 
 
+    def load_plugin_module(self, path, folder, target):
+        os.chdir(path)
+        sys.path.insert(0, path)  # NOTE: I think I'm not using this correctly...
+        # The folder and target aren't working to create parent package references, so using as stopgap.
+        # The above is probably polutling import logic and will cause unforseen import issues.
+        spec   = importlib.util.spec_from_file_location(folder, target)
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        return module
+
+
+    def execute_plugin(self, module: type, plugin: Plugin, loading_data: []):
+        plugin.reference = module.Plugin()
+        keys             = loading_data.keys()
+
+        if "pass_fm_events" in keys:
+            plugin.reference.set_fm_event_system(event_system)
+
+        if "bind_keys" in keys:
+            self._keybindings.append_bindings( loading_data["bind_keys"] )
+
+        plugin.reference.run()
+        self._plugin_collection.append(plugin)
+
     def reload_plugins(self, file: str = None) -> None:
         print(f"Reloading plugins... stub.")