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

psychopy/monitors/MonitorCenter.py

@@ -372,28 +372,6 @@ class MainFrame(wx.Frame):
         calibBox = wx.StaticBoxSizer(boxLabel)
 
         photometerBox = wx.FlexGridSizer(cols=2, hgap=6, vgap=6)
-        # com port entry number
-        self.comPortLabel = wx.StaticText(parent, -1, " ", size=(150, 20))
-        # photometer button
-        # photom type choices should not need localization:
-        self._photomTypeItems = list([p.longName for p in hardware.getAllPhotometers()] + ["Get more..."])
-        self.ctrlPhotomType = wx.Choice(parent, -1, name="Type:",
-                                        choices=self._photomTypeItems)
-
-        _ports = list(hardware.getSerialPorts())
-        self._photomChoices = [_translate("Scan all ports")] + _ports
-        _size = self.ctrlPhotomType.GetSize() + [0, 5]
-        self.ctrlPhotomPort = wx.ComboBox(parent, -1, name="Port:",
-                                          value=self._photomChoices[0],
-                                          choices=self._photomChoices,
-                                          size=_size)
-
-        self.ctrlPhotomType.Bind(wx.EVT_CHOICE, self.onChangePhotomType)
-        self.btnFindPhotometer = wx.Button(parent, -1,
-                                           _translate("Get Photometer"))
-        self.Bind(wx.EVT_BUTTON,
-                  self.onBtnFindPhotometer, self.btnFindPhotometer)
-
         # gamma controls
         self.btnCalibrateGamma = wx.Button(
             parent, -1, _translate("Gamma Calibration..."))
@@ -419,12 +397,11 @@ class MainFrame(wx.Frame):
             parent, -1, _translate("Plot spectra"))
         self.Bind(wx.EVT_BUTTON,
                   self.plotSpectra, self.btnPlotSpectra)
-        photometerBox.AddMany([self.ctrlPhotomType, self.btnFindPhotometer,
-                               self.ctrlPhotomPort, (0, 0),
-                               self.comPortLabel, (0, 0),
-                               self.btnCalibrateGamma, (0, 0),
-                               self.btnTestGamma, self.btnPlotGamma,
-                               self.btnCalibrateColor, self.btnPlotSpectra])
+        photometerBox.AddMany([
+            self.btnCalibrateGamma, (0, 0),
+            self.btnTestGamma, self.btnPlotGamma,
+            self.btnCalibrateColor, self.btnPlotSpectra
+        ])
 
         # ----GAMMA------------
         # calibration grid
@@ -787,54 +764,56 @@ class MainFrame(wx.Frame):
         self.unSavedMonitor = True
 
     def onCalibGammaBtn(self, event):
-        if NO_MEASUREMENTS:
-            # recalculate from previous measure
-            lumsPre = self.currentMon.getLumsPre()
-            lumLevels = self.currentMon.getLevelsPre()
-        else:
-            # present a dialogue to get details for calibration
-            calibDlg = GammaDlg(self, self.currentMon)
-            if calibDlg.ShowModal() != wx.ID_OK:
-                calibDlg.Destroy()
-                return 1
-            nPoints = int(calibDlg.ctrlNPoints.GetValue())
-            stimSize = unicodeToFloat(calibDlg.ctrlStimSize.GetValue())
-            useBits = calibDlg.ctrlUseBits.GetValue()
-            calibDlg.Destroy()
-            autoMode = calibDlg.methodChoiceBx.GetStringSelection()
-            # lib starts at zero but here we allow 1
-            screen = int(calibDlg.ctrlScrN.GetValue()) - 1
+        from psychopy.hardware import monitor, DeviceManager
+        from psychopy.visual import Window
 
