psychopy 2025.2.4__py3-none-any.whl

psychopy/tests/test_experiment/test_py2js.py

@@ -0,0 +1,230 @@
+from psychopy.experiment.py2js_transpiler import translatePythonToJavaScript
+import psychopy.experiment.py2js as py2js
+from psychopy.experiment import Experiment
+from psychopy.experiment.components.code import CodeComponent
+from psychopy.experiment.routines import Routine
+
+
+class TestTranspiler:
+
+    def runTranspile(self, py, js):
+        transpiledCode = translatePythonToJavaScript(py)
+        assert (js == transpiledCode)
+
+    def test_assignment(self):
+        py = ("a = 1")
+        js = ("var a;\na = 1;\n")
+        self.runTranspile(py, js)
+
+    def test_name(self):
+        # Some typical cases
+        exemplars = [
+            {'py': "normalName",
+             'js': "normalName;\n"}
+        ]
+        # Some problem cases
+        tykes = [
+            {'py': "variableName",
+             'js': "variableName;\n"}  # Name containing "var" (should no longer return blank as of #4336)
+        ]
+        for case in exemplars + tykes:
+            self.runTranspile(case['py'], case['js'])
+
+    def test_if_statement(self):
+        py = ("if True:\n    True")
+        js = ("if (true) {\n    true;\n}\n")
+        self.runTranspile(py, js)
+
+    def test_print(self):
+        py = ("print(True)")
+        js = ("console.log(true);\n")
+        self.runTranspile(py, js)
+
+    def test_function(self):
+        py = ("def fun(a):\n    print(a)")
+        js = ("function fun(a) {\n    console.log(a);\n}\n")
+        self.runTranspile(py, js)
+
+    def test_status(self):
+        py = "status = STOPPED"
+        js = "var status;\nstatus = PsychoJS.Status.STOPPED;\n"
+        self.runTranspile(py, js)
+
+    def test_substitutions(self):
+        # Define some cases which should be handled
+        cases = [
+            {'py': "a.append(4)", 'js': "a.push(4);\n"},
+            {'py': "a.split()", 'js': 'a.split(" ");\n'},
+            {'py': "a.split('.')", 'js': 'a.split(".");\n'},
+            {'py': "a.sort(reverse=True)", 'js': "a.reverse();\n"},
+            {'py': "a.sort()", 'js': "a.sort();\n"},
+            {'py': "a.insert(0, 5)", 'js': "a.splice(0, 0, 5);\n"},
+            {'py': "a.insert(-1, x)", 'js': "a.splice((- 1), 0, x);\n"},
+            {'py': "' '.join(a)", 'js': 'a.join(" ");\n'},
+            {'py': "a.index(2)", 'js': "util.index(a, 2);\n"},
+            {'py': "a.count(2)", 'js': "util.count(a, 2);\n"},
+            {'py': "a.lower()", 'js': "a.toLowerCase();\n"},
+            {'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((a.length - 1), 1);\n"},
+        ]
+        # Try each case
+        for case in cases:
+            self.runTranspile(case['py'], case['js'])
+
+    def test_util_substitutions(self):
+        # Define some cases which should be handled
+        cases = [
+            {'py': "shuffle(a)", 'js': "util.shuffle(a);\n"},
+            {'py': "sum(a)", 'js': "util.sum(a);\n"},
+            {'py': "average(a)", 'js': "util.average(a);\n"},
+            {'py': "core.Clock()", 'js': "new util.Clock();\n"},
+        ]
+        # Try each case
+        for case in cases:
+            self.runTranspile(case['py'], case['js'])
+
+
+    def test_var_defs(self):
+        cases = [
+            # Docstring at line 1
+            {'py': (
+"""'''
+Docstring at line 1
+'''
+continueRoutine = False"""
+            ),
+                'var': False},
+            # Comment at line 1
+            {'py': (
+"""# Comment at line 1
+continueRoutine = False"""
+            ),
+             'var': False},
+            # PsychoPy keyword (just one)
+            {'py': (
+"""continueRoutine = False"""
+            ),
+                'var': False},
+            # PsychoPy keywords
+            {'py': (
+"""continueRoutine = False
+expInfo = {}"""
+            ),
+                'var': False},
+            # Numpy keywords
+            {'py': (
+"""sin = None
+pi = 3.14"""
+            ),
+                'var': False},
+            # Package names
+            {'py': (
+"""visual = psychopy.visual
+np = numpy"""
+            ),
+                'var': False},
+            # Component name
+            {'py': (
+"""testComponent = None"""
+            ),
+                'var': False},
+            # Routine name
+            {'py': (
+"""testRoutine = None"""
+            ),
+                'var': False},
+            # Valid var def
+            {'py': (
+"""newVariable = 0"""
+            ),
+                'var': True},
+            # One valid one invalid
+            {'py': (
+"""continueRoutine = False
+newVariable = {}"""
+            ),
+                'var': True},
+            # Valriable from Code component
+            {'py': (
+"""extantVariable = 0"""
+            ),
+                'var': True},
+        ]
+
+        # Setup experiment
+        exp = Experiment()
+        rt = Routine("testRoutine", exp)
+        comp = CodeComponent(exp, parentName="testRoutine", name="testComponent", beforeExp="extantVariable = 1")
+        rt.addComponent(comp)
+        exp.addRoutine("testRoutine", rt)
+        exp.flow.addRoutine(rt, 0)
+        # Add comp and routine names to namespace (this is usually done from Builder
+        exp.namespace.add("testRoutine")
+        exp.namespace.add("testComponent")
+        # Run cases
+        for case in cases:
+            # Translate with exp namespace
+            jsCode = py2js.translatePythonToJavaScript(case['py'], namespace=exp.namespace.all)
+            # Check whether var statements are present
+            if case['var']:
+                assert "var " in jsCode, (
+                    f"Could not find desired var def in:\n"
+                    f"{jsCode}"
+                )
+            else:
+                assert "var " not in jsCode, (
+                    f"Found undesired var def in:\n"
+                    f"{jsCode}"
+                )
+
+
+class Test_PY2JS_Compile:
+    """
+    Test class for py2js code conversion
+    """
+    def test_Py2js_Expression2js(self):
+        """Test that converts a short expression (e.g. a Component Parameter) Python to JS"""
+        input = ['sin(t)',
+                 'cos(t)',
+                 'tan(t)',
+                 'floor(t)',
+                 'ceil(t)',
+                 'pi',
+                 'rand',
+                 'random',
+                 't*5',
+                 '(3, 4)',
+                 '(5*-2)',
+                 '(1,(2,3))',
+                 '2*(2, 3)',
+                 '[1, (2*2)]',
+                 '(.7, .7)',
+                 '(-.7, .7)',
+                 '[-.7, -.7]',
+                 '[-.7, (-.7 * 7)]']
+
+        output = ['Math.sin(t)',
+                  'Math.cos(t)',
+                  'Math.tan(t)',
+                  'Math.floor(t)',
+                  'Math.ceil(t)',
+                  'Math.PI',
+                  'Math.random',
+                  'Math.random',
+                  '(t * 5)',
+                  '[3, 4]',
+                  '(5 * (- 2))',
+                  '[1, [2, 3]]',
+                  '(2 * [2, 3])',
+                  '[1, (2 * 2)]',
+                  '[0.7, 0.7]',
+                  '[(- 0.7), 0.7]',
+                  '[(- 0.7), (- 0.7)]',
+                  '[(- 0.7), ((- 0.7) * 7)]']
+
+        for idx, expr in enumerate(input):
+            # check whether direct match or at least a match when spaces removed
+            assert (py2js.expression2js(expr) == output[idx] or
+            py2js.expression2js(expr).replace(" ", "") == output[idx].replace(" ", ""))

psychopy/tests/test_experiment/test_routines/__init__.py

@@ -0,0 +1 @@
+from .test_base_routine import _TestBaseStandaloneRoutinesMixin, _TestDisabledMixin

psychopy/tests/test_experiment/test_routines/test_EyetrackerCalibrationRoutine.py

@@ -0,0 +1,9 @@
+from . import _TestDisabledMixin, _TestBaseStandaloneRoutinesMixin
+from psychopy import experiment
+from psychopy.experiment.routines.eyetracker_calibrate import EyetrackerCalibrationRoutine
+
+
+class TestEyetrackerCalibrationRoutine(_TestBaseStandaloneRoutinesMixin, _TestDisabledMixin):
+    def setup_method(self):
+        self.exp = experiment.Experiment()
+        self.rt = EyetrackerCalibrationRoutine(exp=self.exp, name="testEyetrackerCalibrationRoutine")

psychopy/tests/test_experiment/test_routines/test_PhotodiodeValidationRoutine.py

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

psychopy/tests/test_experiment/test_routines/test_all_routines.py

@@ -0,0 +1,23 @@
+from . import _TestBaseStandaloneRoutinesMixin, _TestDisabledMixin
+from psychopy import experiment
+import inspect
+
+
+class _Generic(_TestBaseStandaloneRoutinesMixin, _TestDisabledMixin):
+    def __init__(self, rtClass):
+        self.exp = experiment.Experiment()
+        self.rt = rtClass(exp=self.exp, name=f"test{rtClass.__name__}")
+
+
+def test_all_standalone_routines():
+    for rtName, rtClass in experiment.getAllStandaloneRoutines().items():
+        # Make a generic testing object for this component
+        tester = _Generic(rtClass)
+        # Run each method from _TestBaseComponentsMixin on tester
+        for attr, meth in _TestBaseStandaloneRoutinesMixin.__dict__.items():
+            if inspect.ismethod(meth):
+                meth(tester)
+        # Run each method from _TestBaseComponentsMixin on tester
+        for attr, meth in _TestDisabledMixin.__dict__.items():
+            if inspect.ismethod(meth):
+                meth(tester)

psychopy/tests/test_experiment/test_routines/test_base_routine.py

@@ -0,0 +1,154 @@
+from pathlib import Path
+
+import pytest
+
+from psychopy import experiment
+
+
+def _make_minimal_experiment(obj):
+    """
+    Make a minimal experiment with just one routine, the same class as the current standalone routine but with all
+    default params.
+    """
+    # Skip whole test if required attributes aren't present
+    if not hasattr(obj, "rt"):
+        pytest.skip()
+    # Make blank experiment
+    exp = experiment.Experiment()
+    # Create instance of this component with all default params
+    rtClass = type(obj.rt)
+    rt = rtClass(exp=exp, name=f"test{rtClass.__name__}")
+    exp.addStandaloneRoutine(rt.name, rt)
+    exp.flow.addRoutine(rt, 0)
+    # Return experiment, routine and component
+    return rt, exp
+
+
+class _TestBaseStandaloneRoutinesMixin:
+    def test_icons(self):
+        """Check that routine has icons for each app theme"""
+        # Pathify icon file path
+        icon = Path(self.rt.iconFile)
+        # Get paths for each theme
+        files = [
+            icon.parent / "light" / icon.name,
+            icon.parent / "dark" / icon.name,
+            icon.parent / "classic" / icon.name,
+        ]
+        # Check that each path is a file
+        for file in files:
+            assert file.is_file()
+
+    def test_params_used(self):
+        # Make minimal experiment just for this test
+        rt, exp = _make_minimal_experiment(self)
+        # Try with PsychoPy and PsychoJS
+        for target in ("PsychoPy", "PsychoJS"):
+            ## Skip PsychoJS until can write script without saving
+            if target == "PsychoJS":
+                continue
+            # Skip unimplemented targets
+            if target not in rt.targets:
+                continue
+            # Compile script
+            script = exp.writeScript(target=target)
+            # Check that the string value of each param is present in the script
+            experiment.utils.scriptTarget = target
+            # Iterate through every param
+            for routine in exp.flow:
+                for name, param in experiment.getInitVals(routine.params, target).items():
+                    # Conditions to skip...
+                    if not param.direct:
+                        # Marked as not direct
+                        continue
+                    if any(name in depend['param'] for depend in routine.depends):
+                        # Dependent on another param
+                        continue
+                    # Check that param is used
+                    assert str(param) in script, (
+                        f"Value {param} of <psychopy.experiment.params.Param: val={param.val}, valType={param.valType}> "
+                        f"in {type(rt).__name__} not found in {target} script."
+                    )
+
+    def testDeviceClassRefs(self):
+        """
+        Check that any references to device classes in this Routine object point to classes which
+        exist.
+        """
+        # skip test if this element doesn't point to any hardware class
+        if not hasattr(self.rt, "deviceClasses"):
+            pytest.skip()
+            return
+        # get device manager
+        from psychopy.hardware import DeviceManager
+        # iterate through device classes
+        for deviceClass in self.rt.deviceClasses:
+            # resolve any aliases
+            deviceClass = DeviceManager._resolveAlias(deviceClass)
+            # try to import class
+            DeviceManager._resolveClassString(deviceClass)
+
+
+class _TestDisabledMixin:
+    def test_disabled_default_val(self):
+        """
+        Test that routines created with default params are not disabled
+        """
+        # Make minimal experiment just for this test
+        rt, exp = _make_minimal_experiment(self)
+        # Check whether it can be disabled
+        assert 'disabled' in rt.params, (
+            f"{type(rt).__name__} does not have a 'disabled' attribute."
+        )
+        # Check that disabled defaults to False
+        assert rt.params['disabled'].val is False, f"{type(rt).__name__} is defaulting to disabled."
+
+    def test_code_muting(self):
+        """
+        Test that routines are only written when enabled and targets match.
+        """
+        # Make minimal experiment just for this test
+        rt, exp = _make_minimal_experiment(self)
+        # Write experiment and check that routine is written
+        pyScript = exp.writeScript(target="PsychoPy")
+        if "PsychoPy" in type(rt).targets:
+            assert rt.name in pyScript, (
+                f"{type(rt).__name__} not found in compiled Python script when enabled and PsychoPy in targets."
+            )
+        else:
+            assert rt.name not in pyScript, (
+                f"{type(rt).__name__} found in compiled Python script when enabled but PsychoPy not in targets."
+            )
+        # ## disabled until js can compile without saving
+        # jsScript = exp.writeScript(target="PsychoJS")
+        # if "PsychoJS" in type(rt).targets:
+        #     assert rt.name in jsScript, (
+        #         f"{type(rt).__name__} not found in compiled Python script when enabled and PsychoJS in targets."
+        #     )
+        # else:
+        #     assert rt.name not in jsScript, (
+        #         f"{type(rt).__name__} found in compiled Python script when enabled but PsychoJS not in targets."
+        #     )
+
+        # Disable routine then do same tests but assert not present
+        rt.params['disabled'].val = True
+
+        pyScript = exp.writeScript(target="PsychoPy")
+        if "PsychoPy" in type(rt).targets:
+            assert rt.name not in pyScript, (
+                f"{type(rt).__name__} found in compiled Python script when disabled but PsychoPy in targets."
+            )
+        else:
+            assert rt.name not in pyScript, (
+                f"{type(rt).__name__} found in compiled Python script when disabled and PsychoPy not in targets."
+            )
+        # ## disabled until js can compile without saving
+        # jsScript = exp.writeScript(target="PsychoJS")
+        # if "PsychoJS" in type(rt).targets:
+        #     assert rt.name not in jsScript, (
+        #         f"{type(rt).__name__} found in compiled Python script when disabled but PsychoJS in targets."
+        #     )
+        # else:
+        #     assert rt.name not in jsScript, (
+        #         f"{type(rt).__name__} found in compiled Python script when disabled and PsychoJS not in targets."
+        #     )

psychopy/tests/test_experiment/test_routines/test_standalone_routines.py

@@ -0,0 +1,36 @@
+import pytest
+from pathlib import Path
+
+from psychopy import experiment
+
+
+@pytest.mark.stdroutines
+class TestStandaloneRoutines:
+    @classmethod
+    def setup_class(cls):
+        cls.routines = experiment.getAllStandaloneRoutines()
+        # Make basic experiments with one of each standalone routine
+        cls.expPy = experiment.Experiment()
+        cls.expJS = experiment.Experiment()
+
+    def setup_method(self):
+        """This setup is done for each test individually
+        """
+        pass
+
+    def teardown_method(self):
+        pass
+
+    def test_writing(self):
+        # Test both python and JS
+        for target, exp in {"PsychoPy": self.expPy, "PsychoJS": self.expJS}.items():
+            for name, routine in self.routines.items():
+                rt = routine(exp)
+                exp.addStandaloneRoutine(name, rt)
+                exp.flow.addRoutine(rt, 0)
+            # Compile
+            exp.writeScript(target=target)
+            # Remove routines
+            for name, routine in exp.routines.copy().items():
+                exp.flow.removeComponent(routine)
+                del exp.routines[name]

psychopy/tests/test_gui/test_DlgFromDictQt.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from collections import OrderedDict
+from psychopy.gui.qtgui import DlgFromDict
+import pytest
+
+
+@pytest.mark.needs_qt
+class TestDlgFromDictQt:
+    def setup_method(self):
+        self.d = dict(
+            participant='000',
+            handedness=['r', 'l'],
+            exp_type=['foo', 'bar'],
+            exp_version='2017-01-02')
+
+        self.od = OrderedDict(
+            [('participant', '000'),
+             ('handedness', ['r', 'l']),
+             ('exp_type', ['foo', 'bar']),
+             ('exp_version', '2017-01-02')])
+
+        self.title = 'Experiment'
+
+    def test_title(self):
+        dlg = DlgFromDict(self.d, title=self.title, show=False)
+        assert dlg.windowTitle() == self.title
+
+    def test_sort_keys_true(self):
+        dlg = DlgFromDict(self.d, sortKeys=True, show=False)
+        keys = list(self.d.copy().keys())
+        keys.sort()
+        assert keys == dlg._keys
+
+    def test_sort_keys_false(self):
+        dlg = DlgFromDict(self.d, sortKeys=False, show=False)
+        keys = list(self.d.copy().keys())
+        assert keys == dlg._keys
+
+    def test_copy_dict_true(self):
+        dlg = DlgFromDict(self.d, copyDict=True, show=False)
+        assert self.d is not dlg.dictionary
+
+    def test_copy_dict_false(self):
+        dlg = DlgFromDict(self.d, copyDict=False, show=False)
+        assert self.d is dlg.dictionary
+
+    def test_order_list(self):
+        order = ['exp_type', 'participant', 'handedness', 'exp_version']
+        # Be certain we will actually request a different order
+        # further down.
+        assert order != list(self.od.keys())
+
+        dlg = DlgFromDict(self.od, order=order, show=False)
+        assert dlg.inputFieldNames == order
+
+    def test_order_tuple(self):
+        order = ('exp_type', 'participant', 'handedness', 'exp_version')
+        # Be certain we will actually request a different order
+        # further down.
+        assert list(order) != list(self.od.keys())
+
+        dlg = DlgFromDict(self.od, order=order, show=False)
+        assert dlg.inputFieldNames == list(order)
+
+    def test_fixed(self):
+        fixed = 'exp_version'
+        dlg = DlgFromDict(self.d, fixed=fixed, show=False)
+        field = dlg.inputFields[dlg.inputFieldNames.index(fixed)]
+        assert field.isEnabled() is False
+
+    def test_tooltips(self):
+        tip = dict(participant='Tooltip')
+        dlg = DlgFromDict(self.d, tip=tip, show=False)
+        field = dlg.inputFields[dlg.inputFieldNames.index('participant')]
+        assert field.toolTip() == tip['participant']
+
+if __name__ == '__main__':
+    cls = TestDlgFromDictQt()
+    cls.setup_method()
+    cls.test_fixed()

psychopy/tests/test_gui/test_DlgFromDictWx.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from collections import OrderedDict
+from psychopy.gui.wxgui import DlgFromDict
+import pytest
+
+
+@pytest.mark.needs_wx
+class TestDlgFromDictWx:
+    def setup_method(self):
+        self.d = dict(
+            participant='000',
+            handedness=['r', 'l'],
+            exp_type=['foo', 'bar'],
+            exp_version='2017-01-02')
+
+        self.od = OrderedDict(
+            [('participant', '000'),
+             ('handedness', ['r', 'l']),
+             ('exp_type', ['foo', 'bar']),
+             ('exp_version', '2017-01-02')])
+
+        self.title = 'Experiment'
+
+    def test_title(self):
+        dlg = DlgFromDict(self.d, title=self.title, show=False)
+        assert dlg.Title == self.title
+
+    def test_sort_keys_true(self):
+        dlg = DlgFromDict(self.d, sortKeys=True, show=False)
+        keys = sorted(self.d)
+        assert keys == dlg._keys
+
+    def test_sort_keys_false(self):
+        dlg = DlgFromDict(self.d, sortKeys=False, show=False)
+        keys = list(self.d)
+        assert keys == dlg._keys
+
+    def test_copy_dict_true(self):
+        dlg = DlgFromDict(self.d, copyDict=True, show=False)
+        assert self.d is not dlg.dictionary
+
+    def test_copy_dict_false(self):
+        dlg = DlgFromDict(self.d, copyDict=False, show=False)
+        assert self.d is dlg.dictionary
+
+    def test_order_list(self):
+        order = ['exp_type', 'participant', 'handedness', 'exp_version']
+        # Be certain we will actually request a different order
+        # further down.
+        assert order != list(self.od)
+
+        dlg = DlgFromDict(self.od, order=order, show=False)
+        assert dlg.inputFieldNames == order
+
+    def test_order_tuple(self):
+        order = ('exp_type', 'participant', 'handedness', 'exp_version')
+        # Be certain we will actually request a different order
+        # further down.
+        assert list(order) != list(self.od)
+
+        dlg = DlgFromDict(self.od, order=order, show=False)
+        assert dlg.inputFieldNames == list(order)
+
+    def test_fixed(self):
+        fixed = 'exp_version'
+        dlg = DlgFromDict(self.d, fixed=fixed, show=False)
+        field = dlg.inputFields[dlg.inputFieldNames.index(fixed)]
+        assert field.Enabled is False
+
+    def test_tooltips(self):
+        tip = dict(participant='Tooltip')
+        dlg = DlgFromDict(self.d, tip=tip, show=False)
+        field = dlg.inputFields[dlg.inputFieldNames.index('participant')]
+        assert field.ToolTip.GetTip() == tip['participant']
+
+
+if __name__ == '__main__':
+    cls = TestDlgFromDictWx()
+    cls.setup_method()
+    cls.test_fixed()

psychopy/tests/test_hardware/test_device_manager.py

@@ -0,0 +1,36 @@
+from psychopy.hardware import manager
+from psychopy.tests import skip_under_vm
+
+
+class TestDeviceManager:
+    def setup_class(cls):
+        cls.mgr = manager.getDeviceManager()
+
+    @skip_under_vm
+    def test_all_devices(self):
+        devices = (
+            "psychopy.hardware.keyboard.KeyboardDevice",
+            "psychopy.hardware.microphone.MicrophoneDevice",
+            "psychopy.hardware.serialdevice.SerialDevice",
+            # "psychopy_bbtk.tpad.TPadPhotodiodeGroup",  # uncomment when running locally with a BBTK
+
+        )
+        for device in devices:
+            self._test_device(device)
+
+    def _test_device(self, deviceType):
+        # test available getter
+        available = self.mgr.getAvailableDevices(deviceType)
+        # if no devices are available, just return
+        if not len(available):
+            return
+        # create device
+        _device = self.mgr.addDevice(**available[0])
+        # get device
+        name = available[0]['deviceName']
+        device = self.mgr.getDevice(name)
+        assert device == _device
+        # check it's in list of registered devices
+        devices = self.mgr.getInitialisedDevices(deviceType)
+        assert name in devices
+        assert devices[name] == device