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

psychopy/tests/test_experiment/needs_wx/test_components.py

@@ -63,7 +63,7 @@ class TestComponents():
         pass
 
     def test_component_attribs(self):
-        with io.open(self.baselineProfile, 'r', encoding='utf-8-sig') as f:
+        with io.open(self.baselineProfile, 'r', encoding='utf-8-sig', errors='ignore') as f:
             target = f.read()
         targetLines = target.splitlines()
         targetTag = {}

psychopy/tests/test_experiment/test_components/test_RoutineSettingsComponent.py

@@ -0,0 +1,16 @@
+import pytest
+from pathlib import Path
+
+from psychopy.experiment.components.routineSettings import RoutineSettingsComponent
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests
+from psychopy.tests import utils
+
+
+class TestRoutineSettingsComponent(BaseComponentTests):
+    comp = RoutineSettingsComponent
+    
+    def test_disabled_code_muting(self):
+        """
+        RoutineSettings doesn't work like a normal Component w/r/t disabling, so skip this test
+        """
+        pytest.skip()

psychopy/tests/test_experiment/test_components/test_all_components.py

@@ -29,7 +29,7 @@ def test_all_components():
 
 def test_all_have_depth():
     # Define components which shouldn't have depth
-    exceptions = ("PanoramaComponent",)
+    exceptions = ("PanoramaComponent", "FaceAPIComponent")
     # Create experiment
     exp = experiment.Experiment()
     rt = experiment.routines.Routine(exp=exp, name="testRoutine")

psychopy/tests/test_experiment/test_components/test_base_components.py

@@ -3,7 +3,9 @@ import esprima
 import re
 from pathlib import Path
 
+import esprima.error_handler
 import pytest
+import tempfile
 
 from psychopy import experiment
 from psychopy.experiment.loops import TrialHandler
@@ -27,7 +29,7 @@ def _find_global_resource_in_js_experiment(script, resource):
         return present
 
     # Extract resources def at start of experiment
-    resourcesStr = re.search("(?<=resources: \[)[^\]]*", script).group(0)
+    resourcesStr = re.search(r"(?<=resources: \[)[^\]]*", script).group(0)
     # Return bool for whether specified resource is present
     return resource in resourcesStr
 
@@ -43,6 +45,7 @@ class BaseComponentTests:
         """
         # make blank experiment
         exp = experiment.Experiment()
+        exp.name = "Test" + self.comp.__name__ + "MinimalExp"
         # add a Routine
         rt = exp.addRoutine(routineName='TestRoutine')
         exp.flow.addRoutine(rt, 0)
@@ -68,6 +71,16 @@ class BaseComponentTests:
     
     # --- Heritable tests ---
 
+    def test_syntax_errors(self):
+        """
+        Create a basic implementation of this Component with everything set to defaults and check 
+        whether the resulting code has syntax errors
+        """
+        # create minimal experiment
+        comp, rt, exp = self.make_minimal_experiment()
+        # check syntax
+        utils.checkSyntax(exp, targets=self.comp.targets)
+
     def test_icons(self):
         """
         Check that Component has icons for each app theme and that these point to real files
@@ -169,11 +182,11 @@ class BaseComponentTests:
         # define cases and expected start/dur
         cases = [
             # blank start
-            {'startVal': "", 'stopVal': "1", 'startTime': None, 'duration': 1},
+            {'name': "NoStart", 'startVal': "", 'stopVal': "1", 'startTime': None, 'duration': 1},
             # blank stop
-            {'startVal': "0", 'stopVal': "", 'startTime': 0, 'duration': FOREVER},
+            {'name': "NoStop", 'startVal': "0", 'stopVal': "", 'startTime': 0, 'duration': FOREVER},
             # blank both
-            {'startVal': "", 'stopVal': "", 'startTime': None, 'duration': FOREVER},
+            {'name': "NoStartStop", 'startVal': "", 'stopVal': "", 'startTime': None, 'duration': FOREVER},
         ]
         # run all cases
         for case in cases:
@@ -187,23 +200,19 @@ class BaseComponentTests:
             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