-            # run the calibration itself
-            lumLevels = monitors.DACrange(nPoints)
-            _size = self.currentMon.getSizePix()
-            lumsPre = monitors.getLumSeries(photometer=self.photom,
-                                            lumLevels=lumLevels,
-                                            useBits=useBits,
-                                            autoMode=autoMode,
-                                            winSize=_size,
-                                            stimSize=stimSize,
-                                            monitor=self.currentMon,
-                                            screen=screen)
-
-            # allow user to type in values
-            if autoMode == 'semi':
-                inputDlg = GammaLumValsDlg(parent=self, levels=lumLevels)
-                lumsPre = inputDlg.show()  # will be [] if user cancels
-                inputDlg.Destroy()
-
-        # fit the gamma curves
-        if lumsPre is None or len(lumsPre) > 1:
-            self.onCopyCalib(1)  # create a new dated calibration
-            self.currentMon.setLumsPre(lumsPre)  # save for future
-            self.currentMon.setLevelsPre(lumLevels)  # save for future
-            self.btnPlotGamma.Enable(True)
-            self.choiceLinearMethod.Enable()
-
-            # do the fits
-            self.doGammaFits(lumLevels, lumsPre)
+        # get calibration setup params
+        dlg = CalibrationSetupDlg(self)
+        if dlg.ShowModal() == wx.ID_OK:
+            params = dlg.getParams()
         else:
-            logging.warning('No lum values captured/entered')
+            # abort if cancelled
+            return
+        
+        # setup calibration procedure window
+        win = Window(
+            screen=int(params['screen']), 
+            checkTiming=False,
+            fullscr=True
+        )
+        # setup calibration procedure device
+        device = None
+        for profile in DeviceManager.getAvailableDevices(params['photometer']):
+            # instantiate from profile
+            device = DeviceManager.addDevice(**profile)
+            break
+        # catch error if no device found
+        if device is None:
+            win.close()
+            wx.MessageBox(
+                "Could not find any device matching '{photometer}', aborting calibration.".format(**params), 
+                parent=self,
+                style=wx.ICON_ERROR | wx.OK
+            )
+            return
+        
+        # run calibration
+        try:
+            gammaGrid = monitor.calibrateGamma(
+                win,
+                profile['deviceName'],
+                patchSize=float(params['patchSize']),
+                nPoints=float(params['nPoints'])
+            )
+        except Exception as err:
+            win.close()
+            raise err
+        # if gamma was got, set values
+        if gammaGrid is not None:
+            self.gammaGrid.setData(numpy.array(gammaGrid))
+        # teardown
+        win.close()
+        DeviceManager.removeDevice(profile['deviceName'])
 
     def doGammaFits(self, levels, lums):
         linMethod = self.currentMon.getLinearizeMethod()
@@ -1102,6 +1081,127 @@ class MainFrame(wx.Frame):
         plotWindow.addCanvas(figureCanvas)
 
 
