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

psychopy/experiment/components/keyboard/__init__.py

@@ -2,11 +2,12 @@
 # -*- 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).
 
 from pathlib import Path
 
+from psychopy.alerts._alerts import alert
 from psychopy.experiment.components import BaseDeviceComponent, Param, _translate, getInitVals
 from psychopy.experiment import CodeGenerationException, valid_var_re
 from pkgutil import find_loader
@@ -334,144 +335,119 @@ class KeyboardComponent(BaseDeviceComponent):
 
         buff.writeIndented("\n")
         buff.writeIndented("// *%s* updates\n" % self.params['name'])
-        # writes an if statement to determine whether to draw etc
-        self.writeStartTestCodeJS(buff)
-
-        allowedKeysIsVar = (valid_var_re.match(str(allowedKeys)) and not
-                            allowedKeys == 'None')
-
-        if allowedKeysIsVar:
-            # if it looks like a variable, check that the variable is suitable
-            # to eval at run-time
-            raise CodeGenerationException(
-                "Variables for allowKeys aren't supported for JS yet")
-            #code = ("# AllowedKeys looks like a variable named `%s`\n"
-            #        "if not '%s' in locals():\n"
-            #        "    logging.error('AllowedKeys variable `%s` is not defined.')\n"
-            #        "    core.quit()\n"
-            #        "if not type(%s) in [list, tuple, np.ndarray]:\n"
-            #        "    if not isinstance(%s, str):\n"
-            #        "        logging.error('AllowedKeys variable `%s` is "
-            #        "not string- or list-like.')\n"
-            #        "        core.quit()\n" %
-            #        allowedKeys)
-            #
-            #vals = (allowedKeys, allowedKeys, allowedKeys)
-            #code += (
-            #    "    elif not ',' in %s: %s = (%s,)\n" % vals +
-            #    "    else:  %s = eval(%s)\n" % (allowedKeys, allowedKeys))
-            #buff.writeIndentedLines(code)
-            #
-            #keyListStr = "keyList=list(%s)" % allowedKeys  # eval at run time
-
-        buff.writeIndented("// keyboard checking is just starting\n")
-
-        if self.params['syncScreenRefresh'].val:
-            code = ("psychoJS.window.callOnFlip(function() { %(name)s.clock.reset(); });  "
-                    "// t=0 on next screen flip\n"
-                    "psychoJS.window.callOnFlip(function() { %(name)s.start(); }); "
-                    "// start on screen flip\n") % self.params
-        else:
-            code = ("%(name)s.clock.reset();\n"
-                    "%(name)s.start();\n") % self.params
-
-        buff.writeIndentedLines(code)
+        
+        # write code to run on first frame once started
+        indented = self.writeStartTestCodeJS(buff)
+        if indented:
+            buff.writeIndented("// keyboard checking is just starting\n")
 
-        if self.params['discard previous'].val:
             if self.params['syncScreenRefresh'].val:
-                 buff.writeIndented("psychoJS.window.callOnFlip(function() { %(name)s.clearEvents(); });\n"
-                                    % self.params)
+                code = ("psychoJS.window.callOnFlip(function() { %(name)s.clock.reset(); });  "
+                        "// t=0 on next screen flip\n"
+                        "psychoJS.window.callOnFlip(function() { %(name)s.start(); }); "
+                        "// start on screen flip\n") % self.params
             else:
-                buff.writeIndented("%(name)s.clearEvents();\n" % self.params)
+                code = ("%(name)s.clock.reset();\n"
+                        "%(name)s.start();\n") % self.params
 
-        # to get out of the if statement
-        buff.setIndentLevel(-1, relative=True)
-        buff.writeIndented("}\n\n")
+            buff.writeIndentedLines(code)
 
-        # test for stop (only if there was some setting for duration or stop)
-        if self.params['stopVal'].val not in ['', None, -1, 'None']:
+            if self.params['discard previous'].val:
+                if self.params['syncScreenRefresh'].val:
+                    buff.writeIndented("psychoJS.window.callOnFlip(function() { %(name)s.clearEvents(); });\n"
+                                        % self.params)
+                else:
+                    buff.writeIndented("%(name)s.clearEvents();\n" % self.params)
+
+            # to get out of the if statement
+            for n in range(indented):
+                buff.setIndentLevel(-1, relative=True)
+                buff.writeIndented("}\n")
+        
+        # write code to run on last frame when stopping
+        indented = self.writeStopTestCodeJS(buff)
+        if indented:
             # writes an if statement to determine whether to draw etc
             self.writeStopTestCodeJS(buff)
             buff.writeIndented("%(name)s.status = PsychoJS.Status.FINISHED;\n"
-                               "  }\n"
-                               "\n" % self.params)
+                            "  }\n"
+                            "\n" % self.params)
             # to get out of the if statement
