psychopy 2025.1.0__py3-none-any.whl → 2025.2.1__py3-none-any.whl

psychopy/experiment/components/settings/__init__.py

@@ -71,6 +71,11 @@ participantIdAliases = ('participant', 'Participant', 'Subject', 'Observer')
 #         pass
 
 
+def getSoundBackends():
+    from psychopy.sound.sound import Sound
+    return list(Sound.getBackends())
+
+
 class SettingsComponent:
     """This component stores general info about how to run the experiment
     """
@@ -250,8 +255,8 @@ class SettingsComponent:
             "winBackend",
             "Screen",
             "Full-screen window",
-            "Show mouse",
             "Window size (pixels)",
+            "Show mouse",
             "Units",
             "color",
             "blendMode",
@@ -266,16 +271,36 @@ class SettingsComponent:
             fullScr, valType='bool', inputType="bool", allowedTypes=[],
             hint=_translate("Run the experiment full-screen (recommended)"),
             label=_translate("Full-screen window"), categ='Screen')
+        self.params['Window size (pixels)'] = Param(
+            winSize, valType='list', inputType="single", allowedTypes=[],
+            hint=_translate("Size of window (if not fullscreen)"),
+            label=_translate("Window size (pixels)"), categ='Screen'
+        )
+        self.depends.append({
+            'dependsOn': "Full-screen window",  # if...
+            'condition': "",  # matches
+            'param': "Window size (pixels)",  # then...
+            'true': "hide",  # should...
+            'false': "show",  # otherwise...
+        })
+        self.params['Show mouse'] = Param(
+            showMouse, valType='bool', inputType="bool", allowedTypes=[],
+            hint=_translate("Should the mouse be visible on screen? Only applicable for fullscreen experiments."),
+            label=_translate("Show mouse"), categ='Screen'
+        )
+        self.depends.append({
+            'dependsOn': "Full-screen window",  # if...
+            'condition': "",  # matches
+            'param': "Show mouse",  # then...
+            'true': "show",  # should...
+            'false': "hide",  # otherwise...
+        })
         self.params['winBackend'] = Param(
             winBackend, valType='str', inputType="choice", categ="Screen",
             allowedVals=plugins.getWindowBackends(),
             hint=_translate("What Python package should be used behind the scenes for drawing to the window?"),
             label=_translate("Window backend")
-        )
-        self.params['Window size (pixels)'] = Param(
-            winSize, valType='list', inputType="single", allowedTypes=[],
-            hint=_translate("Size of window (if not fullscreen)"),
-            label=_translate("Window size (pixels)"), categ='Screen')
+        )        
         self.params['Screen'] = Param(
             screen, valType='num', inputType="spin", allowedTypes=[],
             hint=_translate("Which physical screen to run on (1 or 2)"),
@@ -323,10 +348,6 @@ class SettingsComponent:
             hint=_translate("Should new stimuli be added or averaged with "
                             "the stimuli that have been drawn already"),
             label=_translate("Blend mode"), categ='Screen')
-        self.params['Show mouse'] = Param(
-            showMouse, valType='bool', inputType="bool", allowedTypes=[],
-            hint=_translate("Should the mouse be visible on screen? Only applicable for fullscreen experiments."),
-            label=_translate("Show mouse"), categ='Screen')
         self.params['measureFrameRate'] = Param(
             measureFrameRate, valType="bool", inputType="bool", categ="Screen",
             label=_translate("Measure frame rate?"),
@@ -381,7 +402,7 @@ class SettingsComponent:
             label=_translate("Force stereo"))
         self.params['Audio lib'] = Param(
             'ptb', valType='str', inputType="choice",
-            allowedVals=['ptb', 'pyo', 'sounddevice', 'pygame'],
+            allowedVals=getSoundBackends,
             hint=_translate("Which Python sound engine do you want to play your sounds?"),
             label=_translate("Audio library"), categ='Audio')
 
@@ -906,13 +927,6 @@ class SettingsComponent:
             "from psychopy import prefs\n"
             "from psychopy import plugins\n"
             "plugins.activatePlugins()\n"  # activates plugins
