Feat/control signal/add control arg

psyneulink/core/components/mechanisms/modulatory/control/controlmechanism.py

@@ -1210,6 +1210,9 @@ class Parameters(ModulatoryMechanism_Base.Parameters):
             constructor_argument='control'
         )
 
+        # MODIFIED 1/2/22 OLD: - MUCH OF THIS SEEMS TO BE COVERED ELSEWHERE; COMMENTING OUT ONLY CAUSES PROBLEMS WITH
+        #                        test_control_signal_and_control_projection_names AND
+        #                        test_json_results_equivalence (stroop_conflict_monitoring_py)
         def _parse_output_ports(self, output_ports):
             def is_2tuple(o):
                 return isinstance(o, tuple) and len(o) == 2
@@ -1231,19 +1234,28 @@ def is_2tuple(o):
                         MECHANISM: output_ports[i][1]
                     }
                 # handle dict of form {PROJECTIONS: <2 item tuple>, <param1>: <value1>, ...}
-                elif (
-                    isinstance(output_ports[i], dict)
-                    and PROJECTIONS in output_ports[i]
-                    and is_2tuple(output_ports[i][PROJECTIONS])
-                ):
-                    full_spec_dict = {
-                        NAME: output_ports[i][PROJECTIONS][0],
-                        MECHANISM: output_ports[i][PROJECTIONS][1],
-                        **{k: v for k, v in output_ports[i].items() if k != PROJECTIONS}
-                    }
-                    output_ports[i] = full_spec_dict
+                elif isinstance(output_ports[i], dict):
+                    # Handle CONTROL as synonym of PROJECTIONS
+                    if CONTROL in output_ports[i]:
+                        # MODIFIED 1/3/22 NEW:
+                        # CONTROL AND PROJECTIONS can't both be used
+                        if PROJECTIONS in output_ports[i]:
+                            raise ControlMechanismError(f"Both 'CONTROL' and 'PROJECTIONS' entries found in "
+                                                        f"specification dict for {ControlSignal.__name__} of "
+                                                        f"'{self.name}': ({output_ports[i]}).")
+                        # MODIFIED 1/3/22 END
+                        # Replace CONTROL with PROJECTIONS
+                        output_ports[i][PROJECTIONS] = output_ports[i].pop(CONTROL)
+                    if (PROJECTIONS in output_ports[i] and is_2tuple(output_ports[i][PROJECTIONS])):
+                        full_spec_dict = {
+                            NAME: output_ports[i][PROJECTIONS][0],
+                            MECHANISM: output_ports[i][PROJECTIONS][1],
+                            **{k: v for k, v in output_ports[i].items() if k != PROJECTIONS}
+                        }
+                        output_ports[i] = full_spec_dict
 
             return output_ports
+        # MODIFIED 1/2/22 END
 
         def _validate_input_ports(self, input_ports):
             if input_ports is None:

psyneulink/core/components/mechanisms/modulatory/control/gating/gatingmechanism.py

@@ -187,7 +187,7 @@
 from psyneulink.core.components.ports.modulatorysignals.gatingsignal import GatingSignal
 from psyneulink.core.globals.defaults import defaultGatingAllocation
 from psyneulink.core.globals.keywords import \
-    GATING, GATING_PROJECTION, GATING_SIGNAL, GATING_SIGNALS, \
+    GATE, GATING, GATING_PROJECTION, GATING_SIGNAL, GATING_SIGNALS, \
     INIT_EXECUTE_METHOD_ONLY, MONITOR_FOR_CONTROL, PROJECTION_TYPE
 from psyneulink.core.globals.parameters import Parameter
 from psyneulink.core.globals.preferences.basepreferenceset import is_pref_set
@@ -399,6 +399,13 @@ class Parameters(ControlMechanism.Parameters):
                     :default value: numpy.array([0.5])
                     :type: ``numpy.ndarray``
 
+                output_ports
+                    see `output_ports <Mechanism_Base.output_ports>`
+
+                    :default value: None
+                    :type:
+                    :read only: True
+
                 gating_allocation
                     see `gating_allocation <GatingMechanism.gating_allocation>`
 
@@ -413,6 +420,63 @@ class Parameters(ControlMechanism.Parameters):
             pnl_internal=True
         )
 
