Merge pull request #27 from NACLab/dev

Dev

Author: ago109

ngcsimlib/__init__.py

@@ -2,7 +2,7 @@
 from . import controller
 from . import commands
 
-import argparse, os, warnings, json
+import argparse, os, json
 from types import SimpleNamespace
 from importlib import import_module
 from ngcsimlib.configManager import init_config, get_config
@@ -17,9 +17,9 @@ def preload_modules(path=None):
     if path is None:
         module_config = get_config("modules")
         if module_config is None:
-            module_path = "json_files/modules.json"
+            module_path = None
         else:
-            module_path = module_config.get("module_path", "json_files/modules.json")
+            module_path = module_config.get("module_path", None)
 
         if module_path is None:
             return
@@ -37,16 +37,16 @@ def preload_modules(path=None):
 
     for module in modules:
         mod = import_module(module.absolute_path)
-        utils._Loaded_Modules[module.absolute_path] = mod
+        utils.modules._Loaded_Modules[module.absolute_path] = mod
 
         for attribute in module.attributes:
             atr = getattr(mod, attribute.name)
-            utils._Loaded_Attributes[attribute.name] = atr
+            utils.modules._Loaded_Attributes[attribute.name] = atr
 
-            utils._Loaded_Attributes[".".join([module.absolute_path, attribute.name])] = atr
+            utils.modules._Loaded_Attributes[".".join([module.absolute_path, attribute.name])] = atr
             if hasattr(attribute, "keywords"):
                 for keyword in attribute.keywords:
-                    utils._Loaded_Attributes[keyword] = atr
+                    utils.modules._Loaded_Attributes[keyword] = atr
 
     utils.set_loaded(True)
 

ngcsimlib/compartment.py

@@ -1,20 +1,26 @@
 from ngcsimlib.operations import BaseOp, overwrite
 from ngcsimlib.utils import Set_Compartment_Batch, get_current_path
+from ngcsimlib.logger import error
 import uuid
 
 
 class Compartment:
     """
-    Compartments in ngcsimlib are container objects for storing the stateful values of components. Compartments are
-    tracked globaly and are automatically linked to components and methods during compiling to allow for stateful
-    mechanics to be run without the need for the class object. Compartments also provide an entry and exit point for
-    values inside of components allowing for cables to be connected for sending and receiving values.
+    Compartments in ngcsimlib are container objects for storing the stateful
+    values of components. Compartments are
+    tracked globaly and are automatically linked to components and methods
+    during compiling to allow for stateful
+    mechanics to be run without the need for the class object. Compartments
+    also provide an entry and exit point for
+    values inside of components allowing for cables to be connected for
+    sending and receiving values.
     """
 
     @classmethod
     def is_compartment(cls, obj):
         """
-        A method for verifying if a provided object is a compartment. All compartments have `_is_compartment` set to
+        A method for verifying if a provided object is a compartment. All
+        compartments have `_is_compartment` set to
         true by default and this is
 
         Args:
@@ -25,14 +31,18 @@ def is_compartment(cls, obj):
         """
         return hasattr(obj, "_is_compartment")
 
-    def __init__(self, initial_value=None, static=False):
+    def __init__(self, initial_value=None, static=False, is_input=False):
         """
-        Builds a compartment to be used inside a component. It is important to note that building compartments
-        outside of components may cause unexpected behavior as components interact with their compartments during
+        Builds a compartment to be used inside a component. It is important
+        to note that building compartments
+        outside of components may cause unexpected behavior as components
+        interact with their compartments during
         construction to finish initializing them.
         Args:
-            initial_value: The initial value of the compartment. As a general practice it is a good idea to
-                provide a value that is similar to the values that will normally be stored here, such as an array of
+            initial_value: The initial value of the compartment. As a general
+            practice it is a good idea to
+                provide a value that is similar to the values that will
+                normally be stored here, such as an array of
                 zeros of the correct length. (default: None)
 
             static: a flag to lock a compartment to be static (default: False)
@@ -44,11 +54,14 @@ def __init__(self, initial_value=None, static=False):
         self._uid = uuid.uuid4()
         self.name = None
         self.path = None
+        self.is_input = is_input
+        self._is_destination = False
 
     def _setup(self, current_component, key):
         """
