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

psychopy/tests/test_experiment/test_components/test_base_components.py

@@ -9,6 +9,8 @@ from psychopy import experiment
 from psychopy.experiment.loops import TrialHandler
 from psychopy.experiment.components import BaseComponent
 from psychopy.experiment.exports import IndentingBuffer
+from psychopy.constants import FOREVER
+from psychopy.tests import utils
 
 
 def _find_global_resource_in_js_experiment(script, resource):
@@ -147,6 +149,62 @@ class BaseComponentTests:
             assert buff.indentLevel == 0, errMsg.format(
                 "experiment end", buff.indentLevel
             )
+    
+    def test_blank_timing(self):
+        """
+        Check that this Component can handle blank start/stop values.
+        """
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
+        # skip if Component doesn't have the relevant params (e.g. Code Component)
+        for key in ("startVal", "startType", "stopVal", "stopType"):
+            if key not in comp.params:
+                pytest.skip()
+        # StaticComponent has entirely bespoke start/stop tests so skip it here
+        if type(comp).__name__ == "StaticComponent":
+            pytest.skip()
+        # make sure start and stop are as times
+        comp.params['startType'].val = "time (s)"
+        comp.params['stopType'].val = "duration (s)"
+        # define cases and expected start/dur
+        cases = [
+            # blank start
+            {'startVal': "", 'stopVal': "1", 'startTime': None, 'duration': 1},
+            # blank stop
+            {'startVal': "0", 'stopVal': "", 'startTime': 0, 'duration': FOREVER},
+            # blank both
+            {'startVal': "", 'stopVal': "", 'startTime': None, 'duration': FOREVER},
+        ]
+        # run all cases
+        for case in cases:
+            # apply values from case
+            comp.params['startVal'].val = case['startVal']
+            comp.params['stopVal'].val = case['stopVal']
+            # get values from start and duration method
+            startTime, duration, nonSlipSafe = comp.getStartAndDuration()
+            # check against expected
+            assert startTime == case['startTime']
+            assert duration == case['duration']
+            # check that it's never non-slip safe
+            assert not nonSlipSafe
+            # temp file to save scripts to for flake
+            import tempfile
+            file = Path(tempfile.gettempdir()) / "test_blank_timing_script.py"
+            # write the script
+            script = exp.writeScript(target="PsychoPy")
+            file.write_text(script, encoding="utf-8")
+            # check for syntax errors
+            try:
+                compile(script, str(file), "exec")
+            except Exception as err:
+                # save script
+                case['fail'] = Path(utils.TESTS_FAILS_PATH) / "test_blank_timing_script.py"
+                case['fail'].write_text(script, encoding="utf-8")
+                # raise error
+                raise AssertionError(
+                    "Syntax error in compiled Builder code when startVal was '%(startVal)s' and "
+                    "stopVal was '%(stopVal)s'. Failed script saved in '%(fail)s'" % case
+                )
 
     def test_disabled_default_val(self):
         """

psychopy/tests/test_experiment/test_py2js.py

@@ -67,7 +67,7 @@ class TestTranspiler:
             {'py': "a.upper()", 'js': "a.toUpperCase();\n"},
             {'py': "a.extend([4, 5, 6])", 'js': "a.concat([4, 5, 6]);\n"},
             {'py': "a.pop(0)", 'js': "a.splice(0, 1);\n"},
-            {'py': "a.pop()", 'js': "a.splice((- 1), 1);\n"},
+            {'py': "a.pop()", 'js': "a.splice((a.length - 1), 1);\n"},
         ]
         # Try each case
         for case in cases:

psychopy/tests/test_hardware/test_keyboard.py

@@ -1,11 +1,20 @@
 import sys
 from psychopy.hardware import keyboard
-from pytest import skip
+import pytest
 import time
+from psychopy import logging
+from psychopy.tests.utils import RUNNING_IN_VM
 
 
-class _TestKeyboard:
-    def testMakeAndReceiveMessage(self):
+class _TestBaseKeyboard:
+    """
+    Tests for the general functionality which should exist across Keyboard backends.
+    """
+    def testReceiveGeneratedKeypress(self):
+        """
+        Test that `KeyboardDevice.receiveMessage` can receive and interpret a KeyPress object
+        correctly, even when that object isn't linked to a physical keypress.
+        """
         # list of events to fake, time to fake them and state of getKeys outputs afterwards
         cases = [
             {'val': "a", 't': 0.1, 'len': 1},
@@ -18,16 +27,43 @@ class _TestKeyboard:
             assert keys[-1] is evt
             assert keys[-1].value == case['val']
 
+    def testAcceptDuplicateResponses(self):
+        """
+        Test that KeyboardDevice can receive multiple presses of the same key without accepting
+        genuine duplicates (e.g. KeyPress objects added twice, or the same object added for press
+        and release)
+        """
+        # clear
+        self.kb.clearEvents()
+        # press space twice and don't release
+        resp1 = self.kb.makeResponse(tDown=0.1, code="space")
+        resp2 = self.kb.makeResponse(tDown=0.2, code="space")
+        # make sure we only have 2 press objects
+        keys = self.kb.getKeys(waitRelease=False, clear=False)
+        assert len(keys) == 2
+        # simulate a release
+        resp1.duration = 0.2
+        resp2.duration = 0.1
+        self.kb.responses += [resp1, resp2]
+        # we should still only have 2 press objects (as these are duplicates)
+        keys = self.kb.getKeys(waitRelease=True, clear=False)
+        assert len(keys) == 2
+        # add the same objects again for no good reason
+        self.kb.responses += [resp1, resp2]
+        # we should STILL only have 2 press objects
+        keys = self.kb.getKeys(waitRelease=True, clear=False)
+        assert len(keys) == 2
+
     def testMuteOutsidePsychopyNotSlower(self):
         """
         Test that responses aren't worryingly slower when using muteOutsidePsychopy
         """
         # skip this test on Linux (as MOP *is* slower due to having to use subprocess)
         if sys.platform == "linux":
-            skip()
-        # delete test kb
-        backend = self.kb._backend
-        del self.kb
+            pytest.skip()
+        # skip speed tests under vm
+        if RUNNING_IN_VM:
+            pytest.skip()
 
         # array to store times
         times = {}
@@ -36,38 +72,170 @@ class _TestKeyboard:
 
         for mop in (True, False):
             # make new keyboard with muteOutsidePsychopy set as desired
-            kb = keyboard.KeyboardDevice(muteOutsidePsychopy=mop)
+            self.kb.muteOutsidePsychopy = mop
             # start timer
             start = time.time()
             # make 10000 responses
             for n in range(nResps):
-                kb.makeResponse(
+                self.kb.makeResponse(
                     code="a", tDown=0
                 )
             # get time
             times[mop] = time.time() - start
-            # delete keyboard
-            del kb
 
         # work out average difference per-response
         avg = (times[True] - times[False]) / nResps
         # make sure average difference will still be less than a frame on high performance monitors
         assert avg < 1/240
 
-        # recreate test kb
-        self.kb = keyboard.KeyboardDevice
+    def teardown_method(self):
+        # clear any keypresses
+        self.kb.getKeys(clear=True)
+        # set mute outside psychopy back to False
+        self.kb.muteOutsidePsychopy = False
+
+
+class _MillikeyMixin:
+    """
+    Mixin to add tests which use a Millikey device to generate keypresses. If no such device is
+    connected, these tests will all skip.
+    """
+    # this attribute should be overwritten when setup_class is called
+    millikey = None
+
+    def setup_class(self):
+        """
+        Create a serial object to interface with a Millikey device,
+        """
+        from psychopy.hardware.serialdevice import SerialDevice
+        from psychopy.tools import systemtools as st
+
+        # systemtools only works on Windows so skip millikey-dependent tests on other OS's
+        if sys.platform != "win32":
+            return
+
+        # use systemtools to find millikey port
+        for profile in st.systemProfilerWindowsOS(classname="Ports", connected=True):
+            # identify by driver name
+            if "usbser.inf" not in profile['Driver Name']:
+                continue
+            # find "COM" in profile description
+            desc = profile['Device Description']
+            start = desc.find("COM") + 3
+            end = desc.find(")", start)
+            # if there's no reference to a COM port, skip
+            if -1 in (start, end):
+                continue
+            # get COM port number
+            num = desc[start:end]
+            # if we've got this far, create device
+            self.millikey = SerialDevice(f"COM{num}", baudrate=128000)
+            # stop looking once we've got one
+            break
+
+    def teardown_class(self):
+        """
+        Close Millikey before finishing tests.
+        """
+        if self.millikey is not None:
+            self.millikey.close()
+
+    def assertMillikey(self):
+        """
+        Make sure a Millikey device is connected (and skip the current test if not)
+        """
+        # if we didn't find a device, skip current test
+        if self.millikey is None:
+            pytest.skip()
+
+    def makeMillikeyKeypress(self, key, duration, delay=0):
+        """
+        Send a trigger to the Millikey device telling to to press a particular key.
+
+        Parameters
+        ----------
+        key : str
+            Key to press
+        duration : int
+            Duration (ms) of the keypress
+        delay : int
+            Delay (ms) before making the keypress
+        """
+        # make sure we have a millikey device
+        self.assertMillikey()
+        # construct command (see https://blog.labhackers.com/?p=285)
+        cmd = "KGEN {} {} {}".format(key, duration, delay)
+        # send
+        self.millikey.sendMessage(cmd)
+        # read any resp1
+        return self.millikey.getResponse()
+
+    def testReceivePhysicalKeypress(self):
+        """
+        Test that physical keypresses are detected.
+
+        Requires a Millikey device to run.
+        """
+        self.makeMillikeyKeypress(key="a", duration=10, delay=10)
+        # get last message
+        resp = self.kb.getKeys()[-1]
+        # check whether the created press was received
+        assert resp.name == "a"
+
+    def testPhysicalKeypressTiming(self):
+        """
+        Test that timing (tDown, rt, etc.) on KeyPress objects received via a physical key press
+        are correct.
+
+        Requires a Millikey device to run.
+        """
+        # define tolerance (ms) for this test
+        tolerance = 4
+        # try a few times to make sure times aren't cumulative
+        for ans, dur, rt in [
+            ("a", 123, 456),
+            ("b", 456, 123),
+            ("c", 123, 123),
+            ("d", 456, 456),
+        ]:
+            # reset keyboard clock
+            self.kb.clock.reset()
+            # wait for rt
+            time.sleep(rt / 1000)
+            # store start time
+            start = logging.defaultClock.getTime()
+            # make a keypress
+            self.makeMillikeyKeypress(key=ans, duration=dur)
+            # wait for press to finish
+            time.sleep(dur / 500)
+            # get last message
+            resp = self.kb.getKeys()[-1]
+            # check correct key
+            assert resp.name == ans
+            # check correct rt
+            assert abs(resp.rt - rt / 1000) <= tolerance / 1000
+            # check correct duration
+            assert abs(resp.duration - dur / 1000) <= tolerance / 1000
+            # check correct start time
+            assert abs(resp.tDown - start) <= tolerance / 1000
 
 
-class TestIohubKeyboard(_TestKeyboard):
+class TestIohubKeyboard(_TestBaseKeyboard, _MillikeyMixin):
     def setup_method(self):
         self.kb = keyboard.KeyboardDevice(backend="iohub", muteOutsidePsychopy=False)
 
 
-class TestPtbKeyboard(_TestKeyboard):
+class TestPtbKeyboard(_TestBaseKeyboard, _MillikeyMixin):
     def setup_method(self):
         self.kb = keyboard.KeyboardDevice(backend="ptb", muteOutsidePsychopy=False)
 
+    def teardown_method(self):
+        self.kb.getKeys(clear=True)
 
-class TestEventKeyboard(_TestKeyboard):
+
+class TestEventKeyboard(_TestBaseKeyboard, _MillikeyMixin):
     def setup_method(self):
         self.kb = keyboard.KeyboardDevice(backend="event", muteOutsidePsychopy=False)
+
+    def teardown_method(self):
+        self.kb.getKeys(clear=True)

psychopy/tests/test_hardware/test_ports.py

@@ -1,3 +1,4 @@
+
 import psychopy.hardware as hw
 import pytest
 try:
@@ -109,17 +110,6 @@ def test_getCRSPhotometers():
         photoms = list(hw.getAllPhotometers())
         assert faked in photoms
 
-def test_getPhotometers():
-    photoms = hw.getAllPhotometers()
-
-    # Always iterable
-    assert isinstance(photoms, Iterable)
-
-    photoms = list(photoms)
-
-    assert len(photoms) > 0
-
-
 # I wish our PR650 would behave like this ;-)
 _MockPhotometer = type("MockPhotometer",(),{"OK": True,"type": "MockPhotometer"})
 

psychopy/tests/test_liaison/test_Liaison.py

@@ -1,3 +1,4 @@
+import threading
 from psychopy import liaison, session, hardware
 from psychopy.hardware import DeviceManager
 from psychopy.tests import utils, skip_under_vm
@@ -88,6 +89,52 @@ class TestLiaison:
             self.server, self.protocol, "session", "runExperiment",
             "exp1"
         )
+    
+    def test_future_trials(self):
+        # add experiment
+        runInLiaison(
+            self.server, self.protocol, "session", "addExperiment",
+            "testFutureTrials/testFutureTrials.psyexp", "testFutureTrials"
+        )
+        time.sleep(1)
+        # define a threaded task to run alongside experiment
+        def _thread():
+            # wait for first meaningful result
+            resp = None
+            i = 0
+            while resp is None and i < 24:
+                # get future trial
+                runInLiaison(
+                    self.server, self.protocol, "session", "getFutureTrial",
+                    "1", "True"
+                )
+                # get result
+                resp = json.loads(self.protocol.messages[-1]["result"])
+                # wait 0.1s
+                time.sleep(0.1)
+                # iterate towards limit
+                i += 1
+            # if we hit iteration limit, fail
+            assert i < 24, "Timed out waiting for a non-None result from getFutureTrial"
+            # does response have all the keys we expect?
+            expectedKeys = (
+                "type", "thisN", "thisRepN", "thisTrialN", "thisIndex", "data"
+            )
+            keysPresent = [key in resp for key in expectedKeys]
+            assert all(keysPresent), "Trial object missing key(s): {}".format(
+                expectedKeys[i] for i, val in enumerate(keysPresent) if not val
+            )
+            # resp should have type "trial_data"
+            assert resp['type'] == "trial_data", (
+                f"First non-None result from getFutureTrial doesn't look like a Trial object: {resp}"
+            )
+        # start thread
+        threading.Thread(target=_thread).start()
+        # run experiment
+        runInLiaison(
+            self.server, self.protocol, "session", "runExperiment",
+            "testFutureTrials"
+        )
 
     def test_experiment_error(self):
         """