+            # update experiment name to indicate what case we're in
+            case['name'] = self.comp.__name__ + case['name']
+            exp.name = "Test%(name)sExp" % case
+            # check that it still writes syntactially valid code
             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")
+                utils.checkSyntax(exp, targets=self.comp.targets)
+            except SyntaxError as err:
                 # raise error
+                case['err'] = err
                 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
+                    "stopVal was '%(stopVal)s'. Failed script saved in psychopy/tests/fails. "
+                    "Original error: %(err)s" % case
                 )
 
     def test_disabled_default_val(self):

psychopy/tests/test_experiment/test_experiment.py

@@ -101,3 +101,99 @@ class TestExperiment:
             else:
                 assert case['value'] not in unhandledResources
 
+    def test_loaded_namespace(self):
+
+        exp = experiment.Experiment()
+        allRoutines = experiment.getAllStandaloneRoutines(fetchIcons=False) 
+
+        """
+        Case structure
+        ==============
+        file : str
+            Experiment file to load
+        expectedSet : Set[str]
+            The expected names in the user namespace after routines are loaded and added
+        names : List[str]
+            Name of each routine to be added after experiment is loaded, paired with tags
+        tags : List[str]
+            Type of each routine to be added after experiment is loaded, paired with names
+            Can be 'CounterbalanceRoutine', 'EyetrackerCalibrationRoutine', 'EyetrackerValidationRoutine'
+        """
+
+        cases = [
+            {"file": "test_counterbalance.psyexp",
+             "expectedSet": {'trial', 'counterbalance', 'counterbalance_2', 'counterbalance_3',
+                             'counterbalance_4', 'counterbalance_5', 'calibration', 'calibration_2'},
+             "names": ['counterbalance', 'counterbalance', 'calibration', 'calibration'],
+             "tags": ['CounterbalanceRoutine', 'CounterbalanceRoutine', 'EyetrackerCalibrationRoutine',
+                      'EyetrackerCalibrationRoutine']},
+            
+            {"file": "test_counterbalance.psyexp",
+             "expectedSet": {'trial', 'counterbalance', 'counterbalance_2', 'counterbalance_3',
+                             'calibration', 'counterbalance_4', 'calibration_2'},
+             "names": ['calibration', 'counterbalance', 'calibration'],
+             "tags": ['EyetrackerCalibrationRoutine', 'EyetrackerCalibrationRoutine', 'EyetrackerCalibrationRoutine']},
+            
+            {"file": "test_custom_missing.psyexp",
+             "expectedSet": {'trial', 'custom_2', 'counterbalance_2', 'counterbalance',
+                             'counterbalance_3', 'calibration', 'calibration_2'},
+             "names": ['counterbalance', 'counterbalance', 'calibration', 'calibration'],
+             "tags": ['CounterbalanceRoutine', 'CounterbalanceRoutine', 'EyetrackerCalibrationRoutine',
+                      'EyetrackerCalibrationRoutine']},
+            
+            {"file": "test_missing_counterbalance.psyexp",
+             "expectedSet": {'trial', 'counterbalance_2', 'counterbalance', 'counterbalance_3'},
+             "names": ['counterbalance', 'counterbalance'],
+             "tags": ['CounterbalanceRoutine', 'EyetrackerCalibrationRoutine']},
+            
+            {"file": "test_mix_exp.psyexp",
+             "expectedSet": {'trial', 'counterbalance', 'calibration', 'counterbalance_2',
+                             'validation', 'counterbalance_3', 'calibration_2', 'validation_2'},
+             "names": ['counterbalance', 'calibration', 'validation'],
+             "tags": ['CounterbalanceRoutine', 'EyetrackerCalibrationRoutine', 'EyetrackerValidationRoutine']},
+            
+            {"file": "test_mix_missing.psyexp",
+             "expectedSet": {'trial', 'calibration_2', 'counterbalance_2', 'calibration',
+                             'counterbalance', 'calibration_3', 'counterbalance_3'},
+             "names": ['calibration_2', 'counterbalance_2', 'calibration', 'counterbalance'],
+             "tags": ['EyetrackerCalibrationRoutine', 'CounterbalanceRoutine', 'EyetrackerCalibrationRoutine',
+                      'CounterbalanceRoutine']},
+            
+            {"file": "test_mix_name_calibration.psyexp",
+             "expectedSet": {'trial', 'calibration_2', 'custom_2', 'counterbalance_2',
+                             'calibration', 'calibration_3', 'custom_3', 'custom'},
+             "names": ['calibration', 'calibration', 'custom_2', 'custom'],
+             "tags": ['EyetrackerCalibrationRoutine', 'CounterbalanceRoutine', 'CounterbalanceRoutine',
+                      'EyetrackerCalibrationRoutine']},
+        ]
+
+        for case in cases:
+            exp.loadFromXML(Path(TESTS_DATA_PATH) / "test_loaded_namespace" / case['file'])
+
+            # add new routines to the experiment and their names to namespace
+            namespace = exp.namespace
+            for (name, tag) in zip(case["names"], case["tags"]):   
+                routine = allRoutines[tag](exp=exp, name=name)
+                rtGoodName = routine.params['name'].val = namespace.makeValid(
+                    routine.params['name'].val)
+                namespace.add(rtGoodName)
+                exp.addStandaloneRoutine(routineName=rtGoodName, routine=routine)
+
+            actualSet = set(namespace.user)
+            expectedSet = case["expectedSet"]
+            print()
+            print(case['file'])
+            print(actualSet)
+            print(expectedSet)
+            print()
+
+            # check for no duplicate names in the namespace.user list
+            assert len(actualSet) == len(expectedSet)
+
+            # check that expected names in namespace.user list is 
+            # equivalent to the actual names in namespace.user
+            assert len(actualSet) == len(actualSet.intersection(expectedSet))
+
+
+
+