-        Finishes initializing the compartment, called by the component that builds the compartment
-        (Handel automatically)
+        Finishes initializing the compartment, called by the component that
+        builds the compartment
+        (Handled automatically)
         """
         self.__add_connection = current_component.add_connection
         self.name = current_component.name + "/" + key
@@ -57,14 +70,15 @@ def _setup(self, current_component, key):
 
     def set(self, value):
         """
-        Sets the value of the compartment if it not static (Raises a runtime error)
+        Sets the value of the compartment if it not static (Raises a runtime
+        error)
         Args:
              value: the new value to be set
         """
         if not self._static:
             self.value = value
         else:
-            raise RuntimeError("Can not assign value to static compartment")
+            error("Can not assign value to static compartment")
 
     def clamp(self, value):
         """
@@ -88,8 +102,10 @@ def __str__(self):
 
     def __lshift__(self, other) -> None:
         """
-        Overrides the left shift operation to be used for wiring compartments into one another
-        if other is not an Operation it will create an overwrite operation with other as the argument,
+        Overrides the left shift operation to be used for wiring compartments
+        into one another
+        if other is not an Operation it will create an overwrite operation
+        with other as the argument,
         otherwise it will use the provided operation
 
         Args:
@@ -102,3 +118,16 @@ def __lshift__(self, other) -> None:
             op = overwrite(other)
             op.set_destination(self)
             self.__add_connection(op)
+
+        self._is_destination = True
+
+    def is_wired(self):
+        """
+        Returns: if this compartment not marked as an input, or is marked and
+        has an input
+
+        """
+        if not self.is_input:
+            return True
+
+        return self._is_destination

ngcsimlib/compilers/command_compiler.py

@@ -66,18 +66,18 @@ def _compile(compile_key, components):
 
     for c_name, component in components.items():
         _, outs, args, params, comps = resolvers[c_name]
-        for _, a in args:
+        for a in args:
             if a not in needed_args:
                 needed_args.append(a)
 
         for connection in component.connections:
-            inputs, outputs = parse_connection(connection)
+            inputs, _ = parse_connection(connection)
             ncs = [str(i) for i in inputs]
             for nc in ncs:
                 if nc not in needed_comps:
                     needed_comps.append(nc)
 
-        for _, comp in comps:
+        for comp in comps:
             path = str(component.__dict__[comp].path)
             if path not in needed_comps:
                 needed_comps.append(path)

ngcsimlib/compilers/component_compiler.py

@@ -1,20 +1,24 @@
 """
 This is the file that contains the code to compile a component for a command.
 
-There are two primary method provided in this file. The first of them is the parse command. This command is designed
-to provide everything that is needed to compile the component down without actually doing so. This is generally used
-by the command compiler to produce a working list of everything that is needed prior to the actual compiling of all
-components.
-
-The second method that is provided in this file the actual method for compiling the component. This method takes in
-the component, the parsed component, and the global argument order for the compiled method. The result of this method
-is the execution order needed to be run to compute the compiled method over this component. This execution order is
-consistent with the same pattern used by the command compiler.
+There are two primary methods provided in this file. The first of them is the
+parse command. This command is designed to provide everything that is needed
+to compile the component down without actually doing so. This is generally
+used by the command compiler to produce a working list of everything that is
+needed prior to the actual compiling of all components.
+
+The second method that is provided in this file the actual method for
+compiling the component. This method takes in the component, the parsed
+component, and the global argument order for the compiled method. The result
+of this method is the execution order needed to be run to compute the
+compiled method over this component. This execution order is consistent with
+the same pattern used by the command compiler.
 
 """
 from ngcsimlib.compilers.op_compiler import compile as op_compile
 from ngcsimlib.utils import get_resolver
 from ngcsimlib.compartment import Compartment
+from ngcsimlib.logger import critical
 
 
 def parse(component, compile_key):
@@ -33,26 +37,36 @@ def parse(component, compile_key):
              the compartments needed
 
     """
-    (pure_fn, output_compartments), (args, parameters, compartments, parse_varnames) = \
+    (pure_fn, output_compartments), (
+        args, parameters, compartments, parse_varnames) = \
         get_resolver(component.__class__, compile_key)
 
     if parse_varnames:
         args = []
         parameters = []
         compartments = []