psychopy/tests/test_misc/test_core.py

@@ -25,6 +25,7 @@ import pytest
 
 import psychopy
 import psychopy.logging as logging
+from psychopy.tests.utils import RUNNING_IN_VM
 from psychopy.visual import Window
 from psychopy.core import (getTime, MonotonicClock, Clock, CountdownTimer, wait,
                            StaticPeriod, shellCall)
@@ -346,6 +347,10 @@ def test_LoggingDefaultClock():
 
 @pytest.mark.staticperiod
 def test_StaticPeriod():
+    # this test is speed sensitive, so skip under VM
+    if RUNNING_IN_VM:
+        pytest.skip()
+
     static = StaticPeriod()
     static.start(0.1)
     wait(0.05)

psychopy/tests/test_session/test_Session.py

@@ -22,7 +22,8 @@ class TestSession:
                 'exp2': "exp2/exp2.psyexp",
                 'testCtrls': "testCtrls/testCtrls.psyexp",
                 'error': "error/error.psyexp",
-                'annotation': "annotation/annotation.psyexp"
+                'annotation': "annotation/annotation.psyexp",
+                'trialNav': "testTrialNav/trialNav.psyexp"
             }
         )
         # setup devices
@@ -45,6 +46,9 @@ class TestSession:
         self.sess.runExperiment("exp2")
         self.sess.runExperiment("exp1")
 