+        output_ports = Parameter(
+            None,
+            stateful=False,
+            loggable=False,
+            read_only=True,
+            structural=True,
+            parse_spec=True,
+            aliases=['control', 'control_signals', 'gate', 'gating_signal'],
+            constructor_argument='gate'
+        )
+
+        def _parse_output_ports(self, output_ports):
+            from psyneulink.core.globals.keywords import NAME, MECHANISM, PROJECTIONS
+            # # FIX: 1/2/22 - ANY WAY TO CALL SUPER TO CALL ControlMechanism.parameters.output_ports._parse_output_ports
+            # super().output_ports._parse_output_ports(output_ports)
+
+            def is_2tuple(o):
+                return isinstance(o, tuple) and len(o) == 2
+
+            if not isinstance(output_ports, list):
+                output_ports = [output_ports]
+
+            for i in range(len(output_ports)):
+                # handle 2-item tuple
+                if is_2tuple(output_ports[i]):
+
+                    # this is an odd case that uses two names in the name entry
+                    # unsure what it means
+                    if isinstance(output_ports[i][0], list):
+                        continue
+
+                    output_ports[i] = {
+                        NAME: output_ports[i][0],
+                        MECHANISM: output_ports[i][1]
+                    }
+                # handle dict of form {PROJECTIONS: <2 item tuple>, <param1>: <value1>, ...}
+                elif isinstance(output_ports[i], dict):
+                    # Handle GATE as synonym of PROJECTIONS
+                    if GATE in output_ports[i]:
+                        # GATE AND PROJECTIONS can't both be used
+                        if PROJECTIONS in output_ports[i]:
+                            raise GatingMechanismError(f"Both 'PROJECTIONS' and 'GATE' entries found in "
+                                                        f"specification dict for {GatingSignal.__name__} of "
+                                                       f"'{self.name}': ({output_ports[i]}).")
+                        # Replace GATE with PROJECTIONS
+                        output_ports[i][PROJECTIONS] = output_ports[i].pop(GATE)
+                    if (PROJECTIONS in output_ports[i] and is_2tuple(output_ports[i][PROJECTIONS])):
+                        full_spec_dict = {
+                            NAME: output_ports[i][PROJECTIONS][0],
+                            MECHANISM: output_ports[i][PROJECTIONS][1],
+                            **{k: v for k, v in output_ports[i].items() if k != PROJECTIONS}
+                        }
+                        output_ports[i] = full_spec_dict
+
+            return output_ports
+
+
     @tc.typecheck
     def __init__(self,
                  default_gating_allocation=None,

psyneulink/core/components/mechanisms/modulatory/control/optimizationcontrolmechanism.py

@@ -582,20 +582,16 @@
 which is used to compute the `net_outcome <ControlMechanism.net_outcome>` of executing its `agent_rep
 <OptimizationControlMechanism.agent_rep>`.
 
-COMMENT:
-    FIX: 1/1/22
     .. note::
-        , and the `allow_probes
-        <Composition.allow_probes>` attribute of the Composition for which the OptimizationControlMechanism is the
-        `controller <Composition.controller>`. The latter allows the values of the items listed in `monitor_for_control
-        <ControlMechanism.monitor_for_control>` to be `INPUT <NodeRole.INTERNAL>` or `INTERNAL <NodeRole.INTERNAL>` `Nodes
-        <Composition_Nodes>` of a `nested Composition <Composition_Nested>` to be monitored and included in the computation
-        of `outcome <ControlMechanism.outcome>` (ordinarily, those must be `OUTPUT <NodeRole.OUTPUT>` Nodes of a nested
-        Composition).  This can be thought of as providing access to "latent variables" of the Composition being evaluated;
-        that is, ones that do not contribute directly to the Composition's `results <Composition_Execution_Results>`. This
-        applies both to items that are monitored directly by the OptimizationControlMechanism or via its ObjectiveMechanism.
-COMMENT
-
+       If a `Node <Composition_Nodes>` other than an `OUTPUT <NodeRole.OUTPUT>` of a `nested <Composition_Nested>`
+       Composition is `specified to be monitored <ControlMechanism_Monitor_for_Control>`, it is assigned as a `PROBE
+       <NodeRole.PROBE>` of that nested Composition. Although `PROBE <NodeRole.PROBE>` Nodes are generally treated
+       like `OUTPUT <NodeRole.OUTPUT>` Nodes (since they project out of the Composition to which they belong), their
+       `value <Mechanism_Base.value>` is not included in the `output_values <Composition.output_values>` or `results
+       <Composition.results>` attributes of the Composition for which the OptimizationControlMechanism is the
+       `controller <Composition.controller>`, unless that Composition's `include_probes_in_output
+       <Composition.include_probes_in_output>` attribute is set to True (see `Composition_Probes` for additional
+       information).
 
 .. _OptimizationControlMechanism_Function:
 
@@ -2322,14 +2318,6 @@ def _gen_llvm_output_port_parse_variable(self, ctx, builder, params, context, va
         builder.store(builder.load(val_ptr), dest_ptr)
         return oport_input
 
-    # Deprecated - this is now a Parameter
-    # @property
-    # def state_feature_values(self):
-    #     if hasattr(self.agent_rep, 'model_based_optimizer') and self.agent_rep.model_based_optimizer is self:
-    #         return self.agent_rep._get_predicted_input()
-    #     else:
-    #         return np.array(np.array(self.variable[1:]).tolist())
-
     @property
     def agent_rep_type(self):
         from psyneulink.core.compositions.compositionfunctionapproximator import CompositionFunctionApproximator