psychopy 2024.2.4__py3-none-any.whl → 2025.1.0__py3-none-any.whl

psychopy/tests/test_sound/test_sound.py

@@ -1,6 +1,7 @@
 """Test PsychoPy sound.py using pygame backend; will fail if have already used pyo
 """
 
+from pathlib import Path
 from psychopy import prefs, core, plugins
 prefs.hardware['audioLib'] = ['ptb', 'sounddevice']
 
@@ -8,6 +9,7 @@ import pytest
 import shutil
 from tempfile import mkdtemp
 from psychopy import sound #, microphone
+from psychopy.hardware import DeviceManager, speaker
 
 import numpy
 
@@ -16,52 +18,121 @@ import numpy
 from psychopy.tests.utils import TESTS_PATH, TESTS_DATA_PATH
 
 @pytest.mark.needs_sound
-class TesSounds:
-    @classmethod
+class TestSounds:
     def setup_class(self):
         self.contextName='ptb'
         self.tmp = mkdtemp(prefix='psychopy-tests-sound')
+        # create just one instance for each speaker
+        self.speakers = {}
+        for profile in DeviceManager.getAvailableDevices(
+            "psychopy.hardware.speaker.SpeakerDevice"
+        ):
+            self.speakers[profile['index']] = speaker.SpeakerDevice(profile['index'])
+        # if there's no devices, skip everything
+        if not len(self.speakers):
+            pytest.skip()
 
-    @classmethod
     def teardown_class(self):
+        for i, spk in self.speakers.items():
+            spk.close()
+        # delete temp dir
         if hasattr(self, 'tmp'):
             shutil.rmtree(self.tmp, ignore_errors=True)
 
-    def test_init(self):
-        for note in ['A', 440, '440', [1,2,3,4], numpy.array([1,2,3,4])]:
-            sound.Sound(note, secs=.1)
-        with pytest.raises(ValueError):
-            sound.Sound('this is not a file name')
-        with pytest.raises(ValueError):
-            sound.Sound(-1)
-        with pytest.raises(ValueError):
-            sound.Sound(440, secs=-1)
-        with pytest.raises(ValueError):
-            sound.Sound(440, secs=0)
-        with pytest.raises(DeprecationWarning):
-            sound.setaudioLib('foo')
+    def test_playback(self):
+        """
+        Check that Sound can be initialised with a variety of values
+        """
+        # check values which should work
+        cases = [
+            # default stim
+            "default.mp3",
+            "default.wav",
+            # extant file
+            Path(TESTS_DATA_PATH) / "Electronic_Chime-KevanGC-495939803.wav",
+            # notes
+            "A",
+            440,
+            '440', 
+            [1,2,3,4], 
+            numpy.array([1,2,3,4]),
+        ]
+        # try on every speaker
+        for i, spk in self.speakers.items():
+            for case in cases:
+                snd = sound.Sound(
+                    value=case,
+                    secs=0.1,
+                    speaker=spk,
+                )
+                snd.play()
+                snd.stop()
+    
+    def test_error(self):
+        """
+        Check that various invalid values raise the correct error
+        """
+        # check values which should error
+        cases = [
+            {'val': "'this is not a file name'", 'secs': .1, 'err': ValueError},
+            {'val': "-1", 'secs': .1, 'err': ValueError},
+        ]
+        # try on every speaker
+        for i, spk in self.speakers.items():
+            for case in cases:
+                with pytest.raises(case['err']):
+                    snd = sound.Sound(
+                        value=case['val'],
+                        secs=0.1,
+                        speaker=spk,
+                    )
+    
+    def test_sample_rate_mismatch(self):
+        """
+        Check that Sound can handle a mismatch of sample rates between a file and a speaker
+        """
+        # specify some common sample rates
+        sampleRates = (
+            8000,
+            16000,
+            22050,
+            32000,
+            44100,
+            48000,
+            96000,
+            192000,
+        )
+        # iterate through speakers
+        for i, spk in self.speakers.items():
+            for sr in sampleRates:
+                # try to play sound on speaker
+                try:
+                    snd = sound.Sound(
+                        value=Path(TESTS_DATA_PATH) / "test_sounds" / f"default_{sr}.wav",
+                        speaker=spk,
+                        secs=-1,
+                    )
+                    snd.play()
+                except Exception as err:
+                    # include sample rate of sound and speaker in error message
+                    raise ValueError(
+                        f"Failed to play sound at sample rate {sr} on speaker {i} (sample rate "
+                        f"{spk.sampleRateHz}), original error: {err}"
+                    )
+                # doesn't need to *actually* play, just check that it doesn't error
+                snd.stop()
 
