psychopy 2024.1.4__py3-none-any.whl → 2024.2.0__py3-none-any.whl

psychopy/experiment/loops.py

@@ -17,6 +17,7 @@ The code that writes out a *_lastrun.py experiment file is (in order):
 """
 
 from copy import deepcopy
+from pathlib import Path
 from xml.etree.ElementTree import Element
 
 from psychopy.experiment import getInitVals
@@ -111,7 +112,11 @@ class TrialHandler(_BaseLoopHandler):
             hint=_translate("Name of a file specifying the parameters for "
                             "each condition (.csv, .xlsx, or .pkl). Browse "
                             "to select a file. Right-click to preview file "
-                            "contents, or create a new file."))
+                            "contents, or create a new file."),
+            ctrlParams={
+                'template': Path(__file__).parent / "loopTemplate.xltx"
+            }
+        )
         self.params['endPoints'] = Param(
             list(endPoints), valType='num', inputType="single", updates=None, allowedUpdates=None,
             label=_translate('End points'),
@@ -153,34 +158,45 @@ class TrialHandler(_BaseLoopHandler):
         inits = getInitVals(self.params)
         # import conditions from file?
         if self.params['conditionsFile'].val in ['None', None, 'none', '']:
-            condsStr = "[None]"
+            inits['trialList'] = (
+                "[None]"
+            )
         elif self.params['Selected rows'].val in ['None', None, 'none', '']:
             # just a conditions file with no sub-selection
-            _con = "data.importConditions(%s)"
-            condsStr = _con % self.params['conditionsFile']
+            inits['trialList'] = (
+                "data.importConditions(%(conditionsFile)s)"
+            ) % inits
         else:
             # a subset of a conditions file
-            condsStr = ("data.importConditions(%(conditionsFile)s, selection="
-                        "%(Selected rows)s)") % self.params
+            inits['trialList'] = (
+                 "data.importConditions(\n"
+                 "    %(conditionsFile)s, \n"
+                 "    selection=%(Selected rows)s\n"
+                 ")\n"
+            ) % inits
         # also a 'thisName' for use in "for thisTrial in trials:"
         makeLoopIndex = self.exp.namespace.makeLoopIndex
-        self.thisName = makeLoopIndex(self.params['name'].val)
+        self.thisName = inits['loopIndex'] = makeLoopIndex(self.params['name'].val)
         # write the code
-        code = ("\n# set up handler to look after randomisation of conditions etc\n"
-                "%(name)s = data.TrialHandler(nReps=%(nReps)s, method=%(loopType)s, \n"
-                "    extraInfo=expInfo, originPath=-1,\n")
+        code = (
+            "\n"
+            "# set up handler to look after randomisation of conditions etc\n"
+            "%(name)s = data.TrialHandler2(\n"
+            "    name='%(name)s',\n"
+            "    nReps=%(nReps)s, \n"
+            "    method=%(loopType)s, \n"
+            "    extraInfo=expInfo, \n"
+            "    originPath=-1, \n"
+            "    trialList=%(trialList)s, \n"
+            "    seed=%(random seed)s, \n"
+            ")\n"
+        )
         buff.writeIndentedLines(code % inits)
-        # the next line needs to be kept separate to preserve potential string formatting
-        # by the user in condStr (i.e. it shouldn't be a formatted string itself
-        code = "    trialList=" + condsStr + ",\n"  # conditions go here
-        buff.writeIndented(code)
-        code = "    seed=%(random seed)s, name='%(name)s')\n"
+        code = (
+            "thisExp.addLoop(%(name)s)  # add the loop to the experiment\n" 
+            "%(loopIndex)s = %(name)s.trialList[0]  # so we can initialise stimuli with some values\n"
+        )
         buff.writeIndentedLines(code % inits)
-
-        code = ("thisExp.addLoop(%(name)s)  # add the loop to the experiment\n" +
-                self.thisName + " = %(name)s.trialList[0]  " +
-                "# so we can initialise stimuli with some values\n")
-        buff.writeIndentedLines(code % self.params)
         # unclutter the namespace
         if not self.exp.prefsBuilder['unclutteredNamespace']:
             code = ("# abbreviate parameter names if possible (e.g. rgb = %(name)s.rgb)\n"
@@ -189,6 +205,14 @@ class TrialHandler(_BaseLoopHandler):
                     "        globals()[paramName] = %(name)s[paramName]\n")
             buff.writeIndentedLines(code % {'name': self.thisName})
 
+        # send data to Liaison before loop starts
+        if self.params['isTrials'].val:
+            buff.writeIndentedLines(
+                "if thisSession is not None:\n"
+                "    # if running in a Session with a Liaison client, send data up to now\n"
+                "    thisSession.sendExperimentData()\n"
+            )
+
         # then run the trials loop
         code = "\nfor %s in %s:\n"
         buff.writeIndentedLines(code % (self.thisName, self.params['name']))
@@ -200,18 +224,13 @@ class TrialHandler(_BaseLoopHandler):
         )
         buff.writeIndentedLines(code % self.params)
 
-        # handle pausing
-        code = (
-            "# pause experiment here if requested\n"
-            "if thisExp.status == PAUSED:\n"
-            "    pauseExperiment(\n"
-            "        thisExp=thisExp, \n"
-            "        win=win, \n"
-            "        timers=[routineTimer], \n"
-            "        playbackComponents=[]\n"
-            ")\n"
-        )
-        buff.writeIndentedLines(code)
+        # send data to Liaison at start of each iteration
+        if self.params['isTrials'].val:
+            buff.writeIndentedLines(
+                "if thisSession is not None:\n"
+                "    # if running in a Session with a Liaison client, send data up to now\n"
+                "    thisSession.sendExperimentData()\n"
+            )
         # unclutter the namespace
         if not self.exp.prefsBuilder['unclutteredNamespace']:
             code = ("# abbreviate parameter names if possible (e.g. rgb = %(name)s.rgb)\n"
@@ -331,9 +350,6 @@ class TrialHandler(_BaseLoopHandler):
             buff.writeIndentedLines(
                 "thisExp.nextEntry()\n"
                 "\n"
-                "if thisSession is not None:\n"
-                "    # if running in a Session with a Liaison client, send data up to now\n"
-                "    thisSession.sendExperimentData()\n"
             )
         # end of the loop. dedent
         buff.setIndentLevel(-1, relative=True)
@@ -341,7 +357,13 @@ class TrialHandler(_BaseLoopHandler):
                            % (self.params['nReps'], self.params['name']))
         buff.writeIndented("\n")
         # save data
-        if self.params['isTrials'].val == True:
+        if self.params['isTrials'].val:
+            # send final data to Liaison
+            buff.writeIndentedLines(
+                "if thisSession is not None:\n"
+                "    # if running in a Session with a Liaison client, send data up to now\n"
+                "    thisSession.sendExperimentData()\n"
+            )
             # a string to show all the available variables (if the conditions
             # isn't just None or [None])
             saveExcel = self.exp.settings.params['Save excel file'].val
@@ -615,11 +637,37 @@ class MultiStairHandler(_BaseLoopHandler):
             label=_translate('Conditions'),
             hint=_translate("A list of dictionaries describing the "
                             "differences between each staircase"))
+
+        def getTemplate():
+            """
+            Method to get the template for this loop's chosen stair type. This is specified as a
+            method rather than a simple value as the control needs to update its target according
+            to the current value of stairType.
+
+            Returns
+            -------
+            pathlib.Path
+                Path to the appropriate template file
+            """
+            # root folder
+            root = Path(__file__).parent
+            # get file path according to stairType param
+            if self.params['stairType'] == "QUEST":
+                return root / "questTemplate.xltx"
+            elif self.params['stairType'] == "questplus":
+                return root / "questPlusTemplate.xltx"
+            else:
+                return root / "staircaseTemplate.xltx"
+
         self.params['conditionsFile'] = Param(
             conditionsFile, valType='file', inputType='table', updates=None, allowedUpdates=None,
             label=_translate('Conditions'),
             hint=_translate("An xlsx or csv file specifying the parameters "
-                            "for each condition"))
+                            "for each condition"),
+            ctrlParams={
+                'template': getTemplate
+            }
+        )
         self.params['isTrials'] = Param(
             isTrials, valType='bool', inputType='bool', updates=None, allowedUpdates=None,
             label=_translate("Is trials"),

psychopy/experiment/params.py

@@ -116,38 +116,73 @@ class Param():
     def __init__(self, val, valType, inputType=None, allowedVals=None, allowedTypes=None,
                  hint="", label="", updates=None, allowedUpdates=None,
                  allowedLabels=None, direct=True,
-                 canBePath=True,
+                 canBePath=True, ctrlParams=None,
                  categ="Basic"):
         """
