psychopy 2024.1.3__py3-none-any.whl → 2024.2.0__py3-none-any.whl

psychopy/gui/wxgui.py

@@ -13,11 +13,11 @@ import wx
 import numpy
 import os
 from psychopy.localization import _translate
-from pkg_resources import parse_version
+from packaging.version import Version
 
 OK = wx.ID_OK
 
-thisVer = parse_version(wx.__version__)
+thisVer = Version(wx.__version__)
 
 def ensureWxApp():
     # make sure there's a wxApp prior to showing a gui, e.g., for expInfo
@@ -26,9 +26,9 @@ def ensureWxApp():
         wx.Dialog(None, -1)  # not shown; FileDialog gives same exception
         return True
     except wx._core.PyNoAppError:
-        if thisVer < parse_version('2.9'):
+        if thisVer < Version('2.9'):
             return wx.PySimpleApp()
-        elif thisVer >= parse_version('4.0') and thisVer < parse_version('4.1'):
+        elif thisVer >= Version('4.0') and thisVer < Version('4.1'):
             raise Exception(
                     "wx>=4.0 clashes with pyglet and making it unsafe "
                     "as a PsychoPy gui helper. Please install PyQt (4 or 5)"

psychopy/hardware/__init__.py

@@ -7,7 +7,7 @@ from itertools import chain
 from psychopy import logging
 from . import eyetracker, listener
 from .manager import DeviceManager, deviceManager
-from .base import BaseDevice
+from .base import BaseDevice, BaseResponse, BaseResponseDevice
 
 try:
     from collections.abc import Iterable

psychopy/hardware/base.py

@@ -14,6 +14,7 @@ __all__ = [
 
 import json
 import inspect
+import time
 
 
 class BaseResponse:
@@ -170,6 +171,17 @@ class BaseResponseDevice(BaseDevice):
         """
         pass
 
+    def hasUnfinishedMessage(self):
+        """
+        If there is a message which have been partially received but not finished (e.g. 
+        getting the start of a message from a serial device but no end of line character 
+        yet), this will return True.
+
+        If not implemented or not relevant on a given device (e.g. Keyboard, which only 
+        sends full messages), this will always return False.
+        """
+        return False
+
     def parseMessage(self, message):
         raise NotImplementedError(
             "All subclasses of BaseDevice must implement the method `parseMessage`"

psychopy/hardware/camera/__init__.py

@@ -1725,7 +1725,7 @@ class Camera:
 
         # current camera frame since the start of recording
         self._player = None  # media player instance
-        self._status = NOT_STARTED
+        self.status = NOT_STARTED
         self._isRecording = False
         self._bufferSecs = float(bufferSecs)
         self._lastFrame = None  # use None to avoid imports for ImageStim
@@ -1943,20 +1943,6 @@ class Camera:
         """
         return getCameraDescriptions(collapse=collapse)
 
-    @property
-    def status(self):
-        """Status flag for the camera (`int`).
-
-        Can be either `RECORDING`, `STOPPED`, `STOPPING`, or `NOT_STARTED`. This 
-        property used in Builder output scripts and does not update on its own.
-
-        """
-        return self._status
-
-    @status.setter
-    def status(self, value):
-        self._status = value
-
     @property
     def device(self):
         """Camera to use (`str` or `None`).

psychopy/hardware/cedrus.py

@@ -19,18 +19,17 @@ instead (bundled with Standalone PsychoPy)::
 """
 
 import psychopy.logging as logging
+from psychopy.tools.pkgtools import PluginStub
+
+
+class RB730(
+    PluginStub, 
+    plugin="psychopy-cedrus", 
+    doclink="https://psychopy.github.io/psychopy-cedrus/coder/RB730"
+):
+    pass
+
 
-try:
-    from psychopy_cedrus import RB730
-except (ModuleNotFoundError, ImportError):
-    logging.error(
-        "Support for Cedrus Corporation hardware is not available this "
-        "session. Please install `psychopy-cedrus` and restart the session "
-        "to enable support.")
-except Exception as e:
-    logging.error(
-        "Error encountered while loading `psychopy-cedrus`. Check logs for "
-        "more information.")
 
 if __name__ == "__main__":
     pass

psychopy/hardware/crs/colorcal.py

@@ -5,26 +5,17 @@
 # Copyright (C) 2002-2018 Jonathan Peirce (C) 2019-2024 Open Science Tools Ltd.
 # Distributed under the terms of the GNU General Public License (GPL).
 
-import psychopy.logging as logging
-
-try:
-    from psychopy_crs.colorcal import ColorCAL
-except (ModuleNotFoundError, ImportError, NameError):
-    logging.error(
-        "Support for Cambridge Research Systems ColorCAL is not available this "
-        "session. Please install `psychopy-crs` and restart the session to "
-        "enable support.")
-except Exception as e:
-    logging.error(
-        "Error encountered while loading `psychopy-crs`. Check logs for more "
-        "information.")
-else:
-    # Monkey-patch our metadata into CRS class if missing required attributes
-    if not hasattr(ColorCAL, "longName"):
-        setattr(ColorCAL, "longName", "CRS ColorCAL")
-
-    if not hasattr(ColorCAL, "driverFor"):
-        setattr(ColorCAL, "driverFor", ["colorcal"])
-
-if __name__ == "__main__":
+
+from psychopy.tools.pkgtools import PluginStub
+
+
+class ColorCAL(PluginStub, plugin="psychopy-crs", doclink="https://psychopy.github.io/psychopy-crs/coder/ColorCAL"):
     pass
+
+
+# Monkey-patch our metadata into CRS class if missing required attributes
+if not hasattr(ColorCAL, "longName"):
+    setattr(ColorCAL, "longName", "CRS ColorCAL")
+
+if not hasattr(ColorCAL, "driverFor"):
+    setattr(ColorCAL, "driverFor", ["colorcal"])

psychopy/hardware/crs/optical.py

@@ -21,26 +21,16 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-import psychopy.logging as logging
+from psychopy.tools.pkgtools import PluginStub
 
-try:
-    from psychopy_crs.optical import OptiCAL
-except (ModuleNotFoundError, ImportError):
-    logging.error(
-        "Support for Cambridge Research Systems OptiCAL is not available this "
-        "session. Please install `psychopy-crs` and restart the session to "
-        "enable support.")
-except Exception as e:
-    logging.error(
-        "Error encountered while loading `psychopy-crs`. Check logs for more "
-        "information.")
-else:
-    # Monkey-patch our metadata into CRS class if missing required attributes
-    if not hasattr(OptiCAL, "longName"):
-        setattr(OptiCAL, "longName", "CRS OptiCal")
 
-    if not hasattr(OptiCAL, "driverFor"):
-        setattr(OptiCAL, "driverFor", ["optical"])
-
-if __name__ == "__main__":
+class OptiCAL(PluginStub, plugin="psychopy-crs", doclink="https://psychopy.github.io/psychopy-crs/coder/OptiCAL"):
     pass
+
+
+# Monkey-patch our metadata into CRS class if missing required attributes
+if not hasattr(OptiCAL, "longName"):
+    setattr(OptiCAL, "longName", "CRS OptiCal")
+
+if not hasattr(OptiCAL, "driverFor"):
+    setattr(OptiCAL, "driverFor", ["optical"])

psychopy/hardware/emulator.py

@@ -18,20 +18,23 @@ These are optional components that can be obtained by installing the
 
 """
 
-import psychopy.logging as logging
-
-try:
-    from psychopy_mri_emulator import (
-        SyncGenerator, ResponseEmulator, launchScan)
-except (ModuleNotFoundError, ImportError):
-    logging.error(
-        "Support for software fMRI emulation is not available this session. "
-        "Please install `psychopy-mri-emulator` and restart the session to "
-        "enable support.")
-except Exception as e:
-    logging.error(
-        "Error encountered while loading `psychopy-mri-emulator`. Check logs "
-        "for more information.")
+
+from psychopy.tools.pkgtools import PluginStub
+
+
+class SyncGenerator(
+    PluginStub,
+    plugin="psychopy-mri-emulator"
+):
+    pass
+
+
+class ResponseEmulator(
+    PluginStub,
+    plugin="psychopy-mri-emulator"
+):
+    pass
+
 
 if __name__ == "__main__":
     pass

psychopy/hardware/eyetracker.py

@@ -1,48 +1,46 @@
 from psychopy.constants import STARTED, NOT_STARTED, PAUSED, STOPPED, FINISHED
 from psychopy.alerts import alert
 from psychopy import logging
+from psychopy.iohub.devices import importDeviceModule
 from psychopy.tools.attributetools import AttributeGetSetMixin
 from copy import copy
+import importlib
 import sys
 
 
 class EyetrackerControl(AttributeGetSetMixin):
-    currentlyRecording = False
 
     def __init__(self, tracker, actionType="Start and Stop"):
         self.tracker = tracker
         self.actionType = actionType
-        self._status = NOT_STARTED
+        self.status = NOT_STARTED
+
+    def start(self):
+        """
+        Start recording
+        """
+        # if previously at a full stop, clear events
+        if not self.tracker.isRecordingEnabled():
+            logging.exp("eyetracker.clearEvents()")
+            self.tracker.clearEvents()
+        # start recording
+        self.tracker.setRecordingState(True)
+        logging.exp("eyetracker.setRecordingState(True)")
+
+    def stop(self):
+        """
+        Stop recording
+        """
+        self.tracker.setRecordingState(False)
+        logging.exp("eyetracker.setRecordingState(False)")
 
     @property
-    def status(self):
-        return self._status
-
-    @status.setter
-    def status(self, value):
-        old = self._status
-        new = self._status = value
-        # Skip if there's no change
-        if new == old:
-            return
-        # Start recording if set to STARTED
-        if new in (STARTED,):
-            if old in (NOT_STARTED, STOPPED, FINISHED):
-                # If was previously at a full stop, clear events before starting again
-                if self.actionType.find('Start') >= 0 and EyetrackerControl.currentlyRecording is False:
-                    logging.exp("eyetracker.clearEvents()")
-                    self.tracker.clearEvents()
-            # Start recording
-            if self.actionType.find('Start') >= 0 and not EyetrackerControl.currentlyRecording:
-                self.tracker.setRecordingState(True)
-                logging.exp("eyetracker.setRecordingState(True)")
-                EyetrackerControl.currentlyRecording = True
-        # Stop recording if set to any stop constants
-        if new in (NOT_STARTED, PAUSED, STOPPED, FINISHED):
-            if self.actionType.find('Stop') >= 0 and EyetrackerControl.currentlyRecording:
-                self.tracker.setRecordingState(False)
-                logging.exp("eyetracker.setRecordingState(False)")
-                EyetrackerControl.currentlyRecording = False
+    def currentlyRecording(self):
+        """
+        Check if the eyetracker is currently recording
+        added for backwards compatibility, should be removed in future
+        """
+        return self.tracker.isRecordingEnabled()
 
     @property
     def pos(self):
@@ -84,94 +82,20 @@ class EyetrackerCalibration:
     def __iter__(self):
         """Overload dict() method to return in ioHub format"""
         tracker = self.eyetracker.getIOHubDeviceClass(full=True)
-
-        # Make sure that target will use the same color space and units as calibration
-        if self.target.colorSpace == self.colorSpace and self.target.units == self.units:
-            target = self.target
-        else:
-            target = copy(self.target)
-            target.colorSpace = self.colorSpace
-            target.units = self.units
-        # Get self as dict
-        asDict = {}
-
-        textColor = self.textColor
-        if isinstance(textColor, str) and textColor.lower() == 'auto':
-            textColor = None
-
-        if tracker == 'eyetracker.hw.sr_research.eyelink.EyeTracker':
-            # As EyeLink
-            asDict = {
-                'target_attributes': dict(target),
-                'type': self.targetLayout,
-                'auto_pace': self.progressMode == "time",
-                'pacing_speed': self.targetDelay,
-                'randomize': self.randomisePos,
-                'text_color': textColor,
-                'screen_background_color': getattr(self.win._color, self.colorSpace)
-            }
-        elif tracker == 'eyetracker.hw.tobii.EyeTracker':
-            # As Tobii
-            targetAttrs = dict(target)
-            targetAttrs['animate'] = {
-                'enable': self.movementAnimation,
-                'expansion_ratio': self.expandScale,
-                'contract_only': self.expandScale == 1
-            }
-            asDict = {
-                'target_attributes': targetAttrs,
-                'type': self.targetLayout,
-                'randomize': self.randomisePos,
-                'auto_pace': self.progressMode == "time",
-                'target_delay': self.targetDelay,
-                'target_duration': self.targetDur,
-                'unit_type': self.units,
-                'color_type': self.colorSpace,
-                'text_color': textColor,
-                'screen_background_color': getattr(self.win._color, self.colorSpace),
-            }
-        elif tracker == 'eyetracker.hw.gazepoint.gp3.EyeTracker':
-            # As GazePoint
-            targetAttrs = dict(target)
-            targetAttrs['animate'] = {
-                'enable': self.movementAnimation,
-                'expansion_ratio': self.expandScale,
-                'contract_only': self.expandScale == 1
-            }
-            asDict = {
-                'use_builtin': False,
-                'target_delay': self.targetDelay,
-                'target_duration': self.targetDur,
-                'target_attributes': targetAttrs,
-                'type': self.targetLayout,
-                'randomize': self.randomisePos,
-                'unit_type': self.units,
-                'color_type': self.colorSpace,
-                'text_color': textColor,
-                'screen_background_color': getattr(self.win._color, self.colorSpace),
-            }
-
-        elif tracker == 'eyetracker.hw.mouse.EyeTracker':
-            # As MouseGaze
-            targetAttrs = dict(target)
-            targetAttrs['animate'] = {
-                'enable': self.movementAnimation,
-                'expansion_ratio': self.expandScale,
-                'contract_only': self.expandScale == 1
-            }
-            # Run as MouseGaze
-            asDict = {
-                'target_attributes': targetAttrs,
-                'type': self.targetLayout,
-                'randomize': self.randomisePos,
-                'auto_pace': self.progressMode == "time",
-                'pacing_speed': self.targetDelay,
-                'unit_type': self.units,
-                'color_type': self.colorSpace,
-                'text_color': textColor,
-                'screen_background_color': getattr(self.win._color, self.colorSpace),
-            }
-        # Return
+        # split into package and class name
+        pkgName = ".".join(tracker.split(".")[:-1])
+        clsName = tracker.split(".")[-1]
+        # make sure pkgName is fully qualified
+        if not pkgName.startswith("psychopy.iohub.devices."):
+            pkgName = "psychopy.iohub.devices." + pkgName
+        # import package
+        pkg = importDeviceModule(pkgName)
+        # get tracker class
+        trackerCls = getattr(pkg, clsName)
+        # get self as dict
+        asDict = trackerCls.getCalibrationDict(self)
+
+        # return
         for key, value in asDict.items():
             yield key, value
 

psychopy/hardware/gammasci.py

@@ -14,19 +14,8 @@ These are optional components that can be obtained by installing the
 
 """
 
-import psychopy.logging as logging
-
-try:
-    from psychopy_gammasci import S470
-except (ModuleNotFoundError, ImportError):
-    logging.error(
-        "Support for Gamma-Scientific Inc. hardware is not available this "
-        "session. Please install `psychopy-gammasci` and restart the session "
-        "to enable support.")
-except Exception as e:
-    logging.error(
-        "Error encountered while loading `psychopy-gammasci`. Check logs for "
-        "more information.")
-
-if __name__ == "__main__":
+from psychopy.tools.pkgtools import PluginStub
+
+
+class S470(PluginStub, plugin="psychopy-gammasci", doclink="https://psychopy.github.io/psychopy-gammasci/coder/S470"):
     pass

psychopy/hardware/keyboard.py

@@ -67,6 +67,7 @@ import psychopy.clock
 from psychopy import logging
 from psychopy.constants import NOT_STARTED
 import time
+import numpy as np
 
 from psychopy.hardware.base import BaseResponseDevice, BaseResponse
 from psychopy.hardware import DeviceManager
@@ -231,6 +232,25 @@ class Keyboard(AttributeGetSetMixin):
             keyList=keyList, ignoreKeys=ignoreKeys, waitRelease=waitRelease, clear=clear
         )
 
+    def getState(self, keys):
+        """
+        Get the current state of a key or set of keys
+
+        Parameters
+        ----------
+        keys : str or list[str]
+            Either the code for a single key, or a list of key codes.
+        
+        Returns
+        -------
+        keys : bool or list[bool]
+            True if pressed, False if not. Will be a single value if given a 
+            single key, or a list of bools if given a list of keys.
+        """
+        return self.device.getState(
+            keys=keys
+        )
+
     def waitKeys(self, maxWait=float('inf'), keyList=None, waitRelease=True,
                  clear=True):
         return self.device.waitKeys(
@@ -493,7 +513,7 @@ class KeyboardDevice(BaseResponseDevice, aliases=["keyboard"]):
                 if resp.value in ignoreKeys:
                     wanted = False
             # if we got this far and the key is still wanted and not present, add it to output
-            if wanted and resp not in keys:
+            if wanted and not any(k is resp for k in keys):
                 keys.append(resp)
             # if clear=True, mark wanted responses as toClear
             if wanted and clear:
@@ -504,6 +524,70 @@ class KeyboardDevice(BaseResponseDevice, aliases=["keyboard"]):
 
         return keys
 
+    def getState(self, keys):
+        """
+        Get the current state of a key or set of keys
+
+        Parameters
+        ----------
+        keys : str or list[str]
+            Either the code for a single key, or a list of key codes.
+        
+        Returns
+        -------
+        keys : bool or list[bool]
+            True if pressed, False if not. Will be a single value if given a 
+            single key, or a list of bools if given a list of keys.
+        """
+        # if given a string, convert to a list
+        if isinstance(keys, str):
+            keys = [keys]
+        # start off False
+        state = [False] * len(keys)
+
+        if KeyboardDevice._backend == 'ptb':
+            # use ptb.Keyboard.check if backend is ptb
+            for buffer in self._buffers.values():
+                # get output from ptb
+                anyPressed, t, mat = buffer.dev.check()
+                # if got any key...
+                if mat.any():
+                    # convert each key index to a key name
+                    for i in np.where(mat.flatten())[0]:
+                        # account for ptb's 1-based indexing
+                        i = int(i) + 1
+                        # get key name from index (or None if not applicable)
+                        name = keyNames.get(i, None)
+                        # check if it's on our list
+                        if name in keys:
+                            state[keys.index(name)] = True
+        elif KeyboardDevice._backend == 'iohub':
+            # get current state of ioHub keyboard
+            ioHubState = KeyboardDevice._iohubKeyboard.getCurrentDeviceState()
+            # iterate through pressed keys
+            for i in ioHubState.get("pressed_keys", {}):
+                # iohub returns strings - integerise
+                i = int(i)
+                # get key name from index (or None if not applicable)
+                name = keyNames.get(i, None)
+                # check if it's on our list
+                if name in keys:
+                    state[keys.index(name)] = True
+        else:
+            # make a key state handler
+            handler = event.pyglet.window.key.KeyStateHandler()
+            # iterate through our list of keys
+            for i, key in enumerate(keys):
+                # if handler has an entry for the given key, it's pressed
+                state[i] = handler[getattr(event.pyglet.window.key, key.upper())]
+
+        # if state is a single value, remove list wrapper
+        if len(state) == 1:
+            state = state[0]
+        
+        return state
+
+
     def dispatchMessages(self):
         if KeyboardDevice._backend == 'ptb':
             for buffer in self._buffers.values():
@@ -521,7 +605,6 @@ class KeyboardDevice(BaseResponseDevice, aliases=["keyboard"]):
         elif KeyboardDevice._backend == 'iohub':
             # get events from backend (need to reverse order)
             key_events = KeyboardDevice._iohubKeyboard.getKeys(clear=True)
-            key_events.reverse()
             # parse and receive each event
             for k in key_events:
                 kpress = self.parseMessage(k)
@@ -552,10 +635,13 @@ class KeyboardDevice(BaseResponseDevice, aliases=["keyboard"]):
         response = None
 
         if KeyboardDevice._backend == 'ptb':
-            message['time'] -= self.clock.getLastResetTime()
             if message['down']:
                 # if message is from a key down event, make a new response
-                response = KeyPress(code=message['keycode'], tDown=message['time'])
+                response = KeyPress(
+                    code=message['keycode'],
+                    tDown=message['time'] - logging.defaultClock.getLastResetTime()
+                )
+                response.rt = message['time'] - self.clock.getLastResetTime()
                 self._keysStillDown.append(response)
             else:
                 # if message is from a key up event, alter existing response
@@ -563,7 +649,7 @@ class KeyboardDevice(BaseResponseDevice, aliases=["keyboard"]):
                     if key.code == message['keycode']:
                         response = key
                         # calculate duration
-                        key.duration = message['time'] - key.tDown
+                        key.duration = message['time'] - key.tDown - logging.defaultClock.getLastResetTime()
                         # remove key from stillDown
                         self._keysStillDown.remove(key)
                         # stop processing keys as we're done
@@ -573,7 +659,8 @@ class KeyboardDevice(BaseResponseDevice, aliases=["keyboard"]):
             if message.type == "KEYBOARD_PRESS":
                 # if message is from a key down event, make a new response
                 response = KeyPress(code=message.char, tDown=message.time, name=message.key)
-                response.rt = response.tDown - self.clock.getLastResetTime()
+                response.rt = response.tDown - (
+                    self.clock.getLastResetTime() - self._iohubKeyboard.clock.getLastResetTime())
                 self._keysStillDown.append(response)
             else:
                 # if message is from a key up event, alter existing response
@@ -600,9 +687,9 @@ class KeyboardDevice(BaseResponseDevice, aliases=["keyboard"]):
 
     def waitKeys(self, maxWait=float('inf'), keyList=None, waitRelease=True,
                  clear=True):
-        """Same as `~psychopy.hardware.keyboard.Keyboard.getKeys`, 
+        """Same as `~psychopy.hardware.keyboard.Keyboard.getKeys`,
         but halts everything (including drawing) while awaiting keyboard input.
-    
+
         :Parameters:
             maxWait : any numeric value.
                 Maximum number of seconds period and which keys to wait for.
@@ -622,9 +709,9 @@ class KeyboardDevice(BaseResponseDevice, aliases=["keyboard"]):
             clear : **True** or False
                 Whether to clear the keyboard event buffer (and discard preceding
                 keypresses) before starting to monitor for new keypresses.
-    
+
         Returns None if times out.
-    
+
         """
         timer = psychopy.clock.Clock()
 
@@ -643,6 +730,7 @@ class KeyboardDevice(BaseResponseDevice, aliases=["keyboard"]):
 
     def clearEvents(self, eventType=None):
         """Clear the events from the Keyboard such as previous key presses"""
+        # clear backend buffers
         if KeyboardDevice._backend == 'ptb':
             for buffer in self._buffers.values():
                 buffer.flush()  # flush the device events to the soft buffer
@@ -654,6 +742,9 @@ class KeyboardDevice(BaseResponseDevice, aliases=["keyboard"]):
         else:
             global event
             event.clearEvents(eventType)
+        # clear dispatched responses
+        self.responses = []
+
         logging.info("Keyboard events cleared", obj=self)
 
 
@@ -745,7 +836,7 @@ class _KeyBuffer(object):
         if not keyList and not waitRelease:
             keyPresses = list(self._keysStillDown)
             for k in list(self._keys):
-                if not any(x.name == k.name and x.tDown == k.tDown  for x in keyPresses):
+                if not any(x.name == k.name and x.tDown == k.tDown for x in keyPresses):
                     keyPresses.append(k)
             if clear:
                 self._keys = deque()

psychopy/hardware/listener.py

@@ -135,6 +135,9 @@ class ListenerLoop(threading.Thread):
                 # dispatch messages from devices
                 for device in self.devices:
                     device.dispatchMessages()
+            # if there are no more devices attached, stop
+            if not len(self.devices):
+                self._active = False
             # sleep for 10ms
             time.sleep(self.refreshRate)