psychopy 2024.2.1__py3-none-any.whl → 2024.2.5__py3-none-any.whl

psychopy/app/plugin_manager/dialog.py

@@ -68,7 +68,6 @@ class EnvironmentManagerDlg(wx.Dialog):
 
         self.notebook.ChangeSelection(0)
 
-
     @staticmethod
     def getPackageVersionInfo(packageName):
         """Query packages for available versions.
@@ -278,10 +277,13 @@ class EnvironmentManagerDlg(wx.Dialog):
             )
         else:
             command.append('--user')
-        
+
         # add other options to the command
         command += ['--prefer-binary', '--no-input', '--no-color']
-            
+
+        # disable pip version check
+        command += ['--disable-pip-version-check']
+
         # write command to output panel
         self.output.writeCmd(" ".join(command))
         # append own name to extra
@@ -359,7 +361,7 @@ class EnvironmentManagerDlg(wx.Dialog):
         # write installation termination statement
         msg = "Installation complete"
         if 'pipname' in self.pipProcess.extra:
-            msg = f"Finished installing %(pipname)s" % self.pipProcess.extra
+            msg = "Finished installing %(pipname)s" % self.pipProcess.extra
         self.output.writeTerminus(msg)
 
         # if we have a plugin, write additional plugin information post-install
@@ -411,12 +413,12 @@ class EnvironmentManagerDlg(wx.Dialog):
         # refresh view
         pkgtools.refreshPackages()
         self.pluginMgr.updateInfo()
-    
+
     def onUninstallExit(self, pid, exitCode):
         # write installation termination statement
         msg = "Uninstall complete"
         if 'pipname' in self.pipProcess.extra:
-            msg = f"Finished uninstalling %(pipname)s" % self.pipProcess.extra
+            msg = "Finished uninstalling %(pipname)s" % self.pipProcess.extra
         self.output.writeTerminus(msg)
         # clear pip process
         self.pipProcess = None
@@ -435,7 +437,7 @@ class EnvironmentManagerDlg(wx.Dialog):
             # if they change their mind, cancel closing
             if dlg.ShowModal() == wx.ID_NO:
                 return
-        
+
         if evt is not None:
             evt.Skip()
 

psychopy/app/ribbon.py

@@ -467,7 +467,8 @@ class FrameRibbonButton(wx.Button, handlers.ThemeMixin):
         wx.Button.__init__(self, parent, style=wx.BORDER_NONE | style, size=(w, 44))
         self.SetMinSize((40, 44))
         # set label
-        self.SetLabelText(label)
+        if label and style | wx.BU_NOTEXT != style:
+            self.SetLabelText(label)
         # set tooltip
         if tooltip and style | wx.BU_NOTEXT == style:
             # if there's no label, include it in the tooltip

psychopy/app/runner/runner.py

@@ -490,7 +490,6 @@ class RunnerPanel(wx.Panel, ScriptProcess, handlers.ThemeMixin):
 
         # setup ribbon
         self.ribbon = RunnerRibbon(self)
-        self.ribbon.buttons['pyswitch'].setMode(0)
         self.mainSizer.Add(self.ribbon, border=0, flag=wx.EXPAND | wx.ALL)
 
         # Setup splitter
@@ -684,11 +683,13 @@ class RunnerPanel(wx.Panel, ScriptProcess, handlers.ThemeMixin):
         # get relevant paths
         htmlPath = str(self.currentFile.parent / self.outputPath)
         jsFile = self.currentFile.parent / (self.currentFile.stem + ".js")
-        # make sure JS file exists
-        if not os.path.exists(jsFile):
-            generateScript(outfile=str(jsFile),
-                           exp=self.loadExperiment(),
-                           target="PsychoJS")
+        # regenerate JS file
+        if self.currentFile.suffix == ".psyexp":
+            generateScript(
+                outfile=str(jsFile),
+                exp=self.loadExperiment(),
+                target="PsychoJS"
+            )
         # start server
         self.startServer(htmlPath, port=port)
         # open experiment
@@ -841,25 +842,36 @@ class RunnerPanel(wx.Panel, ScriptProcess, handlers.ThemeMixin):
         del self.entries[self.currentFile]  # remove from our tracking dictionary
         self.expCtrl.DeleteItem(self.currentSelection) # from wx control
         self.app.updateWindowMenu()
-
-    def onRunModeToggle(self, evt):
+    
+    def updateRunModeIcons(self, evt=None):
         """