+class CalibrationSetupDlg(wx.Dialog):
+    """
+    Dialog getting params for a gamma calibration, which also runs said calibration
+    """
+    def __init__(self, parent):
+        from psychopy.app.builder.validators import WarningManager
+        from psychopy.experiment.params import Param
+        from psychopy.app.builder.dialogs.paramCtrls import ParamCtrl, EVT_PARAM_CHANGED
+
+        wx.Dialog.__init__(
+            self, 
+            parent, 
+            title=_translate("Calibrate gamma"),
+            style=wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER
+        )
+        # setup sizer
+        self.border = wx.BoxSizer(wx.VERTICAL)
+        self.SetSizer(self.border)
+        self.sizer = wx.BoxSizer(wx.VERTICAL)
+        self.border.Add(
+            self.sizer, border=12, proportion=1, flag=wx.EXPAND | wx.ALL
+        )
+        # create warnings handler
+        self.warnings = WarningManager(self)
+        # define params
+        self.params = {}
+        self.params['screen'] = Param(
+            1, valType="code", inputType="single",
+            label=_translate("Screen"),
+            hint=_translate(
+                "Screen to run the calibration on"
+            )
+        )
+        def getPhotometers():
+            from psychopy.experiment.monitor import BasePhotometerDeviceBackend
+            from psychopy.preferences import prefs
+            # start with nothing
+            devices = [(None, "")]
+            # iterate through known photometer device backends
+            for cls in BasePhotometerDeviceBackend.__subclasses__():
+                # add their device class against their label
+                devices.append(
+                    (cls.deviceClass, cls.backendLabel)
+                )
+            
+            return devices
+        def getPhotometerValues():
+            return [val[0] for val in getPhotometers()]
+        def getPhotometerLabels():
+            return [val[1] for val in getPhotometers()]
+        self.params['photometer'] = Param(
+            getPhotometerValues()[0], valType="str", inputType="choice", 
+            allowedVals=getPhotometerValues, allowedLabels=getPhotometerLabels,
+            label=_translate("Photometer"),
+            hint=_translate(
+                "Photometer device, from the device manager, to use for this calibration"
+            )
+        )
+        self.params['patchSize'] = Param(
+            0.3, valType="code", inputType="single",
+            label=_translate("Patch size"),
+            hint=_translate(
+                "How much of the screen (0-1) the calibration patch should occupy"
+            )
+        )
+        self.params['nPoints'] = Param(
+            8, valType="code", inputType="single", 
+            label=_translate("Calibration points"),
+            hint=_translate(
+                "How many calibration points to use"
+            )
+        )
+        # add param ctrls
+        self.paramCtrls = {}
+        for key, param in self.params.items():
+            # add label
+            lbl = wx.StaticText(
+                self, label=param.label
+            )
+            self.sizer.Add(
+                lbl, border=6, flag=wx.EXPAND | wx.LEFT | wx.TOP | wx.RIGHT
+            )
+            # add ctrl
+            self.paramCtrls[key] = ParamCtrl(
+                self, 
+                'photometer', 
+                param, 
+                element=None, 
+                warnings=self.warnings
+            )
+            self.sizer.Add(
+                self.paramCtrls[key], border=6, flag=wx.EXPAND | wx.ALL
+            )
+        # add 
+        self.paramCtrls['photometer'].Bind(EVT_PARAM_CHANGED, self.onPhotometerChosen)
+        # add buttons
+        btns = self.CreateStdDialogButtonSizer(flags=wx.OK | wx.CANCEL)
+        self.border.Add(
+            btns, border=6, flag=wx.EXPAND | wx.ALL
+        )
+        for btn in btns.GetChildren():
+            if btn.Window is not None and btn.Window.Id == wx.ID_OK:
+                self.okBtn = btn.Window
+        # start off with OK disabled
+        self.okBtn.Disable()
+
+        self.Layout()
+        self.Fit()
+    
+    def onPhotometerChosen(self, evt=None):
+        self.okBtn.Enable(
+            bool(self.paramCtrls['photometer'].getValue())
+        )
+    
+    def getParams(self):
+        return {
+            key: ctrl.getValue() 
+            for key, ctrl in self.paramCtrls.items()
+        }
+
+
 class GammaLumValsDlg(wx.Dialog):
     """A dialogue to manually get the luminance values recorded for each level
     """

psychopy/plugins/__init__.py

@@ -437,7 +437,7 @@ def scanPlugins():
             if not ep.group.startswith("psychopy"):
                 continue
             # make sure we have an entry for this distribution
-            if sys.version.startswith("3.8"):
+            if sys.version.startswith("3.8") or sys.version.startswith("3.9"):
                 distName = dist.metadata['name']
             else:
                 distName = dist.name
@@ -789,10 +789,10 @@ def loadPlugin(plugin):
                 f"Registering entry point {ep.value} (from {plugin}) to {ep.group}:{ep.name}"
             )
             try:
-                ep = ep.load()  # load the entry point
+                mod = ep.load()  # load the entry point
 
                 # Raise a warning if the plugin is being loaded from a zip file.
