loader missing

plugins/loader.py

@@ -0,0 +1,100 @@
+"""
+    implementing a plugin loader i.e can load a function from a file given parameters
+"""
+import importlib as IL
+import importlib.util
+import os
+import json
+import shutil
+import pandas as pd
+
+class Loader :
+    """
+    This class is intended to load a plugin and make it available and assess the quality of the developed plugin
+    """
+   
+    def __init__(self,**_args):
+        """
+        """
+        # _names = _args['names'] if 'names' in _args else None
+        # path = _args['path'] if 'path' in _args else None
+        # self._names = _names if type(_names) == list else [_names]
+        self._modules = {}
+        self._names = []
+        if 'file' in _args :
+            self.load(**_args)
+        # self._registry = _args['registry']
+
+    def load (self,**_args):
+        """
+        This function loads a plugin from a given location
+        :file   location of the file
+        """
+        self._modules = {}
+        self._names = []
+        path = _args ['file']
+        _decoratorName = None if 'decorator' not in _args else _args['decorator']
+        
+        if os.path.exists(path) :
+            _alias = path.split(os.sep)[-1]
+            spec = importlib.util.spec_from_file_location(_alias, path)
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module) #--loads it into sys.modules
+            for _name in dir(module) :
+                if self.isplugin(module,_name,_decoratorName) :
+                    self._modules[_name] = getattr(module,_name)
+        return self._modules is not None
+                    # self._names [_name]
+    # def format (self,**_args):
+    #     uri = _args['alias'],_args['name']
+    # def set(self,_pointer) :
+    def set(self,_key) :
+        """
+        This function will set a pointer to the list of modules to be called
+        This should be used within the context of using the framework as a library
+        """
+        if type(_key).__name__ == 'function':
+            #
+            # The pointer is in the code provided by the user and loaded in memory
+            #
+            _pointer = _key
+            _key = 'inline@'+_key.__name__
+            # self._names.append(_key.__name__)
+        else:
+            _pointer = self._registry.get(key=_key)
+
+        if _pointer  :
+            self._modules[_key] = _pointer
+            self._names.append(_key)
+        
+    def isplugin(self,module,name,attr=None):
+        """
+        This function determines if a module is a recognized plugin
+        :module     module object loaded from importlib
+        :name       name of the functiion of interest
+        :attr       decorator attribute name (if any)
+        """
+        
+        p = type(getattr(module,name)).__name__ =='function'
+        q = True if not attr else hasattr(getattr(module,name),attr)
+        #
+        # @TODO: add a generated key, and more indepth validation
+        return p and q
+    
+    def has(self,_name):
+        """
+        This will determine if the module name is loaded or not
+        """
+        return _name in self._modules 
+    def names (self):
+        return list(self._modules.keys())
+    def get (self,_name=None):
+        """
+        This functiion determines how many modules loaded vs unloaded given the list of names
+        """
+        return self._modules.get(_name,None) if _name else self._modules
+    def apply(self,_name,**_args):
+        _pointer = self.get(_name)
+        if _pointer :
+            return _pointer (**_args) if _args else _pointer()
+