-        Function to execute when switching between pilot and run modes
+        Function to update run/pilot icons according to run mode
         """
-        mode = evt.GetInt()
-        # update buttons
+        mode = self.ribbon.buttons['pyswitch'].mode
         # show/hide run buttons
         for key in ("pyrun", "jsrun"):
             self.ribbon.buttons[key].Show(mode)
         # hide/show pilot buttons
         for key in ("pypilot", "jspilot"):
             self.ribbon.buttons[key].Show(not mode)
+        # update
+        self.ribbon.Layout()
+
+    def onRunModeToggle(self, evt):
+        """
+        Function to execute when switching between pilot and run modes
+        """
+        mode = evt.GetInt()
+        # update buttons
+        self.updateRunModeIcons()
         # update experiment mode
         if self.currentExperiment is not None:
             # find any Builder windows with this experiment open
             for frame in self.app.getAllFrames(frameType='builder'):
                 if frame.exp == self.currentExperiment:
-                    frame.ribbon.buttons['pyswitch'].setMode(mode)
+                    frame.ribbon.buttons['pyswitch'].setMode(mode, silent=True)
+                    if hasattr(frame, "updateRunModeIcons"):
+                        frame.updateRunModeIcons()
             # update current selection
             runMode = "pilot"
             if mode:
@@ -902,7 +914,7 @@ class RunnerPanel(wx.Panel, ScriptProcess, handlers.ThemeMixin):
         # disable stop
         self.ribbon.buttons['pystop'].Disable()
         # switch mode
-        self.ribbon.buttons['pyswitch'].setMode(runMode == "run", silent=True)
+        self.ribbon.buttons['pyswitch'].setMode(runMode == "run")
         # update
         self.updateAlerts()
         self.app.updateWindowMenu()

psychopy/clock.py

@@ -332,14 +332,18 @@ class Clock(MonotonicClock):
         self._epochTimeAtLastReset -= t
 
     def add(self, t):
-        """DEPRECATED: use .addTime() instead
+        """
+        DEPRECATED: use .addTime() instead
 
         This function adds time TO THE BASE (t0) which, counterintuitively,
         reduces the apparent time on the clock
         """
-        logging.warning("DEPRECATED: Clock.add() is deprecated in favor of .addTime() due to "
-                        "the counterintuitive design (it added time to the baseline, which "
-                        "reduced the values returned from getTime()")
+        psychopy.logging.log(msg=(
+            "Clock.add() is deprecated in favor of .addTime() due to the counterintuitive design "
+            "(it added time to the baseline, which reduced the values returned from getTime() )"
+            ),
+            level=psychopy.logging.DEPRECATION
+        )
         self._timeAtLastReset += t
         self._epochTimeAtLastReset += t
 

psychopy/core.py.orig

