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

psychopy/experiment/routines/eyetracker_calibrate/__init__.py

@@ -16,6 +16,7 @@ class EyetrackerCalibrationRoutine(BaseStandaloneRoutine):
     def __init__(self, exp, name='calibration',
                  progressMode="time", targetDur=1.5, expandDur=1, expandScale=1.5,
                  movementAnimation=True, movementDur=1.0, targetDelay=1.0,
+                 useCustom=False, customTarget="",
                  innerFillColor='green', innerBorderColor='black', innerBorderWidth=2, innerRadius=0.0035,
                  fillColor='', borderColor="black", borderWidth=2, outerRadius=0.01,
                  colorSpace="rgb", units='from exp settings',
@@ -27,6 +28,10 @@ class EyetrackerCalibrationRoutine(BaseStandaloneRoutine):
         self.url = "https://psychopy.org/builder/components/eyetracker_calibration.html"
 
         self.exp.requirePsychopyLibs(['iohub', 'hardware'])
+        self.exp.requireImport(
+            importName="EyetrackerCalibration",
+            importFrom="psychopy.hardware.eyetracker"
+        )
 
         # Basic params
         self.order += [
@@ -41,7 +46,7 @@ class EyetrackerCalibrationRoutine(BaseStandaloneRoutine):
         self.params['targetLayout'] = Param(targetLayout,
                                             valType='str', inputType="choice", categ='Basic',
                                             allowedVals=['THREE_POINTS', 'FIVE_POINTS', 'NINE_POINTS', "THIRTEEN_POINTS"],
-                                            hint=_translate("Pre-defined target layouts"),
+                                            hint=_translate("How many targets do you want to be presented for calibration? Points will be displayed in a grid."),
                                             label=_translate("Target layout"))
 
         self.params['randomisePos'] = Param(randomisePos,
@@ -54,6 +59,8 @@ class EyetrackerCalibrationRoutine(BaseStandaloneRoutine):
                                      label=_translate("Text color"))
         # Target Params
         self.order += [
+            "useCustom",
+            "customTarget",
             "targetStyle",
             "fillColor",
             "borderColor",
@@ -66,6 +73,31 @@ class EyetrackerCalibrationRoutine(BaseStandaloneRoutine):
             "innerRadius",
         ]
 
+        self.params['useCustom'] = Param(
+            useCustom, valType="code", inputType="bool", categ="Target",
+            label=_translate("Use custom?"),
+            hint=_translate(
+                "Check this box to use a custom stimulus as a calibration target, rather than "
+                "creating one from params."
+            ),
+            direct=False
+        )
+
+        self.params['customTarget'] = Param(
+            customTarget, valType="code", inputType="single", categ="Target",
+            label=_translate("Custom target"),
+            hint=_translate(
+                "Give the name of any visual Component to use it as a calibration target."
+            )
+        )
+        self.depends.append({
+            "dependsOn": 'useCustom',  # if...
+            "condition": "",  # meets...
+            "param": 'customTarget',  # then...
+            "true": "show",  # should...
+            "false": "hide",  # otherwise...
+        })
+
         self.params['innerFillColor'] = Param(innerFillColor,
                                      valType='color', inputType="color", categ='Target',
                                      hint=_translate("Fill color of the inner part of the target"),
@@ -118,6 +150,27 @@ class EyetrackerCalibrationRoutine(BaseStandaloneRoutine):
                                      allowedVals=['from exp settings'], direct=False,
                                      hint=_translate("Units of dimensions for this stimulus"),
                                      label=_translate("Spatial units"))
+        # hide all target params if using custom
+        for thisParam in (
+            "targetStyle",
+            "fillColor",
+            "borderColor",
+            "innerFillColor",
+            "innerBorderColor",
+            "colorSpace",
+            "borderWidth",
+            "innerBorderWidth",
+            "outerRadius",
+            "innerRadius",
+            "units",
+        ):
+            self.depends.append({
+                "dependsOn": 'useCustom',  # if...
+                "condition": "",  # meets...
+                "param": thisParam,  # then...
+                "true": "hide",  # should...
+                "false": "show",  # otherwise...
+            })
 
         # Animation Params
         self.order += [
@@ -230,29 +283,35 @@ class EyetrackerCalibrationRoutine(BaseStandaloneRoutine):
 
         BaseStandaloneRoutine.writeMainCode(self, buff)
 
-        # Make target
+        # make target
         code = (
             "# define target for %(name)s\n"
-            "%(name)sTarget = visual.TargetStim(win, \n"
-        )
-        buff.writeIndentedLines(code % inits)
-        buff.setIndentLevel(1, relative=True)
-        code = (
-                "name='%(name)sTarget',\n"
-                "radius=%(outerRadius)s, fillColor=%(fillColor)s, borderColor=%(borderColor)s, lineWidth=%(borderWidth)s,\n"
-                "innerRadius=%(innerRadius)s, innerFillColor=%(innerFillColor)s, innerBorderColor=%(innerBorderColor)s, innerLineWidth=%(innerBorderWidth)s,\n"
-                "colorSpace=%(colorSpace)s, units=%(units)s\n"
-        )
-        buff.writeIndentedLines(code % inits)
-        buff.setIndentLevel(-1, relative=True)
-        code = (
-            ")"
         )
+        if self.params['useCustom']:
+            code += (
+                "%(name)sTarget = %(customTarget)s\n"
+            )
+        else:
+            code += (
+                "%(name)sTarget = visual.TargetStim(win, \n"
+                "    name='%(name)sTarget',\n"
+                "    radius=%(outerRadius)s, \n"
+                "    fillColor=%(fillColor)s, \n"
+                "    borderColor=%(borderColor)s, \n"
+                "    lineWidth=%(borderWidth)s, \n"
+                "    innerRadius=%(innerRadius)s, \n"
+                "    innerFillColor=%(innerFillColor)s, \n"
+                "    innerBorderColor=%(innerBorderColor)s, \n"
+                "    innerLineWidth=%(innerBorderWidth)s,\n"
+                "    colorSpace=%(colorSpace)s, \n"
+                "    units=%(units)s\n"
+                ")\n"
+            )
         buff.writeIndentedLines(code % inits)
         # Make config object
         code = (
             "# define parameters for %(name)s\n"
-            "%(name)s = hardware.eyetracker.EyetrackerCalibration(win, \n"
+            "%(name)s = EyetrackerCalibration(win, \n"
         )
         buff.writeIndentedLines(code % inits)
         buff.setIndentLevel(1, relative=True)

psychopy/experiment/routines/eyetracker_validate/__init__.py

@@ -61,7 +61,7 @@ class EyetrackerValidationRoutine(BaseStandaloneRoutine):
         self.params['targetLayout'] = Param(targetLayout,
                                             valType='str', inputType="choice", categ='Basic',
                                             allowedVals=positions + ["CUSTOM..."],
-                                            hint=_translate("Pre-defined target layouts"),
+                                            hint=_translate("How many targets do you want to be presented for calibration? Points will be displayed in a grid."),
                                             label=_translate("Target layout"))
 
         self.depends.append(

psychopy/experiment/routines/unknown/__init__.py

@@ -7,6 +7,8 @@ class UnknownRoutine(BaseStandaloneRoutine):
     targets = []
     iconFile = Path(__file__).parent / "unknown.png"
     tooltip = "Unknown routine"
+    # hide from the Components panel
+    hidden = True
 
     def __init__(self, exp, name=''):
         BaseStandaloneRoutine.__init__(self, exp, name=name)

psychopy/experiment/routines/{photodiodeValidator → visualValidator}/__init__.py

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 from pathlib import Path
+from psychopy.alerts._alerts import alert
 from psychopy.experiment import Param
 from psychopy.experiment.plugins import PluginDevicesMixin, DeviceBackend
 from psychopy.experiment.components import getInitVals
@@ -9,86 +10,62 @@ from psychopy.experiment.routines import Routine, BaseValidatorRoutine
 from psychopy.localization import _translate
 
 
-class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
+class VisualValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
     """
-    Use a photodiode to confirm that stimuli are presented when they should be.
+    Use a light sensor to confirm that visual stimuli are presented when they should be.
     """
     targets = ['PsychoPy']
 
     categories = ['Validation']
-    iconFile = Path(__file__).parent / 'photodiode_validator.png'
-    tooltip = _translate('Photodiode validator')
+    iconFile = Path(__file__).parent / 'visual_validator.png'
+    tooltip = _translate(
+        "Use a light sensor to confirm that visual stimuli are presented when they should be."
+    )
     deviceClasses = []
     version = "2025.1.0"
 
     def __init__(
             self,
             # basic
-            exp, name='photodiode',
-            variability="1/60", report="log",
-            findThreshold=True, threshold=127,
+            exp, name='visualVal',
+            findThreshold=True, threshold=0.5,
             # layout
-            findDiode=True, diodePos="(1, 1)", diodeSize="(0.1, 0.1)", diodeUnits="norm",
+            findSensor=True, sensorPos="(1, 1)", sensorSize="(0.1, 0.1)", sensorUnits="norm",
             # device
-            deviceLabel="", deviceBackend="screenbuffer", port="", channel="0",
-            # data
-            saveValid=True,
+            deviceLabel="", deviceBackend="screenbuffer", channel="0",
     ):
 
         self.exp = exp  # so we can access the experiment if necess
         self.params = {}
         self.depends = []
-        super(PhotodiodeValidatorRoutine, self).__init__(exp, name=name)
+        super(VisualValidatorRoutine, self).__init__(exp, name=name)
         self.order += []
-        self.type = 'PhotodiodeValidator'
+        self.type = 'VisualValidator'
 
-        exp.requireImport(
-            importName="photodiode",
-            importFrom="psychopy.hardware",
-            importAs="phd"
-        )
+        exp.requirePsychopyLibs(['validation'])
 
         # --- Basic ---
         self.order += [
-            "variability",
-            "report",
             "findThreshold",
             "threshold",
-            "findDiode",
-            "diodePos",
-            "diodeSize",
-            "diodeUnits",
+            "findSensor",
+            "sensorPos",
+            "sensorSize",
+            "sensorUnits",
         ]
-
-        self.params['variability'] = Param(
-            variability, valType="code", inputType="single", categ="Basic",
-            label=_translate("Variability (s)"),
-            hint=_translate(
-                "How much variation from intended presentation times (in seconds) is acceptable?"
-            )
-        )
-        self.params['report'] = Param(
-            report, valType="str", inputType="choice", categ="Basic",
-            allowedVals=["log", "err"],
-            allowedLabels=[_translate("Log warning"), _translate("Raise error")],
-            label=_translate("On fail..."),
-            hint=_translate(
-                "What to do when the validation fails. Just log, or stop the script and raise an error?"
-            )
-        )
         self.params['findThreshold'] = Param(
             findThreshold, valType="bool", inputType="bool", categ="Basic",
             label=_translate("Find best threshold?"),
             hint=_translate(
-                "Run a brief Routine to find the best threshold for the photodiode at experiment start?"
+                "Run a brief Routine to find the best threshold for the light sensor at experiment start?"
             )
         )
         self.params['threshold'] = Param(
             threshold, valType="code", inputType="single", categ="Basic",
             label=_translate("Threshold"),
             hint=_translate(
-                "Light threshold at which the photodiode should register a positive, units go from 0 (least light) to "
-                "255 (most light)."
+                "Light threshold at which the light sensor should register a positive, units go from 0 (least sensitive) to "
+                "1 (most sensitive)."
             )
         )
         self.depends.append({
@@ -98,40 +75,40 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
             "true": "hide",  # should...
             "false": "show",  # otherwise...
         })
-        self.params['findDiode'] = Param(
-            findDiode, valType="code", inputType="bool", categ="Basic",
-            label=_translate("Find diode?"),
+        self.params['findSensor'] = Param(
+            findSensor, valType="code", inputType="bool", categ="Basic",
+            label=_translate("Find sensor?"),
             hint=_translate(
-                "Run a brief Routine to find the size and position of the photodiode at experiment start?"
+                "Run a brief Routine to find the size and position of the light sensor at experiment start?"
             )
         )
-        self.params['diodePos'] = Param(
-            diodePos, valType="list", inputType="single", categ="Basic",
+        self.params['sensorPos'] = Param(
+            sensorPos, valType="list", inputType="single", categ="Basic",
             updates="constant", allowedUpdates=['constant', 'set every repeat', 'set every frame'],
             label=_translate("Position [x,y]"),
             hint=_translate(
-                "Position of the photodiode on the window."
+                "Position of the light sensor on the window."
             )
         )
-        self.params['diodeSize'] = Param(
-            diodeSize, valType="list", inputType="single", categ="Basic",
+        self.params['sensorSize'] = Param(
+            sensorSize, valType="list", inputType="single", categ="Basic",
             updates="constant", allowedUpdates=['constant', 'set every repeat', 'set every frame'],
             label=_translate("Size [x,y]"),
             hint=_translate(
-                "Size of the area covered by the photodiode on the window."
+                "Size of the area covered by the light sensor on the window."
             )
         )
-        self.params['diodeUnits'] = Param(
-            diodeUnits, valType="str", inputType="choice", categ="Basic",
+        self.params['sensorUnits'] = Param(
+            sensorUnits, valType="str", inputType="choice", categ="Basic",
             allowedVals=['from exp settings', 'deg', 'cm', 'pix', 'norm', 'height', 'degFlatPos', 'degFlat'],
             label=_translate("Spatial units"),
             hint=_translate(
-                "Spatial units in which the photodiode size and position are specified."
+                "Spatial units in which the light sensor size and position are specified."
             )
         )
-        for param in ("diodePos", "diodeSize", "diodeUnits"):
+        for param in ("sensorPos", "sensorSize", "sensorUnits"):
             self.depends.append({
-                "dependsOn": "findDiode",  # if...
+                "dependsOn": "findSensor",  # if...
                 "condition": "==True",  # is...
                 "param": param,  # then...
                 "true": "hide",  # should...
@@ -159,31 +136,22 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
             deviceBackend, valType="code", inputType="choice", categ="Device",
             allowedVals=self.getBackendKeys,
             allowedLabels=self.getBackendLabels,
-            label=_translate("Photodiode type"),
+            label=_translate("Light sensor type"),
             hint=_translate(
-                "Type of photodiode to use."
+                "Type of light sensor to use."
             ),
             direct=False
         )
         self.params['channel'] = Param(
             channel, valType="code", inputType="single", categ="Device",
-            label=_translate("Photodiode channel"),
+            label=_translate("Light sensor channel"),
             hint=_translate(
-                "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 "
+                "If relevant, a channel number attached to the light sensor, to distinguish it "
+                "from other light sensors on the same port. Leave blank to use the first light sensor "
                 "which can detect the Window."
             )
         )
 
-        # --- Data ---
-        self.params['saveValid'] = Param(
-            saveValid, valType="code", inputType="bool", categ="Data",
-            label=_translate('Save validation results'),
-            hint=_translate(
-                "Save validation results after validating on/offset times for stimuli"
-            )
-        )
-
         self.loadBackends()
 
     def writeDeviceCode(self, buff):
@@ -207,9 +175,8 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
         # find threshold if indicated
         if self.params['findThreshold']:
             code = (
-                "# find threshold for photodiode\n"
-                "if %(deviceLabelCode)s.getThreshold(channel=%(channel)s) is None:\n"
-                "    %(deviceLabelCode)s.findThreshold(win, channel=%(channel)s)\n"
+                "# find threshold for light sensor\n"
+                "%(deviceLabelCode)s.findThreshold(win, channel=%(channel)s)\n"
             )
         else:
             code = (
@@ -217,54 +184,51 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
             )
         buff.writeOnceIndentedLines(code % inits)
         # find pos if indicated
-        if self.params['findDiode']:
+        if self.params['findSensor']:
             code = (
-                "# find position and size of photodiode\n"
-                "if %(deviceLabelCode)s.pos is None and %(deviceLabelCode)s.size is None and %(deviceLabelCode)s.units is None:\n"
-                "    %(deviceLabelCode)s.findPhotodiode(win, channel=%(channel)s)\n"
+                "# find position and size of the light sensor\n"
+                "%(deviceLabelCode)s.findSensor(win, channel=%(channel)s)\n"
             )
             buff.writeOnceIndentedLines(code % inits)
 
     def writeMainCode(self, buff):
         inits = getInitVals(self.params)
-        # get diode
+        # get Sensor
         code = (
-            "# diode object for %(name)s\n"
-            "%(name)sDiode = deviceManager.getDevice(%(deviceLabel)s)\n"
+            "# Sensor object for %(name)s\n"
+            "%(name)sSensor = deviceManager.getDevice(%(deviceLabel)s)\n"
         )
         buff.writeIndentedLines(code % inits)
 
         if self.params['threshold'] and not self.params['findThreshold']:
             code = (
-                "%(name)sDiode.setThreshold(%(threshold)s, channel=%(channel)s)\n"
+                "%(name)sSensor.setThreshold(%(threshold)s, channel=%(channel)s)\n"
             )
             buff.writeIndentedLines(code % inits)
-        # find/set diode position
-        if not self.params['findDiode']:
+        # find/set Sensor position
+        if not self.params['findSensor']:
             code = ""
             # set units (unless None)
-            if self.params['diodeUnits']:
+            if self.params['sensorUnits']:
                 code += (
-                    "%(name)sDiode.units = %(diodeUnits)s\n"
+                    "%(name)sSensor.units = %(sensorUnits)s\n"
                 )
             # set pos (unless None)
-            if self.params['diodePos']:
+            if self.params['sensorPos']:
                 code += (
-                    "%(name)sDiode.pos = %(diodePos)s\n"
+                    "%(name)sSensor.pos = %(sensorPos)s\n"
                 )
             # set size (unless None)
-            if self.params['diodeSize']:
+            if self.params['sensorSize']:
                 code += (
-                    "%(name)sDiode.size = %(diodeSize)s\n"
+                    "%(name)sSensor.size = %(sensorSize)s\n"
                 )
             buff.writeIndentedLines(code % inits)
         # create validator object
         code = (
             "# validator object for %(name)s\n"
-            "%(name)s = phd.PhotodiodeValidator(\n"
-            "    win, %(name)sDiode, %(channel)s,\n"
-            "    variability=%(variability)s,\n"
-            "    report=%(report)s,\n"
+            "%(name)s = validation.VisualValidator(\n"
+            "    win, %(name)sSensor, %(channel)s,\n"
             ")\n"
         )
         buff.writeIndentedLines(code % inits)
@@ -297,7 +261,7 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
 
         # choose a clock to sync to according to component's params
         if "syncScreenRefresh" in stim.params and stim.params['syncScreenRefresh']:
-            clockStr = ""
+            clockStr = "clock=globalClock"
         else:
             clockStr = "clock=routineTimer"
         # sync component start/stop timers with validator clocks
@@ -328,12 +292,18 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
         """
         # get starting indent level
         startIndent = buff.indentLevel
-
+        # choose attributes based on sync status
+        if "syncScreenRefresh" in stim.params and stim.params['syncScreenRefresh']:
+            startAttr = "tStartRefresh"
+            stopAttr = "tStopRefresh"
+        else:
+            startAttr = "tStart"
+            stopAttr = "tStop"
         # validate start time
         code = (
             "# validate {name} start time\n"
             "if {name}.status == STARTED and %(name)s.status == STARTED:\n"
-            "    %(name)s.tStart, %(name)s.tStartValid = %(name)s.validate(state=True, t={name}.tStartRefresh)\n"
+            "    %(name)s.tStart, %(name)s.tStartDelay = %(name)s.validate(state=True, t={name}.{startAttr})\n"
             "    if %(name)s.tStart is not None:\n"
             "        %(name)s.status = FINISHED\n"
         )
@@ -341,19 +311,15 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
             # save validated start time if stim requested
             code += (
             "        thisExp.addData('{name}.%(name)s.started', %(name)s.tStart)\n"
+            "        thisExp.addData('%(name)s.startDelay', %(name)s.tStartDelay)\n"
             )
-        if self.params['saveValid']:
-            # save validation result if params requested
-            code += (
-            "        thisExp.addData('{name}.started.valid', %(name)s.tStartValid)\n"
-            )
-        buff.writeIndentedLines(code.format(**stim.params) % self.params)
+        buff.writeIndentedLines(code.format(startAttr=startAttr, **stim.params) % self.params)
 
         # validate stop time
         code = (
             "# validate {name} stop time\n"
             "if {name}.status == FINISHED and %(name)s.status == STARTED:\n"
-            "    %(name)s.tStop, %(name)s.tStopValid = %(name)s.validate(state=False, t={name}.tStopRefresh)\n"
+            "    %(name)s.tStop, %(name)s.tStopDelay = %(name)s.validate(state=False, t={name}.{stopAttr})\n"
             "    if %(name)s.tStop is not None:\n"
             "        %(name)s.status = FINISHED\n"
         )
@@ -361,13 +327,9 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
             # save validated start time if stim requested
             code += (
             "        thisExp.addData('{name}.%(name)s.stopped', %(name)s.tStop)\n"
+            "        thisExp.addData('{name}.%(name)s.stopDelay', %(name)s.tStopDelay)\n"
             )
-        if self.params['saveValid']:
-            # save validation result if params requested
-            code += (
-            "        thisExp.addData('{name}.stopped.valid', %(name)s.tStopValid)\n"
-            )
-        buff.writeIndentedLines(code.format(**stim.params) % self.params)
+        buff.writeIndentedLines(code.format(stopAttr=stopAttr, **stim.params) % self.params)
 
         # return change in indent level
         return buff.indentLevel - startIndent
@@ -375,6 +337,7 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
     def findConnectedStimuli(self):
         # list of linked components
         stims = []
+        routines = []
         # inspect each Routine
         for emt in self.exp.flow:
             # skip non-standard Routines
@@ -388,22 +351,28 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
                 if compValidator == self:
                     # if found, add the comp to the list
                     stims.append(comp)
+                    # add to list of Routines containing comps
+                    if emt not in routines:
+                        routines.append(emt)
+        # if any rt has two validated comps, warn
+        if len(routines) < len(stims):
+            alert(3610, obj=self, strFields={'validator': self.name})
 
         return stims
 
 
-class ScreenBufferPhotodiodeValidatorBackend(DeviceBackend):
+class ScreenBufferVisualValidatorBackend(DeviceBackend):
     """
-    Adds a basic screen buffer emulation backend for PhotodiodeValidator, as well as acting as an
-    example for implementing other photodiode device backends.
+    Adds a basic screen buffer emulation backend for VisualValidator, as well as acting as an
+    example for implementing other light sensor device backends.
     """
 
     key = "screenbuffer"
     label = _translate("Screen Buffer (Debug)")
-    component = PhotodiodeValidatorRoutine
-    deviceClasses = ["psychopy.hardware.photodiode.ScreenBufferSampler"]
+    component = VisualValidatorRoutine
+    deviceClasses = ["psychopy.hardware.lightsensor.ScreenBufferSampler"]
 
-    def getParams(self: PhotodiodeValidatorRoutine):
+    def getParams(self: VisualValidatorRoutine):
         # define order
         order = [
         ]
@@ -416,13 +385,13 @@ class ScreenBufferPhotodiodeValidatorBackend(DeviceBackend):
         # no requirements needed - so just return
         return
 
-    def writeDeviceCode(self: PhotodiodeValidatorRoutine, buff):
+    def writeDeviceCode(self: VisualValidatorRoutine, buff):
         # get inits
         inits = getInitVals(self.params)
         # make ButtonGroup object
         code = (
             "deviceManager.addDevice(\n"
-            "    deviceClass='psychopy.hardware.photodiode.ScreenBufferSampler',\n"
+            "    deviceClass='psychopy.hardware.lightsensor.ScreenBufferSampler',\n"
             "    deviceName=%(deviceLabel)s,\n"
             "    win=win,\n"
             ")\n"

psychopy/experiment/utils.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 # Part of the PsychoPy library
-# Copyright (C) 2002-2018 Jonathan Peirce (C) 2019-2024 Open Science Tools Ltd.
+# Copyright (C) 2002-2018 Jonathan Peirce (C) 2019-2025 Open Science Tools Ltd.
 # Distributed under the terms of the GNU General Public License (GPL).
 
 """Utility functions to support Experiment classes

psychopy/gui/__init__.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 #  Part of the PsychoPy library
-# Copyright (C) 2002-2018 Jonathan Peirce (C) 2019-2024 Open Science Tools Ltd.
+# Copyright (C) 2002-2018 Jonathan Peirce (C) 2019-2025 Open Science Tools Ltd.
 # Distributed under the terms of the GNU General Public License (GPL).
 
 """