-        )
-        # adjust the prefs for this study if needed
-        if self.params['Audio lib'].val.lower() != 'use prefs':
-            buff.writelines(
-                "prefs.hardware['audioLib'] = {}\n".format(self.params['Audio lib'])
-            )
-        buff.write(
             "from psychopy import %s\n" % ', '.join(psychopyImports) +
             "from psychopy.tools import environmenttools\n"
             "from psychopy.constants import (\n"
@@ -926,7 +940,8 @@ class SettingsComponent:
             "from numpy.random import %s\n" % ', '.join(_numpyRandomImports) +
             "import os  # handy system and path functions\n" +
             "import sys  # to get file system encoding\n"
-            "\n")
+            "\n"
+        )
 
         if not self.params['eyetracker'] == "None" or self.params['keyboardBackend'] == "ioHub":
             code = (
@@ -1768,14 +1783,17 @@ class SettingsComponent:
             "    )\n"
         )
         buff.writeIndentedLines(code % inits)
-        # write any device setup code required by a component
-        for rt in self.exp.flow:
-            if isinstance(rt, Routine):
-                for comp in rt:
-                    if hasattr(comp, "writeDeviceCode"):
-                        comp.writeDeviceCode(buff)
-            elif isinstance(rt, BaseStandaloneRoutine):
-                rt.writeDeviceCode(buff)
+        # setup devices from config
+        for deviceName in self.exp.getRequiredDeviceNames():
+            if deviceName in prefs.devices:
+                # write device setup if possile
+                prefs.devices[deviceName].writeDeviceCode(buff)
+            elif deviceName is None:
+                # if default, let init code handle device
+                pass
+            else:
+                # alert if not
+                alert(4810, strFields={'deviceName': deviceName})
 
         code = (
             "# return True if completed successfully\n"

psychopy/experiment/components/sound/__init__.py

@@ -11,6 +11,7 @@ from pathlib import Path
 from psychopy.alerts._alerts import alert
 from psychopy.experiment.components import BaseDeviceComponent, Param, getInitVals, \
     _translate
+from psychopy.experiment.devices import DeviceBackend
 from psychopy.experiment.utils import canBeNumeric
 from psychopy.tools.audiotools import knownNoteNames
 
@@ -23,6 +24,12 @@ class SoundComponent(BaseDeviceComponent):
     tooltip = _translate('Sound: play recorded files or generated sounds', )
     deviceClasses = ["psychopy.hardware.speaker.SpeakerDevice"]
     validatorClasses = ["AudioValidatorRoutine"]
+    legacyParams = [
+        # old device setup params, no longer needed as this is handled by DeviceManager
+        "speakerIndex",
+        "resample",
+        "latencyClass",
+    ]
 
     def __init__(
         self,
@@ -72,7 +79,7 @@ class SoundComponent(BaseDeviceComponent):
         hnt = _translate("A sound can be a note name (e.g. A or Bf), a number"
                          " to specify Hz (e.g. 440) or a filename")
         self.params['sound'] = Param(
-            sound, valType='str', inputType="file", allowedTypes=[], updates='constant', categ='Basic',
+            sound, valType='str', inputType="soundFile", allowedTypes=[], updates='set every repeat', categ='Basic',
             allowedUpdates=['set every repeat'],
             hint=hnt,
             label=_translate("Sound"))
@@ -118,61 +125,6 @@ class SoundComponent(BaseDeviceComponent):
             ),
             label=_translate("Force end of Routine"))
 