-            buff.setIndentLevel(-1, relative=True)
-
-        buff.writeIndented("if (%(name)s.status === PsychoJS.Status.STARTED) {\n" % self.params)
-        buff.setIndentLevel(1, relative=True)  # to get out of if statement
-        dedentAtEnd = 1  # keep track of how far to dedent later
-        # do we need a list of keys? (variable case is already handled)
-        if allowedKeys in [None, "none", "None", "", "[]", "()"]:
-            keyListStr = "[]"
-        elif not allowedKeysIsVar:
-            try:
-                keyList = eval(allowedKeys)
-            except Exception:
-                raise CodeGenerationException(
-                    self.params["name"], "Allowed keys list is invalid.")
-            # this means the user typed "left","right" not ["left","right"]
-            if type(keyList) == tuple:
-                keyList = list(keyList)
-            elif isinstance(keyList, str):  # a single string/key
-                keyList = [keyList]
-            keyListStr = "%s" % repr(keyList)
-
-        # check for keypresses
-        waitRelease = "false"
-        if self.params['registerOn'] == "release":
-            waitRelease = "true"
-        code = ("let theseKeys = {name}.getKeys({{keyList: {keyStr}, waitRelease: {waitRelease}}});\n"
-                "_{name}_allKeys = _{name}_allKeys.concat(theseKeys);\n"
-                "if (_{name}_allKeys.length > 0) {{\n")
-        buff.writeIndentedLines(
-            code.format(
-                name=self.params['name'],
-                waitRelease=waitRelease,
-                keyStr=keyListStr
-            )
-        )
-        buff.setIndentLevel(1, True)
-        dedentAtEnd += 1
-        # how do we store it?
-        if store == 'first key':  # then see if a key has already been pressed
-            code = ("{name}.keys = _{name}_allKeys[0].name;  // just the first key pressed\n"
-                    "{name}.rt = _{name}_allKeys[0].rt;\n"
-                    "{name}.duration = _{name}_allKeys[0].duration;\n")
-            buff.writeIndentedLines(code.format(name=self.params['name']))
-        elif store == 'last key' or store =='nothing':
-            code = ("{name}.keys = _{name}_allKeys[_{name}_allKeys.length - 1].name;  // just the last key pressed\n"
-                    "{name}.rt = _{name}_allKeys[_{name}_allKeys.length - 1].rt;\n"
-                    "{name}.duration = _{name}_allKeys[_{name}_allKeys.length - 1].duration;\n")
-            buff.writeIndentedLines(code.format(name=self.params['name']))
-        elif store == 'all keys':
-            code = ("{name}.keys = _{name}_allKeys.map((key) => key.name);  // storing all keys\n"
-                    "{name}.rt = _{name}_allKeys.map((key) => key.rt);\n" \
-                    "{name}.duration = _{name}_allKeys.map((key) => key.duration);\n")
-            buff.writeIndentedLines(code.format(name=self.params['name']))
+            for n in range(indented):
+                buff.setIndentLevel(-1, relative=True)
+                buff.writeIndented("}\n")
 
-        if storeCorr:
-            code = ("// was this correct?\n"
-                    "if ({name}.keys == {correctAns}) {{\n"
-                    "    {name}.corr = 1;\n"
-                    "}} else {{\n"
-                    "    {name}.corr = 0;\n"
-                    "}}\n")
+        # write code to run each frame while active
+        indented = self.writeActiveTestCodeJS(buff)
+        if indented:
+            # do we need a list of keys? (variable case is already handled)
+            if allowedKeys in [None, "none", "None", "", "[]", "()"]:
+                keyListStr = "[]"
+            else:
+                if isinstance(allowedKeys, str) and "," in allowedKeys:
+                    # it might be a list without [], if so split and recombine
+                    keyList = [item.strip() for item in allowedKeys.split(",")]
+                    keyListStr = f"[{','.join(keyList)}]"
+                else:
+                    # otherwise just use the value as is
+                    keyListStr = str(allowedKeys)
+            # check for keypresses
+            waitRelease = "false"
+            if self.params['registerOn'] == "release":
+                waitRelease = "true"
+            code = ("let theseKeys = {name}.getKeys({{keyList: {keyStr}, waitRelease: {waitRelease}}});\n"
+                    "_{name}_allKeys = _{name}_allKeys.concat(theseKeys);\n"
+                    "if (_{name}_allKeys.length > 0) {{\n")
             buff.writeIndentedLines(
                 code.format(
                     name=self.params['name'],
-                    correctAns=self.params['correctAns']
+                    waitRelease=waitRelease,
+                    keyStr=keyListStr
                 )
             )