-        varnames = pure_fn.__func__.__code__.co_varnames[:pure_fn.__func__.__code__.co_argcount]
-
-        for idx, n in enumerate(varnames):
-            if n not in component.__dict__.keys():
-                args.append((idx, n))
-            elif Compartment.is_compartment(component.__dict__[n]):
-                compartments.append((idx, n))
+        varnames = pure_fn.__func__.__code__.co_varnames[
+                   :pure_fn.__func__.__code__.co_argcount]
+
+        for name in varnames:
+            if name not in component.__dict__.keys():
+                args.append(name)
+            elif Compartment.is_compartment(component.__dict__[name]):
+                compartments.append(name)
             else:
-                parameters.append((idx, n))
+                parameters.append(name)
 
         if output_compartments is None:
             output_compartments = compartments[:]
 
+        for comp in output_compartments:
+            if not Compartment.is_compartment(component.__dict__[comp]):
+                critical(
+                    f"When attempting to compile "
+                    f"\"{component.__class__.__name__}\", with the key "
+                    f"\"{compile_key}\", the located output value \"{comp}\" "
+                    f"is not a compartment object.")
+
     return (pure_fn, output_compartments, args, parameters, compartments)
 
 
@@ -76,13 +90,13 @@ def compile(component, resolver):
         exc_order.append(op_compile(connection))
 
     ### Component resolve
-    comp_ids = [str(component.__dict__[comp].path) for _, comp in comps]
+    comp_ids = [str(component.__dict__[comp].path) for comp in comps]
     out_ids = [str(component.__dict__[comp].path) for comp in outs]
 
-    funParams = {narg: component.__dict__[narg] for _, narg in (list(params))}
+    funParams = {narg: component.__dict__[narg] for narg in params}
 
     def compiled(**kwargs):
-        funArgs = {narg: kwargs.get(narg) for _, narg in (list(_args))}
+        funArgs = {narg: kwargs.get(narg) for narg in _args}
         funComps = {narg.split('/')[-1]: kwargs.get(narg) for narg in comp_ids}
 
         return pure_fn.__func__(**funParams, **funArgs, **funComps)

ngcsimlib/compilers/op_compiler.py

@@ -1,16 +1,20 @@
 """
-This file contains the logic needed to compile down an operation and produce an execution order that is compatible
-with the order found in the command compiler.
-
-This file contains two methods a parse and a compile method for operations. The parse method returns the metadata
-needed by the command compiler to know what values the operation will use.
-
-The second one is the compile method which returns the execution order for the compile operation. It is important to
-know that all operation should have an `is_compilable` flag set to true if they are compilable. Some operations such
-as the `add` operation are not compilable as their resolve method contains execution logic that will not be captured
-by the compiled command.
+This file contains the logic needed to compile down an operation and produce
+an execution order that is compatible with the order found in the command
+compiler.
+
+This file contains two methods a parse and a compile method for operations.
+The parse method returns the metadata needed by the command compiler to know
+what values the operation will use.
+
+The second one is the compile method which returns the execution order for
+the compile operation. It is important to know that all operation should have
+an `is_compilable` flag set to true if they are compilable. Some operations
+such as the `add` operation are not compilable as their resolve method
+contains execution logic that will not be captured by the compiled command.
 """
 from ngcsimlib.operations.baseOp import BaseOp
+from ngcsimlib.compartment import Compartment
 from ngcsimlib.logger import critical
 
 
@@ -24,19 +28,31 @@ def parse(op):
     Returns:
         the parsed operation
     """
-    assert op.is_compilable
+    assert op.is_compilable, ("Trying to compile an operation that is flagged "
+                              "as not compilable")
+    if op.destination is not None and not Compartment.is_compartment(
+        op.destination):
+        critical(
+            f"An operation that is being compiled has an invalid destination,"
+            f" {op.destination}")
+
     inputs = []
     for s in op.sources:
         if isinstance(s, BaseOp):
             needed_inputs, dest = parse(s)
             if dest is not None:
                 critical(
-                    "An operation with a destination compartment is being used as a source object for another "
+                    "An operation with a destination compartment is being "
+                    "used as a source object for another "
                     "operation")
             for inp in needed_inputs:
                 if inp not in inputs:
                     inputs.append(inp)
         else:
+            if not Compartment.is_compartment(s):
+                critical(
+                    "An operation has source that is not a compartment or "
+                    "instance of BaseOp")
             inputs.append(s.path)
 
     return inputs, op.destination.name if op.destination is not None else None