-        # --- Device params ---
-        self.order += [
-            "speakerIndex",
-            "resample",
-            "latencyClass",
-        ]
-        def getSpeakerLabels():
-            from psychopy.hardware.speaker import SpeakerDevice
-            labels = [_translate("From preferences")]
-            for profile in SpeakerDevice.getAvailableDevices():
-                labels.append(profile['deviceName'])
-
-            return labels
-
-        def getSpeakerValues():
-            from psychopy.hardware.speaker import SpeakerDevice
-            vals = [""]
-            for profile in SpeakerDevice.getAvailableDevices():
-                vals.append(profile['index'])
-
-            return vals
-
-        self.params['speakerIndex'] = Param(
-            speakerIndex, valType="str", inputType="choice", categ="Device",
-            allowedVals=getSpeakerValues,
-            allowedLabels=getSpeakerLabels,
-            hint=_translate(
-                "What speaker to play this sound on"
-            ),
-            label=_translate("Speaker"))
-        self.params['resample'] = Param(
-            resample, valType="str", inputType="bool", categ="Device",
-            label=_translate("Resample"),
-            hint=_translate(
-                "If the sample rate of a clip doesn't match the sample rate of the speaker, should "
-                "we resample it to match?"
-            )
-        )
-        self.params['latencyClass'] = Param(
-            latencyClass, valType="code", inputType="choice", categ="Device",
-            allowedVals=[0, 1, 2, 3, 4],
-            allowedLabels=[
-                _translate("Shared"), 
-                _translate("Shared low-latency (recommended)"), 
-                _translate("Exclusive low-latency"),
-                _translate("Exclusive aggressive low-latency (with fallback)"),
-                _translate("Exclusive aggressive low-latency (no fallback)"),
-            ],
-            label=_translate("Latency/exclusivity mode"),
-            hint=_translate(
-                "How should PsychoPy handle latency? Some options will result in other apps being "
-                "denied access to the speaker while your experiment is running."
-            )
-        )
-
         # --- Testing ---
         self.params['validator'] = Param(
             validator, valType="code", inputType="choice", categ="Testing",
@@ -184,25 +136,13 @@ class SoundComponent(BaseDeviceComponent):
             )
         )
 
-    def writeDeviceCode(self, buff):
-        inits = getInitVals(self.params)
-        # alert user to inefficient configuration
-        if self.params['resample'] and self.params['latencyClass'] == 2:
-            alert(3210, strFields={'deviceName': inits['deviceLabel']})
-        # initialise speaker
+    def writeInitCode(self, buff):
+        # set sound backend (only once per exp)
         code = (
-            "# create speaker %(deviceLabel)s\n"
-            "deviceManager.addDevice(\n"
-            "    deviceName=%(deviceLabel)s,\n"
-            "    deviceClass='psychopy.hardware.speaker.SpeakerDevice',\n"
-            "    index=%(speakerIndex)s,\n"
-            "    resample=%(resample)s,\n"
-            "    latencyClass=%(latencyClass)s,\n"
-            ")\n"
+            "# set audio backend\n"
+            "sound.Sound.backend = %(Audio lib)s\n"
         )
-        buff.writeOnceIndentedLines(code % inits)
-
-    def writeInitCode(self, buff):
+        buff.writeOnceIndentedLines(code % self.exp.settings.params)
         # replaces variable params with sensible defaults
         inits = getInitVals(self.params)
         if not canBeNumeric(inits['stopVal'].val):
@@ -430,3 +370,72 @@ class SoundComponent(BaseDeviceComponent):
                 params=params,
                 target=target,
             )
+
+
+class SpeakerDeviceBackend(DeviceBackend):
+    # name of this backend to display in Device Manager
+    backendLabel = "Speaker"
+    # class of the device which this backend corresponds to
+    deviceClass = "psychopy.hardware.speaker.SpeakerDevice"
+    # icon to show in device manager
+    icon = "light/sound.png"
+
+    def __init__(self, profile):
+        # init parent class
+        DeviceBackend.__init__(self, profile)
+
+        # add params
+        self.order += [
+            "latencyClass",
+            "resample",
+        ]
+        self.params['latencyClass'] = Param(
+            1, valType="code", inputType="choice",
+            allowedVals=[0, 1, 2, 3, 4],
+            allowedLabels=[
+                _translate("Shared"), 
+                _translate("Shared low-latency (recommended)"), 
+                _translate("Exclusive low-latency"),
+                _translate("Exclusive aggressive low-latency (with fallback)"),
+                _translate("Exclusive aggressive low-latency (no fallback)"),
+            ],
+            label=_translate("Latency/exclusivity mode"),
+            hint=_translate(
+                "How should PsychoPy handle latency? Some options will result in other apps being "
+                "denied access to the speaker while your experiment is running."
+            )
+        )
+        self.params['resample'] = Param(
+            True, valType="str", inputType="bool",
+            label=_translate("Resample"),
+            hint=_translate(
+                "If the sample rate of a clip doesn't match the sample rate of the speaker, should "
+                "we resample it to match?"
+            )
+        )
+    
+    def writeDeviceCode(self, buff):
+        """
+        Code to setup a device with this backend.
+
+        Parameters
+        ----------
+        buff : io.StringIO
+            Text buffer to write code to.
+        """
+        # alert user to inefficient configuration
+        if self.params['resample'] and self.params['latencyClass'] == 2:
+            alert(3210, strFields={'deviceName': self.params['deviceLabel']})
+        # write basic code
+        self.writeBaseDeviceCode(buff, close=False)
+        # add exclusive param and close
+        code = (
+            "    resample=%(resample)s,\n"
+            "    latencyClass=%(latencyClass)s,\n"
+            ")\n"
+        )
+        buff.writeIndentedLines(code % self.params)
+
+
+# register backend with Component
+SoundComponent.registerBackend(SpeakerDeviceBackend)