psychopy/tests/test_experiment/test_loops.py

@@ -5,9 +5,10 @@ from pathlib import Path
 from tempfile import mkdtemp
 
 import numpy as np
+import pandas as pd
 
 from ..utils import TESTS_DATA_PATH
-from psychopy import experiment, core
+from psychopy import experiment, core, logging
 
 from psychopy import prefs, core
 prefs.hardware['audioLib'] = ['ptb', 'sounddevice']
@@ -54,13 +55,16 @@ class TestLoops:
 
             # Run Python script to generate data file
             stdout, stderr = core.shellCall([sys.executable, str(pyScriptFile)], stderr=True)
+            # print stdout so the test suite can see it
             print(stdout)
-            print(stderr)
+            # log any errors so the test suite can see them
+            if stderr:
+                logging.error(stderr)
+            # error if data didn't save
             if not datafile.is_file():
                 raise RuntimeError("Data file wasn't saved. PsychoPy StdErr below:\n" + stderr)
             # Load data file
-            with open(datafile, "rb") as f:
-                data = np.recfromcsv(f, case_sensitive=True)
+            data = pd.read_csv(str(datafile)).values.tolist()
 
             # Store
             cls.cases[filename] = {
@@ -71,6 +75,10 @@ class TestLoops:
                 'stdout': stdout,
                 'stderr': stderr,
             }
