Merge branch 'transition' into dev

Author: willgebhardt

ngcsimlib/__init__.py

@@ -2,6 +2,7 @@
 from . import controller
 from . import commands
 
+
 import argparse, os, json
 from types import SimpleNamespace
 from importlib import import_module

ngcsimlib/compilers/__init__.py

@@ -1,3 +1,2 @@
-from .command_compiler import compile_command, dynamic_compile, wrap_command
-from .component_compiler import compile as compile_component
-from .op_compiler import compile as compile_op
+from .legacy_compiler.command_compiler import compile_command, dynamic_compile
+from .utils import wrap_command, compose

ngcsimlib/compilers/legacy_compiler/__init__.py

@@ -38,9 +38,9 @@
 passed in at run time.
 
 """
-from ngcsimlib.compilers.component_compiler import parse as parse_component, \
+from ngcsimlib.compilers.legacy_compiler.component_compiler import parse as parse_component, \
     compile as compile_component
-from ngcsimlib.compilers.op_compiler import parse as parse_connection
+from ngcsimlib.compilers.legacy_compiler.op_compiler import parse as parse_connection
 from ngcsimlib.utils import Get_Compartment_Batch, Set_Compartment_Batch
 from ngcsimlib.logger import critical
 
@@ -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:
@@ -158,22 +157,3 @@ def dynamic_compile(*components, compile_key=None):
     return _compile(compile_key, {c.name: c for c in components})
 
 
-def wrap_command(command):
-    """
-    Wraps the provided command to provide the state of all compartments as input
-    and saves the returned state to all compartments after running. Designed to
-    be used with compiled commands
-
-    Args:
-        command: the command to wrap
-
-    Returns:
-        the output of the command after it's been executed
-    """
-
-    def _wrapped(**kwargs):
-        vals = command(Get_Compartment_Batch(), **kwargs)
-        Set_Compartment_Batch(vals)
-        return vals
-
-    return _wrapped

ngcsimlib/compilers/command_compiler.py …lers/legacy_compiler/command_compiler.pyngcsimlib/compilers/command_compiler.py renamed to ngcsimlib/compilers/legacy_compiler/command_compiler.py ngcsimlib/compilers/command_compiler.py renamed to ngcsimlib/compilers/legacy_compiler/command_compiler.py

@@ -15,8 +15,8 @@
 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.compilers.legacy_compiler.op_compiler import compile as op_compile
+from ngcsimlib.utils import get_transition
 from ngcsimlib.compartment import Compartment
 from ngcsimlib.logger import critical
 
@@ -40,20 +40,25 @@ 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)
 
     if parse_varnames:
         args = []
         parameters = []
         compartments = []
-        varnames = pure_fn.__func__.__code__.co_varnames[
-                   :pure_fn.__func__.__code__.co_argcount]
+        try:
+            func = pure_fn.__func__
+        except:
+            func = pure_fn
+
+        varnames = func.__code__.co_varnames[
+                   :func.__code__.co_argcount]
 
         for name in varnames:
             if name not in component.__dict__.keys():
@@ -77,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:
@@ -104,11 +109,16 @@ def compile(component, resolver):
 
     comp_key_key = [(narg.split('/')[-1], narg) for narg in comp_ids]
 
+    try:
+        func = pure_fn.__func__
+    except:
+        func = pure_fn
+
     def compiled(**kwargs):
         funArgs = {narg: kwargs.get(narg) for narg in _args}
         funComps = {knarg: kwargs.get(narg) for knarg, narg in comp_key_key}
 
-        return pure_fn.__func__(**funParams, **funArgs, **funComps)
+        return func(**funParams, **funArgs, **funComps)
 
     exc_order.append((compiled, out_ids, component.name, comp_ids))
     return exc_order

ngcsimlib/compilers/component_compiler.py …rs/legacy_compiler/component_compiler.pyngcsimlib/compilers/component_compiler.py renamed to ngcsimlib/compilers/legacy_compiler/component_compiler.py ngcsimlib/compilers/component_compiler.py renamed to ngcsimlib/compilers/legacy_compiler/component_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/compilers/op_compiler.py …compilers/legacy_compiler/op_compiler.pyngcsimlib/compilers/op_compiler.py renamed to ngcsimlib/compilers/legacy_compiler/op_compiler.py ngcsimlib/compilers/op_compiler.py renamed to ngcsimlib/compilers/legacy_compiler/op_compiler.py

@@ -0,0 +1,49 @@
+from ngcsimlib.compilers.utils import compose
+from ngcsimlib.compilers.process_compiler.component_compiler import compile as compile_component
+from ngcsimlib.logger import warn
+from functools import wraps
+from ngcsimlib.utils import add_component_transition, add_transition_meta
+
+class Process(object):
+    def __init__(self):
+        self._method = None
+
+    @property
+    def pure(self):
+        return self._method
+
+    def __rshift__(self, other):
+        return self.transition(other)
+
+    def transition(self, transition_call):
+        new_step = compile_component(transition_call)
+        self._method = compose(self._method, new_step)
+        return self
+
+    def execute(self, current_state, **kwargs):
+        if self._method is None:
+            warn("Attempting to execute a process with no transition steps")
+            return
+        return self.pure(current_state, **kwargs)
+
+
+def transition(output_compartments):
+    def _wrapper(f):
+        @wraps(f)
+        def inner(*args, **kwargs):
+            return f(*args, **kwargs)
+
+        inner.fargs = f.__func__.__code__.co_varnames[:f.__func__.__code__.co_argcount]
+        inner.f = f
+        inner.output_compartments = output_compartments
+
+        class_name = ".".join(f.__qualname__.split('.')[:-1])
+        resolver_key = f.__qualname__.split('.')[-1]
+
+        add_component_transition(class_name, resolver_key,
+                               (f, output_compartments))
+
+        add_transition_meta(class_name, resolver_key,([], [], [], True))
+
+        return inner
+    return _wrapper

ngcsimlib/compilers/process.py

@@ -0,0 +1,51 @@
+from ngcsimlib.compilers.process_compiler.op_compiler import compile as op_compile
+from ngcsimlib.compartment import Compartment
+from ngcsimlib.compilers.utils import compose
+
+def compile(transition_method):
+    composition = None
+    component = transition_method.__self__
+
+    pure_fn = transition_method.f
+    output = transition_method.output_compartments
+
+    varnames = transition_method.fargs
+
+    args = []
+    compartments = []
+    parameters = []
+
+    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(name)
+
+    for conn in component.connections:
+        composition = compose(composition, op_compile(conn))
+
+    arg_methods = []
+    for a in args:
+        arg_methods.append((a, lambda current_state, **kwargs: kwargs.get(a, None)))
+
+    for p in parameters:
+        arg_methods.append((p, lambda current_state, **kwargs: component.__dict__.get(p, None)))
+
+    for c in compartments:
+        arg_methods.append((c, lambda current_state, **kwargs: current_state.get(component.__dict__[c].path, None)))
+
+    def compiled(current_state, **kwargs):
+        kargvals = {key: m(current_state, **kwargs) for key, m in arg_methods}
+        vals = pure_fn(**kargvals)
+        if len(output) > 1:
+            for v, o in zip(vals, output):
+                current_state[component.__dict__[o].path] = v
+        else:
+            current_state[component.__dict__[output[0]].path] = vals
+        return current_state
+
+    composition = compose(composition, compiled)
+
+    return composition

ngcsimlib/compilers/process_compiler/component_compiler.py

@@ -0,0 +1,29 @@
+from ngcsimlib.operations.baseOp import BaseOp
+
+def compile(op):
+    """
+        compiles the operation down to its execution order
+
+    Args:
+        op: the operation to compile
+
+    Returns:
+        the execution order needed to run this operation compiled
+    """
+    arg_methods = []
+    for s in op.sources:
+        if isinstance(s, BaseOp):
+            arg_methods.append(compile(s))
+        else:
+            arg_methods.append(lambda current_state, **kwargs: current_state[s.path])
+
+    def compiled(current_state, **kwargs):
+        argvals = [m(current_state, **kwargs) for m in arg_methods]
+        val = op.operation(*argvals)
+        if op.destination is not None:
+            current_state[op.destination.path] = val
+            return current_state
+        else:
+            return val
+
+    return compiled

ngcsimlib/compilers/process_compiler/op_compiler.py

@@ -0,0 +1,30 @@
+from ngcsimlib.utils.compartment import Get_Compartment_Batch, Set_Compartment_Batch
+
+
+def wrap_command(command):
+    """
+    Wraps the provided command to provide the state of all compartments as input
+    and saves the returned state to all compartments after running. Designed to
+    be used with compiled commands
+
+    Args:
+        command: the command to wrap
+
+    Returns:
+        the output of the command after it's been executed
+    """
+
+    def _wrapped(**kwargs):
+        vals = command(Get_Compartment_Batch(), **kwargs)
+        Set_Compartment_Batch(vals)
+        return vals
+
+    return _wrapped
+
+
+def compose(current_composition, next_method):
+    if current_composition is None:
+        return next_method
+
+    return lambda current_state, **kwargs: next_method(
+        current_composition(current_state, **kwargs), **kwargs)