+            buff.setIndentLevel(1, True)
+            indented += 1
+            # how do we store it?
+            if store == 'first key':  # then see if a key has already been pressed
+                code = ("{name}.keys = _{name}_allKeys[0].name;  // just the first key pressed\n"
+                        "{name}.rt = _{name}_allKeys[0].rt;\n"
+                        "{name}.duration = _{name}_allKeys[0].duration;\n")
+                buff.writeIndentedLines(code.format(name=self.params['name']))
+            elif store == 'last key' or store =='nothing':
+                code = ("{name}.keys = _{name}_allKeys[_{name}_allKeys.length - 1].name;  // just the last key pressed\n"
+                        "{name}.rt = _{name}_allKeys[_{name}_allKeys.length - 1].rt;\n"
+                        "{name}.duration = _{name}_allKeys[_{name}_allKeys.length - 1].duration;\n")
+                buff.writeIndentedLines(code.format(name=self.params['name']))
+            elif store == 'all keys':
+                code = ("{name}.keys = _{name}_allKeys.map((key) => key.name);  // storing all keys\n"
+                        "{name}.rt = _{name}_allKeys.map((key) => key.rt);\n" \
+                        "{name}.duration = _{name}_allKeys.map((key) => key.duration);\n")
+                buff.writeIndentedLines(code.format(name=self.params['name']))
+
+            if storeCorr:
+                code = ("// was this correct?\n"
+                        "if ({name}.keys == {correctAns}) {{\n"
+                        "    {name}.corr = 1;\n"
+                        "}} else {{\n"
+                        "    {name}.corr = 0;\n"
+                        "}}\n")
+                buff.writeIndentedLines(
+                    code.format(
+                        name=self.params['name'],
+                        correctAns=self.params['correctAns']
+                    )
+                )
 
-        if forceEnd == True:
-            code = ("// a response ends the routine\n"
-                    "continueRoutine = false;\n")
-            buff.writeIndentedLines(code)
+            if forceEnd == True:
+                code = ("// a response ends the routine\n"
+                        "continueRoutine = false;\n")
+                buff.writeIndentedLines(code)
 
-        for dedents in range(dedentAtEnd):
-            buff.setIndentLevel(-1, relative=True)
-            buff.writeIndented("}\n")
+            # to get out of the if statement
+            for n in range(indented):
+                buff.setIndentLevel(-1, relative=True)
+                buff.writeIndented("}\n")
+        
         buff.writeIndented("\n")
 
     def writeRoutineEndCode(self, buff):

psychopy/experiment/components/microphone/__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).
 
 # Author: Jeremy R. Gray, 2012
@@ -14,21 +14,6 @@ from psychopy.tools import stringtools as st, systemtools as syst, audiotools as
 from psychopy.experiment.components import (
     BaseComponent, BaseDeviceComponent, Param, getInitVals, _translate
 )
-from psychopy.tools.audiotools import sampleRateQualityLevels
-
-_hasPTB = True
-try:
-    import psychtoolbox.audio as audio
-except (ImportError, ModuleNotFoundError):
-    logging.warning(
-        "The 'psychtoolbox' library cannot be loaded but is required for audio "
-        "capture (use `pip install psychtoolbox` to get it). Microphone "
-        "recording will be unavailable this session. Note that opening a "
-        "microphone stream will raise an error.")
-    _hasPTB = False
-
-# Get list of sample rates
-sampleRates = {r[1]: r[0] for r in sampleRateQualityLevels.values()}
 
 
 class MicrophoneComponent(BaseDeviceComponent):
@@ -53,19 +38,25 @@ class MicrophoneComponent(BaseDeviceComponent):
         'google': "psychopy.sound.transcribe:GoogleCloudTranscriber"
     }
 
