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

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/tools/fontmanager.py

@@ -947,7 +947,7 @@ class FontManager():
                 return False
         # If font is found, make glfont
         fontInfo = fontInfos[0]
-        identifier = "{}_{}".format(str(fontInfo), size)
+        identifier = "{}_{}_{}".format(str(fontInfo), size, lineSpacing)
         glFont = self._glFonts.get(identifier)
         if glFont is None:
             glFont = GLFont(fontInfo.path, size, lineSpacing=lineSpacing)

psychopy/tools/versionchooser.py

@@ -33,7 +33,7 @@ _remoteVersionsCache = []
 versionMap = OrderedDict({
     Version('2.7'): (Version("0.0"), Version("2020.2.0")),
     Version('3.6'): (Version("1.9"), Version("2022.1.0")),
-    Version('3.8'): (Version("2022.1.0"), Version("2024.1.0")),
+    Version('3.8'): (Version("2022.1.0"), None),
     Version('3.10'): (Version("2023.2.0"), None),
 })
 # fill out intermediate versions

psychopy/visual/noise.py

@@ -30,5 +30,14 @@ except (ModuleNotFoundError, ImportError):
         "Support for `NoiseStim` is not available this session. Please install "
         "`psychopy-visionscience` and restart the session to enable support.")
 
+
+class NoiseStim:
+    """
+    `psychopy.visual.NoiseStim` is now located within the `psychopy-visionscience` plugin. You
+    can find the documentation for it `here
+    <https://psychopy.github.io/psychopy-visionscience/coder/NoiseStim>`_
+    """
+
+
 if __name__ == "__main__":
     pass

psychopy/visual/radial.py

@@ -26,6 +26,14 @@ except (ModuleNotFoundError, ImportError):
         "Support for `RadialStim` is not available this session. Please install "
         "`psychopy-visionscience` and restart the session to enable support.")
 
+
+class RadialStim:
+    """
+    `psychopy.visual.RadialStim` is now located within the `psychopy-visionscience` plugin. You
+    can find the documentation for it `here <https://psychopy.github.io/psychopy-visionscience/coder/RadialStim>`_
+    """
+
+
 if __name__ == "__main__":
     pass
 

psychopy/visual/secondorder.py

@@ -25,5 +25,14 @@ except (ModuleNotFoundError, ImportError):
         "install `psychopy-visionscience` and restart the session to enable "
         "support.")
 
+
+class EnvelopeGrating:
+    """
+    `psychopy.visual.EnvelopeGrating` is now located within the `psychopy-visionscience` plugin. You
+    can find the documentation for it
+    `here <https://psychopy.github.io/psychopy-visionscience/coder/EnvelopeGrating>`_
+    """
+
+
 if __name__ == "__main__":
     pass

psychopy/visual/textbox2/textbox2.py

@@ -79,7 +79,7 @@ class TextBox2(BaseVisualStim, DraggingMixin, ContainerMixin, ColorMixin):
                  bold=False,
                  italic=False,
                  placeholder="Type here...",
-                 lineSpacing=None,
+                 lineSpacing=1.0,
                  letterSpacing=None,
                  padding=None,  # gap between box and text
                  speechPoint=None,
@@ -190,10 +190,11 @@ class TextBox2(BaseVisualStim, DraggingMixin, ContainerMixin, ColorMixin):
         self._pixelScaling = self.letterHeightPix / self.letterHeight
         self.bold = bold
         self.italic = italic
+        if lineSpacing is None:
+            lineSpacing = 1.0
+        self.lineSpacing = lineSpacing
         self.glFont = None  # will be set by the self.font attribute setter
         self.font = font
-        if lineSpacing is not None:
-            self.lineSpacing = lineSpacing
         self.letterSpacing = letterSpacing
         # If font not found, default to Open Sans Regular and raise alert
         if not self.glFont:
@@ -353,7 +354,7 @@ class TextBox2(BaseVisualStim, DraggingMixin, ContainerMixin, ColorMixin):
             self.caret.color = self._foreColor
 
     @attributeSetter
-    def font(self, fontName, italic=False, bold=False):
+    def font(self, fontName):
         if isinstance(fontName, GLFont):
             self.glFont = fontName
             self.__dict__['font'] = fontName.name
@@ -362,7 +363,9 @@ class TextBox2(BaseVisualStim, DraggingMixin, ContainerMixin, ColorMixin):
             self.glFont = allFonts.getFont(
                     fontName,
                     size=self.letterHeightPix,
-                    bold=self.bold, italic=self.italic)
+                    bold=self.bold,
+                    italic=self.italic,
+                    lineSpacing=self.lineSpacing)
 
     @attributeSetter
     def overflow(self, value):
@@ -610,19 +613,6 @@ class TextBox2(BaseVisualStim, DraggingMixin, ContainerMixin, ColorMixin):
         """
         return self._letterHeight.pix[1]
 
-    @property
-    def lineSpacing(self):
-        if hasattr(self.glFont, "lineSpacing"):
-            return self.glFont.lineSpacing
-
-    @lineSpacing.setter
-    def lineSpacing(self, value):
-        if hasattr(self, "_placeholder"):
-            self._placeholder.lineSpacing = value
-        if hasattr(self.glFont, "lineSpacing"):
-            self.glFont.lineSpacing = value
-        self._needVertexUpdate = True
-
     @attributeSetter
     def letterSpacing(self, value):
         """
@@ -930,6 +920,9 @@ class TextBox2(BaseVisualStim, DraggingMixin, ContainerMixin, ColorMixin):
 
                 # are we wrapping the line?
                 if charcode == "\n":
+                    # check if we have stored the top/bottom of the previous line yet
+                    if lineN + 1 > len(_lineBottoms):
+                        _lineBottoms.append(current[1])
                     lineWPix = current[0]
                     current[0] = 0
                     current[1] -= font.height
@@ -1628,6 +1621,8 @@ class Caret(ColorMixin):
             self.index = len(self.textbox._lineNs)
         # Get line of index
         if self.index >= len(self.textbox._lineNs):
+            if len(self.textbox._lineBottoms) - 1 > self.textbox._lineNs[-1]:
+                return len(self.textbox._lineBottoms) - 1
             return self.textbox._lineNs[-1]
         else:
             return self.textbox._lineNs[self.index]
@@ -1718,9 +1713,12 @@ class Caret(ColorMixin):
         else:
             # Otherwise, get caret position from character vertices
             if self.index >= len(textbox._lineNs):
-                # If the caret is after the last char, position it to the right
-                chrVerts = textbox._vertices.pix[range((ii-1) * 4, (ii-1) * 4 + 4)]
-                x = chrVerts[2, 0]  # x-coord of left edge (of final char)
+                if len(textbox._lineBottoms) - 1 > textbox._lineNs[-1]:
+                    x = textbox._lineWidths[len(textbox._lineBottoms) - 1]
+                else:
+                    # If the caret is after the last char, position it to the right
+                    chrVerts = textbox._vertices.pix[range((ii-1) * 4, (ii-1) * 4 + 4)]
+                    x = chrVerts[2, 0]  # x-coord of left edge (of final char)
             else:
                 # Otherwise, position it to the left
                 chrVerts = textbox._vertices.pix[range(ii * 4, ii * 4 + 4)]

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: psychopy
-Version: 2024.1.1
+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>