+    def test_trial_navigation(self):
+        self.sess.runExperiment("trialNav")
+
     def test_ctrls(self):
         """
         Check that experiments check Session often enough for pause/resume commands sent asynchronously will still work.

psychopy/tests/test_tools/test_versionchooser.py

@@ -2,6 +2,9 @@
 """Tests for psychopy.tools.versionchooser"""
 import os
 import sys
+import unittest
+import subprocess
+import shutil
 from pathlib import Path
 
 import psychopy
@@ -168,11 +171,39 @@ class TestVersionRange:
             )
 
 
-"""
-
-TODO: Tests to write:
-
-* Fail if git isn't there
-* Fail if git can't download repo
-
-"""
+class TestGitInstallation(unittest.TestCase):
+    def test_git_installed(self):
+        # Test if Git is installed on this system.
+        try:
+            # Attempt to get the Git version
+            result = subprocess.run(["git", "--version"], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            # Check if the command was successful
+            self.assertTrue(result.returncode == 0, "Git is not installed or not in the PATH.")
+        except subprocess.CalledProcessError:
+            # If an error occurs, the test should fail
+            self.fail("Git is not installed or not in the PATH.")
+
+
+class TestGitClone(unittest.TestCase):
+    def test_git_can_clone_repo(self):
+        # Test that Git can clone a repository
+        repo_url = "https://github.com/git/git"  # Using a reliable repo that is always available
+        target_dir = "temp_repo"
+
+        try:
+            # Ensure the target directory does not exist before cloning
+            if os.path.exists(target_dir):
+                shutil.rmtree(target_dir)
+
+            # Run 'git clone' and capture output
+            subprocess.run(['git', 'clone', repo_url, target_dir], check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        except subprocess.CalledProcessError as e:
+            # If Git clone fails for any reason
+            self.fail(f"Git clone command failed: {e}")
+        except FileNotFoundError:
+            # If the 'git' command is not found
+            self.fail("Git is not installed on this system.")
+        finally:
+            # Clean up by removing the cloned directory if it exists
+            if os.path.exists(target_dir):
+                shutil.rmtree(target_dir)

psychopy/tests/test_visual/test_all_stimuli.py

@@ -100,21 +100,6 @@ class _baseVisualTest():
         #make sure we start with a clean window
         self.win.flip()
 
-    def test_auto_draw(self):
-        win = self.win
-        stims=[]
-        stims.append(visual.PatchStim(win))
-        stims.append(visual.ShapeStim(win))
-        stims.append(visual.TextStim(win))
-        for stim in stims:
-            assert stim.status==constants.NOT_STARTED
-            stim.autoDraw = True
-            assert stim.status==constants.STARTED
-            stim.autoDraw = False
-            assert stim.status==constants.FINISHED
-            assert stim.status==constants.STOPPED
-            "{}".format(stim) #check that str(xxx) is working
-
     def test_imageAndGauss(self):
         win = self.win
         fileName = os.path.join(utils.TESTS_DATA_PATH, 'testimage.jpg')
@@ -219,47 +204,6 @@ class _baseVisualTest():
         utils.compareScreenshot('circleHex_%s.png' %(self.contextName), win)
         win.flip()
 
-
-    def test_gabor(self):
-        win = self.win
-        #using init
-        gabor = visual.PatchStim(win, mask='gauss', ori=-45,
-            pos=[0.6 * self.scaleFactor, -0.6 * self.scaleFactor],
-            sf=2.0 / self.scaleFactor, size=2 * self.scaleFactor,
-            interpolate=True)
-        gabor.draw()
-        utils.compareScreenshot('gabor1_%s.png' %(self.contextName), win)
-        win.flip()#AFTER compare screenshot
-
-        #using .set()
-        gabor.ori = 45
-        gabor.size -= 0.2 * self.scaleFactor
-        gabor.setColor([45, 30, 0.3], colorSpace='dkl')
-        gabor.sf += 0.2 / self.scaleFactor
-        gabor.pos += [-0.5*self.scaleFactor, 0.5*self.scaleFactor]
-        gabor.contrast = 0.8
-        gabor.opacity = 0.8
-        gabor.draw()
-        utils.compareScreenshot('gabor2_%s.png' %(self.contextName), win)
-        win.flip()
-        "{}".format(gabor) #check that str(xxx) is working
-
-    @pytest.mark.bufferimage
-    def test_bufferImage(self):
-        """BufferImage inherits from ImageStim, so test .ori. .pos etc there not here
-        """
-        win = self.win
-        gabor = visual.PatchStim(win, mask='gauss', ori=-45,
-            pos=[0.6*self.scaleFactor, -0.6*self.scaleFactor],
-            sf=2.0/self.scaleFactor, size=2*self.scaleFactor,
-            interpolate=True)
-
-        bufferImgStim = visual.BufferImageStim(self.win, stim=[gabor],
-            interpolate=True)
-        bufferImgStim.draw()
-        utils.compareScreenshot('bufferimg_gabor_%s.png' %(self.contextName), win, crit=8)
-        win.flip()
-
     #def testMaskMatrix(self):
     #    #aims to draw the exact same stimulus as in testGabor, but using filters
     #    win=self.win
@@ -334,33 +278,6 @@ class _baseVisualTest():
             utils.compareScreenshot('blend_add_%s.png' %self.contextName,
                                     win, crit=20)
 
-    def test_mov(self):
-        win = self.win
-        if self.win.winType == 'pygame':
-            pytest.skip("movies only available for pyglet backend")
-
-        win.flip()
-        #construct full path to the movie file
-        fileName = os.path.join(utils.TESTS_DATA_PATH, 'testMovie.mp4')
-        #check if present
-        if not os.path.isfile(fileName):
-            raise IOError('Could not find movie file: %s'
-                          % os.path.abspath(fileName))
-        #then do actual drawing
-        pos = [0.6*self.scaleFactor, -0.6*self.scaleFactor]
-        mov = visual.MovieStim3(win, fileName, pos=pos, noAudio=True)
-        mov.setFlipVert(True)
-        mov.setFlipHoriz(True)
-        threshold = 30
-        for frameN in range(10):
-            mov.draw()
-
-            if frameN==0:
-                utils.compareScreenshot('movFrame1_%s.png' %self.contextName,
-                                        win, crit=threshold)
-            win.flip()
-        "{}".format(mov) #check that str(xxx) is working
-
     def test_rect(self):
         win = self.win
         rect = visual.Rect(win)
@@ -550,20 +467,6 @@ class _baseVisualTest():
                                 win, crit=30)
         #aperture should automatically disable on exit
 
-    def test_rating_scale(self):
-        if self.win.winType=='pygame':
-            pytest.skip("RatingScale not available on pygame")
-        # try to avoid text; avoid default / 'triangle' because it does not display on win XP
-        win = self.win
-        win.flip()
-        rs = visual.RatingScale(win, low=0, high=1, precision=100, size=3, pos=(0,-.4),
-                        labels=[' ', ' '], scale=' ',
-                        marker='glow', markerStart=0.7, markerColor='darkBlue', autoLog=False)
-        "{}".format(rs) #check that str(xxx) is working
-        rs.draw()
-        utils.compareScreenshot('ratingscale1_%s.png' %(self.contextName), win, crit=40.0)
-        win.flip()#AFTER compare screenshot
-
     @skip_under_vm
     def test_refresh_rate(self):
         if self.win.winType=='pygame':

psychopy/tests/test_visual/test_image.py

@@ -3,10 +3,8 @@ from pathlib import Path
 from psychopy import visual, colors, core
 from .test_basevisual import _TestUnitsMixin
 from psychopy.tests.test_experiment.test_component_compile_python import _TestBoilerplateMixin
-from .. import utils
-
-from ..utils import TESTS_DATA_PATH
-
+from psychopy.tests import utils
+import pytest
 
 class TestImage(_TestUnitsMixin, _TestBoilerplateMixin):
     """
@@ -17,7 +15,7 @@ class TestImage(_TestUnitsMixin, _TestBoilerplateMixin):
         self.win = visual.Window()
         self.obj = visual.ImageStim(
             self.win,
-            str(Path(TESTS_DATA_PATH) / 'testimage.jpg'),
+            str(Path(utils.TESTS_DATA_PATH) / 'testimage.jpg'),
             colorSpace='rgb1',
         )
 
@@ -187,6 +185,9 @@ class TestImageAnimation:
         """
         Check that images can be updated sufficiently fast to create frame animations
         """
+        # skip speed tests under vm
+        if utils.RUNNING_IN_VM:
+            pytest.skip()
         # Create clock
         clock = core.Clock()
         # Try at each size