Allowed for custom process classes

Updated processes to track needed kwargs, and to allow for custom process classes to be used

Author: willgebhardt

ngcsimlib/__init__.py

@@ -8,6 +8,7 @@
 from ngcsimlib.configManager import init_config, get_config
 from ngcsimlib.logger import warn
 from pkg_resources import get_distribution
+from ngcsimlib.compilers.process import Process, transition
 
 __version__ = get_distribution('ngcsimlib').version  ## set software version
 
@@ -36,17 +37,21 @@ def preload_modules(path=None):
         modules = json.load(file, object_hook=lambda d: SimpleNamespace(**d))
 
     for module in modules:
-        mod = import_module(module.absolute_path)
-        utils.modules._Loaded_Modules[module.absolute_path] = mod
+        load_module(module)
 
-        for attribute in module.attributes:
-            atr = getattr(mod, attribute.name)
-            utils.modules._Loaded_Attributes[attribute.name] = atr
+def load_module(module):
+    mod = import_module(module.absolute_path)
+    utils.modules._Loaded_Modules[module.absolute_path] = mod
 
-            utils.modules._Loaded_Attributes[".".join([module.absolute_path, attribute.name])] = atr
-            if hasattr(attribute, "keywords"):
-                for keyword in attribute.keywords:
-                    utils.modules._Loaded_Attributes[keyword] = atr
+    for attribute in module.attributes:
+        atr = getattr(mod, attribute.name)
+        utils.modules._Loaded_Attributes[attribute.name] = atr
+
+        utils.modules._Loaded_Attributes[
+            ".".join([module.absolute_path, attribute.name])] = atr
+        if hasattr(attribute, "keywords"):
+            for keyword in attribute.keywords:
+                utils.modules._Loaded_Attributes[keyword] = atr
 
 ###### Initialize Config
 def configure():

ngcsimlib/compilers/process.py

@@ -10,15 +10,18 @@ def __init__(self, name):
         self._method = None
         self._calls = []
         self.name = name
+        self._needed_args = set([])
         self._needed_contexts = set([])
 
         cc = get_current_context()
         if cc is not None:
             cc.register_process(self)
 
     @staticmethod
-    def make_process(process_spec):
-        newProcess = Process(process_spec['name'])
+    def make_process(process_spec, custom_process_klass=None):
+        if custom_process_klass is None:
+            custom_process_klass = Process
+        newProcess = custom_process_klass(process_spec['name'])
 
         for x in process_spec['calls']:
             path = x['path']
@@ -37,21 +40,31 @@ def __rshift__(self, other):
     def transition(self, transition_call):
         self._calls.append({"path": transition_call.__self__.path, "key": transition_call.resolver_key})
         self._needed_contexts.add(infer_context(transition_call.__self__.path))
-        new_step = compile_component(transition_call)
+        new_step, new_args = compile_component(transition_call)
+
+        for arg in new_args:
+            self._needed_args.add(arg)
         self._method = compose(self._method, new_step)
         return self
 
     def execute(self, update_state=False, **kwargs):
         if self._method is None:
             warn("Attempting to execute a process with no transition steps")
             return
+        for arg in self._needed_args:
+            if arg not in kwargs.keys():
+                warn("Missing kwarg", arg, "in kwargs for Process", self.name)
+            return
         state = self.pure(self.get_required_state(include_special_compartments=True), **kwargs)
         if update_state:
             self.updated_modified_state(state)
         return state
 
     def as_obj(self):
-        return {"name": self.name, "calls": self._calls}
+        return {"name": self.name, "class": self.__class__.__name__, "calls": self._calls}
+
+    def get_required_args(self):
+        return self._needed_args
 
     def get_required_state(self, include_special_compartments=False):
         compound_state = {}

ngcsimlib/compilers/process_compiler/component_compiler.py

@@ -47,8 +47,9 @@ def compile(transition_method):
         composition = compose(composition, op_compile(conn))
 
     arg_methods = []
-
+    needed_args = []
     for a in args:
+        needed_args.append(a)
         arg_methods.append((a, __make_get_arg(a)))
 
     for p in parameters:
@@ -69,4 +70,4 @@ def compiled(current_state, **kwargs):
 
     composition = compose(composition, compiled)
 
-    return composition
+    return composition, needed_args

ngcsimlib/context.py

@@ -478,10 +478,10 @@ def _make_op(self, op_spec):
     def make_process(self, path_to_process_file):
         with open(path_to_process_file, 'r') as file:
             process_spec = json.load(file)
-
-            all_processes = [Process.make_process(p) for p in process_spec]
-            for p in all_processes:
-                self.__setattr__(p.name, p)
+            for p in process_spec:
+                klass = load_from_path(p["class"])
+                process = Process.make_process(p, klass)
+                self.__setattr__(process.name, process)
 
     @staticmethod
     def dynamicCommand(fn):
@@ -584,6 +584,13 @@ def make_modules(self):
                                 modules[module]["attributes"]):
                 modules[module]["attributes"].append({"name": klass})
 
+        jProcesses = self._json_objects['processes']
+        for process in jProcesses:
+            mod = process.__class__.__module__
+            klass = process.__class__.__name__
+            modules[mod] = {"attributes": []}
+            modules[mod]["attributes"].append({"name": klass})
+
         _modules = []
         for key, value in modules.items():
             _modules.append(