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

psychopy/experiment/components/microphone/__init__.py

@@ -10,6 +10,7 @@ from pathlib import Path
 
 from psychopy import logging
 from psychopy.alerts import alert
+from psychopy.experiment.devices import DeviceBackend
 from psychopy.tools import stringtools as st, systemtools as syst, audiotools as at
 from psychopy.experiment.components import (
     BaseComponent, BaseDeviceComponent, Param, getInitVals, _translate
@@ -24,7 +25,6 @@ class MicrophoneComponent(BaseDeviceComponent):
     iconFile = Path(__file__).parent / 'microphone.png'
     tooltip = _translate('Microphone: basic sound capture (fixed onset & '
                          'duration), okay for spoken words')
-    deviceClasses = ['psychopy.hardware.microphone.MicrophoneDevice']
 
     # dict of available transcribers (plugins can add entries to this)
     localTranscribers = {
@@ -37,14 +37,22 @@ class MicrophoneComponent(BaseDeviceComponent):
     transcriberPaths = {
         'google': "psychopy.sound.transcribe:GoogleCloudTranscriber"
     }
+    legacyParams = [
+        # old device setup params, no longer needed as this is handled by DeviceManager
+        "device",
+        "exclusive",
+        "sampleRate",
+        "channels",
+        "stereo",
+        "channel",
+        "maxSize"
+    ]
 
     def __init__(
         self, exp, parentName, name='mic',
         startType='time (s)', startVal=0.0,
         stopType='duration (s)', stopVal=2.0,
         startEstim='', durationEstim='',
-        device=None,
-        exclusive=False,
         outputType='default', speakTimes=False, trimSilent=False,
         policyWhenFull='warn',
         transcribe=False, transcribeBackend="none",
@@ -52,6 +60,8 @@ class MicrophoneComponent(BaseDeviceComponent):
         transcribeWhisperModel="base",
         transcribeWhisperDevice="auto",
         #legacy
+        device=None,
+        exclusive=False,
         sampleRate=48000, 
         channels=2,
         stereo=None, 
@@ -74,44 +84,6 @@ class MicrophoneComponent(BaseDeviceComponent):
             'The duration of the recording in seconds; blank = 0 sec')
         self.params['stopType'].hint = msg
 
-        # --- Device params ---
-        self.order += [
-            "device",
-            "exclusive",
-            "maxSize",
-        ]
-
-        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]
-
-        self.params['device'] = Param(
-            device, valType='str', inputType="choice", categ="Device",
-            allowedVals=getDeviceIndices,
-            allowedLabels=getDeviceNames,
-            label=_translate("Device"),
-            hint=_translate(
-                "What microphone device would you like the use to record? This will only affect "
-                "local experiments - online experiments ask the participant which mic to use."
-            )
-        )
-        self.params['exclusive'] = Param(
-            exclusive, valType="code", inputType="bool", categ="Device",
-            label=_translate("Exclusive control"),
-            hint=_translate(
-                "Take exclusive control of the microphone, so other apps can't use it during your "
-                "experiment."
-            )
-        )
-
         # --- Data params ---
         msg = _translate(
             "What file type should output audio files be saved as?")
@@ -268,32 +240,6 @@ class MicrophoneComponent(BaseDeviceComponent):
         """
         return {'None': "none", **self.localTranscribers, **self.onlineTranscribers}
 
-    def writeDeviceCode(self, buff):
-        """
-        Code to setup the CameraDevice for this component.
-
-        Parameters
-        ----------
-        buff : io.StringIO
-            Text buffer to write code to.
-        """
-        inits = getInitVals(self.params)
-
-        # --- setup mic ---
-        # force index to str type (holdover from when we used numeric indices)
-        inits['device'].valType = "str"
-        # initialise mic device
-        code = (
-            "# initialise microphone\n"
-            "deviceManager.addDevice(\n"
-            "    deviceClass='psychopy.hardware.microphone.MicrophoneDevice',\n"
-            "    deviceName=%(deviceLabel)s,\n"
-            "    index=%(device)s,\n"
-            "    exclusive=%(exclusive)s,\n"
-            ")\n"
-        )
-        buff.writeOnceIndentedLines(code % inits)
-
     def writeStartCode(self, buff):
         inits = getInitVals(self.params)
         # Use filename with a suffix to store recordings
@@ -366,7 +312,7 @@ class MicrophoneComponent(BaseDeviceComponent):
     def writeInitCodeJS(self, buff):
         inits = getInitVals(self.params)
         # Alert user if non-default value is selected for device
-        if inits['device'].val != '$None':
+        if inits['deviceLabel'].val not in (None, "", 'None'):
             alert(5055, strFields={'name': inits['name'].val})
         # Write code
         code = (
@@ -462,9 +408,7 @@ class MicrophoneComponent(BaseDeviceComponent):
             inits['transcribeBackend'].val = None
         # Warn user if their transcriber won't work locally
         if inits['transcribe'].val:
-            if  self.params['transcribeBackend'].val in self.localTranscribers:
-                inits['transcribeBackend'].val = self.localTranscribers[self.params['transcribeBackend'].val]
-            else:
+            if  self.params['transcribeBackend'].val not in self.localTranscribers.values():
                 default = list(self.localTranscribers.values())[0]
                 alert(4610, strFields={"transcriber": inits['transcribeBackend'].val, "default": default})
         # Store recordings from this routine
@@ -608,42 +552,49 @@ class MicrophoneComponent(BaseDeviceComponent):
         buff.writeIndentedLines(code % inits)
 
 
-def getDeviceName(index):
-    """
-    Get device name from a given index
-
-    Parameters
-    ----------
-    index : int or None
-        Index of the device to use
-    """
-    name = "defaultMicrophone"
-    if isinstance(index, str) and index.isnumeric():
-        index = int(index)
-    for dev in syst.getAudioCaptureDevices():
-        if dev['index'] == index:
-            name = dev['name']
-
-    return name
-
-
-def getDeviceVarName(index, case="camel"):
-    """
-    Get device name from a given index and convert it to a valid variable name.
-
-    Parameters
-    ----------
-    index : int or None
-        Index of the device to use
-    case : str
-        Format of the variable name (see stringtools.makeValidVarName for info on accepted formats)
-    """
-    # Get device name
-    name = getDeviceName(index)
-    # If device name is just default, add "microphone" for clarity
-    if name == "default":
-        name += "_microphone"
-    # Make valid
-    varName = st.makeValidVarName(name, case=case)
-
-    return varName
+class MicrophoneDeviceBackend(DeviceBackend):
+    # name of this backend to display in Device Manager
+    backendLabel = "Microphone"
+    # class of the device which this backend corresponds to
+    deviceClass = "psychopy.hardware.microphone.MicrophoneDevice"
+    # icon to show in device manager
+    icon = "light/microphone.png"
+
+    def __init__(self, profile):
+        # init parent class
+        DeviceBackend.__init__(self, profile)
+
+        # add params
+        self.order += [
+            "exclusive",
+        ]
+        self.params['exclusive'] = Param(
+            False, valType="code", inputType="bool",
+            label=_translate("Exclusive control"),
+            hint=_translate(
+                "Take exclusive control of the microphone, so other apps can't use it during your "
+                "experiment."
+            )
+        )
+    
+    def writeDeviceCode(self, buff):
+        """
+        Code to setup a device with this backend.
+
+        Parameters
+        ----------
+        buff : io.StringIO
+            Text buffer to write code to.
+        """
+        # write basic code
+        self.writeBaseDeviceCode(buff, close=False)
+        # add exclusive param and close
+        code = (
+            "    exclusive=%(exclusive)s,\n"
+            ")\n"
+        )
+        buff.writeIndentedLines(code % self.params)
+
+
+# register backend with Component
+MicrophoneComponent.registerBackend(MicrophoneDeviceBackend)

psychopy/experiment/components/movie/__init__.py

@@ -281,15 +281,13 @@ class MovieComponent(BaseVisualComponent):
             code = (
                 "%(name)s.setAutoDraw(False)\n"
             )
-            if self.params['backend'].val not in ('moviepy', 'avbin', 'vlc'):
-                code += "%(name)s.stop()\n"
             buff.writeIndentedLines(code % self.params)
         # to get out of the if statement
         buff.setIndentLevel(-indented, relative=True)
 
         # do force end of trial code
         if self.params['forceEndRoutine'].val is True:
-            code = ("if %s.isFinished:  # force-end the Routine\n"
+            code = ("if %s.status == FINISHED:  # force-end the Routine\n"
                     "    continueRoutine = False\n" %
                     self.params['name'])
             buff.writeIndentedLines(code)
@@ -336,6 +334,7 @@ class MovieComponent(BaseVisualComponent):
         if self.params['stopWithRoutine']:
             # stop at the end of the Routine, if requested
             code = (
+                "%(name)s.setAutoDraw(False)\n"
                 "%(name)s.stop()  # ensure movie has stopped at end of Routine\n"
             )
             buff.writeIndentedLines(code % self.params)

psychopy/experiment/components/serialOut/__init__.py

@@ -6,11 +6,12 @@
 # Distributed under the terms of the GNU General Public License (GPL).
 from copy import copy
 from pathlib import Path
+from psychopy.experiment.devices import DeviceBackend
 from psychopy.tools import stringtools as st
-from psychopy.experiment.components import BaseComponent, Param, _translate, getInitVals
+from psychopy.experiment.components import BaseDeviceComponent, Param, _translate, getInitVals
 
 
-class SerialOutComponent(BaseComponent):
+class SerialOutComponent(BaseDeviceComponent):
     """A class for sending signals from the parallel port"""
 
     categories = ['I/O', 'EEG']
@@ -19,6 +20,19 @@ class SerialOutComponent(BaseComponent):
     iconFile = Path(__file__).parent / 'serial.png'
     tooltip = _translate('Serial out: send signals from a serial port')
     beta = False
+    legacyParams = [
+        # superceded by "startDataChar", "startDataCode", et al.
+        "startdata",
+        "stopdata",
+        # old device setup params, no longer needed as this is handled by DeviceManager
+        "port",
+        "baudrate",
+        "bytesize",
+        "stopbits",
+        "parity",
+        "timeout"
+    ]
+    
 
     def __init__(self, exp, parentName, name='serialPort',
                  startType='time (s)', startVal=0.0,
@@ -37,88 +51,106 @@ class SerialOutComponent(BaseComponent):
 
         self.type = 'SerialOut'
         self.url = "https://www.psychopy.org/builder/components/serialout.html"
-        self.exp.requireImport('serial')
+        
+        for prefix, label, titleLabel, default in (
+            ("start", _translate("start"), _translate("Start"), b"r"),
+            ("stop", _translate("stop"), _translate("Stop"), b"x"),
+        ):
 
-        self.params['port'] = Param(
-            port, valType='str', inputType="single", categ='Basic',
-            hint=_translate("Serial port to connect to"),
-            label=_translate("Port")
-        )
-        self.params['baudrate'] = Param(
-            baudrate, valType='int', inputType="single", categ="Device",
-            hint=_translate("The baud rate, or speed, of the connection."),
-            label=_translate("Baud rate")
-        )
-        self.params['bytesize'] = Param(
-            bytesize, valType='int', inputType="single", categ="Device",
-            hint=_translate("Size of bits to be sent."),
-            label=_translate("Data bits")
-        )
-        self.params['stopbits'] = Param(
-            stopbits, valType='int', inputType="single", categ="Device",
-            hint=_translate("Size of bits to be sent on stop."),
-            label=_translate("Stop bits")
-        )
-        self.params['parity'] = Param(
-            parity, valType='str', inputType="choice", categ="Device",
-            allowedVals=('N', 'E', 'O', 'M', 'S'),
-            allowedLabels=("None", "Even", "Off", "Mark", "Space"),
-            hint=_translate("Parity mode."),
-            label=_translate("Parity")
-        )
+            self.params[prefix + 'DataType'] = Param(
+                "str", valType="str", inputType="choice", categ="Basic",
+                allowedVals=["str", "num", "binary", "char", "code"],
+                allowedLabels=[
+                    _translate("String"), _translate("Numeric (0-255)"), 
+                    _translate("Binary"), _translate("Character (Byte)"), _translate("Code")
+                ],
+                hint=_translate(
+                    "Type of data to be sent: A number, a binary sequence, a character byte, or custom code ($)"
+                ),
+                label=_translate("{} data type").format(titleLabel)
+            )
 
-        self.params['timeout'] = Param(
-            timeout, valType='int', inputType="single", allowedTypes=[], categ="Device",
-            hint=_translate("Time at which to give up listening for a response (leave blank for no limit)"),
-            label=_translate("Timeout"))
-
-        self.params['startdata'] = Param(
-            startdata, valType='str', inputType="single", allowedTypes=[], categ='Basic',
-            hint=_translate("Data to be sent at start of pulse. Data will be converted to bytes, so to specify a"
-                            "numeric value directly use $chr(...)."),
-            label=_translate("Start data"))
-        self.params['stopdata'] = Param(
-            stopdata, valType='str', inputType="single", allowedTypes=[], categ='Basic',
-            hint=_translate("String data to be sent at end of pulse. Data will be converted to bytes, so to specify a"
-                            "numeric value directly use $chr(...)."),
-            label=_translate("Stop data"))
+            self.params[prefix + 'DataStr'] = Param(
+                default.decode("utf-8"), valType="str", inputType="single", categ="Basic",
+                hint=_translate("Send a regular string (which will be converted to binary) on {}").format(label),
+                label=_translate("{} data (string)").format(titleLabel)
+            )
+            self.depends.append({
+                'dependsOn': prefix + "DataType",  # if...
+                'condition': "== 'str'",  # meets...
+                'param': prefix + "DataStr",  # then...
+                'true': "show",  # should...
+                'false': "hide",  # otherwise...
+            })
+
+            self.params[prefix + 'DataNumeric'] = Param(
+                ord(default), valType="code", inputType="single", categ="Basic",
+                hint=_translate("Send a number between 0-255 on {}").format(label),
+                label=_translate("{} data (numeric)").format(titleLabel)
+            )
+            self.depends.append({
+                'dependsOn': prefix + "DataType",  # if...
+                'condition': "== 'num'",  # meets...
+                'param': prefix + "DataNumeric",  # then...
+                'true': "show",  # should...
+                'false': "hide",  # otherwise...
+            })
+
+            self.params[prefix + 'DataBinary'] = Param(
+                bin(ord(default))[2:], valType="code", inputType="single", categ="Basic",
+                hint=_translate("Send a binary sequence (1s and 0s) on {}").format(label),
+                label=_translate("{} data (binary)").format(titleLabel)
+            )
+            self.depends.append({
+                'dependsOn': prefix + "DataType",  # if...
+                'condition': "== 'binary'",  # meets...
+                'param': prefix + "DataBinary",  # then...
+                'true': "show",  # should...
+                'false': "hide",  # otherwise...
+            })
+
+            self.params[prefix + 'DataChar'] = Param(
+                "\\x" + hex(ord(default))[2:], valType="str", inputType="single", categ="Basic",
+                hint=_translate("Send a character byte (e.g. \\x73) on {}").format(label),
+                label=_translate("{} data (char)").format(titleLabel)
+            )
+            self.depends.append({
+                'dependsOn': prefix + "DataType",  # if...
+                'condition': "== 'char'",  # meets...
+                'param': prefix + "DataChar",  # then...
+                'true': "show",  # should...
+                'false': "hide",  # otherwise...
+            })
+
+            self.params[prefix + 'DataCode'] = Param(
+                repr(default), valType="code", inputType="single", categ="Basic",
+                hint=_translate("Send custom code (e.g. from a variable) on {}").format(label),
+                label=_translate("{} data (code)").format(titleLabel)
+            )
+            self.depends.append({
+                'dependsOn': prefix + "DataType",  # if...
+                'condition': "== 'code'",  # meets...
+                'param': prefix + "DataCode",  # then...
+                'true': "show",  # should...
+                'false': "hide",  # otherwise...
+            })
+          
         self.params['getResponse'] = Param(
             getResponse, valType='bool', inputType='bool', categ="Data",
             hint=_translate("After sending a signal, should PsychoPy read and record a response from the port?"),
             label=_translate("Get response?")
         )
 
-    def writeRunOnceInitCode(self, buff):
-        inits = getInitVals(self.params, "PsychoPy")
-        # Get device-based variable name
-        inits['varName'] = self.getDeviceVarName()
-        # Create object for serial device
-        code = (
-            "# Create serial object for device at port %(port)s\n"
-            "%(varName)s = serial.Serial(\n"
-        )
-        for key in ('port', 'baudrate', 'bytesize', 'parity', 'stopbits', 'timeout'):
-            if self.params[key].val is not None:
-                code += (
-                    f"    {key}=%({key})s,\n"
-                )
-        code += (
-            ")\n"
-        )
-        buff.writeOnceIndentedLines(code % inits)
-
     def writeInitCode(self, buff):
         inits = getInitVals(self.params, "PsychoPy")
-        # Get device-based variable name
-        inits['varName'] = self.getDeviceVarName()
-        # Point component name to device object
+        # point component name to device object
         code = (
             "\n"
-            "# point %(name)s to device at port %(port)s and make sure it's open\n"
-            "%(name)s = %(varName)s\n"
+            "# point %(name)s to device named %(deviceLabel)s and make sure it's open\n"
+            "%(name)s = deviceManager.getDevice(%(deviceLabel)s)\n"
             "%(name)s.status = NOT_STARTED\n"
-            "if not %(name)s.is_open:\n"
-            "    %(name)s.open()\n"
+            "if not %(name)s.com.is_open:\n"
+            "    %(name)s.com.open()\n"
         )
         buff.writeIndentedLines(code % inits)
 
@@ -126,28 +158,48 @@ class SerialOutComponent(BaseComponent):
         params = copy(self.params)
         # Get containing loop
         params['loop'] = self.currentLoop
+        
 
         # On component start, send start bits
         indented = self.writeStartTestCode(buff)
         if indented:
+            # get data string to write
+            if params['startDataType'] == "str":
+                params['startData'] = params['startDataStr']
+            elif params['startDataType'] == "num":
+                params['startData'] = "bytes(chr(%(startDataNumeric)s), 'utf-8')" % params
+            elif params['startDataType'] == "binary":
+                params['startData'] = "0b%(startDataBinary)s" % params
+            elif params['startDataType'] == "char":
+                params['startData'] = "b%(startDataChar)s" % params
+            elif params['startDataType'] == "code":
+                params['startData'] = params['startDataCode']
+            else:
+                raise TypeError(f"Unknown data type {params['startDataType']}")
+            # write code to send it (immediately or on refresh)
             if self.params['syncScreenRefresh']:
                 code = (
-                    "win.callOnFlip(%(name)s.write, bytes(%(startdata)s, 'utf8'))\n"
+                    "win.callOnFlip(%(name)s.sendMessage, %(startData)s)\n"
                 )
             else:
                 code = (
-                    "%(name)s.write(bytes(%(startdata)s, 'utf8'))\n"
+                    "%(name)s.sendMessage(%(startData)s)\n"
                 )
             buff.writeIndented(code % params)
-            # Update status
+            # store code that was sent
+            code = (
+                "%(loop)s.addData('%(name)s.stopData', %(startData)s)\n"
+            )
+            buff.writeIndented(code % params)
+            # update status
             code = (
                 "%(name)s.status = STARTED\n"
             )
             buff.writeIndented(code % params)
-            # If we want responses, get them
+            # if we want responses, get them
             if self.params['getResponse']:
                 code = (
-                    "%(loop)s.addData('%(name)s.startResp', %(name)s.read())\n"
+                    "%(loop)s.addData('%(name)s.startResp', %(name)s.getResponse())\n"
                 )
                 buff.writeIndented(code % params)
         # Dedent
@@ -156,24 +208,43 @@ class SerialOutComponent(BaseComponent):
         # On component stop, send stop pulse
         indented = self.writeStopTestCode(buff)
         if indented:
+            # get data string to write
+            if params['stopDataType'] == "str":
+                params['stopData'] = params['stopDataStr']
+            elif params['stopDataType'] == "num":
+                params['stopData'] = "bytes(bytearray([%(stopDataNumeric)s]))" % params
+            elif params['stopDataType'] == "binary":
+                params['stopData'] = "0b%(stopDataBinary)s" % params
+            elif params['stopDataType'] == "char":
+                params['stopData'] = "b'%(stopDataChar)s'" % params
+            elif params['stopDataType'] == "code":
+                params['stopData'] = params['stopDataCode']
+            else:
+                raise TypeError(f"Unknown data type {params['stopDataType']}")
+            # write code to send it (immediately or on refresh)
             if self.params['syncScreenRefresh']:
                 code = (
-                    "win.callOnFlip(%(name)s.write, bytes(%(stopdata)s, 'utf8'))\n"
+                    "win.callOnFlip(%(name)s.sendMessage, %(stopData)s)\n"
                 )
             else:
                 code = (
-                    "%(name)s.write(bytes(%(stopdata)s, 'utf8'))\n"
+                    "%(name)s.sendMessage(%(stopData)s)\n"
                 )
             buff.writeIndented(code % params)
-            # Update status
+            # store code that was sent
+            code = (
+                "%(loop)s.addData('%(name)s.stopData', %(stopData)s)\n"
+            )
+            buff.writeIndented(code % params)
+            # update status
             code = (
                 "%(name)s.status = FINISHED\n"
             )
             buff.writeIndented(code % params)
-            # If we want responses, get them
+            # if we want responses, get them
             if self.params['getResponse']:
                 code = (
-                    "%(loop)s.addData('%(name)s.stopResp', %(name)s.read())\n"
+                    "%(loop)s.addData('%(name)s.stopResp', %(name)s.getResponse())\n"
                 )
                 buff.writeIndented(code % params)
         # Dedent
@@ -182,24 +253,52 @@ class SerialOutComponent(BaseComponent):
     def writeExperimentEndCode(self, buff):
         # Close the port
         code = (
-            "# Close %(name)s\n"
-            "if %(name)s.is_open:\n"
-            "    %(name)s.close()\n"
+            "# close %(name)s\n"
+            "if %(name)s.com.is_open:\n"
+            "    %(name)s.com.close()\n"
         )
         buff.writeIndentedLines(code % self.params)
 
-    def getDeviceVarName(self, case="camel"):
+
+class SerialDeviceBackend(DeviceBackend):
+    backendLabel = "Serial Device"
+    deviceClass = "psychopy.hardware.serialdevice.SerialDevice"
+    icon = "light/serial.png"
+
+    def __init__(self, profile):
+        # init parent class
+        DeviceBackend.__init__(self, profile)
+
+        # define order
+        self.order += [
+            "timeout",
+        ]
+
+        self.params['timeout'] = Param(
+            "", valType='code', inputType="single", allowedTypes=[],
+            hint=_translate("Time at which to give up listening for a response (leave blank for no limit)"),
+            label=_translate("Timeout")
+        )
+    
+    def writeDeviceCode(self, buff):
         """
-        Create a variable name from the port address of this component's device.
+        Code to setup a device with this backend.
 
         Parameters
         ----------
-        case : str
-            Format of the variable name (see stringtools.makeValidVarName for info on accepted formats)
+        buff : io.StringIO
+            Text buffer to write code to.
         """
-        # Add "serial_" in case port name is all numbers
-        name = "serial_%(port)s" % self.params
-        # Make valid
-        varName = st.makeValidVarName(name, case=case)
+        inits = getInitVals(self.params)
+        # write basic code
+        self.writeBaseDeviceCode(buff, close=False)
+        # add param and close
+        code = (
+            "    pauseDuration=(%(timeout)s or 0.1) / 3,\n"  
+            ")\n"
+        )
+        buff.writeIndentedLines(code % inits)
+
 
-        return varName
+# register backend with Component
+SerialOutComponent.registerBackend(SerialDeviceBackend)