Refactor/state and projection/specification bug fix 2

Scripts/DEMO SCRIPTS/documentation_examples.py

@@ -186,9 +186,9 @@ def mechanisms():
     # FIXME: ObjectiveMechanismError: "PROGRAM ERROR: call to
     # State._parse_state_spec() for OutputState of ComparatorMechanism-1
     # should have returned dict or State, but returned <class 'str'> instead"
-    my_comparator_mech = ComparatorMechanism(sample=my_action_select_mech,
-                                             target=my_reward_mech,
-                                             input_states=[[0], [0]])
+    my_comparator_mech = ComparatorMechanism(default_variable = [[0], [0]],
+                                             sample=my_action_select_mech,
+                                             target=my_reward_mech)
     # which function keyword argument description is correct?
     # endregion
 

Scripts/Models/GilzenratModel.py

@@ -14,6 +14,8 @@
 from psyneulink.components.process import Process
 from psyneulink.components.system import System
 from psyneulink.library.subsystems.agt.lccontrolmechanism import LCControlMechanism
+from psyneulink.components.projections.pathway.mappingprojection import MappingProjection
+from psyneulink.globals.keywords import PROJECTION_TYPE, RECEIVER, SENDER, MATRIX
 
 # --------------------------------- Global Variables ----------------------------------------
 
@@ -38,7 +40,8 @@
 
 # numerical integration
 time_step_size = 0.02
-number_of_trials = int(20/time_step_size)
+# number_of_trials = int(20/time_step_size)
+number_of_trials = 1
 
 # noise
 standard_deviation = 0.22*(time_step_size**0.5)
@@ -99,7 +102,9 @@
         objective_mechanism=ObjectiveMechanism(
                                     function=Linear,
                                     monitored_output_states=[(decision_layer, None, None, np.array([[0.3],[0.0]]))],
-                                    input_states=[[0]],
+                                    # monitored_output_states=[{PROJECTION_TYPE: MappingProjection,
+                                    #                           SENDER: decision_layer,
+                                    #                           MATRIX: np.array([[0.3],[0.0]])}],
                                     name='LC ObjectiveMechanism'
         ),
         modulated_mechanisms=[decision_layer, response],

psyneulink/components/component.py