+    
+    def teardown_class(cls):
+        # delete temp folder
+        shutil.rmtree(cls.tempDir)
 
     def test_output_length(self):
         """

psychopy/tests/test_experiment/test_params.py

@@ -91,9 +91,9 @@ class TestStyle:
             phrase = re.sub(pattern=(
                 f"(?<= )({pattern})(?= )"  # space before and after
                 f"|(?<= )({pattern})$"  # space before and line end after
-                f"|(?<= )({pattern})(?=[^\w\s]+)"  # space before and punctuation after
+                f"|(?<= )({pattern})(?=[^\\w\\s]+)"  # space before and punctuation after
                 f"|^({pattern})(?= )"  # line start before and space after
-                f"|^({pattern})(?=[^\w\s]+)"  # line start before and punctuation after
+                f"|^({pattern})(?=[^\\w\\s]+)"  # line start before and punctuation after
                 f"|^({pattern})$"  # line start before and line end after
             ), string=phrase, repl=repl)
 
@@ -174,8 +174,8 @@ def test_param_str():
          "js": f"{_q}Hello there{_q}"},
         # Enforced string
         {"obj": Param("\\, | or /", "str", canBePath=False),
-         "py": f"{_q}{_sl}, \| or /{_q}",
-         "js": f"{_q}{_sl}, \| or /{_q}"},
+         "py": f"{_q}{_sl}, \\| or /{_q}",
+         "js": f"{_q}{_sl}, \\| or /{_q}"},
         # Dollar string
         {"obj": Param("$win.color", "str"),
          "py": f"win.color",
@@ -270,6 +270,19 @@ def test_param_str():
         {'obj': Param("$left", "list"),
          'py': r"left",
          'js': r"left"},
+        # f strings as code with a newline (GitHub issue #3476)
+        # (uncomment when JS resolves as described below)
+        # {'obj': Param("$f\"I would like a \\n line break here\"", "str"), 
+        #  'py': r"f\"I would like a \\n line break here\"",
+        #  'js': r"`I would like a \\n line break here`"},
+        # backslash in file path (GitHub issue #3734)
+        {'obj': Param("path\\to\\resource", "str", canBePath=True),
+         'py': r"'path/to/resource'",
+         'js': r"'path/to/resource'"},
+        # dollar sign in string (GitHub issue #4259)
+        {'obj': Param("$Math.E+'$'", "str"),
+         'py': r"Math\.E\+'\$'",
+         'js': r"\(Math.E \+ \"\$\"\)"},
     ]
 
     # Take note of what the script target started as

psychopy/tests/test_experiment/test_routines/test_PhotodiodeValidationRoutine.py

@@ -1,9 +1,9 @@
 from . import _TestDisabledMixin, _TestBaseStandaloneRoutinesMixin
 from psychopy import experiment
-from psychopy.experiment.routines.photodiodeValidator import PhotodiodeValidatorRoutine
+from psychopy.experiment.routines.visualValidator import VisualValidatorRoutine
 
 
 class TestEyetrackerCalibrationRoutine(_TestBaseStandaloneRoutinesMixin, _TestDisabledMixin):
     def setup_method(self):
         self.exp = experiment.Experiment()
-        self.rt = PhotodiodeValidatorRoutine(exp=self.exp, name="testPhotodiodeValidatorRoutine")
+        self.rt = VisualValidatorRoutine(exp=self.exp, name="testVisualValidatorRoutine")

psychopy/tests/test_hardware/test_photodiode.py

@@ -0,0 +1,66 @@
+import pytest
+from psychopy import core, visual
+from psychopy.tests.utils import RUNNING_IN_VM
+from psychopy.hardware.lightsensor import BaseLightSensorGroup, LightSensorResponse
+
+
+class DummyPhotodiode(BaseLightSensorGroup):
+
+    def __init__(self, channels=1, threshold=None, pos=None, size=None, units=None):
+        # make a basic timer
+        self.timer = core.Clock()
+        # queue of messages that can be manually added
+        self.queue = []
+        # initialise base
+        BaseLightSensorGroup.__init__(
+            self, channels=channels, threshold=threshold, pos=pos, size=size, units=units
+        )
+
+    def dispatchMessages(self):
+        for msg in self.queue:
+            self.responses = self.parseMessage(msg)
+
+    def parseMessage(self, message):
+        """
+
+        Parameters
+        ----------
+        message : tuple[float, bool, int, float]
+            Raw message, in the format:
+                - float: Timestamp
+                - bool: True/False lightsensor state
+                - int: Channel in question
+
+        Returns
+        -------
+        LightSensorResponse
+            Photodiode response
+        """
+        # split message
+        t, value, channel = message
+        # make obj
+        return LightSensorResponse(
+            t, value, channel, threshold=self.threshold[channel]
+        )
+    
+    def _setThreshold(self, threshold, channel):
+        self.threshold[channel] = threshold
+
+    def resetTimer(self, clock=None):
+        self.timer.reset()
+
+class TestPhotodiode:
+
+    def setup_class(self):
+        self.lightsensor = DummyPhotodiode()
+        self.win = visual.Window()
+
+    def test_handle_no_response(self):
+        """
+        If no response (as will be the case here), should try n times and then give up.
+        """
+        # this one takes a while and isn't all that helpful if you can't watch it, so skip under vm
+        if RUNNING_IN_VM:
+            pytest.skip()
+        # try to find the lightsensor, knowing full well it'll get nothing as this is a dummy
+        self.lightsensor.findSensor(win=self.win, retryLimit=2)

psychopy/tests/test_liaison/test_Liaison.py

@@ -191,10 +191,10 @@ class TestLiaison:
         Test that attribute strings (e.g. "session.win") are actualized by Liaison to be the
         object they represent.
         """