-                if '.zip' in inspect.getfile(ep):
+                if '.zip' in inspect.getfile(mod):
                     logging.warning(
                         "Plugin `{}` is being loaded from a zip file. This may "
                         "cause issues with the plugin's functionality.".format(plugin))
@@ -801,7 +801,7 @@ def loadPlugin(plugin):
                 msg = f"Skipping entry point {ep.value} (from {plugin}) to {ep.group}:{ep.name}"
                 # append reason
                 if isinstance(err, ImportError):
-                    msg += f" as {ep.value} cannot be imported."
+                    msg += f" as {ep.value} cannot be imported ({err})."
                 else:
                     msg += f", reason: {err}"
                 # log message
@@ -811,6 +811,8 @@ def loadPlugin(plugin):
                     _failed_plugins_.append(plugin)
 
                 continue
+            else:
+                ep = mod
 
             # If we get here, the entry point is valid and we can safely add it
             # to PsychoPy's namespace.

psychopy/preferences/devices.py

@@ -0,0 +1,80 @@
+import importlib
+import json
+from pathlib import Path
+
+
+class DeviceConfig(dict):
+    """
+    Dict linked to a JSON file, used to store configuration parameters for devices in the Device 
+    Manager.
+
+    Parameters
+    ----------
+    file : str or pathlib.Path
+        JSON file this dict is linked to
+    """
+    def __init__(self, file):
+        # load file on init
+        self.load(file)
+    
+    def copy(self):
+        """
+        Create a copy of this DeviceConfig, linked to the same file. Useful for making temporary 
+        changes which can then be made permenant by calling `save`
+
+        Returns
+        -------
+        DeviceConfig
+            A new DeviceConfig loaded from the same file as this one.
+        """
+        return DeviceConfig(self.file)
+    
+    def reload(self):
+        """
+        Load this DeviceConfig again from its file, overwriting any local changes. Useful if you 
+        have made and saved changes in a copy and want to make sure this DeviceConfig object 
+        is up to date with the file.
+        """
+        self.load(self.file)
+    
+    def load(self, file):
+        """
+        Load configuration from a given file. Doing so will also set the file that this 
+        DeviceConfig object is linked to.
+
+        Parameters
+        ----------
+        file : str or pathlib.Path
+            JSON file to load from
+        """
+        # start off empty
+        self.clear()
+        # store file path
+        self.file = Path(file)
+        # read file
+        data = json.loads(
+            self.file.read_text()
+        )
+        # apply
+        for key, val in data.items():
+            # get class from stored data
+            mod = ".".join(
+                val['__cls__'].split(".")[:-1]
+            )
+            name = val['__cls__'].split(".")[-1]
+            cls = getattr(importlib.import_module(mod), name)
+            # initialise class with profile from stored data
+            self[key] = cls.fromJSON(val)
+            # make sure device name and device key line up
+            self[key].name = key
+    
+    def save(self):
+        """
+        Save the contents of this DeviceConfig object to its linked JSON file.
+        """
+        # save
+        self.file.write_text(
+            json.dumps({
+                key: device.toJSON() for key, device in self.items()
+            }, indent=True)
+        )

psychopy/preferences/generateHints.py

@@ -11,6 +11,7 @@ import sys
 from psychopy import core
 
 write_mode = 'w'
+new_line = '\n'
 
 hintsFile = 'hints.py'
 comments_all = []
@@ -68,7 +69,7 @@ for specfile in specfiles:
 
 # Output hint.py
 try:
-    fp = open(hintsFile, write_mode)
+    fp = open(hintsFile, write_mode, newline=new_line)
     fp.write('#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n')
     fp.write('# This file was generated by generateHints.py.\n')
     fp.write('# Following strings are used to localize hints in '

psychopy/preferences/preferences.py

@@ -7,6 +7,7 @@ import sys
 import platform
 from pathlib import Path
 from psychopy import logging
+from . import devices
 from .. import __version__
 
 from packaging.version import Version
@@ -71,7 +72,7 @@ class Preferences:
         self.paths = {}  # this will remain a dictionary
         self.keys = {}  # does not remain a dictionary
 
-        self.getPaths()
+        # Only call loadAll, which will handle getPaths
         self.loadAll()
         # setting locale is now handled in psychopy.localization.init
         # as called upon import by the app
@@ -101,7 +102,7 @@ class Preferences:
             print(msg % userCfg)
         self.loadAll()  # reloads, now getting all from .spec
 
-    def getPaths(self):
+    def getPaths(self, userDir=None):
         """Get the paths to various directories and files used by PsychoPy.
 
         If the paths are not found, they are created. Usually, this is only
@@ -130,6 +131,7 @@ class Preferences:
         self.paths['resources'] = dirResources
         self.paths['assets'] = join(dirPsychoPy, "assets")
         self.paths['tests'] = join(dirPsychoPy, 'tests')
+        self.paths['scripts'] = join(dirPsychoPy, 'scripts')
         # path to libs/frameworks
         if 'PsychoPy.app/Contents' in exePath:
             self.paths['libs'] = exePath.replace("MacOS/python", "Frameworks")
@@ -139,16 +141,25 @@ class Preferences:
             # if there isn't an app folder at all then this is a lib-only psychopy
             # so don't try to load app prefs etc
             NO_APP = True
+        # get user dir
+        if userDir is not None and os.path.isdir(userDir):
+            self.paths['userPrefsDir'] = join(
+                userDir, '.psychopy3'
+            )
+        elif sys.platform == 'win32':
+            self.paths['userPrefsDir'] = join(
+                os.environ['APPDATA'], 'psychopy3'
+            )
+        else:
+            self.paths['userPrefsDir'] = join(
+                os.environ['HOME'], '.psychopy3'
+            )
+        # get system-appropriate spec file
         if sys.platform == 'win32':
             self.paths['prefsSpecFile'] = join(prefSpecDir, 'Windows.spec')
-            self.paths['userPrefsDir'] = join(os.environ['APPDATA'],
-                                              'psychopy3')
         else:
-            self.paths['prefsSpecFile'] = join(prefSpecDir,
-                                               platform.system() + '.spec')
-            self.paths['userPrefsDir'] = join(os.environ['HOME'],
-                                              '.psychopy3')
-
+            self.paths['prefsSpecFile'] = join(
+                prefSpecDir, platform.system() + '.spec')
         # directory for files created by the app at runtime needed for operation
         self.paths['userCacheDir'] = join(self.paths['userPrefsDir'], 'cache')
 
@@ -175,7 +186,10 @@ class Preferences:
             except OSError as err:
                 if err.errno != errno.EEXIST:
                     raise
-
+        # make sure there's a device manager config file
+        deviceCfgFile = self.paths['deviceCfgFile'] = Path(self.paths['userPrefsDir']) / "devices.json"
+        if not deviceCfgFile.is_file():
+            deviceCfgFile.write_text("{}", encoding="utf-8")
         # site-packages root directory for user-installed packages
         userPkgRoot = Path(self.paths['packages'])
 
@@ -268,9 +282,10 @@ class Preferences:
                     Path(self.paths['themes']) / file.name
                 )
 
-    def loadAll(self):
+    def loadAll(self, userDir=None):
         """Load the user prefs and the application data
         """
+        self.getPaths(userDir=userDir)
         self._validator = validate.Validator()
 
         # note: self.paths['userPrefsDir'] gets set in loadSitePrefs()
@@ -340,6 +355,15 @@ class Preferences:
             cfg.write()
         
         return cfg
+    
+    @property
+    def devices(self):
+        if not hasattr(self, "_devices"):
+            self._devices = devices.DeviceConfig(
+            self.paths['deviceCfgFile']
+        )
+        
+        return self._devices
 
     def saveUserPrefs(self):
         """Validate and save the various setting to the appropriate files