@@ -350,7 +350,8 @@ class `UserList <https://docs.python.org/3.6/library/collections.html?highlight=
 from psyneulink.globals.log import Log
 from psyneulink.globals.preferences.componentpreferenceset import ComponentPreferenceSet, kpVerbosePref
 from psyneulink.globals.preferences.preferenceset import PreferenceEntry, PreferenceLevel, PreferenceSet
-from psyneulink.globals.utilities import ContentAddressableList, ReadOnlyOrderedDict, convert_to_np_array, is_same_function_spec, iscompatible, kwCompatibilityLength
+from psyneulink.globals.utilities import ContentAddressableList, ReadOnlyOrderedDict, convert_to_np_array, \
+    is_same_function_spec, iscompatible, kwCompatibilityLength, is_matrix
 
 __all__ = [
     'Component', 'COMPONENT_BASE_CLASS', 'component_keywords', 'ComponentError', 'ComponentLog', 'ExecutionStatus',
@@ -2080,7 +2081,6 @@ def _validate_params(self, request_set, target_set=None, context=None):
 
             # Check if param value is of same type as one with the same name in paramClassDefaults;
             #    don't worry about length
-
             if iscompatible(param_value, self.paramClassDefaults[param_name], **{kwCompatibilityLength:0}):
                 # If param is a dict, check that entry exists in paramClassDefaults
                 # IMPLEMENTATION NOTE:
@@ -2161,16 +2161,27 @@ def _validate_params(self, request_set, target_set=None, context=None):
             elif hasattr(param_value, FUNCTION) and callable(param_value.function):
                 target_set[param_name] = param_value
 
+            # It has already passed as the name of a valid param, so let it pass;
+            #    value should be validated in subclass _validate_params override
+            elif isinstance(param_name, str):
+                # FIX: 10/3/17 - THIS IS A HACK;  IT SHOULD BE HANDLED EITHER
+                # FIX:           MORE GENERICALLY OR LOCALLY (E.G., IN OVERRIDE OF _validate_params)
+                if param_name == 'matrix':
+                    if is_matrix(self.paramClassDefaults[param_name]):
+                        # FIX:  ?? ASSIGN VALUE HERE, OR SIMPLY ALLOW AND ASSUME IT WILL BE PARSED ELSEWHERE
+                        # param_value = self.paramClassDefaults[param_name]
+                        # target_set[param_name] = param_value
+                        target_set[param_name] = param_value
+                    else:
+                        raise ComponentError("Value of {} param for {} ({}) must be a valid matrix specification".
+                                             format(param_name, self.name, param_value))
+                target_set[param_name] = param_value
+
             # Parameter is not a valid type
             else:
                 if type(self.paramClassDefaults[param_name]) is type:
                     type_name = 'the name of a subclass of ' + self.paramClassDefaults[param_name].__base__.__name__
-                else:
-                    type_name = self.paramClassDefaults[param_name].__class__.__name__
-                if param_name == 'matrix':
-                    raise ComponentError("Value of {} param for {} ({}) must be a valid matrix specification".
-                                    format(param_name, self.name, param_value))
-                raise ComponentError("Value of {} param for {} ({}) must be compatible with {}".
+                raise ComponentError("Value of {} param for {} ({}) is not compatible with {}".
                                     format(param_name, self.name, param_value, type_name))
 
     def _get_param_value_from_tuple(self, param_spec):

psyneulink/components/mechanisms/processing/objectivemechanism.py

@@ -418,7 +418,8 @@
 from psyneulink.components.mechanisms.processing.processingmechanism import ProcessingMechanism_Base
 from psyneulink.components.states.outputstate import OutputState, PRIMARY_OUTPUT_STATE, standard_output_states
 from psyneulink.components.states.state import _parse_state_spec
-from psyneulink.globals.keywords import CONTROL, EXPONENTS, FUNCTION, INPUT_STATES, LEARNING, MATRIX, OBJECTIVE_MECHANISM, SENDER, TIME_SCALE, VARIABLE, WEIGHTS, kwPreferenceSetName, DEFAULT_MATRIX
+from psyneulink.globals.keywords import CONTROL, EXPONENTS, FUNCTION, INPUT_STATES, LEARNING, MATRIX, \
+    OBJECTIVE_MECHANISM, SENDER, TIME_SCALE, VARIABLE, WEIGHTS, kwPreferenceSetName, DEFAULT_MATRIX, DEFAULT_VARIABLE
 from psyneulink.globals.preferences.componentpreferenceset import is_pref_set, kpReportOutputPref
 from psyneulink.globals.preferences.preferenceset import PreferenceEntry, PreferenceLevel
 from psyneulink.globals.utilities import ContentAddressableList
@@ -640,7 +641,7 @@ class ClassDefaults(ProcessingMechanism_Base.ClassDefaults):
     # FIX:  TYPECHECK MONITOR TO LIST OR ZIP OBJECT
     @tc.typecheck
     def __init__(self,
-                 input_states=None,
+                 default_variable=None,
                  function=LinearCombination,
                  output_states:tc.optional(tc.any(list, dict))=[OUTCOME],
                  params=None,
@@ -651,16 +652,38 @@ def __init__(self,
 
         if MONITORED_OUTPUT_STATES in kwargs and kwargs[MONITORED_OUTPUT_STATES] is not None:
             name_string = name or 'an ' + ObjectiveMechanism.__name__
-            if input_states:
-                # warnings.warn("Both \'{}\' and \'{}\' args were specified in constuctor for {}; "
-                #               "an attempt will be made to merge them but this may produce unexpected results.".
-                #               format(MONITORED_OUTPUT_STATES, INPUT_STATES, name_string))
-                input_states.append(kwargs[MONITORED_OUTPUT_STATES])
+            # FIX: 10/26/17: TRY TO INTEGRATE input_states AND monitored_output_states
+            # FIX:           OR DOCUMENT OTHERWISE (I.E., USE OF default_variable
+            # if input_states:
+            #     raise ObjectiveMechanismError("Both \'{}\' and \'{}\' args were specified in constuctor for {}.".
+            #                                   format(MONITORED_OUTPUT_STATES, INPUT_STATES, name_string))
+            #     # warnings.warn("Both \'{}\' and \'{}\' args were specified in constuctor for {}; "
+            #     #               "an attempt will be made to merge them but this may produce unexpected results.".
+            #     #               format(MONITORED_OUTPUT_STATES, INPUT_STATES, name_string))
+            #     # if not len(input_states) == len(kwargs[MONITORED_OUTPUT_STATES]):
+            #     #     raise ObjectiveMechanismError("The {} arg specified for {} ({}) must be the same length as {} ({})".
+            #     #                                   format(INPUT_STATES,name,input_states,
+            #     #                                          MONITORED_OUTPUT_STATES,
+            #     #                                          kwargs[MONITORED_OUTPUT_STATES] ))
             input_states = kwargs[MONITORED_OUTPUT_STATES]
             del kwargs[MONITORED_OUTPUT_STATES]
             if kwargs:
+                if INPUT_STATES in kwargs:
+                    raise ObjectiveMechanismError("\'{}\' argument is not supported for an {} "
+                                                  "(found in constructor for: \'{}\'); \'{}\' should be used instead".
+                                                  format(INPUT_STATES,
+                                                         self.__class__.__name__,
+                                                         name_string,
+                                                         MONITORED_OUTPUT_STATES))
+                # if DEFAULT_VARIABLE in kwargs:
+                #     raise ObjectiveMechanismError("\'{}\' argument is not supported for an {} "
+                #                                   "(found in constructor for: \'{}\'); \'{}\' should be used instead".
+                #                                   format(INPUT_STATES,
+                #                                          self.__class__.__name__,
+                #                                          name_string,
+                #                                          MONITORED_OUTPUT_STATES))
                 raise ObjectiveMechanismError("\'Invalid arguments used in constructor for {}".
-                                              format(kwargs.keys(), name_string))
+                                              format(kwargs.keys(), name))
 
         # Assign args to params and functionParams dicts (kwConstants must == arg names)
         params = self._assign_args_to_param_dicts(input_states=input_states,
@@ -676,7 +699,7 @@ def __init__(self,
                                                                self.standard_output_states,
                                                                indices=PRIMARY_OUTPUT_STATE)
 
-        super().__init__(variable=None,
+        super().__init__(variable=default_variable,
                          input_states=input_states,
                          output_states=output_states,
                          params=params,