psychopy 2024.1.4__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

@@ -3,6 +3,7 @@ from psychopy.hardware import keyboard
 import pytest
 import time
 from psychopy import logging
+from psychopy.tests.utils import RUNNING_IN_VM
 
 
 class _TestBaseKeyboard:
@@ -26,6 +27,33 @@ class _TestBaseKeyboard:
             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
@@ -33,6 +61,9 @@ class _TestBaseKeyboard:
         # skip this test on Linux (as MOP *is* slower due to having to use subprocess)
         if sys.platform == "linux":
             pytest.skip()
+        # skip speed tests under vm
+        if RUNNING_IN_VM:
+            pytest.skip()
 
         # array to store times
         times = {}

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

psychopy/tests/test_visual/test_textbox.py

@@ -102,6 +102,42 @@ class Test_textbox(_TestColorMixin, _TestUnitsMixin, _TestBoilerplateMixin):
                 #self.win.getMovieFrame(buffer='back').save(Path(utils.TESTS_DATA_PATH) / filename)
                 utils.compareScreenshot(Path(utils.TESTS_DATA_PATH) / filename, self.win, crit=20)
 
+    def test_ori(self):
+        # setup textbox
+        self.textbox.color = "black"
+        self.textbox.fillColor = "white"
+        self.textbox.units = "pix"
+        self.textbox.size = (100, 50)
+        self.textbox.pos = (0, 0)
+        self.textbox.letterHeight = 5
+        # define params to use
+        orientations = [
+            0, 120, 180, 240,
+        ]
+        anchors = [
+            "top left", "center", "bottom right",
+        ]
+        # try each combination
+        for ori in orientations:
+            for anchor in anchors:
+                # flip
+                self.win.flip()
+                # set params
+                self.textbox.ori = ori
+                self.textbox.anchor = anchor
+                self.textbox._layout()
+                # draw
+                self.textbox.draw()
+                # construct exemplar filename
+                exemplar = f"test_ori_{ori}_{anchor}.png"
+                # check/make exemplar
+                # self.win.getMovieFrame(buffer='back').save(
+                #     Path(utils.TESTS_DATA_PATH) / "Test_textbox" / exemplar
+                # )
+                utils.compareScreenshot(
+                    Path(utils.TESTS_DATA_PATH) / "Test_textbox" / exemplar, self.win, crit=20
+                )
+
     def test_colors(self):
         # Do base tests
         _TestColorMixin.test_colors(self)

psychopy/tests/utils.py

@@ -6,6 +6,7 @@ import shutil
 import numpy as np
 import io
 from psychopy import logging, colors
+from psychopy.tools import systemtools
 
 try:
     from PIL import Image
@@ -14,6 +15,9 @@ except ImportError:
 
 import pytest
 
+# boolean indicating whether tests are running in a VM
+RUNNING_IN_VM = systemtools.isVM_CI() is not None
+
 # define the path where to find testing data
 # so tests could be ran from any location
 TESTS_PATH = abspath(dirname(__file__))

psychopy/tools/filetools.py

@@ -74,7 +74,7 @@ def _synonymiseExtensions(assets):
 
 
 # Names accepted by stimulus classes & the filename of the default stimulus to use
-defaultStimRoot = Path(__file__).parent.parent / "app" / "Resources"
+defaultStimRoot = Path(__file__).parent.parent / "assets"
 defaultStim = {
     # Image stimuli
     "default.png": "default.png",