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

psychopy/__init__.py

@@ -12,14 +12,14 @@
 import os
 import sys
 
-__version__ = '2024.1.2'
+__version__ = '2024.1.3'
 __license__ = 'GPL v3'
 __author__ = 'Open Science Tools Ltd'
 __author_email__ = 'support@opensciencetools.org'
 __maintainer_email__ = 'support@opensciencetools.org'
 __url__ = 'https://www.psychopy.org/'
 __download_url__ = 'https://github.com/psychopy/psychopy/releases/'
-__git_sha__ = '4e4ac7977'
+__git_sha__ = 'a2e6ccdec'
 __build_platform__ = 'n/a'
 
 __all__ = ["gui", "misc", "visual", "core",

psychopy/experiment/components/mouse/__init__.py

@@ -364,10 +364,22 @@ class MouseComponent(BaseComponent):
             buff.writeIndentedLines(code % self.params)
             buff.setIndentLevel(1, relative=True)
             dedent += 1
+            # keep track of whether something's been written
+            hasContent = False
+            # write code to check clickable stim, if there are any
             if self.params['clickable'].val:
                 self._writeClickableObjectsCode(buff)
+                hasContent = True
+            # write code to check correct stim, if there are any
             if self.params['storeCorrect']:
                 self._writeCorrectAnsCode(buff)
+                hasContent = True
+            # if current if statement has no content, add a pass
+            if not hasContent:
+                buff.writeIndentedLines(
+                    "pass"
+                )
+
             return buff, dedent
 
         # No mouse tracking, end routine on any or valid click

psychopy/experiment/routines/counterbalance/__init__.py

@@ -43,7 +43,7 @@ class CounterbalanceRoutine(BaseStandaloneRoutine):
         self.params['specMode'] = Param(
             specMode, valType="str", inputType="choice", categ="Basic",
             allowedVals=["uniform", "file"],
-            allowedLabels=[_translate("Num. groups"), _translate("Conditions file")],
+            allowedLabels=[_translate("Num. groups"), _translate("Conditions file (local only)")],
             label=_translate("Groups from..."),
             hint=_translate(
                 "Specify groups using an Excel file (for fine tuned control), specify as a variable name, or specify a "

psychopy/hardware/keyboard.py

@@ -573,7 +573,7 @@ class KeyboardDevice(BaseResponseDevice, aliases=["keyboard"]):
             if message.type == "KEYBOARD_PRESS":
                 # if message is from a key down event, make a new response
                 response = KeyPress(code=message.char, tDown=message.time, name=message.key)
-                response.rt = response.tDown
+                response.rt = response.tDown - self.clock.getLastResetTime()
                 self._keysStillDown.append(response)
             else:
                 # if message is from a key up event, alter existing response

psychopy/tests/test_experiment/test_components/__init__.py

@@ -1 +1 @@
-from .test_base_components import _TestBaseComponentsMixin, _TestDisabledMixin
+from .test_base_components import BaseComponentTests

psychopy/tests/test_experiment/test_components/{test_ButtonBox.py → test_ButtonBoxComponent.py}

@@ -11,21 +11,14 @@ from psychopy.hardware.button import ButtonResponse
 from psychopy.experiment.routines import Routine
 from psychopy.experiment.components.buttonBox import ButtonBoxComponent
 from psychopy.experiment.components.code import CodeComponent
-from .test_base_components import _TestBaseComponentsMixin
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests
+from psychopy.hardware.button import ButtonBox
 
 
-class TestButtonBoxComponent(_TestBaseComponentsMixin):
-    def setup_method(self):
-        self.exp = Experiment()
-        # make blank routine
-        self.routine = Routine(name="testRoutine", exp=self.exp)
-        self.exp.addRoutine("testRoutine", self.routine)
-        self.exp.flow.addRoutine(self.routine, 0)
-        # make component
-        self.comp = ButtonBoxComponent(
-            exp=self.exp, name="testPhotodiodeValidatorRoutine", parentName="testRoutine"
-        )
-
+class TestButtonBoxComponent(BaseComponentTests):
+    comp = ButtonBoxComponent
+    libraryClass = ButtonBox
+    
     def test_values(self):
         """
         Test that a variety of different values work when run from Builder.
@@ -65,9 +58,8 @@ class TestButtonBoxComponent(_TestBaseComponentsMixin):
                 thisCase[keys[i]] = val
             # add case
             cases.append(thisCase)
-
-        # make an experiment
-        exp = Experiment()
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
         # configure experiment
         exp.requireImport("ButtonResponse", importFrom="psychopy.hardware.button")
         exp.settings.params['Full-screen window'].val = False
@@ -79,18 +71,8 @@ class TestButtonBoxComponent(_TestBaseComponentsMixin):
             resps = case.pop("resps")
             if not isinstance(resps, (list, tuple)):
                 resps = [resps]
-            # make a name
-            name = f"rt{i}"
-            # make a Routine
-            rt = exp.addRoutine(name, Routine(name=name, exp=exp))
-            exp.flow.addRoutine(rt, 0)
             # add timeout
             rt.settings.params['stopVal'].val = 0.2
-            # make a Component
-            comp = ButtonBoxComponent(
-                exp, parentName=name, name=name + "_comp", **case
-            )
-            rt.addComponent(comp)
             # make a Code Component to send responses
             code = (
                 "if frameN > 1:\n"
@@ -104,7 +86,7 @@ class TestButtonBoxComponent(_TestBaseComponentsMixin):
                     name=comp.name, value=resp.value, channel=resp.channel
                 )
             codeComp = CodeComponent(
-                exp, parentName=name + "_code", eachFrame=code
+                exp, parentName=comp.name + "_code", eachFrame=code
             )
             rt.addComponent(codeComp)
         # save exp in temp directory

psychopy/tests/test_experiment/test_components/{test_Code.py → test_CodeComponent.py}

@@ -2,42 +2,30 @@ from pathlib import Path
 from tempfile import mkdtemp
 
 from psychopy import experiment
-from . import _TestDisabledMixin, _TestBaseComponentsMixin
+from . import BaseComponentTests
 from psychopy.experiment.loops import TrialHandler
 from psychopy.experiment.routines import Routine
 from psychopy.experiment.components.code import CodeComponent
 from psychopy.tests.utils import TESTS_DATA_PATH
 
 
-class TestCodeComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
+class TestCodeComponent(BaseComponentTests):
     """
     Test that Code coponents have the correct params and write as expected.
     """
+    comp = CodeComponent
 
     @classmethod
     def setup_class(cls):
-        cls.exp = experiment.Experiment() # create once, not every test
         try:
             cls.tempDir = mkdtemp(dir=Path(__file__).root, prefix='psychopy-tests-app')
         except (PermissionError, OSError):
             # can't write to root on Linux
             cls.tempDir = mkdtemp(prefix='psychopy-tests-app')
 
-    def setup_method(self):
-        # Make blank experiment
-        self.exp = experiment.Experiment()
-        # Make blank routine
-        self.routine = Routine(name="testRoutine", exp=self.exp)
-        self.exp.addRoutine("testRoutine", self.routine)
-        self.exp.flow.addRoutine(self.routine, 0)
-        # Add loop around routine
-        self.loop = TrialHandler(exp=self.exp, name="testLoop")
-        self.exp.flow.addLoop(self.loop, 0, -1)
-        # Make Mouse component
-        self.comp = CodeComponent(exp=self.exp, parentName="testRoutine", name="testCode")
-        self.routine.addComponent(self.comp)
-
     def test_all_code_component_tabs(self):
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
         # Names of each tab in a Code component
         tabs = {
             'Before Experiment': '___before_experiment___',
@@ -50,11 +38,11 @@ class TestCodeComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
         # Add markers to component
         for paramName, marker in tabs.items():
             jsParamName = paramName.replace(" ", " JS ")
-            self.comp.params[paramName].val = self.comp.params[jsParamName].val = marker
+            comp.params[paramName].val = comp.params[jsParamName].val = " = ".join([self.comp.__name__, comp.name, marker])
 
         # Write script
-        pyScript = self.exp.writeScript(target="PsychoPy")
-        jsScript = self.exp.writeScript(target="PsychoJS")
+        pyScript = exp.writeScript(target="PsychoPy")
+        jsScript = exp.writeScript(target="PsychoJS")
 
         # Check that code from each tab exists in compiled script
         for lang, script in {"Python": pyScript, "JS": jsScript}.items():

psychopy/tests/test_experiment/test_components/test_GratingComponent.py

@@ -0,0 +1,7 @@
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests, _TestLibraryClassMixin
+from psychopy.experiment.components.grating import GratingComponent
+from psychopy.visual import GratingStim
+
+class TestGratingComponent(BaseComponentTests, _TestLibraryClassMixin):
+    comp = GratingComponent
+    libraryClass = GratingStim

psychopy/tests/test_experiment/test_components/test_ImageComponent.py

@@ -0,0 +1,8 @@
+from psychopy.experiment.components.image import ImageComponent
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests, _TestDepthMixin, _TestLibraryClassMixin
+from psychopy.visual.image import ImageStim
+
+
+class TestImage(BaseComponentTests, _TestLibraryClassMixin):
+    comp = ImageComponent
+    libraryClass = ImageStim

psychopy/tests/test_experiment/test_components/{test_Mouse.py → test_MouseComponent.py}

@@ -1,65 +1,52 @@
 from pathlib import Path
 
-from . import _TestDisabledMixin, _TestBaseComponentsMixin
-from psychopy.experiment import Experiment
+from . import BaseComponentTests
 from psychopy.experiment.loops import TrialHandler
-from psychopy.experiment.routines import Routine
 from psychopy.experiment.components.mouse import MouseComponent
 from psychopy.experiment.components.polygon import PolygonComponent
 from psychopy.tests.utils import TESTS_DATA_PATH
 from psychopy.hardware.mouse import Mouse
 
 
-class TestMouseComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
+class TestMouseComponent(BaseComponentTests):
     """
     Test that Mouse coponents have the correct params and write as expected.
     """
+    comp = MouseComponent
     libraryClass = Mouse
 
-    def setup_method(self):
-        # Make blank experiment
-        self.exp = Experiment()
-        # Make blank routine
-        self.routine = Routine(name="testRoutine", exp=self.exp)
-        self.exp.addRoutine("testRoutine", self.routine)
-        self.exp.flow.addRoutine(self.routine, 0)
-        # Add loop around routine
-        self.loop = TrialHandler(exp=self.exp, name="testLoop")
-        self.exp.flow.addLoop(self.loop, 0, -1)
-        # Make Mouse component
-        self.comp = MouseComponent(exp=self.exp, parentName="testRoutine", name="testMouse")
-        self.routine.addComponent(self.comp)
-        # Make a rect for when we need something to click on
-        self.target = PolygonComponent(exp=self.exp, parentName="testRoutine", name="testPolygon")
-        self.routine.addComponent(self.target)
-
     def test_click_save_end_clickable_cases(self):
         """
         Test all combinations of options for what to save, what can be clicked on & what kind of clicks to end the
         routine on.
         """
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
+        # make a rect for when we need something to click on
+        target = PolygonComponent(exp=exp, parentName=rt.name, name="testPolygon")
+        
         saveMouseStateCases = [
             {'val': "final",
-             'want': ["thisExp.addData('testMouse.x', x)"],  # should contain code for adding final value of x
-             'avoid': ["testMouse.x.append(x)"]},  # should not contain code to update testMouse.x in frame loop
+             'want': [f"thisExp.addData('{comp.name}.x', x)"],  # should contain code for adding final value of x
+             'avoid': [f"{comp.name}.x.append(x)"]},  # should not contain code to update testMouse.x in frame loop
             {'val': "on click",
-             'want': ["thisExp.addData('testMouse.x', testMouse.x)",  # should add testMouse.x at the end
-                      "testMouse.x.append(x)"],  # should contain code to update testMouse.x in frame loop
-             'avoid': ["thisExp.addData('testMouse.x', x)"]},  # should not add final value of x
+             'want': [f"thisExp.addData('{comp.name}.x', {comp.name}.x)",  # should add testMouse.x at the end
+                      f"{comp.name}.x.append(x)"],  # should contain code to update testMouse.x in frame loop
+             'avoid': [f"thisExp.addData('{comp.name}.x', x)"]},  # should not add final value of x
             {'val': "on valid click",
-             'want': ["thisExp.addData('testMouse.x', testMouse.x)",  # should add testMouse.x at the end
-                      "testMouse.x.append(x)",  # should contain code to update testMouse.x in frame loop
+             'want': [f"thisExp.addData('{comp.name}.x', {comp.name}.x)",  # should add testMouse.x at the end
+                      f"{comp.name}.x.append(x)",  # should contain code to update testMouse.x in frame loop
                       "if gotValidClick:"],  # should check for valid clicks
-             'avoid': ["thisExp.addData('testMouse.x', x)"]},  # should not add final value of x
+             'avoid': [f"thisExp.addData('{comp.name}.x', x)"]},  # should not add final value of x
             {'val': "every frame",
-             'want': ["thisExp.addData('testMouse.x', testMouse.x)",  # should add testMouse.x at the end
-                      "testMouse.x.append(x)"],  # should contain code to update testMouse.x in frame loop
-             'avoid': ["thisExp.addData('testMouse.x', x)"]},  # should not add final value of x
+             'want': [f"thisExp.addData('{comp.name}.x', {comp.name}.x)",  # should add testMouse.x at the end
+                      f"{comp.name}.x.append(x)"],  # should contain code to update testMouse.x in frame loop
+             'avoid': [f"thisExp.addData('{comp.name}.x', x)"]},  # should not add final value of x
             {'val': "never",
              'want': [],
-             'avoid': ["thisExp.addData('testMouse.x', testMouse.x)",  # should not add testMouse.x at the end
-                       "testMouse.x.append(x)",  # should not contain code to update testMouse.x in frame loop
-                       "thisExp.addData('testMouse.x', x)"]},  # should not add final value of x]},
+             'avoid': [f"thisExp.addData('{comp.name}.x', {comp.name}.x)",  # should not add testMouse.x at the end
+                       f"{comp.name}.x.append(x)",  # should not contain code to update testMouse.x in frame loop
+                       f"thisExp.addData('{comp.name}.x', x)"]},  # should not add final value of x]},
         ]
         forceEndRoutineOnPressCases = [
             {'val':  "never",
@@ -85,54 +72,54 @@ class TestMouseComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
         # Iterate through saveMouseState cases
         for SMScase in saveMouseStateCases:
             # Set saveMouseState
-            self.comp.params['saveMouseState'].val = SMScase['val']
+            comp.params['saveMouseState'].val = SMScase['val']
             for FEROPcase in forceEndRoutineOnPressCases:
                 # Set forceEndRoutineOnPress
-                self.comp.params['forceEndRoutineOnPress'].val = FEROPcase['val']
+                comp.params['forceEndRoutineOnPress'].val = FEROPcase['val']
                 for Ccase in clickableCases:
                     # Set clickable
-                    self.comp.params['clickable'].val = Ccase['val']
+                    comp.params['clickable'].val = Ccase['val']
 
                     # Compile script
-                    script = self.exp.writeScript(target="PsychoPy")
+                    script = exp.writeScript(target="PsychoPy")
                     try:
                         # Look for wanted phrases
                         for phrase in SMScase['want']:
                             assert phrase in script, (
-                                f"{phrase} not found in script when saveMouseState={self.comp.params['saveMouseState']}, "
-                                f"forceEndRoutineOnPress={self.comp.params['forceEndRoutineOnPress']} and "
-                                f"clickable={self.comp.params['clickable']}"
+                                f"{phrase} not found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
                             )
                         for phrase in FEROPcase['want']:
                             assert phrase in script, (
-                                f"{phrase} not found in script when saveMouseState={self.comp.params['saveMouseState']}, "
-                                f"forceEndRoutineOnPress={self.comp.params['forceEndRoutineOnPress']} and "
-                                f"clickable={self.comp.params['clickable']}"
+                                f"{phrase} not found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
                             )
                         for phrase in Ccase['want']:
                             assert phrase in script, (
-                                f"{phrase} not found in script when saveMouseState={self.comp.params['saveMouseState']}, "
-                                f"forceEndRoutineOnPress={self.comp.params['forceEndRoutineOnPress']} and "
-                                f"clickable={self.comp.params['clickable']}"
+                                f"{phrase} not found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
                             )
                         # Check there's no avoid phrases
                         for phrase in SMScase['avoid']:
                             assert phrase not in script, (
-                                f"{phrase} found in script when saveMouseState={self.comp.params['saveMouseState']}, "
-                                f"forceEndRoutineOnPress={self.comp.params['forceEndRoutineOnPress']} and "
-                                f"clickable={self.comp.params['clickable']}"
+                                f"{phrase} found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
                             )
                         for phrase in FEROPcase['avoid']:
                             assert phrase not in script, (
-                                f"{phrase} found in script when saveMouseState={self.comp.params['saveMouseState']}, "
-                                f"forceEndRoutineOnPress={self.comp.params['forceEndRoutineOnPress']} and "
-                                f"clickable={self.comp.params['clickable']}"
+                                f"{phrase} found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
                             )
                         for phrase in Ccase['avoid']:
                             assert phrase not in script, (
-                                f"{phrase} found in script when saveMouseState={self.comp.params['saveMouseState']}, "
-                                f"forceEndRoutineOnPress={self.comp.params['forceEndRoutineOnPress']} and "
-                                f"clickable={self.comp.params['clickable']}"
+                                f"{phrase} found in script when saveMouseState={comp.params['saveMouseState']}, "
+                                f"forceEndRoutineOnPress={comp.params['forceEndRoutineOnPress']} and "
+                                f"clickable={comp.params['clickable']}"
                             )
                     except AssertionError as err:
                         # If any assertion fails, save script to view

psychopy/tests/test_experiment/test_components/{test_Polygon.py → test_PolygonComponent.py}

@@ -1,37 +1,21 @@
-from pathlib import Path
-
-from . import _TestDisabledMixin, _TestBaseComponentsMixin
-from psychopy.experiment import Experiment
-from psychopy.experiment.loops import TrialHandler
-from psychopy.experiment.routines import Routine
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests, _TestLibraryClassMixin
 from psychopy.experiment.components.polygon import PolygonComponent
 from psychopy.visual.polygon import Polygon
 
 
-class TestPolygonComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
+class TestPolygonComponent(BaseComponentTests, _TestLibraryClassMixin):
     """
     Test that Polygon coponents have the correct params and write as expected.
     """
+    comp = PolygonComponent
     libraryClass = Polygon
 
-    def setup_method(self):
-        # Make blank experiment
-        self.exp = Experiment()
-        # Make blank routine
-        self.routine = Routine(name="testRoutine", exp=self.exp)
-        self.exp.addRoutine("testRoutine", self.routine)
-        self.exp.flow.addRoutine(self.routine, 0)
-        # Add loop around routine
-        self.loop = TrialHandler(exp=self.exp, name="testLoop")
-        self.exp.flow.addLoop(self.loop, 0, -1)
-        # Make a rect for when we need something to click on
-        self.comp = PolygonComponent(exp=self.exp, parentName="testRoutine", name="testPolygon")
-        self.routine.addComponent(self.comp)
-
     def test_vertices_usage(self):
         """
         Test that vertices values are used only under the correct conditions
         """
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
         # Define values to look for and avoid in code according to value of shape
         cases = [
             # Shape is a line
@@ -61,14 +45,14 @@ class TestPolygonComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
              'avoid': ["___nVertices___"]},
         ]
         # Setup component with markers for nVertices and vertices
-        self.comp.params['nVertices'].val = "___nVertices___"
-        self.comp.params['vertices'].val = "___vertices___"
+        comp.params['nVertices'].val = "___nVertices___"
+        comp.params['vertices'].val = "___vertices___"
         # Test each case
         for case in cases:
             # Set shape
-            self.comp.params['shape'].val = case['val']
+            comp.params['shape'].val = case['val']
             # Write experiment
-            pyScript = self.exp.writeScript(target="PsychoPy")
+            pyScript = exp.writeScript(target="PsychoPy")
             # Look for sought values in experiment script
             for seekVal in case['seek']:
                 assert seekVal in pyScript, (

psychopy/tests/test_experiment/test_components/{test_ResourceManager.py → test_ResourceManagerComponent.py}

@@ -1,23 +1,13 @@
 from pathlib import Path
 
-from . import _TestBaseComponentsMixin, _TestDisabledMixin
-from .test_base_components import _find_global_resource_in_js_experiment
+from psychopy.tests.test_experiment.test_components.test_base_components import BaseComponentTests, _find_global_resource_in_js_experiment
 from psychopy.experiment.components.resourceManager import ResourceManagerComponent
 from psychopy import experiment
 from ...utils import TESTS_DATA_PATH
 
 
-class TestResourceManagerComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
-    def setup_method(self):
-        # Make blank experiment
-        self.exp = experiment.Experiment()
-        # Make blank routine
-        self.routine = experiment.routines.Routine(name="testRoutine", exp=self.exp)
-        self.exp.addRoutine("testRoutine", self.routine)
-        self.exp.flow.addRoutine(self.routine, 0)
-        # Make Resource Manager component
-        self.comp = ResourceManagerComponent(exp=self.exp, parentName="testRoutine", name="testResourceManager")
-        self.routine.addComponent(self.comp)
+class TestResourceManagerComponent(BaseComponentTests):
+    comp = ResourceManagerComponent
 
     def test_handled_resources_removed(self):
         """

psychopy/tests/test_experiment/test_components/{test_Settings.py → test_SettingsComponent.py}

@@ -1,13 +1,11 @@
 from pathlib import Path
 
-from . import _TestBaseComponentsMixin, _TestDisabledMixin
 from .test_base_components import _find_global_resource_in_js_experiment
-from psychopy.experiment.components.settings import SettingsComponent
 from psychopy import experiment
 from ...utils import TESTS_DATA_PATH
 
 
-class TestSettingsComponent(_TestBaseComponentsMixin):
+class TestSettingsComponent:
     def test_unhandled_resources_js(self):
         """
         Check that resources not otherwise handled are present at the start of the experiment

psychopy/tests/test_experiment/test_components/{test_Static.py → test_StaticComponent.py}

@@ -1,23 +1,14 @@
 from pathlib import Path
 
-from . import _TestBaseComponentsMixin, _TestDisabledMixin
+from . import BaseComponentTests
 from .test_base_components import _find_global_resource_in_js_experiment
 from psychopy.experiment.components.static import StaticComponent
 from psychopy import experiment, data
 from ...utils import TESTS_DATA_PATH
 
 
-class TestStaticComponent(_TestBaseComponentsMixin, _TestDisabledMixin):
-    def setup_method(self):
-        # Make blank experiment
-        self.exp = experiment.Experiment()
-        # Make blank routine
-        self.routine = experiment.routines.Routine(name="testRoutine", exp=self.exp)
-        self.exp.addRoutine("testRoutine", self.routine)
-        self.exp.flow.addRoutine(self.routine, 0)
-        # Make Static component
-        self.comp = StaticComponent(exp=self.exp, parentName="testRoutine", name="testStatic")
-        self.routine.addComponent(self.comp)
+class TestStaticComponent(BaseComponentTests):
+    comp = StaticComponent
 
     def test_handled_resources_removed(self):
         """

psychopy/tests/test_experiment/test_components/test_all_components.py

@@ -1,10 +1,10 @@
 from psychopy.experiment.exports import IndentingBuffer
-from . import _TestBaseComponentsMixin, _TestDisabledMixin
+from . import BaseComponentTests
 from psychopy import experiment
 import inspect
 
 
-class _Generic(_TestBaseComponentsMixin, _TestDisabledMixin):
+class _Generic(BaseComponentTests):
     def __init__(self, compClass):
         self.exp = experiment.Experiment()
         self.rt = experiment.routines.Routine(exp=self.exp, name="testRoutine")
@@ -18,14 +18,12 @@ def test_all_components():
     for compName, compClass in experiment.getAllComponents().items():
         if compName == "SettingsComponent":
             continue
-        # Make a generic testing object for this component
-        tester = _Generic(compClass)
-        # Run each method from _TestBaseComponentsMixin on tester
-        for attr, meth in _TestBaseComponentsMixin.__dict__.items():
-            if inspect.ismethod(meth):
-                meth(tester)
-        # Run each method from _TestBaseComponentsMixin on tester
-        for attr, meth in _TestDisabledMixin.__dict__.items():
+        # make a generic testing object for this component
+        tester = BaseComponentTests()
+        # make sure it has a comp class assigned
+        tester.comp = compClass
+        # Run each method from BaseComponentTests on tester
+        for attr, meth in BaseComponentTests.__dict__.items():
             if inspect.ismethod(meth):
                 meth(tester)
 
@@ -104,59 +102,3 @@ def test_visual_set_autodraw():
             f"{compName} does not set autoDraw in its Each Frame code. If this is acceptable, add the component name "
             f"to `skipComponents`."
         )
-
-def test_indentation_consistency():
-    """
-    No component should exit any of its write methods at a different indent level as it entered, as this would break
-    subsequent components / routines.
-    """
-    for compName, compClass in experiment.getAllComponents().items():
-        if compName == "SettingsComponent":
-            continue
-        # Make a generic testing object for this component
-        tester = _Generic(compClass)
-        # Skip if component doesn't have a start/stop time
-        if "startVal" not in tester.comp.params or "stopVal" not in tester.comp.params:
-            continue
-        # Check that each write method exits at the same indent level as it entered
-        buff = IndentingBuffer(target="PsychoPy")
-        msg = "Writing {} code for {} changes indent level by {} when start is `{}` and stop is `{}`."
-        # Setup flow for writing
-        tester.exp.flow.writeStartCode(buff)
-        # Try combinations of start/stop being set/unset
-        cases = [
-            {"startVal": "0", "stopVal": "1"},
-            {"startVal": "", "stopVal": "1"},
-            {"startVal": "0", "stopVal": ""},
-            {"startVal": "", "stopVal": ""},
-        ]
-        for case in cases:
-            tester.comp.params["startType"].val = "time (s)"
-            tester.comp.params["stopType"].val = "time (s)"
-            for param, val in case.items():
-                tester.comp.params[param].val = val
-            # Init
-            tester.comp.writeInitCode(buff)
-            assert buff.indentLevel == 0, msg.format(
-                "init", type(tester.comp).__name__, buff.indentLevel, case['startVal'], case['stopVal']
-            )
-            # Start routine
-            tester.comp.writeRoutineStartCode(buff)
-            assert buff.indentLevel == 0, msg.format(
-                "routine start", type(tester.comp).__name__, buff.indentLevel, case['startVal'], case['stopVal']
-            )
-            # Each frame
-            tester.comp.writeFrameCode(buff)
-            assert buff.indentLevel == 0, msg.format(
-                "each frame", type(tester.comp).__name__, buff.indentLevel, case['startVal'], case['stopVal']
-            )
-            # End routine
-            tester.comp.writeRoutineEndCode(buff)
-            assert buff.indentLevel == 0, msg.format(
-                "routine end", type(tester.comp).__name__, buff.indentLevel, case['startVal'], case['stopVal']
-            )
-            # End experiment
-            tester.comp.writeExperimentEndCode(buff)
-            assert buff.indentLevel == 0, msg.format(
-                "experiment end", type(tester.comp).__name__, buff.indentLevel, case['startVal'], case['stopVal']
-            )

psychopy/tests/test_experiment/test_components/test_base_components.py

@@ -6,27 +6,9 @@ from pathlib import Path
 import pytest
 
 from psychopy import experiment
+from psychopy.experiment.loops import TrialHandler
 from psychopy.experiment.components import BaseComponent
-
-
-def _make_minimal_experiment(obj):
-    """
-    Make a minimal experiment with just one routine containing just one component, of the same class as the current
-    component but with all default params.
-    """
-    # Skip whole test if required attributes aren't present
-    if not hasattr(obj, "comp"):
-        pytest.skip()
-    # Make blank experiment
-    exp = experiment.Experiment()
-    rt = exp.addRoutine(routineName='TestRoutine')
-    exp.flow.addRoutine(rt, 0)
-    # Create instance of this component with all default params
-    compClass = type(obj.comp)
-    comp = compClass(exp=exp, parentName='TestRoutine', name=f"test{compClass.__name__}")
-    rt.append(comp)
-    # Return experiment, routine and component
-    return comp, rt, exp
+from psychopy.experiment.exports import IndentingBuffer
 
 
 def _find_global_resource_in_js_experiment(script, resource):
@@ -48,34 +30,228 @@ def _find_global_resource_in_js_experiment(script, resource):
     return resource in resourcesStr
 
 
-class _TestBaseComponentsMixin:
-    # Class in the PsychoPy libraries (visual, sound, hardware, etc.) corresponding to this component
-    libraryClass = None
+class BaseComponentTests:
+    # component class to test
+    comp = None
 
-    def test_icons(self):
-        """Check that component has icons for each app theme"""
-        # Skip whole test if required attributes aren't present
-        if not hasattr(self, "comp"):
+    # --- Utility methods ---
+    def make_minimal_experiment(self):
+        """
+        Make a minimal experiment with just one routine containing just one component, of the same class as the current component but with all default params.
+        """
+        # make blank experiment
+        exp = experiment.Experiment()
+        # add a Routine
+        rt = exp.addRoutine(routineName='TestRoutine')
+        exp.flow.addRoutine(rt, 0)
+        # add a loop around the Routine
+        loop = TrialHandler(exp=exp, name="testLoop")
+        exp.flow.addLoop(loop, 0, -1)
+        # create instance of this test's Component with all default params
+        comp = self.comp(exp=exp, parentName='TestRoutine', name=f"test{self.comp.__name__}")
+        rt.append(comp)
+        # return experiment, Routine and Component
+        return comp, rt, exp
+    
+    @pytest.fixture(autouse=True)
+    def assert_comp_class(self):
+        """
+        Make sure this test object has an associated Component class - and skip the test if not. This is run before each test by default.
+        """
+        # skip whole test if there is no Component connected to test class
+        if self.comp is None:
             pytest.skip()
-        # Pathify icon file path
+        # continue with the test as normal
+        yield
+    
+    # --- Heritable tests ---
+
+    def test_icons(self):
+        """
+        Check that Component has icons for each app theme and that these point to real files
+        """
+        # pathify icon file path
         icon = Path(self.comp.iconFile)
-        # Get paths for each theme
+        # 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
+        # check that each path is a file
         for file in files:
-            assert file.is_file()
+            assert file.is_file(), (
+                f"Could not find file: {file}"
+            )
+    
+    def test_indentation_consistency(self):
+        """
+        No component should exit any of its write methods at a different indent level as it entered, as this would break subsequent components / routines.
+        """
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
+        # skip if component doesn't have a start/stop time
+        if "startVal" not in comp.params or "stopVal" not in comp.params:
+            pytest.skip()
+        # create a text buffer to write to
+        buff = IndentingBuffer(target="PsychoPy")
+        # template message for if test fails
+        errMsgTemplate = "Writing {} code for {} changes indent level by {} when start is `{}` and stop is `{}`."
+        # setup flow for writing
+        exp.flow.writeStartCode(buff)
+        # combinations of start/stop being set/unset to try
+        cases = [
+            {"startVal": "0", "stopVal": "1"},
+            {"startVal": "", "stopVal": "1"},
+            {"startVal": "0", "stopVal": ""},
+            {"startVal": "", "stopVal": ""},
+        ]
+        for case in cases:
+            # update error message for this case
+            errMsg = errMsgTemplate.format(
+                "{}", type(comp).__name__, "{}", case['startVal'], case['stopVal']
+            )
+            # set start/stop types
+            comp.params["startType"].val = "time (s)"
+            comp.params["stopType"].val = "time (s)"
+            # set start/stop values
+            for param, val in case.items():
+                comp.params[param].val = val
+            # write init code
+            comp.writeInitCode(buff)
+            # check indent
+            assert buff.indentLevel == 0, errMsg.format(
+                "init", buff.indentLevel
+            )
+            # write routine start code
+            comp.writeRoutineStartCode(buff)
+            # check indent
+            assert buff.indentLevel == 0, errMsg.format(
+                "routine start", buff.indentLevel
+            )
+            # write each frame code
+            comp.writeFrameCode(buff)
+            # check indent
+            assert buff.indentLevel == 0, errMsg.format(
+                "each frame", buff.indentLevel
+            )
+            # write end routine code
+            comp.writeRoutineEndCode(buff)
+            # check indent
+            assert buff.indentLevel == 0, errMsg.format(
+                "routine end", buff.indentLevel
+            )
+            # write end experiment code
+            comp.writeExperimentEndCode(buff)
+            # check indent
+            assert buff.indentLevel == 0, errMsg.format(
+                "experiment end", buff.indentLevel
+            )
+
+    def test_disabled_default_val(self):
+        """
+        Test that components created with default params are not disabled
+        """
+        # make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
+        # check whether it can be disabled
+        assert 'disabled' in comp.params, (
+            f"{type(comp).__name__} does not have a 'disabled' attribute."
+        )
+        # check that disabled defaults to False
+        assert comp.params['disabled'].val is False, f"{type(comp).__name__} is defaulting to disabled."
+
+    def test_disabled_code_muting(self):
+        """
+        Test that components are only written when enabled and targets match.
+        """
+        # Code Component is never referenced by name, so skip it for this test
+        if self.comp.__name__ == "CodeComponent":
+            pytest.skip()
+        # Make minimal experiment just for this test
+        comp, rt, exp = self.make_minimal_experiment()
+        # Write experiment and check that component is written
+        pyScript = exp.writeScript(target="PsychoPy")
+        if "PsychoPy" in type(comp).targets:
+            assert comp.name in pyScript, (
+                f"{type(comp).__name__} not found in compiled Python script when enabled and PsychoPy in targets."
+            )
+        else:
+            assert comp.name not in pyScript, (
+                f"{type(comp).__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(comp).targets:
+        #     assert comp.name in jsScript, (
+        #         f"{type(comp).__name__} not found in compiled Python script when enabled and PsychoJS in targets."
+        #     )
+        # else:
+        #     assert comp.name not in jsScript, (
+        #         f"{type(comp).__name__} found in compiled Python script when enabled but PsychoJS not in targets."
+        #     )
+
+        # disable component then do same tests but assert not present
+        comp.params['disabled'].val = True
+
+        pyScript = exp.writeScript(target="PsychoPy")
+        if "PsychoPy" in type(comp).targets:
+            assert comp.name not in pyScript, (
+                f"{type(comp).__name__} found in compiled Python script when disabled but PsychoPy in targets."
+            )
+        else:
+            assert comp.name not in pyScript, (
+                f"{type(comp).__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(comp).targets:
+        #     assert comp.name not in jsScript, (
+        #         f"{type(comp).__name__} found in compiled Python script when disabled but PsychoJS in targets."
+        #     )
+        # else:
+        #     assert comp.name not in jsScript, (
+        #         f"{type(comp).__name__} found in compiled Python script when disabled and PsychoJS not in targets."
+        #     )
 
-    def testDeviceClassRefs(self):
+    def test_disabled_components_stay_in_routine(self):
+        """
+        Test that disabled components aren't removed from their routine when experiment is written.
+        """
+        comp, rt, exp = self.make_minimal_experiment()
+        # Disable component
+        comp.params['disabled'].val = True
+        # Writing the script drops the component but, if working properly, only from a copy of the routine, not the
+        # original!
+        exp.writeScript()
+
+        assert comp in rt, f"Disabling {type(comp).name} appears to remove it from its routine on compile."
+class _TestLibraryClassMixin:
+    # class in the PsychoPy libraries (visual, sound, hardware, etc.) corresponding to this component
+    libraryClass = None
+
+    # --- Utility methods ---
+
+    @pytest.fixture(autouse=True)
+    def assert_lib_class(self):
+        """
+        Make sure this test object has an associated library class - and skip the test if not. This is run before each test by default.
+        """
+        # skip whole test if there is no Component connected to test class
+        if self.libraryClass is None:
+            pytest.skip()
+        # continue with the test as normal
+        yield
+    
+    # --- Heritable tests ---
+
+    def test_device_class_refs(self):
         """
         Check that any references to device classes in this Routine object point to classes which
         exist.
         """
         # make minimal experiment just for this test
-        comp, rt, exp = _make_minimal_experiment(self)
+        comp, rt, exp = self.make_minimal_experiment()
         # skip test if this element doesn't point to any hardware class
         if not hasattr(comp, "deviceClasses"):
             pytest.skip()
@@ -91,13 +267,7 @@ class _TestBaseComponentsMixin:
 
     def test_params_used(self):
         # Make minimal experiment just for this test
-        comp, rt, exp = _make_minimal_experiment(self)
-        # Skip if component shouldn't use all of its params
-        if type(comp).__name__ in ["SettingsComponent", "CodeComponent"]:
-            pytest.skip()
-        # Skip if component is deprecated
-        if type(comp).__name__ in ['RatingScaleComponent', 'PatchComponent']:
-            pytest.skip()
+        comp, rt, exp = self.make_minimal_experiment()
         # Try with PsychoPy and PsychoJS
         for target in ("PsychoPy", "PsychoJS"):
             ## Skip PsychoJS until can write script without saving
@@ -134,11 +304,8 @@ class _TestBaseComponentsMixin:
         """
         Check that all params which are settable each frame/repeat have a set method in the corresponding class.
         """
-        # Skip if there's no corresponding library class
-        if self.libraryClass is None:
-            return
         # Make minimal experiment just for this test
-        comp, rt, exp = _make_minimal_experiment(self)
+        comp, rt, exp = self.make_minimal_experiment()
         # Check each param
         for paramName, param in comp.params.items():
             if not param.direct:
@@ -167,91 +334,11 @@ class _TestBaseComponentsMixin:
                 )
 
 
-class _TestDisabledMixin:
-    def test_disabled_default_val(self):
-        """
-        Test that components created with default params are not disabled
-        """
-        # Make minimal experiment just for this test
-        comp, rt, exp = _make_minimal_experiment(self)
-        # Check whether it can be disabled
-        assert 'disabled' in comp.params, (
-            f"{type(comp).__name__} does not have a 'disabled' attribute."
-        )
-        # Check that disabled defaults to False
-        assert comp.params['disabled'].val is False, f"{type(comp).__name__} is defaulting to disabled."
-
-    def test_code_muting(self):
-        """
-        Test that components are only written when enabled and targets match.
-        """
-        # Make minimal experiment just for this test
-        comp, rt, exp = _make_minimal_experiment(self)
-        # Skip for Code components as these purely inject code, name isn't used
-        if type(comp).__name__ in ("CodeComponent"):
-            pytest.skip()
-        # Write experiment and check that component is written
-        pyScript = exp.writeScript(target="PsychoPy")
-        if "PsychoPy" in type(comp).targets:
-            assert comp.name in pyScript, (
-                f"{type(comp).__name__} not found in compiled Python script when enabled and PsychoPy in targets."
-            )
-        else:
-            assert comp.name not in pyScript, (
-                f"{type(comp).__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(comp).targets:
-        #     assert comp.name in jsScript, (
-        #         f"{type(comp).__name__} not found in compiled Python script when enabled and PsychoJS in targets."
-        #     )
-        # else:
-        #     assert comp.name not in jsScript, (
-        #         f"{type(comp).__name__} found in compiled Python script when enabled but PsychoJS not in targets."
-        #     )
-
-        # Disable component then do same tests but assert not present
-        comp.params['disabled'].val = True
-
-        pyScript = exp.writeScript(target="PsychoPy")
-        if "PsychoPy" in type(comp).targets:
-            assert comp.name not in pyScript, (
-                f"{type(comp).__name__} found in compiled Python script when disabled but PsychoPy in targets."
-            )
-        else:
-            assert comp.name not in pyScript, (
-                f"{type(comp).__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(comp).targets:
-        #     assert comp.name not in jsScript, (
-        #         f"{type(comp).__name__} found in compiled Python script when disabled but PsychoJS in targets."
-        #     )
-        # else:
-        #     assert comp.name not in jsScript, (
-        #         f"{type(comp).__name__} found in compiled Python script when disabled and PsychoJS not in targets."
-        #     )
-
-    def test_disabled_components_stay_in_routine(self):
-        """
-        Test that disabled components aren't removed from their routine when experiment is written.
-        """
-        comp, rt, exp = _make_minimal_experiment(self)
-        # Disable component
-        comp.params['disabled'].val = True
-        # Writing the script drops the component but, if working properly, only from a copy of the routine, not the
-        # original!
-        exp.writeScript()
-
-        assert comp in rt, f"Disabling {type(comp).name} appears to remove it from its routine on compile."
-
 
 class _TestDepthMixin:
     def test_depth(self):
         # Make minimal experiment
-        comp, rt, exp = _make_minimal_experiment(self)
+        comp, rt, exp = self.make_minimal_experiment()
         # Get class we're currently working with
         compClass = type(comp)
         # Add index to component name

{psychopy-2024.1.2.dist-info → psychopy-2024.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: psychopy
-Version: 2024.1.2
+Version: 2024.1.3
 Summary: PsychoPy provides easy, precise, flexible experiments in behavioural sciences
 Author-Email: Open Science Tools Ltd <support@opensciencetools.org>
 Maintainer-Email: Open Science Tools Ltd <support@opensciencetools.org>
@@ -23,7 +23,7 @@ Requires-Dist: matplotlib
 Requires-Dist: pyglet==1.4.11; platform_system == "Windows"
 Requires-Dist: pyglet==1.5.27; platform_system != "Windows"
 Requires-Dist: pillow>=9.4.0
-Requires-Dist: pyqt5
+Requires-Dist: pyqt6
 Requires-Dist: pandas>=1.5.3
 Requires-Dist: questplus>=2023.1
 Requires-Dist: openpyxl

{psychopy-2024.1.2.dist-info → psychopy-2024.1.3.dist-info}/RECORD

@@ -1,12 +1,12 @@
-psychopy-2024.1.2.dist-info/METADATA,sha256=M1igQPo08nMH1m8fmlLpFSVVdfg5b9-9IvJC1I0sEYU,6993
-psychopy-2024.1.2.dist-info/WHEEL,sha256=7sv5iXvIiTVJSnAxCz2tGBm9DHsb2vPSzeYeT7pvGUY,90
-psychopy-2024.1.2.dist-info/entry_points.txt,sha256=1LXVqRMSILrbEagrzpJDtmXyEPHX3GnpBJ85TEnxuoI,56
-psychopy-2024.1.2.dist-info/licenses/AUTHORS.md,sha256=MmZf-GmSBscBa_z7ePoqYxbaGe6XOJnld_s6JIQGfS4,2395
-psychopy-2024.1.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+psychopy-2024.1.3.dist-info/METADATA,sha256=Dgf2hQgHlVrGjHGkRlF_xx0N_lUO9X6FETfx-vdWyic,6993
+psychopy-2024.1.3.dist-info/WHEEL,sha256=7sv5iXvIiTVJSnAxCz2tGBm9DHsb2vPSzeYeT7pvGUY,90
+psychopy-2024.1.3.dist-info/entry_points.txt,sha256=1LXVqRMSILrbEagrzpJDtmXyEPHX3GnpBJ85TEnxuoI,56
+psychopy-2024.1.3.dist-info/licenses/AUTHORS.md,sha256=MmZf-GmSBscBa_z7ePoqYxbaGe6XOJnld_s6JIQGfS4,2395
+psychopy-2024.1.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
 psychopy/CHANGELOG.txt,sha256=bRyB9AEemUO4KBYhtBOIWOaXFmX9X3pHgMMF9QyeITA,203527
 psychopy/LICENSE.txt,sha256=d2HeFOYbuXc2LZobE1EkFq3lYV5ge3YSaTL3y1r7KQc,746
 psychopy/LICENSES.txt,sha256=T59KljDkUEEtd40IHWS-S0OTSjzqueGD6oNmgqpRIf0,3145
-psychopy/__init__.py,sha256=tS0DFSNAdVdbqrTmPYpidSvE19az5kUVCOO6yrUaiWM,2757
+psychopy/__init__.py,sha256=TaSpE94UGKdQ0J3pbhPIO_aH4HsJ3AlNIdFspPjwik0,2757
 psychopy/alerts/__init__.py,sha256=buvC7HFn71FhIp1D4XGXkZLeNLk22uO9TSQsxLlYZqU,2178
 psychopy/alerts/_alerts.py,sha256=IMHMXY1mzTCmlOYhHW0_Upb9oAcYzzTWe44BUNXj-ec,6120
 psychopy/alerts/_errorHandler.py,sha256=JNkdx3OJv0PeAeARG09Rgne7dH-aGgUdxdoriDd4KW4,1501
@@ -1446,7 +1446,7 @@ psychopy/experiment/components/microphone/dark/microphone.png,sha256=q6XPPab-nnF
 psychopy/experiment/components/microphone/dark/microphone@2x.png,sha256=x58B_E0YQNUV2dyye52APaf-25S7nfpP70j-2-7PpLQ,1853
 psychopy/experiment/components/microphone/light/microphone.png,sha256=bQztv6e7oCUK8852Zc5RcLt_kEgqI9c_d_S8W-6WEt4,988
 psychopy/experiment/components/microphone/light/microphone@2x.png,sha256=swrycVelLJd8k57jbaS5AYXq5ievFSs-rhsNePv_rQM,1841
-psychopy/experiment/components/mouse/__init__.py,sha256=4dSvLs6h2aZirBRTflbwgpi2GqP_LFfBU4jiEhTG1aE,34264
+psychopy/experiment/components/mouse/__init__.py,sha256=pT5xrJxpOhiZEUKrbkPBFgTGG_yA6xgsDYmZj9dNqUE,34739
 psychopy/experiment/components/mouse/classic/mouse.png,sha256=rXSJ4vFYekhNjANSuJnLdLmCF0-Y6p6s8b7JyL6It9Y,3735
 psychopy/experiment/components/mouse/classic/mouse@2x.png,sha256=Ms-piLdbP1zKFBP5bbiBb7sF_Bps67GG7ZpBnItxoNM,11310
 psychopy/experiment/components/mouse/dark/mouse.png,sha256=KWXV2z5bUx80lwu3H98-8h2XWo9ZyQvM3iRU22CQ7z8,772
@@ -1609,7 +1609,7 @@ psychopy/experiment/questPlusTemplate.xltx,sha256=8c1yt6el4v_iE79FoelLX267TpFrPs
 psychopy/experiment/questTemplate.xltx,sha256=p0FzYmMWJH0uaGRFlAdPT4uSzNBHpV7uPM0gZN5yYds,20668
 psychopy/experiment/routines/__init__.py,sha256=mQTjLeu5H7K_EGp_WZ7I5jXDKNgPF4ViJz00aG_pV-g,3672
 psychopy/experiment/routines/_base.py,sha256=VMln_MS1QPNga64wBR0fB0pMsHu28UeyElZAuIil7pA,38584
-psychopy/experiment/routines/counterbalance/__init__.py,sha256=NuH3o-tm0aF6zlfdD1eEd0vh79zgbdHlf47tYp7CrAk,12603
+psychopy/experiment/routines/counterbalance/__init__.py,sha256=XxkGNfrQoTvuL0i80bWWYy2VANsxN7Fl93Y2C7xpc5c,12616
 psychopy/experiment/routines/counterbalance/classic/counterbalance.png,sha256=ficKpm9rX1A-YIzgFNfM6EbwAklenfKeOwP74ktCgfo,3977
 psychopy/experiment/routines/counterbalance/classic/counterbalance@2x.png,sha256=UwSvAzg0Y9k1jEtkvbzr277tApPB08o4gFRuhhN5NpA,10628
 psychopy/experiment/routines/counterbalance/counterbalanceItems.xltx,sha256=Ht1ZE6c800RGF1LxE6WjWGujNwsMQ04pw6j_VZu86uE,18707
@@ -1683,7 +1683,7 @@ psychopy/hardware/forp.py,sha256=P19o4cmrZD4kHhJwNT0kj5LR-F4kdwXSu5GpYyiis4U,135
 psychopy/hardware/gammasci.py,sha256=odRzQ1kKduDqrQshp582YtKnXnSFPXWc8qic9jjPZMc,1000
 psychopy/hardware/iolab.py,sha256=8fqy-xGe15naHLgYfxELpes5ooNDTUytLTTz9_NhTi0,1067
 psychopy/hardware/joystick/__init__.py,sha256=wBhX_21kRPAlKM2UyEZBYBKhDCfiLHIp-K7r_2bDorI,19109
-psychopy/hardware/keyboard.py,sha256=SCMaOrRwwz5jVZwH-0g7IOa7D1CAFfwNNJk9w6e19Gg,34160
+psychopy/hardware/keyboard.py,sha256=enf7nluy1w3_SYA2B2mCrVY0Cx3ytM5BjtXdkIjiLqk,34192
 psychopy/hardware/knownDevices.json,sha256=rGsTu0MaBdUTUA6bwCKU9D-J03i0oFPDWOw28Eu4Ik0,1791
 psychopy/hardware/labhackers.py,sha256=_fRtMUtSd5f2DXRVgVsXQdF3x9ZDFypXcuxaD0J1C0E,864
 psychopy/hardware/labjacks.py,sha256=CQfxgty2uGdG2bzkcbfw-pKBzxHlnSSVfcPHKlsOC8E,980
@@ -2744,17 +2744,18 @@ psychopy/tests/test_experiment/needs_wx/test_Experiment.py,sha256=HpN-2uiKFitW6y
 psychopy/tests/test_experiment/needs_wx/test_components.py,sha256=nr06cyK0vPbJVOFXESx5Q5ehjKI9i669HbS6cJDzlGA,7092
 psychopy/tests/test_experiment/test_component_compile_js.py,sha256=LrVUQ-izAN23e5M1t3Tg7NaourscsDABSBtPZeEWm24,2775
 psychopy/tests/test_experiment/test_component_compile_python.py,sha256=SALVfXswwu64hyfIsqzPhDru5EVO5tyuUDAOLrXDE10,7002
-psychopy/tests/test_experiment/test_components/__init__.py,sha256=EdYXBYmZlZcMS0LtpZpGIIE7fa0MBka2QLCPvkiFo1I,78
-psychopy/tests/test_experiment/test_components/test_ButtonBox.py,sha256=DRlb5ZteA3owgNqa29c-sKdIfqBt2HxCaRbAa-eymxg,7347
-psychopy/tests/test_experiment/test_components/test_Code.py,sha256=wmFAzpk4SXzLp7Hhatm6MaZEpYPni2HTgoezxPgZG-k,4044
-psychopy/tests/test_experiment/test_components/test_Image.py,sha256=h8rdATikkkkoS8EOem4y_sb0jAnSPnGSxPvkCfANXUk,1057
-psychopy/tests/test_experiment/test_components/test_Mouse.py,sha256=3dhAT7nRfg8aK6ePASBmr6mnGlyZX7HKYB3Ozd54_X4,8609
-psychopy/tests/test_experiment/test_components/test_Polygon.py,sha256=qc3gwI2rze6fzNUbIg8dRaXacQJWlEokfkLo3QE6BK8,3588
-psychopy/tests/test_experiment/test_components/test_ResourceManager.py,sha256=CPozNSM4s9rulbijBlnViS8dhmsa0DjziG8VG7f4s3Q,3040
-psychopy/tests/test_experiment/test_components/test_Settings.py,sha256=iFwD6xN0KZHs5C09OD97OzBwFSec1E5KY3M4KpjO3Ys,3493
-psychopy/tests/test_experiment/test_components/test_Static.py,sha256=wpGpwm8r4vxJA4gIIAwVL3PPcwsMt0narkVmeKL0xJI,2955
-psychopy/tests/test_experiment/test_components/test_all_components.py,sha256=Kc39UU4NJw5uyFO0DR5TEDI-pdRopW68yR9muQvIDcU,7280
-psychopy/tests/test_experiment/test_components/test_base_components.py,sha256=H_VXPo5ul524U9lt7okfAttW9taL0GxAmD8xbrxH8_c,14389
+psychopy/tests/test_experiment/test_components/__init__.py,sha256=qQqf5031kA1-Qcj4ActVGQbE6wB4DQQ2JpdBnf4e7Sc,52
+psychopy/tests/test_experiment/test_components/test_ButtonBoxComponent.py,sha256=sG_M3v97JIrFvpDGRYn7Y21--zvzpQkPTtEnsXspBPk,6748
+psychopy/tests/test_experiment/test_components/test_CodeComponent.py,sha256=8U4Z2FDhn6Gf1DRnOAEEScl47gFHWz1-6_nhAiQwrkI,3460
+psychopy/tests/test_experiment/test_components/test_GratingComponent.py,sha256=zdaSZhd-XAkihUBt7mnq93QEuEDniUeRxE0LHWl98Qo,363
+psychopy/tests/test_experiment/test_components/test_ImageComponent.py,sha256=oFlxj67_r5H68VF84FcGa8rrgBxTo81lURS9L6mBSpA,366
+psychopy/tests/test_experiment/test_components/test_MouseComponent.py,sha256=2pFUhxQmCWBeUvaUxWaayEDFfgkIOP8CtzWP3o2e4UI,7876
+psychopy/tests/test_experiment/test_components/test_PolygonComponent.py,sha256=wXaGVfe-qERMcgtRexFofpjsBjR4WdWKBFtPIBut8Wo,2954
+psychopy/tests/test_experiment/test_components/test_ResourceManagerComponent.py,sha256=n-mB_VoTn3PxUWETjggyU5yvh56k4xQQMYruOy2ScM0,2533
+psychopy/tests/test_experiment/test_components/test_SettingsComponent.py,sha256=hdcoBh8u9X4si97L8naTz7Ix2rzlHK4FpP52-hDYENY,3338
+psychopy/tests/test_experiment/test_components/test_StaticComponent.py,sha256=Ta0gzNMN-lqE77iyQ6z0eR_71ijNlGhSr01IFaiHJoE,2434
+psychopy/tests/test_experiment/test_components/test_all_components.py,sha256=O-7fSqlk-oaTK4HC65_lsDv0sTF4xQ9p0P3uXoenMzc,4403
+psychopy/tests/test_experiment/test_components/test_base_components.py,sha256=StKDjDX8Hg88s_znEpD6ivZlz4Fxuvm_UWiS38dJv_k,17849
 psychopy/tests/test_experiment/test_experiment.py,sha256=WRWimiyviyzkPc85PuqTumrVrbrZe0yB95WYraGXLsw,4439
 psychopy/tests/test_experiment/test_loops.py,sha256=8-lHo7nAXaiorP_hpv2oSyA_UZAt2617L3CyusrIUCs,3703
 psychopy/tests/test_experiment/test_params.py,sha256=e2WjO4T1xvb0sRtZXph9CAcN3YjIN79hzziTiqoEu8o,13172
@@ -2947,4 +2948,4 @@ psychopy/voicekey/parallel_vks.py,sha256=I6a07GvN0Q2k9xidl9YbEUDORG2v9l2H_5Owbpw
 psychopy/voicekey/signal.py,sha256=Mk363qVsvJampVDfsOTdGq7lPESlKmogmNFqasdghJE,1013
 psychopy/voicekey/vk_tools.py,sha256=pFvOvF9b9CfS-JkZ_fv38LxI59hJXQqiz9ymcrJiAFc,8483
 psychopy/web.py,sha256=ohiFb7lW1-0pH_62cR-z8ufZ5Nta2jRIjGS4_zosX_U,10228
-psychopy-2024.1.2.dist-info/RECORD,,
+psychopy-2024.1.3.dist-info/RECORD,,

psychopy/tests/test_experiment/test_components/test_Image.py

@@ -1,24 +0,0 @@
-from psychopy.experiment import Experiment
-from psychopy.experiment.components.image import ImageComponent
-from psychopy.experiment.loops import TrialHandler
-from psychopy.experiment.routines import Routine
-from .test_base_components import _TestDepthMixin, _TestBaseComponentsMixin
-from psychopy.visual.image import ImageStim
-
-
-class TestImage(_TestBaseComponentsMixin, _TestDepthMixin):
-    libraryClass = ImageStim
-
-    def setup_method(self):
-        # Make blank experiment
-        self.exp = Experiment()
-        # Make blank routine
-        self.routine = Routine(name="testRoutine", exp=self.exp)
-        self.exp.addRoutine("testRoutine", self.routine)
-        self.exp.flow.addRoutine(self.routine, 0)
-        # Add loop around routine
-        self.loop = TrialHandler(exp=self.exp, name="testLoop")
-        self.exp.flow.addLoop(self.loop, 0, -1)
-        # Make a rect for when we need something to click on
-        self.comp = ImageComponent(exp=self.exp, parentName="testRoutine", name="testImage")
-        self.routine.addComponent(self.comp)