-        # add screen buffer photodiode
+        # add screen buffer lightsensor
         runInLiaison(
             self.server, self.protocol, "DeviceManager", "addDevice",
-            "psychopy.hardware.photodiode.ScreenBufferSampler", "screenBuffer",
+            "psychopy.hardware.lightsensor.ScreenBufferSampler", "screenBuffer",
             "session.win"
         )
         # get screen buffer photodidoe
@@ -238,7 +238,7 @@ class TestLiaison:
     def test_device_JSON(self):
         cases = {
             'testMic': "psychopy.hardware.microphone.MicrophoneDevice",
-            'testPhotodiode': "psychopy.hardware.photodiode.ScreenBufferSampler",
+            'testPhotodiode': "psychopy.hardware.lightsensor.ScreenBufferSampler",
             'testButtonBox': "psychopy.hardware.button.KeyboardButtonBox"
         }
         for deviceName, deviceClass in cases.items():
@@ -272,4 +272,4 @@ class TestLiaison:
         # make sure error looks correct in JSON format
         result = self.protocol.messages[-1]
         assert result['type'] == "hardware_error"
-        assert "psychopy.hardware.manager.ManagedDeviceError" in result['msg']
+        assert "psychopy.hardware.exceptions.ManagedDeviceError" in result['msg']

psychopy/tests/test_misc/test_clock.py

@@ -6,6 +6,7 @@ import numpy as np
 from psychopy.clock import wait, StaticPeriod, CountdownTimer
 from psychopy.visual import Window
 from psychopy.tools import systemtools
+from psychopy.tests import skip_under_vm
 
 
 def test_StaticPeriod_finish_on_time():
@@ -36,6 +37,7 @@ def test_StaticPeriod_recordFrameIntervals():
     win.close()
 
 
+@skip_under_vm
 def test_StaticPeriod_screenHz():
     """Test if screenHz parameter is respected, i.e., if after completion of the
     StaticPeriod, 1/screenHz seconds are still remaining, so the period will

psychopy/tests/test_misc/test_color.py

@@ -6,6 +6,7 @@ tests in a setting where you can view the output if you have photosensitive
 epilepsy.
 
 """
+from psychopy.alerts import addAlertHandler
 from psychopy.alerts._errorHandler import _BaseErrorHandler
 from psychopy.tests import utils
 from psychopy import visual, colors
@@ -44,6 +45,7 @@ class Test_Window:
     def setup_class(self):
         self.win = visual.Window([128,128], pos=[50,50], allowGUI=False, autoLog=False)
         self.error = _BaseErrorHandler()
+        addAlertHandler(self.error)
 
     @classmethod
     def teardown_class(self):

psychopy/tests/test_misc/test_event.py

@@ -95,6 +95,7 @@ class _baseTest():
         event._onPygletMouseRelease(0, 0, LEFT | MIDDLE | RIGHT, None, emulated=True)
         assert not any(event.mouseButtons)
 
+    @skip_under_vm
     def test_mouse_clock(self):
         x, y = 0, 0
         scroll_x, scroll_y = 1, 1

psychopy/tests/test_plugins/test_plugin_stubs.py