-        @param val: the value for this parameter
-        @type val: any
-        @param valType: the type of this parameter ('num', 'str', 'code')
-        @type valType: string
-        @param allowedVals: possible vals for this param
-            (e.g. units param can only be 'norm','pix',...)
-        @type allowedVals: any
-        @param allowedTypes: if other types are allowed then this is
-            the possible types this parameter can have
-            (e.g. rgb can be 'red' or [1,0,1])
-        @type allowedTypes: list
-        @param hint: describe this parameter for the user
-        @type hint: string
-        @param updates: how often does this parameter update
-            ('experiment', 'routine', 'set every frame')
-        @type updates: string
-        @param allowedUpdates: conceivable updates for this param
-            [None, 'routine', 'set every frame']
-        @type allowedUpdates: list
-        @param categ: category for this parameter
-            will populate tabs in Component Dlg
-        @type allowedUpdates: string
-        @param canBePath: is it possible for this parameter to be
-            a path? If so, writing as str will check for pathlike
-            characters and sanitise if needed.
-        @type canBePath: bool
-        @param direct: purely used in the test suite, marks whether this
-        param's value is expected to appear in the script
-        @type direct: bool
+
+        Parameters
+        ----------
+        val : any
+            The value for this parameter
+        valType : str
+            The type of this parameter, one of:
+            - str: A string, will be compiled with " around it
+            - extendedStr: A long string, will be compiled with " around it and linebreaks will
+              be preserved
+            - code: Some code, will be compiled verbatim or translated to JS (no ")
+            - extendedCode: A block of code, will be compiled verbatim or translated to JS and
+              linebreaks will be preserved
+            - file: A file path, will be compiled like str but will replace unescaped \ with /
+            - list: A list of values, will be compiled like code but if there's no [] or () then
+              these are added
+            Note that, if value begins with a $, it will always be treated as code regardless of
+            valType
+        inputType : str
+            The type of control to make for this parameter in Builder, one of:
+            - single: A single-line text control
+            - multi: A multi-line text control
+            - color: A single-line text control with a button to open the color picker
+            - survey: A single-line text control with a button to open Pavlovia surveys list
+            - file: A single-line text control with a button to open a file browser
+            - fileList: Several file controls with buttons to add/remove
+            - table: A file control with an additional button to open in Excel
+            - choice: A single-choice control (dropdown)
+            - multiChoice: A multi-choice control (tickboxes)
+            - richChoice: A single-choice control (dropdown) with rich text for each option
+            - bool: A single checkbox control
+            - dict: Several key:value pair controls with buttons to add/remove fields
+        allowedVals : list[str]
+            Possible vals for this param (e.g. units param can only be 'norm','pix',...),
+            these are used in the compiled code
+        allowedLabels : list[str] or None
+            Labels corresponding to each value in allowedVals, these are displayed in Builder but
+            not used in the compiled code. Leave as None to simply copy allowedVals.
+        hint : str
+            Tooltip to display when param is hovered over
+        label : str
+            Label to display next to param
+        updates : str
+            How often does this parameter update, usually one of:
+            - constant: Value is set just the once
+            - set every repeat: Value is set at the start of each Routine
+            - set every frame: Value is set each frame
+        allowedUpdates : list[str]
+            List of values to show in the choice control for updates.
+        direct : bool
+            Are we expecting the value of this param to directly appear in the compiled code?
+            Mostly used by the test suite to check that params which should be used are used.
+        canBePath : bool
+            Is it possible for this parameter to be a path? Setting to False will disable
+            filepath sanitization (e.g. for textbox you may not want to replace \ with /)
+        ctrlParams : dict
+            Extra information to pass to the control, such as the Excel template file to use in a
+            `table` control.
+        categ : str
+            Category (tab) under which this param appears in Builder.
+
+        Deprecated params
+        -----------------
+        allowedTypes
         """
         super(Param, self).__init__()
         self.label = label
@@ -165,6 +200,7 @@ class Param():
         self.codeWanted = False
         self.canBePath = canBePath
         self.direct = direct
+        self.ctrlParams = ctrlParams or {}
         self.plugin = None
         if inputType:
             self.inputType = inputType
@@ -311,8 +347,11 @@ class Param():
             return False
         # if not a clear alias, use bool method of value
         return bool(self.val)
-
-    def __deepcopy__(self, memo):
+    
+    def copy(self):
+        """
+        Create a copy of this Param object
+        """
         return Param(
             val=self.val,
             valType=self.valType,
@@ -329,6 +368,9 @@ class Param():
             categ=self.categ
         )
 
+    def __deepcopy__(self, memo):
+        return self.copy()
+
     @property
     def _xml(self):
         # Make root element

psychopy/experiment/py2js_transpiler.py

@@ -337,7 +337,14 @@ class pythonTransformer(ast.NodeTransformer):
         # The default first argument for pop is -1 (remove the last item).
         elif func.attr == 'pop':
             func.attr = 'splice'
-            args = args if args else [ast.Constant(value=-1, kind=None)]
+            # if no args, construct an index that's `<name>.length-1`
+            if not args:
+                args = ast.BinOp(
+                    ast.Attribute(value=func.value, attr="length"), 
+                    ast.Sub(),
+                    ast.Constant(1, kind="int")
+                )
+            # add 1 as a second argument so the last item is deleted
             args = [args, [ast.Constant(value=1, kind=None)]]
 
             return ast.Call(

psychopy/experiment/routines/_base.py

@@ -618,6 +618,23 @@ class Routine(list):
         # create the frame loop for this routine
         code = ('\n# --- Prepare to start Routine "%s" ---\n')
         buff.writeIndentedLines(code % (self.name))
+        # get list of components which have an in-experiment object
+        comps = [
+            c.name for c in self
+            if 'startType' in c.params and c.type != 'Variable'
+        ]
+        compStr = ", ".join(comps)
+        # create object
+        code = (
+            "# create an object to store info about Routine %(name)s\n"
+            "%(name)s = data.Routine(\n"
+            "    name='%(name)s',\n"
+            "    components=[{}],\n"
+            ")\n"
+            "%(name)s.status = NOT_STARTED\n"
+        ).format(compStr)
+        buff.writeIndentedLines(code % self.params)
+
         code = (
             'continueRoutine = True\n'
         )
@@ -626,21 +643,29 @@ class Routine(list):
         # can we use non-slip timing?
         maxTime, useNonSlip = self.getMaxTime()
 
+        # this is the beginning of the routine, before the loop starts
         code = "# update component parameters for each repeat\n"
         buff.writeIndentedLines(code)
-        # This is the beginning of the routine, before the loop starts
         for event in self:
+            # don't write Routine Settings just yet...
+            if event is self.settings:
+                continue
+            # write the other Components'
             event.writeRoutineStartCode(buff)
             event.writeRoutineStartValidationCode(buff)
+        # write the Routine Settings code last
+        self.settings.writeRoutineStartCode(buff)
+        self.settings.writeRoutineStartValidationCode(buff)
 
         code = '# keep track of which components have finished\n'
         buff.writeIndentedLines(code)
-        # Get list of components, but leave out Variable components, which may not support attributes
-        compStr = ', '.join([c.params['name'].val for c in self
-                             if 'startType' in c.params and c.type != 'Variable'])
-        buff.writeIndented('%sComponents = [%s]\n' % (self.name, compStr))
+        # legacy code to support old `...Components` variable
+        code = (
+            "%(name)sComponents = %(name)s.components"
+        )
+        buff.writeIndentedLines(code % self.params)
 
-        code = ("for thisComponent in {name}Components:\n"
+        code = ("for thisComponent in {name}.components:\n"
                 "    thisComponent.tStart = None\n"
                 "    thisComponent.tStop = None\n"
                 "    thisComponent.tStartRefresh = None\n"
@@ -655,12 +680,23 @@ class Routine(list):
                 '\n# --- Run Routine "{name}" ---\n')
         buff.writeIndentedLines(code.format(name=self.name,
                                             clockName=self._clockName))
+        # check for the trials loop ending this Routine
+        if len(self.exp.flow._loopList):
+            loop = self.exp.flow._loopList[-1]
+            code = (
+                "# if trial has changed, end Routine now\n"
+                "if isinstance({name}, data.TrialHandler2) and {thisName}.thisN != {"
+                "name}.thisTrial.thisN:\n"
+                "    continueRoutine = False\n"
+            ).format(name=loop.name, thisName=loop.thisName)
+            buff.writeIndentedLines(code)
+
         # initial value for forceRoutineEnded (needs to happen now as Code components will have executed
         # their Begin Routine code)
         code = (
-            'routineForceEnded = not continueRoutine\n'
+            '%(name)s.forceEnded = routineForceEnded = not continueRoutine\n'
         )
-        buff.writeIndentedLines(code)
+        buff.writeIndentedLines(code % self.params)
 
         if useNonSlip:
             code = f'while continueRoutine and routineTimer.getTime() < {maxTime}:\n'
@@ -706,21 +742,43 @@ class Routine(list):
         )
         buff.writeIndentedLines(code)
 
+        # handle pausing
+        playbackComponents = [
+            comp.name for comp in self
+            if type(comp).__name__ in ("MovieComponent", "SoundComponent")
+        ]
+        playbackComponentsStr = ", ".join(playbackComponents)
+        code = (
+            "# pause experiment here if requested\n"
+            "if thisExp.status == PAUSED:\n"
+            "    pauseExperiment(\n"
+            "        thisExp=thisExp, \n"
+            "        win=win, \n"
+            "        timers=[routineTimer], \n"
+            "        playbackComponents=[{playbackComponentsStr}]\n"
+            "    )\n"
+            "    # skip the frame we paused on\n"
+            "    continue"
+        )
+        code = code.format(playbackComponentsStr=playbackComponentsStr)
+        buff.writeIndentedLines(code)
+
         # are we done yet?
         code = (
-            '\n# check if all components have finished\n'
+            '\n'
+            '# check if all components have finished\n'
             'if not continueRoutine:  # a component has requested a '
             'forced-end of Routine\n'
-            '    routineForceEnded = True\n'
+            '    %(name)s.forceEnded = routineForceEnded = True\n'
             '    break\n'
             'continueRoutine = False  # will revert to True if at least '
             'one component still running\n'
-            'for thisComponent in %sComponents:\n'
+            'for thisComponent in %(name)s.components:\n'
             '    if hasattr(thisComponent, "status") and '
             'thisComponent.status != FINISHED:\n'
             '        continueRoutine = True\n'
             '        break  # at least one component has not yet finished\n')
-        buff.writeIndentedLines(code % self.name)
+        buff.writeIndentedLines(code % self.params)
 
         # update screen
         code = ('\n# refresh the screen\n'
@@ -733,23 +791,25 @@ class Routine(list):
         buff.setIndentLevel(-1, True)
 
         # write the code for each component for the end of the routine
-        code = ('\n# --- Ending Routine "%s" ---\n'
-                'for thisComponent in %sComponents:\n'
+        code = ('\n# --- Ending Routine "%(name)s" ---\n'
+                'for thisComponent in %(name)s.components:\n'
                 '    if hasattr(thisComponent, "setAutoDraw"):\n'
                 '        thisComponent.setAutoDraw(False)\n')
-        buff.writeIndentedLines(code % (self.name, self.name))
+        buff.writeIndentedLines(code % self.params)
         for event in self:
             event.writeRoutineEndCode(buff)
 
         if useNonSlip:
             code = (
                 "# using non-slip timing so subtract the expected duration of this Routine (unless ended on request)\n"
-                "if routineForceEnded:\n"
+                "if %(name)s.maxDurationReached:\n"
+                "    routineTimer.addTime(-%(name)s.maxDuration)\n" 
+                "elif %(name)s.forceEnded:\n"
                 "    routineTimer.reset()\n"
                 "else:\n"
-                "    routineTimer.addTime(-%f)\n"
-            )
-            buff.writeIndentedLines(code % (maxTime))
+                "    routineTimer.addTime(-{:f})\n"
+            ).format(maxTime)
+            buff.writeIndentedLines(code % self.params)
 
     def writeRoutineBeginCodeJS(self, buff, modular):
 
@@ -773,13 +833,21 @@ class Routine(list):
         maxTime, useNonSlip = self.getMaxTime()
         if useNonSlip:
             buff.writeIndented('routineTimer.add(%f);\n' % (maxTime))
+        # keep track of whether max duration is reached
+        code = (
+            "%(name)sMaxDurationReached = false;\n"
+        )
+        buff.writeIndentedLines(code % self.params)
 
         code = "// update component parameters for each repeat\n"
         buff.writeIndentedLines(code)
         # This is the beginning of the routine, before the loop starts
         for thisCompon in self:
+            if thisCompon is self.settings:
+                continue
             if "PsychoJS" in thisCompon.targets:
                 thisCompon.writeRoutineStartCodeJS(buff)
+        self.settings.writeRoutineStartCodeJS(buff)
 
         code = ("// keep track of which components have finished\n"
                 "%(name)sComponents = [];\n" % self.params)
@@ -937,7 +1005,16 @@ class Routine(list):
                 compon.writeRoutineEndCodeJS(buff)
 
         # reset routineTimer at the *very end* of all non-nonSlip routines
-        if not useNonSlip:
+        if useNonSlip:
+            code = (
+                "if (%(name)sMaxDurationReached) {{\n"
+                "    routineTimer.add(%(name)sMaxDuration);\n"
+                "}} else {{\n"
+                "    routineTimer.add(-{:f});\n"
+                "}}\n"
+            ).format(maxTime)
+            buff.writeIndented(code % self.params)
+        else:
             code = ('// the Routine "%s" was not non-slip safe, so reset '
                     'the non-slip timer\n'
                     'routineTimer.reset();\n\n')
@@ -1002,7 +1079,7 @@ class Routine(list):
                 if duration == FOREVER:
                     # only the *start* of an unlimited event should contribute
                     # to maxTime
-                    duration = 1  # plus some minimal duration so it's visible
+                    duration = 0  # plus some minimal duration so it's visible
                 # now see if we have a end t value that beats the previous max
                 try:
                     # will fail if either value is not defined:
@@ -1014,8 +1091,11 @@ class Routine(list):
         rtDur, numericStop = self.settings.getDuration()
         if rtDur != FOREVER:
             maxTime = rtDur
+        # if nonslip is actively requested, force it
+        if self.settings.params['forceNonSlip'] and maxTime not in (0, FOREVER):
+            nonSlipSafe  = True
         # if there are no components, default to 10s
-        if maxTime == 0:
+        if maxTime in (0, None):
             maxTime = 10
             nonSlipSafe = False
         return maxTime, nonSlipSafe

psychopy/experiment/routines/counterbalance/__init__.py

@@ -91,7 +91,11 @@ class CounterbalanceRoutine(BaseStandaloneRoutine):
             hint=_translate(
                 "Name of a file specifying the parameters for each group (.csv, .xlsx, or .pkl). Browse to select "
                 "a file. Right-click to preview file contents, or create a new file."
-            ))
+            ),
+            ctrlParams={
+                'template': Path(__file__).parent / "counterbalanceItems.xltx"
+            }
+        )
 
         self.params['conditionsVariable'] = Param(
             conditionsVariable, valType='code', inputType="single", categ="Basic",

psychopy/experiment/routines/photodiodeValidator/__init__.py

@@ -19,7 +19,7 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
     iconFile = Path(__file__).parent / 'photodiode_validator.png'
     tooltip = _translate('Photodiode validator')
     deviceClasses = []
-    version = "2024.2.0"
+    version = "2025.1.0"
 
     def __init__(
             self,
@@ -169,8 +169,9 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
             channel, valType="code", inputType="single", categ="Device",
             label=_translate("Photodiode channel"),
             hint=_translate(
-                "If relevant, a channel number attached to the photodiode, to distinguish it from other photodiodes on "
-                "the same port."
+                "If relevant, a channel number attached to the photodiode, to distinguish it "
+                "from other photodiodes on the same port. Leave blank to use the first photodiode "
+                "which can detect the Window."
             )
         )
 
@@ -266,14 +267,14 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
             "    report=%(report)s,\n"
             ")\n"
         )
-        buff.writeIndentedLines(code % self.params)
+        buff.writeIndentedLines(code % inits)
         # connect stimuli
         for stim in self.findConnectedStimuli():
             code = (
                 "# connect {stim} to %(name)s\n"
                 "%(name)s.connectStimulus({stim})\n"
             ).format(stim=stim.params['name'])
-            buff.writeIndentedLines(code % self.params)
+            buff.writeIndentedLines(code % inits)
 
     def writeRoutineStartValidationCode(self, buff, stim):
         """