-    def __init__(self, exp, parentName, name='mic',
-                 startType='time (s)', startVal=0.0,
-                 stopType='duration (s)', stopVal=2.0,
-                 startEstim='', durationEstim='',
-                 channels='auto', device=None,
-                 sampleRate='DVD Audio (48kHz)', maxSize=24000,
-                 outputType='default', speakTimes=False, trimSilent=False,
-                 transcribe=False, transcribeBackend="none",
-                 transcribeLang="en-US", transcribeWords="",
-                 transcribeWhisperModel="base",
-                 transcribeWhisperDevice="auto",
-                 #legacy
-                 stereo=None, channel=None):
+    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",
+        transcribeLang="en-US", transcribeWords="",
+        transcribeWhisperModel="base",
+        transcribeWhisperDevice="auto",
+        #legacy
+        sampleRate=48000, 
+        channels=2,
+        stereo=None, 
+        channel=None
+    ):
         super(MicrophoneComponent, self).__init__(
             exp, parentName, name=name,
             startType=startType, startVal=startVal,
@@ -86,8 +77,7 @@ class MicrophoneComponent(BaseDeviceComponent):
         # --- Device params ---
         self.order += [
             "device",
-            "channels",
-            "sampleRate",
+            "exclusive",
             "maxSize",
         ]
 
@@ -95,7 +85,7 @@ class MicrophoneComponent(BaseDeviceComponent):
             from psychopy.hardware.microphone import MicrophoneDevice
             profiles = MicrophoneDevice.getAvailableDevices()
 
-            return [None] + [profile['index'] for profile in profiles]
+            return ["$None"] + [profile['index'] for profile in profiles]
 
         def getDeviceNames():
             from psychopy.hardware.microphone import MicrophoneDevice
@@ -104,7 +94,7 @@ class MicrophoneComponent(BaseDeviceComponent):
             return ["default"] + [profile['deviceName'] for profile in profiles]
 
         self.params['device'] = Param(
-            device, valType='code', inputType="choice", categ="Device",
+            device, valType='str', inputType="choice", categ="Device",
             allowedVals=getDeviceIndices,
             allowedLabels=getDeviceNames,
             label=_translate("Device"),
@@ -113,43 +103,12 @@ class MicrophoneComponent(BaseDeviceComponent):
                 "local experiments - online experiments ask the participant which mic to use."
             )
         )
-        # grey out device settings when device is default
-        for depParam in ("channels", "sampleRate"):
-            self.depends.append({
-                "dependsOn": "device",  # if...
-                "condition": "== 'None'",  # is...
-                "param": depParam,  # then...
-                "true": "hide",  # should...
-                "false": "show",  # otherwise...
-            })
-        if stereo is not None:
-            # If using a legacy mic component, work out channels from old bool value of stereo
-            channels = ['mono', 'stereo'][stereo]
-        self.params['channels'] = Param(
-            channels, valType='str', inputType="choice", categ='Device',
-            allowedVals=['auto', 'mono', 'stereo'],
-            allowedLabels=[_translate("Auto"), _translate("Mono"), _translate("Stereo")],
-            label=_translate("Channels"),
-            hint=_translate(
-                "Record two channels (stereo) or one (mono, smaller file). Select 'auto' to use as "
-                "many channels as the selected device allows."
-            )
-        )
-        self.params['sampleRate'] = Param(
-            sampleRate, valType='num', inputType="choice", categ='Device',
-            allowedVals=list(sampleRates),
-            label=_translate("Sample rate (hz)"),
-            hint=_translate(
-                "How many samples per second (Hz) to record at"
-            ),
-            direct=False
-        )
-        self.params['maxSize'] = Param(
-            maxSize, valType='num', inputType="single", categ='Device',
-            label=_translate("Max recording size (kb)"),
+        self.params['exclusive'] = Param(
+            exclusive, valType="code", inputType="bool", categ="Device",
+            label=_translate("Exclusive control"),
             hint=_translate(
-                "To avoid excessively large output files, what is the biggest file size you are "
-                "likely to expect?"
+                "Take exclusive control of the microphone, so other apps can't use it during your "
+                "experiment."
             )
         )
 
@@ -162,7 +121,21 @@ class MicrophoneComponent(BaseDeviceComponent):
             hint=msg,
             label=_translate("Output file type")
         )