@@ -0,0 +1,125 @@
+from http.client import RemoteDisconnected
+import importlib
+import pytest
+import requests
+from psychopy import logging
+from psychopy.plugins import PluginStub
+
+
+def test_plugin_stub_docs():
+    """
+    Test that links (docsHome and docsRef) are combined correctly in the docstring of PluginStub
+    """
+    cases = [
+        # docsHome with no docsRef
+        {
+            'plugin': "psychopy-test",
+            'docsHome': "https://psychopy.org",
+            'docsRef': "",
+            'ans': {
+                'docsHome': "https://psychopy.org",
+                'docsLink': "https://psychopy.org/",
+            } 
+        },
+        # docsHome included in docsRef
+        {
+            'plugin': "psychopy-test",
+            'docsHome': "https://psychopy.org",
+            'docsRef': "https://psychopy.org/test",
+            'ans': {
+                'docsHome': "https://psychopy.org",
+                'docsLink': "https://psychopy.org/test",
+            } 
+        },
+        # docsRef without /
+        {
+            'plugin': "psychopy-test",
+            'docsHome': "https://psychopy.org",
+            'docsRef': "test",
+            'ans': {
+                'docsHome': "https://psychopy.org",
+                'docsLink': "https://psychopy.org/test",
+            } 
+        },
+        # docsHome with /
+        {
+            'plugin': "psychopy-test",
+            'docsHome': "https://psychopy.org/",
+            'docsRef': "/test",
+            'ans': {
+                'docsHome': "https://psychopy.org",
+                'docsLink': "https://psychopy.org/test",
+            } 
+        },
+    ]
+
+    for case in cases:
+        # subclass PluginStub with the given values
+        class TestPluginStub(
+            PluginStub,
+            plugin=case['plugin'],
+            docsHome=case['docsHome'],
+            docsRef=case['docsRef'],
+        ):
+            pass
+        # check for the necessary strings in its docstr
+        assert case['plugin'] in TestPluginStub.__doc__
+        assert "<%(docsHome)s>" % case['ans'] in TestPluginStub.__doc__
+        assert "<%(docsLink)s>" % case['ans'] in TestPluginStub.__doc__
+
+
+def test_plugin_stub_links():
+    # import modules with PluginStubs in them
+    knownStubModules = [
+        "psychopy.microphone",
+        "psychopy.hardware.cedrus",
+        "psychopy.hardware.emulator",
+        "psychopy.hardware.gammasci",
+        "psychopy.hardware.minolta",
+        "psychopy.hardware.minolta",
+        "psychopy.hardware.pr",
+        "psychopy.hardware.crs.bits",
+        "psychopy.hardware.crs.optical",
+        "psychopy.hardware.crs.shaders",
+        "psychopy.visual.movie2",
+        "psychopy.visual.movie3",
+        "psychopy.visual.noise",
+        "psychopy.visual.patch",
+        "psychopy.visual.radial",
+        "psychopy.visual.ratingscale",
+        "psychopy.visual.secondorder",
+        "psychopy.hardware.brainproducts",
+        "psychopy.hardware.forp",
+        "psychopy.hardware.iolab",
+        "psychopy.hardware.labjacks",
+        "psychopy.hardware.qmix",
+        "psychopy.hardware.bbtk",
+        "psychopy.sound.backend_pyo",
+        "psychopy.sound.backend_sounddevice",
+        "psychopy.visual.backends.glfwbackend",
+    ]
+    for stubModule in knownStubModules:
+        importlib.import_module(stubModule)
+    # check for an internet connection in general
+    resp = requests.get("https://psychopy.org")
+    if not resp.ok:
+        pytest.skip()
+    # iterate through subclasses of PluginStub
+    for cls in PluginStub.__subclasses__():
+        # skip PluginStubs from the test suite
+        if cls.__module__.startswith("psychopy.tests"):
+            continue
+        # get pages from web
+        try:
+            docsHome = requests.get(cls.docsHome)
+            docsLink = requests.get(cls.docsLink)
+        except RemoteDisconnected:
+            # skip test if there's a connection error
+            pytest.skip()
+        # check that we got some content
+        assert docsHome.ok, (
+            f"No documentation found at {cls.docsHome} (PluginStub for {cls.__module__}:{cls.__name__})"
+        )
+        assert docsLink.ok, (
+            f"No documentation found at {cls.docsLink} (PluginStub for {cls.__module__}:{cls.__name__})"
+        )