psychopy/experiment/components/soundsensor/__init__.py

@@ -1,10 +1,10 @@
 from pathlib import Path
+from psychopy.experiment.devices import DeviceBackend
 from psychopy.experiment.components import BaseComponent, BaseDeviceComponent, Param, getInitVals
-from psychopy.experiment.plugins import PluginDevicesMixin, DeviceBackend
 from psychopy.localization import _translate
 
 
-class SoundSensorComponent(BaseDeviceComponent, PluginDevicesMixin):
+class SoundSensorComponent(BaseDeviceComponent):
     """
     Component for getting button presses from a button box device.
     """
@@ -13,6 +13,14 @@ class SoundSensorComponent(BaseDeviceComponent, PluginDevicesMixin):
     iconFile = Path(__file__).parent / 'soundsensor.png'
     tooltip = _translate('Voice Key: Get input from a microphone as simple true/false values')
     beta = True
+    legacyParams = [
+        # old device setup params, no longer needed as this is handled by DeviceManager
+        "deviceBackend",
+        "meMicrophone",
+        "meThreshold",
+        "meRange",
+        "meSamplingWindow",
+    ]
 
     def __init__(
             self, exp, parentName,
@@ -112,25 +120,6 @@ class SoundSensorComponent(BaseDeviceComponent, PluginDevicesMixin):
             ),
             label=_translate("Correct answer"), direct=False)
 
-        # --- Device params ---
-        self.order += [
-            "deviceBackend",
-        ]
-
-        self.params['deviceBackend'] = Param(
-            deviceBackend, valType="str", inputType="choice", categ="Device",
-            allowedVals=self.getBackendKeys,
-            allowedLabels=self.getBackendLabels,
-            label=_translate("Device backend"),
-            hint=_translate(
-                "What kind of sound sensor is it? What package/plugin should be used to talk to it?"
-            ),
-            direct=False
-        )
-
-        # add params for any backends
-        self.loadBackends()
-
     def writeInitCode(self, buff):
         inits = getInitVals(self.params)
         # code to create object
@@ -267,17 +256,13 @@ class SoundSensorComponent(BaseDeviceComponent, PluginDevicesMixin):
         
 
 class MicrophoneSoundSensorBackend(DeviceBackend):
-    """
-    Adds a basic microphone emulation backend for SoundSensorComponent, as well as acting as an example
-    for implementing other SoundSensorBackends.
-    """
-
-    key = "microphone"
-    label = _translate("Microphone emulator")
-    component = SoundSensorComponent
-    deviceClasses = ['psychopy.hardware.soundsensor.MicrophoneSoundSensorEmulator']
+    backendLabel = "Microphone Sound Sensor"
+    deviceClass = "psychopy.hardware.soundsensor.MicrophoneSoundSensor"
+    icon = "light/soundsensor.png"
 