-
+        self.params['policyWhenFull'] = Param(
+            policyWhenFull, valType="str", inputType="choice", categ="Data",
+            updates="set every repeat",
+            allowedVals=["warn", "roll", "error"],
+            allowedLabels=[
+                _translate("Discard incoming data"), 
+                _translate("Clear oldest data"), 
+                _translate("Raise error"),
+            ],
+            label=_translate("Full buffer policy"),
+            hint=_translate(
+                "What to do when we reach the max amount of audio data which can be safely stored "
+                "in memory?"
+            )
+        )
         msg = _translate(
             "Tick this to save times when the participant starts and stops speaking")
         self.params['speakTimes'] = Param(
@@ -227,7 +200,7 @@ class MicrophoneComponent(BaseDeviceComponent):
         )
         self.depends.append({
             "dependsOn": "transcribeBackend",
-            "condition": "=='Google'",
+            "condition": "=='google'",
             "param": "transcribeLang",
             "true": "show",  # what to do with param if condition is True
             "false": "hide",  # permitted: hide, show, enable, disable
@@ -242,7 +215,7 @@ class MicrophoneComponent(BaseDeviceComponent):
         )
         self.depends.append({
             "dependsOn": "transcribeBackend",
-            "condition": "=='Google'",
+            "condition": "=='google'",
             "param": "transcribeWords",
             "true": "show",  # what to do with param if condition is True
             "false": "hide",  # permitted: hide, show, enable, disable
@@ -307,10 +280,8 @@ class MicrophoneComponent(BaseDeviceComponent):
         inits = getInitVals(self.params)
 
         # --- setup mic ---
-        # Substitute sample rate value for numeric equivalent
-        inits['sampleRate'] = sampleRates[inits['sampleRate'].val]
-        # Substitute channel value for numeric equivalent
-        inits['channels'] = {'mono': 1, 'stereo': 2, 'auto': None}[self.params['channels'].val]
+        # force index to str type (holdover from when we used numeric indices)
+        inits['device'].valType = "str"
         # initialise mic device
         code = (
             "# initialise microphone\n"
@@ -318,14 +289,7 @@ class MicrophoneComponent(BaseDeviceComponent):
             "    deviceClass='psychopy.hardware.microphone.MicrophoneDevice',\n"
             "    deviceName=%(deviceLabel)s,\n"
             "    index=%(device)s,\n"
-            "    maxRecordingSize=%(maxSize)s,\n"
-        )
-        if self.params['device'].val not in ("None", "", None):
-            code += (
-            "    channels=%(channels)s, \n"
-            "    sampleRateHz=%(sampleRate)s, \n"
-            )
-        code += (
+            "    exclusive=%(exclusive)s,\n"
             ")\n"
         )
         buff.writeOnceIndentedLines(code % inits)
@@ -391,14 +355,18 @@ class MicrophoneComponent(BaseDeviceComponent):
             "    recordingFolder=%(name)sRecFolder,\n"
             "    recordingExt='%(outputType)s'\n"
             ")\n"
+            "# tell the experiment handler to save this Microphone's clips if the experiment is "
+            "force ended\n"
+            "runAtExit.append(%(name)s.saveClips)\n"
+            "# connect camera save method to experiment handler so it's called when data saves\n"
+            "thisExp.connectSaveMethod(%(name)s.saveClips)\n"
         )
         buff.writeIndentedLines(code % inits)
 
     def writeInitCodeJS(self, buff):
         inits = getInitVals(self.params)
-        inits['sampleRate'] = sampleRates[inits['sampleRate'].val]
         # Alert user if non-default value is selected for device
-        if inits['device'].val != 'default':
+        if inits['device'].val != '$None':
             alert(5055, strFields={'name': inits['name'].val})
         # Write code
         code = (
@@ -409,9 +377,6 @@ class MicrophoneComponent(BaseDeviceComponent):
         code = (
                 "win : psychoJS.window, \n"
                 "name:'%(name)s',\n"
-                "sampleRateHz : %(sampleRate)s,\n"
-                "channels : %(channels)s,\n"
-                "maxRecordingSize : %(maxSize)s,\n"
                 "loopback : true,\n"
                 "policyWhenFull : 'ignore',\n"
         )
@@ -427,15 +392,6 @@ class MicrophoneComponent(BaseDeviceComponent):
         inits = getInitVals(self.params)
         inits['routine'] = self.parentName
 
-        # If stop time is blank, substitute max stop
-        if self.params['stopVal'] in ('', None, -1, 'None'):
-            self.params['stopVal'].val = at.audioMaxDuration(
-                bufferSize=float(self.params['maxSize'].val) * 1000,
-                freq=float(sampleRates[self.params['sampleRate'].val])
-            )
-            # Show alert
-            alert(4125, strFields={'name': self.params['name'].val, 'stopVal': self.params['stopVal'].val})
-
         # Start the recording
         indented = self.writeStartTestCode(buff)
         if indented: