Refactor resolver

Changed the language to reference transitions not resolvers

Author: willgebhardt

ngcsimlib/compilers/command_compiler.py

@@ -61,8 +61,7 @@ def _compile(compile_key, components):
     | resolve the outputs of the compiled function
 
     Args:
-        compile_key: The key that is being compiled (mapped to each function
-        that has the @resolver decorator above it)
+        compile_key: The key for the transition that is being compiled
 
         components: The list of components to compile for this function
 
@@ -71,15 +70,15 @@ def _compile(compile_key, components):
     """
     assert compile_key is not None
     ## for each component, get compartments, get output compartments
-    resolvers = {}
+    transitions = {}
     for c_name, component in components.items():
-        resolvers[c_name] = parse_component(component, compile_key)
+        transitions[c_name] = parse_component(component, compile_key)
 
     needed_args = []
     needed_comps = []
 
     for c_name, component in components.items():
-        _, outs, args, params, comps = resolvers[c_name]
+        _, outs, args, params, comps = transitions[c_name]
         for a in args:
             if a not in needed_args:
                 needed_args.append(a)
@@ -98,7 +97,7 @@ def _compile(compile_key, components):
 
     exc_order = []
     for c_name, component in components.items():
-        exc_order.extend(compile_component(component, resolvers[c_name]))
+        exc_order.extend(compile_component(component, transitions[c_name]))
 
     def compiled(compartment_values=None, **kwargs):
         if compartment_values is None:

ngcsimlib/compilers/component_compiler.py

@@ -16,7 +16,7 @@
 
 """
 from ngcsimlib.compilers.op_compiler import compile as op_compile
-from ngcsimlib.utils import get_resolver
+from ngcsimlib.utils import get_transition
 from ngcsimlib.compartment import Compartment
 from ngcsimlib.logger import critical
 
@@ -40,11 +40,11 @@ def parse(component, compile_key):
     if component.__class__.__dict__.get("auto_resolve", True):
         (pure_fn, output_compartments), (
             args, parameters, compartments, parse_varnames) = \
-            get_resolver(component.__class__, compile_key)
+            get_transition(component.__class__, compile_key)
     else:
         build_method = component.__class__.__dict__.get(f"build_{compile_key}", None)
         if build_method is None:
-            critical(f"Component {component.name} if flagged to not use resolvers but "
+            critical(f"Component {component.name} if flagged to not use a stored transition but "
                      f"does not have a build_{compile_key} method")
         return build_method(component)
 
@@ -82,20 +82,20 @@ def parse(component, compile_key):
     return (pure_fn, output_compartments, args, parameters, compartments)
 
 
-def compile(component, resolver):
+def compile(component, transition):
     """
         compiles down the component to a single pure method
 
     Args:
         component: the component to compile
 
-        resolver: the parsed output of the component
+        transition: the parsed output of the component
 
     Returns:
         the compiled method
     """
     exc_order = []
-    pure_fn, outs, _args, params, comps = resolver
+    pure_fn, outs, _args, params, comps = transition
 
     ### Op resolve
     for connection in component.connections:

ngcsimlib/compilers/op_compiler.py

@@ -10,7 +10,7 @@
 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
+such as the `add` operation are not compilable as their transition method
 contains execution logic that will not be captured by the compiled command.
 """
 from ngcsimlib.operations.baseOp import BaseOp

ngcsimlib/operations/baseOp.py

@@ -13,7 +13,7 @@ class BaseOp(ABC):
 
     For commands that can be compiled using ngcsimlib's compiler, all their
     operational logic must be contained inside the subclass's operation
-    method. This also means that the resolve  method that is defined on the
+    method. This also means that the transition method that is defined on the
     base class should not be overwritten.
 
     For commands that do not need to be compiled using ngcsimlib's compiler

ngcsimlib/resolver.py

@@ -1,4 +1,6 @@
 """
+Todo: rewrite to have this be the less favorable option
+
 The resolver is an important part of the compiling of components and commands
 in the ngcsimlib compilers.
 
@@ -38,7 +40,7 @@
 """
 
 from ngcsimlib.compartment import Compartment
-from ngcsimlib.utils import add_component_resolver, add_resolver_meta
+from ngcsimlib.utils import add_component_transition, add_transition_meta
 
 
 def resolver(pure_fn,
@@ -99,10 +101,10 @@ def _resolver(fn):
         class_name = ".".join(fn.__qualname__.split('.')[:-1])
         resolver_key = fn.__qualname__.split('.')[-1]
 
-        add_component_resolver(class_name, resolver_key,
+        add_component_transition(class_name, resolver_key,
                                (pure_fn, output_compartments))
 
-        add_resolver_meta(class_name, resolver_key,
+        add_transition_meta(class_name, resolver_key,
                           (args, parameters, compartments, parse_varnames))
 
         def _wrapped(self=None, *_args, **_kwargs):

ngcsimlib/transition.py

@@ -1,5 +1,5 @@
 from ngcsimlib.logger import warn
-from ngcsimlib.utils import add_component_resolver, add_resolver_meta
+from ngcsimlib.utils import add_component_transition, add_transition_meta
 
 def add_transition(pure_fn, cls, output_compartments=None, transition_key=None):
     if output_compartments is None:
@@ -8,9 +8,9 @@ def add_transition(pure_fn, cls, output_compartments=None, transition_key=None):
     key = pure_fn.__qualname__.split('.')[-1] if transition_key is None else transition_key
 
     class_name = cls.__qualname__
-    add_component_resolver(class_name, key,
+    add_component_transition(class_name, key,
                            (pure_fn, output_compartments))
-    add_resolver_meta(class_name, key,
+    add_transition_meta(class_name, key,
                       (None, None, None, True))
 
 

ngcsimlib/utils/__init__.py

@@ -3,5 +3,5 @@
 from .io import *
 from .misc import *
 from .modules import *
-from .resolvers import *
+from .transitions import *
 from .help import *

ngcsimlib/utils/resolvers.py

@@ -0,0 +1,71 @@
+from ngcsimlib.logger import critical, debug
+
+__component_transitions = {}
+__transition_meta_data = {}
+
+
+def get_transition(klass, transition_key, root=None):
+    """
+    A helper method for searching through the transition list
+    """
+    class_name = klass.__name__
+
+    if class_name + "/" + transition_key not in __component_transitions.keys():
+        parent_classes = klass.__bases__
+        if len(parent_classes) == 0:
+            return None, None
+
+        transition = None
+        for parent in parent_classes:
+            transition, meta = get_transition(parent, transition_key,
+                                            root=klass if root is None else root)
+            if transition is not None:
+                return transition, meta
+
+        if transition is None and root is None:
+            critical(class_name, "has no transition for", transition_key)
+        if transition is None:
+            return None, None
+
+    if root is not None:
+        debug(
+            f"{root.__name__} is using the transition from {class_name} for "
+            f"resolving key \"{transition_key}\"")
+    return __component_transitions[class_name + "/" + transition_key], \
+        __transition_meta_data[class_name + "/" + transition_key]
+
+
+def add_component_transition(class_name, transition_key, data):
+    """
+    A helper function for adding component transitions
+    """
+    __component_transitions[class_name + "/" + transition_key] = data
+
+
+def add_transition_meta(class_name, transition_key, data):
+    """
+    A helper function for adding component transition metadata
+    """
+    __transition_meta_data[class_name + "/" + transition_key] = data
+
+
+def using_transition(**kwargs):
+    """
+    A decorator for linking transitions defined in other classes to this class.
+    the keyword arguments are compile_key=class_to_inherit_transition_from. This
+    will add the transition directly to the class and thus will get used before
+    any transitions in parent classes.
+
+    Args:
+        **kwargs:  any number or compile_key=class_to_inherit_transition_from
+    """
+
+    def _klass_wrapper(cls):
+        klass_name = cls.__name__
+        for key, value in kwargs.items():
+            transition, data = get_transition(value, key)
+            add_component_transition(klass_name, key, transition)
+            add_transition_meta(klass_name, key, data)
+        return cls
+
+    return _klass_wrapper