-        points = 100
-        snd = numpy.ones(points) / 20
-
-        #testFile = os.path.join(self.tmp, 'green_48000.wav')
-        #r, d = wavfile.read(testFile)
-        #assert r == 48000
-        #assert len(d) == 92160
-        #s = sound.Sound(testFile)
-
-    def test_play(self):
-        s = sound.Sound(secs=0.1)
-        s.play()
-        core.wait(s.getDuration()+.1)  # allows coverage of _onEOS
-        s.play(loops=1)
-        core.wait(s.getDuration()*2+.1)
-        s.play(loops=-1)
-        s.stop()
-
-    def test_methods(self):
-        s = sound.Sound(secs=0.1)
-        v = s.getVolume()
-        assert v == 1
-        assert s.setVolume(0.5) == 0.5
-        #assert s.setLoops(2) == 2
+    def test_volume(self):
+        """
+        Test that Sound can handle setting/getting its volume
+        """
+        # make a basic sound
+        s = sound.Sound(value="A", secs=0.1)
+        # set volume
+        s.setVolume(1)
+        # check it
+        assert s.getVolume() == 1
+        # set to a different value
+        s.setVolume(0.5)
+        # check it
+        assert s.getVolume() == 0.5

psychopy/tests/test_tools/test_colorspacetools.py

@@ -114,34 +114,35 @@ def test_srgbTF():
 
 
 @pytest.mark.colorspacetools
-def test_cielab2rgb():
-    """Test the CIE-Lab to RGB function using the sRGB transfer function.
-
+def test_cielch2rgb():
+    """Test the CIE-LCh to linear RGB function.
     """
-    # preset CIE-Lab colors using a D65 white-point and expected RGB values
-    cielabD65 = np.array([
-        [0.0, 0.0, 0.0],   # black
-        [100.0,  0.0,  0.0],    # white
-        [53.24, 80.09, 67.20],  # red
-        [87.73, -86.18, 83.18],   # green
-        [32.30, 79.19, -107.86],  # blue
-        [97.14, -21.55, 94.48],  # yellow
-        [91.11, -48.09, -14.13],   # cyan
-        [60.32, 98.23, -60.82]  # magenta
+    # preset CIE-LCh colors
+    cielchColors = np.array([
+        [0.0,    0.0,     0.0],      # black
+        [100.0,  0.0,     0.0],      # white
+        [53.241, 104.552, 39.999],   # red
+        [97.139, 96.905,  102.851],  # yellow
+        [87.735, 119.776, 136.016],  # green
+        [91.113, 50.121,  196.376],  # cyan
+        [32.297, 133.808, 306.285],  # blue
+        [60.324, 115.541, 328.235]   # magenta
     ])
+
+    # test conversion using PsyhoPy RGB [-1:1] values
     rgbExpected = np.array([
-        [-1., -1., -1.],
-        [1., 1., 1.],
-        [1., -1., -1.],
-        [-1., 1., -1.],
-        [-1., -1., 1.],
-        [1., 1., -1.],
-        [-1., 1., 1.],
-        [1., -1., 1.]
+        [-1.0, -1.0, -1.0],  # black
+        [ 1.0,  1.0,  1.0],  # white
+        [ 1.0, -1.0, -1.0],  # red
+        [ 1.0,  1.0, -1.0],  # yellow
+        [-1.0,  1.0, -1.0],  # green
+        [-1.0,  1.0,  1.0],  # cyan
+        [-1.0, -1.0,  1.0],  # blue
+        [ 1.0, -1.0,  1.0]   # magenta
     ])
 
-    # test conversion with D65 white point
-    rgbOutD65 = cielab2rgb(cielabD65, transferFunc=srgbTF)
+    # do the conversion
+    rgbOutD65 = cielch2rgb(cielchColors)
     assert np.allclose(rgbOutD65, rgbExpected, atol=0.01)
 
 

psychopy/tests/test_tools/test_mathtools.py

@@ -570,7 +570,7 @@ def test_invertMatrix():
     # check homogeneous inverse
     ident = np.identity(4)
     for i in range(N):
-        r = rotationMatrix(angles[i], axes[i, :])
+        r = rotationMatrix(angles[i].item(), axes[i, :])
 
         assert isOrthogonal(r)
 
@@ -593,7 +593,7 @@ def test_invertMatrix():
     inv = np.zeros((4, 4))
     ident = np.identity(4)
     for i in range(N):
-        rotationMatrix(angles[i], axes[i, :], out=rout)
+        rotationMatrix(angles[i].item(), axes[i, :], out=rout)
 
         assert isOrthogonal(rout)
 
@@ -615,23 +615,23 @@ def test_invertMatrix():
     eyeOffsets = np.random.uniform(-0.1, 0.1, (N,))
 
     for i in range(N):
-        scrWidth = scrDims[i, 0]
-        scrAspect = scrDims[i, 0] / scrDims[i, 1]
-        viewDist = viewDists[i]
+        scrWidth = scrDims[i, 0].item()
+        scrAspect = scrWidth / scrDims[i, 1].item()
+        viewDist = viewDists[i].item()
 
         # nearClip some distance between screen and eye
-        nearClip = np.random.uniform(0.1, viewDist, (1,))
+        nearClip = np.random.uniform(0.1, viewDist, (1,)).item()
 
         # nearClip some distance beyond screen
         fcMin = viewDist + nearClip
-        farClip = np.random.uniform(fcMin, 1000.0, (1,))
+        farClip = np.random.uniform(fcMin, 1000.0, (1,)).item()
 
         # get projection matrix
         frustum = computeFrustum(
             scrWidth,
             scrAspect,
             viewDist,
-            eyeOffset=eyeOffsets[i],
+            eyeOffset=eyeOffsets[i].item(),
             nearClip=nearClip,
             farClip=farClip)
 
@@ -639,7 +639,7 @@ def test_invertMatrix():
         assert not isAffine(proj)
 
         # create affine view matrix
-        r = rotationMatrix(angles[i], axes[i, :])
+        r = rotationMatrix(angles[i].item(), axes[i, :])
         assert isOrthogonal(r)
 
         t = translationMatrix(trans[i, :])

psychopy/tests/test_tools/test_viewtools.py

@@ -2,11 +2,110 @@
 """Tests for psychopy.tools.viewtools
 """
 
+from psychopy.tools.mathtools import alignTo, lookAt, distance
 from psychopy.tools.viewtools import *
 import numpy as np
 import pytest
 
 
+@pytest.mark.viewtools
+def test_visualAngle():
+    """Test visual angle calculation.
+
+    This tests the visual angle calculation for a few values. The test is
+    performed by converting the visual angle back to a distance and checking if
+    it is the same as the original distance.
+
+    """
+    # test calculation against value computed by hand
+    # obj distance = 0.57m, obj size = 0.01m
+    assert np.isclose(visualAngle(0.01, 0.57), 1.0051633)  # ~1 degree
+
+    # test input vectorization
+    N = 1000
+    np.random.seed(12345)
+    distances = np.random.uniform(0.1, 100.0, (N,))
+    sizes = np.random.uniform(0.01, 10.0, (N,))
+
+    a  = visualAngle(sizes, distances)
+    b = visualAngle(sizes, 0.57)
+    c = visualAngle(1.0, distances)
+
+    # make sure no values are >180 degrees or less than 0
+    assert np.all(a <= 180) and np.all(b <= 180) and np.all(c <= 180)
+    assert np.all(a >= 0) and np.all(b >= 0) and np.all(c >= 0)
+
+
+@pytest.mark.viewtools
+def test_viewMatrix():
+    """Test view matrix generation.
+
+    This create a view matrix using `lookAt` and `viewMatrix` and checks if
+    they look at the same point.
+
+    """
+    N = 1000
+    np.random.seed(12345)
+    targets = np.random.uniform(-100., 100., (N, 3,))
+    origin = [0, 0, 0]
+    orthoProj = orthoProjectionMatrix(-1, 1, -1, 1, 0.1, 100)
+
+    for i in range(N):
+        target = targets[i].tolist()
+
+        # View matrix generation using a quaternion will be canted, but will 
+        # center on the same point
+        V0 = viewMatrix(origin, alignTo([0, 0, -1], target))
+        
+        # Use `lookAt` to generate a view matrix, same as `gluLookAt`
+        V1 = lookAt(origin, target, [0, 1, 0])
+
+        # Check if the the matricies look at the same point if we project the 
+        # target to NDC space. They should both be near the very center of the 
+        # screen
+        posOut0 = pointToNdc(target, V0, orthoProj)
+        posOut1 = pointToNdc(target, V1, orthoProj)
+
+        assert np.isclose(posOut0, posOut1).all()
+
+
+@pytest.mark.viewtools
+def test_projectFrustumToPlane():
+    """Test the projection of the frustum to a plane.
+    """
+    N = 1000
+    np.random.seed(12345)
+    nearClip = 0.025
+    scrDims = np.random.uniform(0.01, 10.0, (N, 2,))
+    viewDists = np.random.uniform(nearClip, 10.0, (N,))
+    eyeOffsets = np.random.uniform(-0.1, 0.1, (N,))
+
+    for i in range(N):
+        scrWidth = scrDims[i, 0]
+        scrAspect = scrDims[i, 0] / scrDims[i, 1]
+        scrHeight = scrWidth * (1.0 / scrAspect)
+        viewDist = viewDists[i]
+
+        farClip = viewDist
+
+        frustum = computeFrustum(
+            scrWidth,
+            scrAspect,
+            viewDist,
+            eyeOffset=eyeOffsets[i],
+            nearClip=nearClip,
+            farClip=farClip)
+
+        frustum = [v.item() for v in frustum]
+
+        topLeft, bottomLeft, _, topRight = projectFrustumToPlane(
+            frustum, viewDist)
+        
+        # should match the screen dimensions
+        assert (np.isclose(distance(topLeft, topRight), scrWidth) and 
+                np.isclose(distance(topLeft, bottomLeft), scrHeight))
+
+
 @pytest.mark.viewtools
 def test_frustumToProjectionMatrix():
     """Ensure the `computeFrustum` + `perspectiveProjectionMatrix` and
@@ -40,6 +139,8 @@ def test_frustumToProjectionMatrix():
             eyeOffset=eyeOffsets[i],
             nearClip=nearClip,
             farClip=farClip)
+        
+        frustum = [v.item() for v in frustum]  # ensure scalars
 
         P = perspectiveProjectionMatrix(*frustum)
 

psychopy/tests/test_validators/test_voicekeyValidator.py

@@ -0,0 +1,95 @@
+import pytest
+from psychopy import core, constants, sound, validation
+from psychopy.hardware import microphone, soundsensor, DeviceManager
+
+
+@pytest.mark.needs_sound
+class TestAudioValidator:
+    def setup_class(cls):
+        cls.vk = cls.speaker = None
+        # find best vk/speaker pair to use
+        for profile in DeviceManager.getAvailableDevices(
+            "psychopy.hardware.soundsensor.MicrophoneSoundSensorEmulator"
+        ):
+            # setup sound sensor
+            try:
+                # make sure the mic exists
+                if not DeviceManager.getDevice(profile['device']):
+                    for micProfile in DeviceManager.getAvailableDevices(
+                        "psychopy.hardware.microphone.MicrophoneDevice"
+                    ):
+                        if micProfile['index'] == profile['device']:
+                            DeviceManager.addDevice(**micProfile)
+                # create sound sensor emulator
+                vk = DeviceManager.addDevice(**profile)
+            except Exception as err:
+                continue
+            # find matching speakers
+            foundSpeakers = vk.findSpeakers(channel=0)
+            # check that speakers can be initialised
+            for speaker in foundSpeakers:
+                try:
+                    sound.Sound("A", speaker=speaker)
+                except:
+                    continue
+                else:
+                    # if successful, we have a matching pair!
+                    cls.speaker = speaker
+                    cls.vk = vk
+        # skip if no devices were found
+        if cls.vk is None or cls.speaker is None:
+            pytest.skip()
+        # create validator
+        cls.validator = validation.AudioValidator(cls.vk)
+    
+    def test_soundHeard(self):
+        """
+        Check that the sound sensor validator detects a sound played from an audible speaker.
+        """
+        # setup timing
+        clock = core.Clock()
+        self.validator.resetTimer(clock)
+        t = 0
+        # setup sound
+        snd = sound.Sound("A", speaker=self.speaker)
+        snd.tStart = snd.tStop = None
+        # set starting statuses
+        snd.status = self.validator.status = constants.NOT_STARTED
+        # begin a frame loop
+        while t < 3:
+            t = clock.getTime()
+            # validate start
+            if self.validator.status == constants.STARTED and snd.status == constants.STARTED:
+                self.validator.tStart, self.validator.valid = self.validator.validate(
+                    state=True, 
+                    t=snd.tStart,
+                    adjustment=0.12
+                )
+                if self.validator.tStart:
+                    self.validator.status = constants.FINISHED
+                    assert self.validator.valid            
+            # validate stop
+            if self.validator.status == constants.STARTED and snd.status == constants.FINISHED:
+                self.validator.tStop, self.validator.valid = self.validator.validate(
+                    state=False, 
+                    t=snd.tStop,
+                    adjustment=0
+                )
+                if self.validator.tStop:
+                    self.validator.status = constants.FINISHED
+                    assert self.validator.valid
+            # start sound
+            if snd.status == constants.NOT_STARTED and t > 1:
+                snd.play()
+                snd.tStart = t
+                snd.status = constants.STARTED
+                self.validator.status = constants.STARTED
+            # stop sound
+            if snd.status == constants.STARTED and t > 2:
+                snd.stop()
+                snd.tStop = t
+                snd.status = constants.FINISHED
+                self.validator.status = constants.STARTED
+        # make sure the validator got some times
+        assert self.validator.tStart is not None
+        assert self.validator.tStop is not None

psychopy/tests/test_visual/test_all_stimuli.py

@@ -227,7 +227,7 @@ class _baseVisualTest():
     def test_text(self):
         win = self.win
         #set font
-        fontFile = str(Path(prefs.paths['resources']) / "fonts" / 'DejaVuSerif.ttf')
+        fontFile = str(utils.TESTS_FONT)
         #using init
         stim = visual.TextStim(win,text=u'\u03A8a', color=[0.5, 1.0, 1.0], ori=15,
             height=0.8*self.scaleFactor, pos=[0,0], font='DejaVu Serif',
@@ -395,7 +395,7 @@ class _baseVisualTest():
             "dots._dotsDir failed to change after dots.setDir()"
         assert prevSignals.sum()!=dots._signalDots.sum(), \
             "dots._signalDots failed to change after dots.setCoherence()"
-        assert not numpy.alltrue(prevVerticesPix==dots.verticesPix), \
+        assert not numpy.all(prevVerticesPix==dots.verticesPix), \
             "dots.verticesPix failed to change after dots.setPos()"
 
     def test_element_array(self):

psychopy/tests/test_visual/test_basevisual.py

@@ -1,14 +1,40 @@
 import json
-from pathlib import Path
-
 import pytest
-from psychopy import visual, layout, event
-from psychopy import colors
-from psychopy.monitors import Monitor
+import importlib
 from copy import copy
+from pathlib import Path
+from psychopy import visual, layout, event, colors
+from psychopy.tools.stimulustools import serialize, actualize
+from psychopy.monitors import Monitor
 from psychopy.tests import utils
 
 
+class _TestSerializationMixin:
+    """
+    Tests that stimuli can be serialized and recreated from serialized form.
+    """
+    # placeholders for object and window
+    obj = None
+    win = None
+
+    def test_serialization(self):
+        # skip if we don't have an object
+        if self.obj is None or self.win is None:
+            pytest.skip()
+        # start by flipping the window
+        self.win.flip()
+        # serialize object
+        params = serialize(self.obj, includeClass=True)
+        # substitute win
+        params['win'] = self.win
+        # recreate object from params
+        dupe = actualize(params)
+        # check object is same class
+        assert isinstance(dupe, type(self.obj))
+        # delete duplicate
+        del dupe
+
+
 class _TestColorMixin:
     # Define expected values for different spaces
     colorExemplars = [
@@ -61,6 +87,10 @@ class _TestColorMixin:
         # If this test object has no obj, skip
         if not self.obj:
             return
+        
+        if hasattr(self, 'resetObj'):
+            self.resetObj()  # reset the stimulus object before this test
+        
         # Test each case
         for case in self.colorTykes + self.colorExemplars:
             for space, color in case.items():
@@ -478,7 +508,7 @@ class _TestUnitsMixin:
                     obj.win = win
                     obj.units = objunits
                     # Add a label for the units
-                    label = visual.TextBox2(win, text=f"Window: {winunits}, Slider: {objunits}", font="Open Sans",
+                    label = visual.TextBox2(win, text=f"Window: {winunits}, Slider: {objunits}", font="Noto Sans",
                                             anchor="top-center", alignment="center top", padding=0.05, units="norm",
                                             pos=(0, 1))
                     # Add instructions
@@ -486,7 +516,7 @@ class _TestUnitsMixin:
                                             text=(
                                                 f"Press ENTER if object is functioning as intended, otherwise press "
                                                 f"any other key."
-                                            ), font="Open Sans", anchor="top-center", alignment="center bottom",
+                                            ), font="Noto Sans", anchor="top-center", alignment="center bottom",
                                             padding=0.05, units="norm", pos=(0, -1))
                     # Draw loop until button is pressed
                     keys = []

psychopy/tests/test_visual/test_button.py

@@ -1,9 +1,9 @@
 from psychopy import visual
-from psychopy.tests.test_visual.test_basevisual import _TestColorMixin
+from psychopy.tests.test_visual.test_basevisual import _TestColorMixin, _TestSerializationMixin
 from psychopy.tests.test_experiment.test_component_compile_python import _TestBoilerplateMixin
 
 
-class TestButton(_TestColorMixin, _TestBoilerplateMixin):
+class TestButton(_TestColorMixin, _TestBoilerplateMixin, _TestSerializationMixin):
 
     @classmethod
     def setup_class(self):

psychopy/tests/test_visual/test_circle.py

@@ -1,13 +1,14 @@
 from pathlib import Path
 
 import pytest
+import copy
 from psychopy import visual
-from .test_basevisual import _TestColorMixin, _TestUnitsMixin
+from .test_basevisual import _TestColorMixin, _TestUnitsMixin, _TestSerializationMixin
 from psychopy.tests.test_experiment.test_component_compile_python import _TestBoilerplateMixin
 from .. import utils
 
 
-class TestCircle(_TestColorMixin, _TestUnitsMixin, _TestBoilerplateMixin):
+class TestCircle(_TestColorMixin, _TestUnitsMixin, _TestBoilerplateMixin, _TestSerializationMixin):
 
     @classmethod
     def setup_class(self):
@@ -24,6 +25,12 @@ class TestCircle(_TestColorMixin, _TestUnitsMixin, _TestBoilerplateMixin):
         # Shape has no foreground color
         self.foreUsed = False
 
+    def resetObj(self):
+        """Reset the stimulus to its initial state.
+        """
+        self.obj = visual.Circle(
+            self.win, units="pix", pos=(0, 0), size=(128, 128), lineWidth=3)
+
     def test_radius(self):
         # Define some use cases
         cases = [
@@ -64,3 +71,4 @@ class TestCircle(_TestColorMixin, _TestUnitsMixin, _TestBoilerplateMixin):
             self.obj.draw()
             # self.win.getMovieFrame(buffer='back').save(Path(utils.TESTS_DATA_PATH) / filename)
             # utils.compareScreenshot(Path(utils.TESTS_DATA_PATH) / filename, self.win, crit=20)
+          

psychopy/tests/test_visual/test_dots.py

@@ -77,7 +77,7 @@ class TestDots:
              'units': 'deg'}
         ]
         # Define an acceptable margin of error (in proportion of size)
-        err = 0.1
+        err = 0.2
         # Create dots
         params = {
             "win": self.win,