-    def getParams(self: SoundSensorComponent):
+    def __init__(self, profile):
+        # init parent class
+        DeviceBackend.__init__(self, profile)
         # define order
         order = [
             "meMicrophone",
@@ -286,31 +271,8 @@ class MicrophoneSoundSensorBackend(DeviceBackend):
             "meSamplingWindow",
         ]
         # define params
-        params = {}
-        def getDeviceIndices():
-            from psychopy.hardware.microphone import MicrophoneDevice
-            profiles = MicrophoneDevice.getAvailableDevices()
-
-            return [None] + [profile['index'] for profile in profiles]
-
-        def getDeviceNames():
-            from psychopy.hardware.microphone import MicrophoneDevice
-            profiles = MicrophoneDevice.getAvailableDevices()
-
-            return ["default"] + [profile['deviceName'] for profile in profiles]
-        
-        params['meMicrophone'] = Param(
-            None, valType="str", inputType="choice", categ="Device",
-            updates="constant", allowedUpdates=None,
-            allowedVals=getDeviceIndices,
-            allowedLabels=getDeviceNames,
-            label=_translate("Microphone"),
-            hint=_translate(
-                "What microphone device to take volume readings from?"
-            )
-        )
-        params['meThreshold'] = Param(
-            0.5, valType="code", inputType="single", categ="Device",
+        self.params['threshold'] = Param(
+            0.5, valType="code", inputType="single",
             updates="constant", allowedUpdates=None,
             label=_translate("Threshold (0-1)"),
             hint=_translate(
@@ -318,17 +280,17 @@ class MicrophoneSoundSensorBackend(DeviceBackend):
                 "register a sound sensor response"
             )
         )
-        params['meRange'] = Param(
-            (0, 1), valType="list", inputType="single", categ="Device",
+        self.params['dbRange'] = Param(
+            (0, 1), valType="list", inputType="single",
             updates="constant", allowedUpdates=None,
             label=_translate("Decibel range"),
             hint=_translate(
                 "What kind of values (dB) would you expect to receive from this device? In other "
-                "words, how many dB does a threshold of 0 and of 255 correspond to?"
+                "words, how many dB does a threshold of 0 and 1 correspond to?"
             )
         )
-        params['meSamplingWindow'] = Param(
-            0.03, valType="code", inputType="single", categ="Device",
+        self.params['samplingWindow'] = Param(
+            0.03, valType="code", inputType="single",
             updates="constant", allowedUpdates=None,
             label=_translate("Sampling window (s)"),
             hint=_translate(
@@ -336,26 +298,27 @@ class MicrophoneSoundSensorBackend(DeviceBackend):
                 "precise, but also less subject to random noise."
             )
         )
+    
+    def writeDeviceCode(self, buff):
+        """
+        Code to setup a device with this backend.
 
-        return params, order
-
-    def addRequirements(self: SoundSensorComponent):
-        self.exp.requireImport(
-            importName="microphone", importFrom="psychopy.hardware"
-        )
-
-    def writeDeviceCode(self: SoundSensorComponent, buff):
-        # get inits
-        inits = getInitVals(self.params)
-        # make ButtonGroup object
+        Parameters
+        ----------
+        buff : io.StringIO
+            Text buffer to write code to.
+        """
+        # write basic code
+        self.writeBaseDeviceCode(buff, close=False)
+        # add exclusive param and close
         code = (
-            "deviceManager.addDevice(\n"
-            "    deviceClass='psychopy.hardware.soundsensor.MicrophoneSoundSensorEmulator',\n"
-            "    deviceName=%(deviceLabel)s,\n"
-            "    device=%(meMicrophone)s,\n"
-            "    threshold=%(meThreshold)s, \n"
-            "    dbRange=%(meRange)s, \n"
-            "    samplingWindow=%(meSamplingWindow)s, \n"
+            "    threshold=%(threshold)s, \n"
+            "    dbRange=%(dbRange)s, \n"
+            "    samplingWindow=%(samplingWindow)s,\n"
             ")\n"
         )
-        buff.writeOnceIndentedLines(code % inits)
+        buff.writeIndentedLines(code % self.params)
+
+
+# register backend with Component
+SoundSensorComponent.registerBackend(MicrophoneSoundSensorBackend)