@@ -0,0 +1,169 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""Basic functions, including timing, rush (imported), quit
+"""
+# Part of the PsychoPy library
+# Copyright (C) 2002-2018 Jonathan Peirce (C) 2019-2021 Open Science Tools Ltd.
+# Distributed under the terms of the GNU General Public License (GPL).
+
+import sys
+import threading
+import subprocess
+import shlex
+import locale
+
+# some things are imported just to be accessible within core's namespace
+from psychopy.clock import (MonotonicClock, Clock, CountdownTimer,
+                            wait, monotonicClock, getAbsTime,
+                            StaticPeriod)  # pylint: disable=W0611
+
+# always safe to call rush, even if its not going to do anything for a
+# particular OS
+from psychopy.platform_specific import rush  # pylint: disable=W0611
+from psychopy import logging
+<<<<<<< HEAD
+from psychopy.constants import STARTED, NOT_STARTED, FINISHED
+=======
+from psychopy.constants import STARTED, NOT_STARTED, FINISHED, PY3
+from psychopy.iohub.client import ioHubConnection
+>>>>>>> c06fff3cf5e2f418f6db297fd47819041a00c07d
+
+try:
+    import pyglet
+    havePyglet = True
+    # may not want to check, to preserve terminal window focus
+    checkPygletDuringWait = True
+except ImportError:
+    havePyglet = False
+    checkPygletDuringWait = False
+
+try:
+    import glfw
+    haveGLFW = True
+except ImportError:
+    haveGLFW = False
+
+runningThreads = []  # just for backwards compatibility?
+openWindows = []  # visual.Window updates this, event.py and clock.py use it
+
+# Set getTime in core to == the monotonicClock instance created in the
+# clockModule.
+# The logging module sets the defaultClock to == clock.monotonicClock,
+# so by default the core.getTime() and logging.defaultClock.getTime()
+# functions return the 'same' timebase.
+#
+# This way 'all' OSs have a core.getTime() timebase that starts at 0.0 when
+# the experiment is launched, instead of it being this way on Windows only
+# (which was also a descripancy between OS's when win32 was using time.clock).
+
+
+def getTime(applyZero = True):
+    """Get the current time since psychopy.core was loaded.
+
+
+
+    Version Notes: Note that prior to PsychoPy 1.77.00 the behaviour of
+    getTime() was platform dependent (on OSX and linux it was equivalent to
+    :func:`psychopy.core.getAbsTime`
+    whereas on windows it returned time since loading of the module, as now)
+    """
+    return monotonicClock.getTime(applyZero)
+
+
+def quit():
+    """Close everything and exit nicely (ending the experiment)
+    """
+    # pygame.quit()  # safe even if pygame was never initialised
+    logging.flush()
+
+    # properly shutdown ioHub server
+    if ioHubConnection.ACTIVE_CONNECTION:
+        ioHubConnection.ACTIVE_CONNECTION.quit()
+
+    for thisThread in threading.enumerate():
+        if hasattr(thisThread, 'stop') and hasattr(thisThread, 'running'):
+            # this is one of our event threads - kill it and wait for success
+            thisThread.stop()
+            while thisThread.running == 0:
+                pass  # wait until it has properly finished polling
+
+    sys.exit(0)  # quits the python session entirely
+
+
+def shellCall(shellCmd, stdin='', stderr=False, env=None, encoding=None):
+    """Call a single system command with arguments, return its stdout.
+    Returns stdout, stderr if stderr is True.
+    Handles simple pipes, passing stdin to shellCmd (pipes are untested
+    on windows) can accept string or list as the first argument
+
+    Parameters
+    ----------
+    shellCmd : str, or iterable
+        The command to execute, and its respective arguments.
+
+    stdin : str, or None
+        Input to pass to the command.
+
+    stderr : bool
+        Whether to return the standard error output once execution is finished.
+
+    env : dict
+        The environment variables to set during execution.
+
+    encoding : str
+        The encoding to use for communication with the executed command.
+        This argument will be ignored on Python 2.7.
+
+    Notes
+    -----
+    We use ``subprocess.Popen`` to execute the command and establish
+    `stdin` and `stdout` pipes.
+    Python 2.7 always opens the pipes in text mode; however,
+    Python 3 defaults to binary mode, unless an encoding is specified.
+    To unify pipe communication across Python 2 and 3, we now provide an
+    `encoding` parameter, enforcing `utf-8` text mode by default.
+    This parameter is present from Python 3.6 onwards; using an older
+    Python 3 version will raise an exception. The parameter will be ignored
+    when running Python 2.7.
+
+    """
+    if encoding is None:
+        encoding = locale.getpreferredencoding()
+
+    if type(shellCmd) == str:
+        # safely split into cmd+list-of-args, no pipes here
+        shellCmdList = shlex.split(shellCmd)
+    elif type(shellCmd) == bytes:
+        # safely split into cmd+list-of-args, no pipes here
+        shellCmdList = shlex.split(shellCmd.decode('utf-8'))
+    elif type(shellCmd) in (list, tuple):  # handles whitespace in filenames
+        shellCmdList = shellCmd
+    else:
+        msg = 'shellCmd requires a string or iterable.'
+        raise TypeError(msg)
+
+    cmdObjects = []
+    for obj in shellCmdList:
+        if type(obj) != bytes:
+            cmdObjects.append(obj)
+        else:
+            cmdObjects.append(obj.decode('utf-8'))
+
+    # the `encoding` parameter results in unicode coming back
+    if sys.version_info.minor >= 6:
+        proc = subprocess.Popen(cmdObjects, stdin=subprocess.PIPE,
+                                stdout=subprocess.PIPE,
+                                stderr=subprocess.PIPE,
+                                encoding=encoding, env=env)
+    else:
+        msg = 'shellCall() requires Python 2.7, or 3.6 and newer.'
+        raise RuntimeError(msg)
+
+    stdoutData, stderrData = proc.communicate(stdin)
+
+    del proc
+    if stderr:
+        return stdoutData.strip(), stderrData.strip()
+    else:
+        return stdoutData.strip()

psychopy/demos/builder/Design Templates/randomisedBlocks/randomisedBlocks_lastrun.py

@@ -0,0 +1,330 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+This experiment was created using PsychoPy3 Experiment Builder (v2022.2.0dev3),
+    on Thu May 26 17:00:03 2022
+If you publish work using this script the most relevant publication is:
+
+    Peirce J, Gray JR, Simpson S, MacAskill M, Höchenberger R, Sogo H, Kastman E, Lindeløv JK. (2019) 
+        PsychoPy2: Experiments in behavior made easy Behav Res 51: 195. 
+        https://doi.org/10.3758/s13428-018-01193-y
+
+"""
+
+# --- Import packages ---
+from psychopy import locale_setup
+from psychopy import prefs
+from psychopy import sound, gui, visual, core, data, event, logging, clock, colors, layout
+from psychopy.constants import (NOT_STARTED, STARTED, PLAYING, PAUSED,
+                                STOPPED, FINISHED, PRESSED, RELEASED, FOREVER)
+
+import numpy as np  # whole numpy lib is available, prepend 'np.'
+from numpy import (sin, cos, tan, log, log10, pi, average,
+                   sqrt, std, deg2rad, rad2deg, linspace, asarray)
+from numpy.random import random, randint, normal, shuffle, choice as randchoice
+import os  # handy system and path functions
+import sys  # to get file system encoding
+
+import psychopy.iohub as io
+from psychopy.hardware import keyboard
+
+
+
+# Ensure that relative paths start from the same directory as this script
+_thisDir = os.path.dirname(os.path.abspath(__file__))
+os.chdir(_thisDir)
+# Store info about the experiment session
+psychopyVersion = '2022.2.0dev3'
+expName = 'blockedTrials'  # from the Builder filename that created this script
+expInfo = {
+    'session': '001',
+    'participant': "subj%06.0f" %(random()*100000),
+}
+# --- Show participant info dialog --
+dlg = gui.DlgFromDict(dictionary=expInfo, sortKeys=False, title=expName)
+if dlg.OK == False:
+    core.quit()  # user pressed cancel
+expInfo['date'] = data.getDateStr()  # add a simple timestamp
+expInfo['expName'] = expName
+expInfo['psychopyVersion'] = psychopyVersion
+
+# Data file name stem = absolute path + name; later add .psyexp, .csv, .log, etc
+filename = _thisDir + os.sep + u'data/%s_%s_%s' % (expInfo['participant'], expName, expInfo['date'])
+
+# An ExperimentHandler isn't essential but helps with data saving
+thisExp = data.ExperimentHandler(name=expName, version='',
+    extraInfo=expInfo, runtimeInfo=None,
+    originPath='psychopy/demos/builder/Design Templates/randomisedBlocks/randomisedBlocks_lastrun.py',
+    savePickle=True, saveWideText=True,
+    dataFileName=filename)
+# save a log file for detail verbose info
+logFile = logging.LogFile(filename+'.log', level=logging.EXP)
+logging.console.setLevel(logging.WARNING)  # this outputs to the screen, not a file
+
+endExpNow = False  # flag for 'escape' or other condition => quit the exp
+frameTolerance = 0.001  # how close to onset before 'same' frame
+
+# Start Code - component code to be run after the window creation
+
+# --- Setup the Window ---
+win = visual.Window(
+    size=[1440, 900], fullscr=True, screen=0, 
+    winType='pyglet', allowGUI=False, allowStencil=False,
+    monitor='testMonitor', color=[0,0,0], colorSpace='rgb',
+    blendMode='avg', useFBO=True, 
+    units='height')
+# store frame rate of monitor if we can measure it
+expInfo['frameRate'] = win.getActualFrameRate()
+if expInfo['frameRate'] != None:
+    frameDur = 1.0 / round(expInfo['frameRate'])
+else:
+    frameDur = 1.0 / 60.0  # could not measure, so guess
+# --- Setup input devices ---
+ioConfig = {}
+
+# Setup iohub keyboard
+ioConfig['Keyboard'] = dict(use_keymap='psychopy')
+
+ioSession = '1'
+if 'session' in expInfo:
+    ioSession = str(expInfo['session'])
+ioServer = io.launchHubServer(window=win, **ioConfig)
+eyetracker = None
+
+# create a default keyboard (e.g. to check for escape)
+defaultKeyboard = keyboard.Keyboard(backend='iohub')
+
+# --- Initialize components for Routine "readyMessage" ---
+readyMessageClock = core.Clock()
+textbox = visual.TextBox2(
+     win, text='', font='Open Sans',
+     pos=(0, 0),     letterHeight=0.05,
+     size=(0.4, 0.4), borderWidth=2.0,
+     color='white', colorSpace='rgb',
+     opacity=1.0,
+     bold=False, italic=False,
+     lineSpacing=1.0,
+     padding=None, alignment='center',
+     anchor='center',
+     fillColor=None, borderColor=None,
+     flipHoriz=False, flipVert=False, languageStyle='LTR',
+     editable=False,
+     name='textbox',
+     autoLog=True,
+)
+
+# --- Initialize components for Routine "trial" ---
+trialClock = core.Clock()
+image = visual.ImageStim(
+    win=win,
+    name='image', units='height', 
+    image='sin', mask=None, anchor='center',
+    ori=0, pos=(0, 0), size=(0.5,0.5),
+    color=[1,1,1], colorSpace='rgb', opacity=1,
+    flipHoriz=False, flipVert=False,
+    texRes=128, interpolate=True, depth=0.0)
+
+# Create some handy timers
+globalClock = core.Clock()  # to track the time since experiment started
+routineTimer = core.CountdownTimer()  # to track time remaining of each (non-slip) routine 
+
+# set up handler to look after randomisation of conditions etc
+blocks = data.TrialHandler(nReps=2, method='random', 
+    extraInfo=expInfo, originPath=-1,
+    trialList=data.importConditions('chooseBlock.xlsx'),
+    seed=None, name='blocks')
+thisExp.addLoop(blocks)  # add the loop to the experiment
+thisBlock = blocks.trialList[0]  # so we can initialise stimuli with some values
+# abbreviate parameter names if possible (e.g. rgb = thisBlock.rgb)
+if thisBlock != None:
+    for paramName in thisBlock:
+        exec('{} = thisBlock[paramName]'.format(paramName))
+
+for thisBlock in blocks:
+    currentLoop = blocks
+    # abbreviate parameter names if possible (e.g. rgb = thisBlock.rgb)
+    if thisBlock != None:
+        for paramName in thisBlock:
+            exec('{} = thisBlock[paramName]'.format(paramName))
+    
+    # --- Prepare to start Routine "readyMessage" ---
+    continueRoutine = True
+    routineTimer.add(1.000000)
+    # update component parameters for each repeat
+    textbox.reset()
+    textbox.setText(readyMsg)
+    # keep track of which components have finished
+    readyMessageComponents = [textbox]
+    for thisComponent in readyMessageComponents:
+        thisComponent.tStart = None
+        thisComponent.tStop = None
+        thisComponent.tStartRefresh = None
+        thisComponent.tStopRefresh = None
+        if hasattr(thisComponent, 'status'):
+            thisComponent.status = NOT_STARTED
+    # reset timers
+    t = 0
+    _timeToFirstFrame = win.getFutureFlipTime(clock="now")
+    readyMessageClock.reset(-_timeToFirstFrame)  # t0 is time of first possible flip
+    frameN = -1
+    
+    # --- Run Routine "readyMessage" ---
+    while continueRoutine and routineTimer.getTime() > 0:
+        # get current time
+        t = readyMessageClock.getTime()
+        tThisFlip = win.getFutureFlipTime(clock=readyMessageClock)
+        tThisFlipGlobal = win.getFutureFlipTime(clock=None)
+        frameN = frameN + 1  # number of completed frames (so 0 is the first frame)
+        # update/draw components on each frame
+        
+        # *textbox* updates
+        if textbox.status == NOT_STARTED and tThisFlip >= 0.0-frameTolerance:
+            # keep track of start time/frame for later
+            textbox.frameNStart = frameN  # exact frame index
+            textbox.tStart = t  # local t and not account for scr refresh
+            textbox.tStartRefresh = tThisFlipGlobal  # on global time
+            win.timeOnFlip(textbox, 'tStartRefresh')  # time at next scr refresh
+            textbox.setAutoDraw(True)
+        if textbox.status == STARTED:
+            # is it time to stop? (based on global clock, using actual start)
+            if tThisFlipGlobal > textbox.tStartRefresh + 1.0-frameTolerance:
+                # keep track of stop time/frame for later
+                textbox.tStop = t  # not accounting for scr refresh
+                textbox.frameNStop = frameN  # exact frame index
+                win.timeOnFlip(textbox, 'tStopRefresh')  # time at next scr refresh
+                textbox.setAutoDraw(False)
+        
+        # check for quit (typically the Esc key)
+        if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]):
+            core.quit()
+        
+        # check if all components have finished
+        if not continueRoutine:  # a component has requested a forced-end of Routine
+            break
+        continueRoutine = False  # will revert to True if at least one component still running
+        for thisComponent in readyMessageComponents:
+            if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
+                continueRoutine = True
+                break  # at least one component has not yet finished
+        
+        # refresh the screen
+        if continueRoutine:  # don't flip if this routine is over or we'll get a blank screen
+            win.flip()
+    
+    # --- Ending Routine "readyMessage" ---
+    for thisComponent in readyMessageComponents:
+        if hasattr(thisComponent, "setAutoDraw"):
+            thisComponent.setAutoDraw(False)
+    blocks.addData('textbox.started', textbox.tStartRefresh)
+    blocks.addData('textbox.stopped', textbox.tStopRefresh)
+    
+    # set up handler to look after randomisation of conditions etc
+    trials = data.TrialHandler(nReps=1, method='random', 
+        extraInfo=expInfo, originPath=-1,
+        trialList=data.importConditions(condsFile),
+        seed=None, name='trials')
+    thisExp.addLoop(trials)  # add the loop to the experiment
+    thisTrial = trials.trialList[0]  # so we can initialise stimuli with some values
+    # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb)
+    if thisTrial != None:
+        for paramName in thisTrial:
+            exec('{} = thisTrial[paramName]'.format(paramName))
+    
+    for thisTrial in trials:
+        currentLoop = trials
+        # abbreviate parameter names if possible (e.g. rgb = thisTrial.rgb)
+        if thisTrial != None:
+            for paramName in thisTrial:
+                exec('{} = thisTrial[paramName]'.format(paramName))
+        
+        # --- Prepare to start Routine "trial" ---
+        continueRoutine = True
+        routineTimer.add(1.500000)
+        # update component parameters for each repeat
+        image.setImage(stimFile)
+        # keep track of which components have finished
+        trialComponents = [image]
+        for thisComponent in trialComponents:
+            thisComponent.tStart = None
+            thisComponent.tStop = None
+            thisComponent.tStartRefresh = None
+            thisComponent.tStopRefresh = None
+            if hasattr(thisComponent, 'status'):
+                thisComponent.status = NOT_STARTED
+        # reset timers
+        t = 0
+        _timeToFirstFrame = win.getFutureFlipTime(clock="now")
+        trialClock.reset(-_timeToFirstFrame)  # t0 is time of first possible flip
+        frameN = -1
+        
+        # --- Run Routine "trial" ---
+        while continueRoutine and routineTimer.getTime() > 0:
+            # get current time
+            t = trialClock.getTime()
+            tThisFlip = win.getFutureFlipTime(clock=trialClock)
+            tThisFlipGlobal = win.getFutureFlipTime(clock=None)
+            frameN = frameN + 1  # number of completed frames (so 0 is the first frame)
+            # update/draw components on each frame
+            
+            # *image* updates
+            if image.status == NOT_STARTED and tThisFlip >= 0.5-frameTolerance:
+                # keep track of start time/frame for later
+                image.frameNStart = frameN  # exact frame index
+                image.tStart = t  # local t and not account for scr refresh
+                image.tStartRefresh = tThisFlipGlobal  # on global time
+                win.timeOnFlip(image, 'tStartRefresh')  # time at next scr refresh
+                image.setAutoDraw(True)
+            if image.status == STARTED:
+                # is it time to stop? (based on global clock, using actual start)
+                if tThisFlipGlobal > image.tStartRefresh + 1.0-frameTolerance:
+                    # keep track of stop time/frame for later
+                    image.tStop = t  # not accounting for scr refresh
+                    image.frameNStop = frameN  # exact frame index
+                    win.timeOnFlip(image, 'tStopRefresh')  # time at next scr refresh
+                    image.setAutoDraw(False)
+            
+            # check for quit (typically the Esc key)
+            if endExpNow or defaultKeyboard.getKeys(keyList=["escape"]):
+                core.quit()
+            
+            # check if all components have finished
+            if not continueRoutine:  # a component has requested a forced-end of Routine
+                break
+            continueRoutine = False  # will revert to True if at least one component still running
+            for thisComponent in trialComponents:
+                if hasattr(thisComponent, "status") and thisComponent.status != FINISHED:
+                    continueRoutine = True
+                    break  # at least one component has not yet finished
+            
+            # refresh the screen
+            if continueRoutine:  # don't flip if this routine is over or we'll get a blank screen
+                win.flip()
+        
+        # --- Ending Routine "trial" ---
+        for thisComponent in trialComponents:
+            if hasattr(thisComponent, "setAutoDraw"):
+                thisComponent.setAutoDraw(False)
+        trials.addData('image.started', image.tStartRefresh)
+        trials.addData('image.stopped', image.tStopRefresh)
+        thisExp.nextEntry()
+        
+    # completed 1 repeats of 'trials'
+    
+# completed 2 repeats of 'blocks'
+
+
+# --- End experiment ---
+# Flip one final time so any remaining win.callOnFlip() 
+# and win.timeOnFlip() tasks get executed before quitting
+win.flip()
+
+# these shouldn't be strictly necessary (should auto-save)
+thisExp.saveAsWideText(filename+'.csv', delim='auto')
+thisExp.saveAsPickle(filename)
+logging.flush()
+# make sure everything is closed down
+if eyetracker:
+    eyetracker.setConnectionState(False)
+thisExp.abort()  # or data files will save again on exit
+win.close()
+core.quit()