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

psychopy/app/plugin_manager/plugins.py

@@ -1222,6 +1222,13 @@ def getAllPluginDetails():
             return None
         # otherwise get as a string
         value = resp.text
+
+        if value is None or value == "":
+            return None
+
+        # make sure we are using UTF-8 encoding
+        value = value.encode('utf-8', 'ignore').decode('utf-8')
+
         # attempt to parse JSON
         try:
             database = json.loads(value)

psychopy/demos/builder/Feature Demos/progress/progressBar.psyexp

@@ -125,7 +125,7 @@
         <Param val="from exp settings" valType="str" updates="None" name="units" />
       </TextboxComponent>
       <ProgressComponent name="timer10" plugin="None">
-        <Param val="center left" valType="str" updates="constant" name="anchor" />
+        <Param val="center-left" valType="str" updates="constant" name="anchor" />
         <Param val="grey" valType="color" updates="constant" name="borderColor" />
         <Param val="grey" valType="color" updates="constant" name="color" />
         <Param val="rgb" valType="str" updates="constant" name="colorSpace" />
@@ -190,7 +190,7 @@
         <Param val="from exp settings" valType="str" updates="None" name="units" />
       </TextboxComponent>
       <ProgressComponent name="timer5" plugin="None">
-        <Param val="center left" valType="str" updates="constant" name="anchor" />
+        <Param val="center-left" valType="str" updates="constant" name="anchor" />
         <Param val="darkgrey" valType="color" updates="constant" name="borderColor" />
         <Param val="darkgrey" valType="color" updates="constant" name="color" />
         <Param val="rgb" valType="str" updates="constant" name="colorSpace" />
@@ -255,7 +255,7 @@
         <Param val="from exp settings" valType="str" updates="None" name="units" />
       </TextboxComponent>
       <ProgressComponent name="timer1" plugin="None">
-        <Param val="center left" valType="str" updates="constant" name="anchor" />
+        <Param val="center-left" valType="str" updates="constant" name="anchor" />
         <Param val="lightgrey" valType="color" updates="constant" name="borderColor" />
         <Param val="lightgrey" valType="color" updates="constant" name="color" />
         <Param val="rgb" valType="str" updates="constant" name="colorSpace" />
@@ -320,7 +320,7 @@
         <Param val="from exp settings" valType="str" updates="None" name="units" />
       </TextboxComponent>
       <ProgressComponent name="trialCtr" plugin="None">
-        <Param val="center left" valType="str" updates="constant" name="anchor" />
+        <Param val="center-left" valType="str" updates="constant" name="anchor" />
         <Param val="dodgerblue" valType="color" updates="constant" name="borderColor" />
         <Param val="dodgerblue" valType="color" updates="constant" name="color" />
         <Param val="rgb" valType="str" updates="constant" name="colorSpace" />

psychopy/experiment/components/buttonBox/__init__.py

@@ -161,6 +161,14 @@ class ButtonBoxComponent(BaseDeviceComponent, PluginDevicesMixin):
             f"%(name)s.resetTimer({clockStr})\n"
         )
         buff.writeIndentedLines(code % self.params)
+        # clear keys
+        code = (
+            "# clear %(name)s button presses\n"
+            "%(name)s.buttons = []\n"
+            "%(name)s.times = []\n"
+            "%(name)s.corr = []\n"
+            )
+        buff.writeIndentedLines(code % self.params)
 
     def writeFrameCode(self, buff):
         params = self.params
@@ -201,7 +209,10 @@ class ButtonBoxComponent(BaseDeviceComponent, PluginDevicesMixin):
                 # include code to get correct
                 if self.params['storeCorrect']:
                     code += (
-                "    %(name)s.corr.append(_thisResp.channel in %(correctAns)s)\n"
+                "    if _thisResp.channel in %(correctAns)s or _thisResp.channel == %(correctAns)s:\n"
+                "        %(name)s.corr.append(1)\n"
+                "    else:\n"
+                "        %(name)s.corr.append(0)\n"
                     )
             elif self.params['store'] == "last":
                 # if storing last, replace
@@ -212,7 +223,10 @@ class ButtonBoxComponent(BaseDeviceComponent, PluginDevicesMixin):
                 # include code to get correct
                 if self.params['storeCorrect']:
                     code += (
-                "    %(name)s.corr = _thisResp.channel in %(correctAns)s\n"
+                "    if _thisResp.channel in %(correctAns)s or _thisResp.channel == %(correctAns)s:\n"
+                "        %(name)s.corr = 1\n"
+                "    else:\n"
+                "        %(name)s.corr = 0\n"
                     )
             elif self.params['store'] == "first":
                 # if storing first, replace but only if empty
@@ -224,7 +238,10 @@ class ButtonBoxComponent(BaseDeviceComponent, PluginDevicesMixin):
                 # include code to get correct
                 if self.params['storeCorrect']:
                     code += (
-                "        %(name)s.corr = _thisResp.channel in %(correctAns)s\n"
+                "        if _thisResp.channel in %(correctAns)s or _thisResp.channel == %(correctAns)s:\n"
+                "            %(name)s.corr = 1\n"
+                "        else:\n"
+                "            %(name)s.corr = 0\n"
                     )
             else:
                 code = "pass\n"
@@ -260,15 +277,7 @@ class ButtonBoxComponent(BaseDeviceComponent, PluginDevicesMixin):
             "thisExp.addData('%(name)s.corr', %(name)s.corr)\n"
         )
         buff.writeIndentedLines(code % params)
-        # clear keys
-        code = (
-            "# clear %(name)s button presses\n"
-            "%(name)s.buttons = []\n"
-            "%(name)s.times = []\n"
-            "%(name)s.corr = []\n"
-        )
-        buff.writeIndentedLines(code % params)
-
+        
 
 class KeyboardButtonBoxBackend(DeviceBackend):
     """

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/components/progress/__init__.py

@@ -24,7 +24,7 @@ class ProgressComponent(BaseVisualComponent):
                  progress=0,
                  color="white", fillColor="None", borderColor="white", colorSpace="rgb",
                  opacity=1, lineWidth=4,
-                 pos=(0, 0), size=(0.5, 0.5), anchor="center left", ori=0, units="height",
+                 pos=(0, 0), size=(0.5, 0.5), anchor="center-left", ori=0, units="height",
                  disabled=False):
 
         self.exp = exp  # so we can access the experiment if necess

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/experiment/routines/photodiodeValidator/__init__.py

@@ -17,7 +17,7 @@ class PhotodiodeValidatorRoutine(BaseValidatorRoutine, PluginDevicesMixin):
 
     categories = ['Validation']
     iconFile = Path(__file__).parent / 'photodiode_validator.png'
-    tooltip = _translate('')
+    tooltip = _translate('Photodiode validator')
     deviceClasses = []
     version = "2024.2.0"
 

psychopy/hardware/keyboard.py

@@ -521,7 +521,6 @@ class KeyboardDevice(BaseResponseDevice, aliases=["keyboard"]):
         elif KeyboardDevice._backend == 'iohub':
             # get events from backend (need to reverse order)
             key_events = KeyboardDevice._iohubKeyboard.getKeys(clear=True)
-            key_events.reverse()
             # parse and receive each event
             for k in key_events:
                 kpress = self.parseMessage(k)
@@ -573,7 +572,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._iohubKeyboard.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