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

psychopy/platform_specific/linux.py

@@ -29,18 +29,27 @@ if not importCtypesFailed:
     class _SchedParams(ctypes.Structure):
         _fields_ = [('sched_priority', ctypes.c_int)]
 
-warnMax = """Could not raise thread priority with sched_setscheduler.
+# Text that appears at the top of the dialog with provides instructions to the
+# user.
+_introStr = (
+    u"Could not set the thread priority with sched_setscheduler.\n"
+    u"For optimal performance on Linux, Psychtoolbox requires additional\n"
+    u"configuration changes to be made to this system by entering the\n"
+    u"following commands into your terminal:\n\n{cmdstr}"
+)
 
-To enable rush(), if you are using a debian-based Linux, try this:
-  'sudo setcap cap_sys_nice=eip %s'  [NB: install 'setcap' first.]
-If you are using the system's python (eg /usr/bin/python2.x), its highly
-recommended to change cap_sys_nice back to normal afterwards:
-  'sudo setcap cap_sys_nice= %s'"""
-
-warnNormal = ("Failed to set thread priority to normal with "
-              "sched_setscheduler.\n"
-              "Try:  'sudo setcap cap_sys_nice= %s'")
+# config file path
+_confPath = u"/etc/security/limits.d/99-psychopylimits.conf"
 
+# these are the commands we want the user to run in their terminal
+_cmdStr = (
+    u"sudo groupadd --force psychopy\n\n"
+    u"sudo usermod -a -G psychopy $USER\n\n"
+    u"sudo gedit {fpath}\n"
+    u"@psychopy - nice -20\n"
+    u"@psychopy - rtprio 50\n"
+    u"@psychopy - memlock unlimited")
+warnMax = _introStr.format(cmdstr=_cmdStr.format(fpath=_confPath))
 
 def rush(value=True, realtime=False):
     """Raise the priority of the current thread/process using
@@ -48,32 +57,21 @@ def rush(value=True, realtime=False):
 
     realtime arg is not used in Linux implementation.
 
-    NB for rush() to work on (debian-based?) Linux requires that the
-    script is run using a copy of python that is allowed to change
-    priority, eg: sudo setcap cap_sys_nice=eip <sys.executable>,
-    and maybe restart PsychoPy. If <sys.executable> is the system python,
-    it's important to restore it back to normal to avoid possible
-    side-effects. Alternatively, use a different python executable,
-    and change its cap_sys_nice.
+    NB for rush() to work on Linux requires that the script is run by
+    a user with sufficient permissions to raise the priority of a process.
+    In PsychoPy, we suggest adding the user to a group with these permissions.
 
-    For RedHat-based systems, 'sudo chrt ...' at run-time might be
-    needed instead, not sure.
-    see http://rt.et.redhat.com/wiki/images/8/8e/Rtprio.pdf
+    If this function returns `False`, see the log for instructions on how
+    to set up such a group.
     """
     if importCtypesFailed:
         return False
 
-    if value:  # set to RR with max priority
-        schedParams = _SchedParams()
-        schedParams.sched_priority = c.sched_get_priority_max(SCHED_RR)
-        err = c.sched_setscheduler(0, SCHED_RR, ctypes.byref(schedParams))
-        if err == -1:  # returns 0 if OK
-            logging.warning(warnMax % (sys.executable, sys.executable))
-    else:  # set to RR with normal priority
-        schedParams = _SchedParams()
-        schedParams.sched_priority = c.sched_get_priority_min(SCHED_NORMAL)
-        err = c.sched_setscheduler(0, SCHED_NORMAL, ctypes.byref(schedParams))
-        if err == -1:  # returns 0 if OK
-            logging.warning(warnNormal % sys.executable)
+    schedParams = _SchedParams()
+    sched = SCHED_RR if value else SCHED_NORMAL
+    schedParams.sched_priority = c.sched_get_priority_min(sched)
+    err = c.sched_setscheduler(0, sched, ctypes.byref(schedParams))
+    if err == -1:
+        logging.warning(warnMax)
 
-    return True
+    return not err

psychopy/platform_specific/win32.py

@@ -18,10 +18,9 @@
 # define THREAD_PRIORITY_HIGHEST         2
 # define THREAD_PRIORITY_TIME_CRITICAL   15
 
-import os
-
 try:
     from ctypes import windll
+    from ctypes.wintypes import HANDLE, DWORD, BOOL, INT, UINT
     windll = windll.kernel32
     importWindllFailed = False
 except Exception:
@@ -47,6 +46,28 @@ ES_CONTINUOUS = 0x80000000
 ES_DISPLAY_REQUIRED = 0x00000002
 ES_SYSTEM_REQUIRED = 0x00000001
 
+GetCurrentProcessId = windll.GetCurrentProcessId
+GetCurrentProcessId.restype = HANDLE
+
+OpenProcess = windll.OpenProcess
+OpenProcess.restype = HANDLE
+OpenProcess.argtypes = (DWORD, BOOL, DWORD)
+
+GetCurrentThread = windll.GetCurrentThread
+GetCurrentThread.restype = HANDLE
+
+SetPriorityClass = windll.SetPriorityClass
+SetPriorityClass.restype = BOOL
+SetPriorityClass.argtypes = (HANDLE, DWORD)
+
+SetThreadPriority = windll.SetThreadPriority
+SetThreadPriority.restype = BOOL
+SetThreadPriority.argtypes = (HANDLE, INT)
+
+SetThreadExecutionState = windll.SetThreadExecutionState
+SetThreadExecutionState.restype = UINT
+SetThreadExecutionState.argtypes = (UINT,)
+
 
 def rush(enable=True, realtime=False):
     """Raise the priority of the current thread/process.
@@ -62,21 +83,25 @@ def rush(enable=True, realtime=False):
         return False
 
     pr_rights = PROCESS_QUERY_INFORMATION | PROCESS_SET_INFORMATION
-    pr = windll.OpenProcess(pr_rights, FALSE, os.getpid())
+    pr = windll.OpenProcess(pr_rights, FALSE, GetCurrentProcessId())
     thr = windll.GetCurrentThread()
 
-    if enable is True:
-        if realtime is False:
-            windll.SetPriorityClass(pr, HIGH_PRIORITY_CLASS)
-            windll.SetThreadPriority(thr, THREAD_PRIORITY_HIGHEST)
+    # In this context, non-zero is success and zero is error
+    out = 1
+
+    if enable:
+        if not realtime:
+            out = SetPriorityClass(pr, HIGH_PRIORITY_CLASS) != 0
+            out &= SetThreadPriority(thr, THREAD_PRIORITY_HIGHEST) != 0
         else:
-            windll.SetPriorityClass(pr, REALTIME_PRIORITY_CLASS)
-            windll.SetThreadPriority(thr, THREAD_PRIORITY_TIME_CRITICAL)
+            out = SetPriorityClass(pr, REALTIME_PRIORITY_CLASS) != 0
+            out &= SetThreadPriority(thr, THREAD_PRIORITY_TIME_CRITICAL) != 0
 
     else:
-        windll.SetPriorityClass(pr, NORMAL_PRIORITY_CLASS)
-        windll.SetThreadPriority(thr, THREAD_PRIORITY_NORMAL)
-    return True
+        out = SetPriorityClass(pr, NORMAL_PRIORITY_CLASS) != 0
+        out &= SetThreadPriority(thr, THREAD_PRIORITY_NORMAL) != 0
+
+    return out != 0
 
 
 def waitForVBL():
@@ -95,5 +120,5 @@ def sendStayAwake():
     Currently supported on: windows, macOS.
     """
     code = ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED
-    success = windll.SetThreadExecutionState(code)
+    success = SetThreadExecutionState(code)
     return success

psychopy/plugins/__init__.py

@@ -29,20 +29,19 @@ import sys
 import inspect
 import collections
 import hashlib
-import importlib
-import psychopy.tools.pkgtools as pkgtools
-import pkg_resources
-import psychopy.tools.pkgtools as pkgtools
+import importlib, importlib.metadata
 from psychopy import logging
 from psychopy.preferences import prefs
 
-# add the plugins folder to as a distribution location
-try:
-    pkgtools.addDistribution(prefs.paths['packages'])
-except KeyError:
-    # this error likely wont happen unless the prefs are missing keys
-    logging.error('Cannot add plugin directory as distribution location. '
-                  'Plugins will be unavailable this session.')
+# Configure the environment to use our custom site-packages location for
+# user-installed packages (i.e. plugins).
+USER_PACKAGES_PATH = str(prefs.paths['userPackages'])
+# check if we're in a virtual environment or not
+inVenv = hasattr(sys, 'real_prefix') or sys.prefix != sys.base_prefix
+
+# add the plugins folder to the path
+if not inVenv and USER_PACKAGES_PATH not in sys.path:
+    sys.path.insert(0, USER_PACKAGES_PATH)  # add to path
 
 # Keep track of plugins that have been loaded. Keys are plugin names and values
 # are their entry point mappings.
@@ -61,6 +60,40 @@ _failed_plugins_ = []
 # Functions
 #
 
+def getEntryPointGroup(group, subgroups=False):
+    """
+    Get all entry points which target a specific group.
+
+    Parameters
+    ----------
+    group : str
+        Group to look for (e.g. "psychopy.experiment.components" for plugin Components)
+    subgroups : bool
+        If True, then will also look for subgroups (e.g. "psychopy.experiment" will also return
+        entry points for "psychopy.experiment.components")
+
+    Returns
+    -------
+    list[importlib.metadata.Entrypoint]
+        List of EntryPoint objects for the given group
+    """
+    # start off with no entry points or sections
+    entryPoints = []
+
+    if subgroups:
+        # if searching subgroups, iterate through entry point groups
+        for thisGroup, eps in importlib.metadata.entry_points().items():
+            # get entry points within matching group
+            if thisGroup.startswith(group):
+                # add to list of all entry points
+                entryPoints += eps
+    else:
+        # otherwise, just get the requested group
+        entryPoints += importlib.metadata.entry_points().get(group, [])
+
+    return entryPoints
+
+
 def resolveObjectFromName(name, basename=None, resolve=True, error=True):
     """Get an object within a module's namespace using a fully-qualified or
     relative dotted name.
@@ -254,7 +287,7 @@ def getBundleInstallTarget(projectName):
 
     """
     return os.path.join(
-        prefs.paths['packages'], pkg_resources.safe_name(projectName))
+        prefs.paths['packages'], projectName)
 
 
 def refreshBundlePaths():
@@ -285,12 +318,18 @@ def refreshBundlePaths():
     pluginTopLevelDirs = os.listdir(pluginBaseDir)
     for pluginDir in pluginTopLevelDirs:
         fullPath = os.path.join(pluginBaseDir, pluginDir)
-        allDists = pkg_resources.find_distributions(fullPath, only=False)
+        allDists = importlib.metadata.distributions(path=pluginDir)
         if not allDists:  # no packages found, move on
             continue
 
         # does the sud-directory contain an appropriately named distribution?
-        validDist = any([dist.project_name == pluginDir for dist in allDists])
+        validDist = False
+        for dist in allDists:
+            if sys.version.startswith("3.8"):
+                distName = dist.metadata['name']
+            else:
+                distName = dist.name
+            validDist = validDist or distName == pluginDir
         if not validDist:
             continue
 
@@ -301,11 +340,41 @@ def refreshBundlePaths():
         foundBundles.append(pluginDir)
 
     # refresh package index since the working set is now stale
-    pkgtools.refreshPackages()
+    scanPlugins()
 
     return foundBundles
 
 
+def getPluginConfigPath(plugin):
+    """Get the path to the configuration file for a plugin.
+
+    This function returns the path to folder alloted to a plugin for storing
+    configuration files. This is useful for plugins that require user settings
+    to be stored in a file.
+
+    Parameters
+    ----------
+    plugin : str
+        Name of the plugin package to get the configuration file for.
+
+    Returns
+    -------
+    str
+        Path to the configuration file for the plugin.
+
+    """
+    # check if the plugin is installed first
+    if plugin not in _installed_plugins_:
+        raise ValueError("Plugin `{}` is not installed.".format(plugin))
+    
+    # get the config directory
+    import pathlib
+    configDir = pathlib.Path(prefs.paths['configs']) / 'plugins' / plugin
+    configDir.mkdir(parents=True, exist_ok=True)
+
+    return configDir
+
+
 def installPlugin(package, local=True, upgrade=False, forceReinstall=False,
                   noDeps=False):
     """Install a plugin package.
@@ -327,7 +396,8 @@ def installPlugin(package, local=True, upgrade=False, forceReinstall=False,
 
     """
     # determine where to install the package
-    installWhere = getBundleInstallTarget(package) if local else None
+    installWhere = USER_PACKAGES_PATH if local else None
+    import psychopy.tools.pkgtools as pkgtools
     pkgtools.installPackage(
         package, 
         target=installWhere,
@@ -354,30 +424,27 @@ def scanPlugins():
 
     """
     global _installed_plugins_
-    _installed_plugins_ = {}  # clear installed plugins
-
-    refreshBundlePaths()  # refresh plugin bundles directory
-
-    # make sure we have the plugin directory in the working set
-    pluginDir = prefs.paths['packages']
-    if pluginDir not in pkg_resources.working_set.entries:
-        pkg_resources.working_set.add_entry(pluginDir)
-
-    # find all packages with entry points defined
-    pluginEnv = pkg_resources.Environment()  # supported by the platform
-    dists, _ = pkg_resources.working_set.find_plugins(pluginEnv)
-
-    for dist in dists:
-        entryMap = dist.get_entry_map()
-        if any([i.startswith('psychopy') for i in entryMap.keys()]):
-            logging.debug('Found plugin `{}` at location `{}`.'.format(
-                dist.project_name, dist.location))
-            _installed_plugins_[dist.project_name] = entryMap
-
-            # try adding the plugin to the working set
-            if dist.location not in pkg_resources.working_set.entries:
-                pkg_resources.working_set.add(dist)
-
+    _installed_plugins_ = {}  # clear the cache
+    # iterate through installed packages
+    for dist in importlib.metadata.distributions(path=sys.path + [USER_PACKAGES_PATH]):
+        # map all entry points
+        for ep in dist.entry_points:
+            # skip entry points which don't target PsychoPy
+            if not ep.group.startswith("psychopy"):
+                continue
+            # make sure we have an entry for this distribution
+            if sys.version.startswith("3.8"):
+                distName = dist.metadata['name']
+            else:
+                distName = dist.name
+            if distName not in _installed_plugins_:
+                _installed_plugins_[distName] = {}
+            # make sure we have an entry for this group
+            if ep.group not in _installed_plugins_[distName]:
+                _installed_plugins_[distName][ep.group] = {}
+            # map entry point
+            _installed_plugins_[distName][ep.group][ep.name] = ep
+    
     return len(_installed_plugins_)
 
 
@@ -507,51 +574,6 @@ def isStartUpPlugin(plugin):
     return plugin in listPlugins(which='startup')
 
 
-def loadPluginBuilderElements(plugin):
-    """
-    Load entry points from plugin which are relevant to Builder, e.g.
-    Component/Routine extensions for listing available hardware backends.
-
-    Parameters
-    ----------
-    plugin : str
-        Name of the plugin package to load. This usually refers to the package
-        or project name.
-
-    Returns
-    -------
-    bool
-        `True` if successful, `False` if failed.
-    """
-    # if plugin has already failed to load once, don't try again
-    if plugin in _failed_plugins_:
-        return False
-    # get entry points for plugin
-    ep = pluginEntryPoints(plugin)
-    # define modules in which entry points are relevant to Builder
-    modules = (
-        "psychopy.experiment.routines",
-        "psychopy.experiment.components",
-    )
-    # get any points pointing to these modules
-    relevantPoints = []
-    for mod in modules:
-        pts = ep.get(mod, {})
-        relevantPoints += list(pts.values())
-    # import all relevant classes
-    for point in relevantPoints:
-        try:
-            importlib.import_module(point.module_name)
-            return True
-        except:
-            # if import failed for any reason, log error and mark failure
-            logging.error(
-                f"Failed to load {point.module_name}.{point.name} from plugin {plugin}."
-            )
-            _failed_plugins_.append(plugin)
-            return False
-
-
 def loadPlugin(plugin):
     """Load a plugin to extend PsychoPy.
 
@@ -576,10 +598,11 @@ def loadPlugin(plugin):
     will continue running. This may be undesirable in some cases, since features
     the plugin provides may be needed at some point and would lead to undefined
     behavior if not present. If you want to halt the application if a plugin
-    fails to load, consider using :func:`requirePlugin`.
+    fails to load, consider using :func:`requirePlugin` to assert that a plugin
+    is loaded before continuing.
 
     It is advised that you use this function only when using PsychoPy as a
-    library. If using the builder or coder GUI, it is recommended that you use
+    library. If using the Builder or Coder GUI, it is recommended that you use
     the plugin dialog to enable plugins for PsychoPy sessions spawned by the
     experiment runner. However, you can still use this function if you want to
     load additional plugins for a given experiment, having their effects
@@ -694,26 +717,43 @@ def loadPlugin(plugin):
         # that the entry points are valid. This prevents plugins from being
         # partially loaded which can cause all sorts of undefined behaviour.
         for attr, ep in attrs.items():
+            try:
+                # parse the module name from the entry point value
+                if ':' in ep.value:
+                    module_name, _ = ep.value.split(':', 1)
+                else:
+                    module_name = ep.value
+                module_name = module_name.split(".")[0]
+            except ValueError:
+                logging.error(
+                    "Plugin `{}` entry point `{}` is not formatted correctly. "
+                    "Skipping.".format(plugin, ep))
+
+                if plugin not in _failed_plugins_:
+                    _failed_plugins_.append(plugin)
+
+                return False
+
             # Load the module the entry point belongs to, this happens
             # anyways when .load() is called, but we get to access it before
             # we start binding. If the module has already been loaded, don't
             # do this again.
-            if ep.module_name not in sys.modules:
+            if module_name not in sys.modules:
                 # Do stuff before loading entry points here, any executable code
                 # in the module will run to configure it.
                 try:
-                    imp = importlib.import_module(ep.module_name)
+                    imp = importlib.import_module(module_name)
                 except (ModuleNotFoundError, ImportError):
                     importSuccess = False
                     logging.error(
                         "Plugin `{}` entry point requires module `{}`, but it "
-                        "cannot be imported.".format(plugin, ep.module_name))
+                        "cannot be imported.".format(plugin, module_name))
                 except:
                     importSuccess = False
                     logging.error(
                         "Plugin `{}` entry point requires module `{}`, but an "
                         "error occurred while loading it.".format(
-                            plugin, ep.module_name))
+                            plugin, module_name))
                 else:
                     importSuccess = True
 
@@ -742,6 +782,13 @@ def loadPlugin(plugin):
                     # return False
             try:
                 ep = 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):
+                    logging.warning(
+                        "Plugin `{}` is being loaded from a zip file. This may "
+                        "cause issues with the plugin's functionality.".format(plugin))
+
             except ImportError as e:
                 logging.error(
                     "Failed to load entry point `{}` of plugin `{}`. "
@@ -751,21 +798,11 @@ def loadPlugin(plugin):
                 if plugin not in _failed_plugins_:
                     _failed_plugins_.append(plugin)
 
-                return False
-            except pkg_resources.DistributionNotFound:
-                logging.error(
-                    "Failed to load entry point `{}` of plugin `{}` due to "
-                    "missing distribution required by the application."
-                    "Skipping.".format(str(ep), plugin))
-
-                if plugin not in _failed_plugins_:
-                    _failed_plugins_.append(plugin)
-
                 return False
             except Exception:  # catch everything else
                 logging.error(
                     "Failed to load entry point `{}` of plugin `{}` for unknown"
-                    "reasons. Skipping.".format(str(ep), plugin))
+                    " reasons. Skipping.".format(str(ep), plugin))
 
                 if plugin not in _failed_plugins_:
                     _failed_plugins_.append(plugin)
@@ -784,10 +821,16 @@ def loadPlugin(plugin):
             # add the object to the module or unbound class
             setattr(targObj, attr, ep)
             logging.debug(
-                "Assigning to entry point `{}` to `{}`.".format(
+                "Assigning the entry point `{}` to `{}`.".format(
                     ep.__name__, fqn + '.' + attr))
 
             # --- handle special cases ---
+            # Note - We're going to handle special cases here for now, but
+            # this will eventually be handled by special functions in the 
+            # target modules (e.g. `getAllPhotometers()` in 
+            # `psychopy.hardware.photometer`) which can detect the loaded 
+            # attribute inside the module and add it to a collection.
+
             if fqn == 'psychopy.visual.backends':  # if window backend
                 _registerWindowBackend(attr, ep)
             elif fqn == 'psychopy.experiment.components':  # if component
@@ -990,18 +1033,8 @@ def pluginMetadata(plugin):
             "Plugin `{}` is not installed or does not have entry points for "
             "PsychoPy.".format(plugin))
 
-    pkg = pkg_resources.get_distribution(plugin)
-    metadata = pkg.get_metadata(pkg.PKG_INFO)
-
-    metadict = {}
-    for line in metadata.split('\n'):
-        if not line:
-            continue
-
-        line = line.strip().split(': ')
-        if len(line) == 2:
-            field, value = line
-            metadict[field] = value
+    pkg = importlib.metadata.distribution(plugin)
+    metadict = dict(pkg.metadata)
 
     return metadict
 
@@ -1072,7 +1105,6 @@ def activatePlugins(which='all'):
     # load each plugin and apply any changes to Builder
     for plugin in listPlugins(which):
         loadPlugin(plugin)
-        loadPluginBuilderElements(plugin)
 
 
 # Keep track of currently installed window backends. When a window is loaded,

psychopy/plugins/util.py

@@ -0,0 +1,39 @@
+import importlib.metadata
+
+
+def getEntryPoints(module, submodules=True, flatten=True):
+    """
+    Get entry points which target a particular module.
+
+    Parameters
+    ----------
+    module : str
+        Import string for the target module (e.g.
+        `"psychopy.iohub.devices"`)
+    submodules : bool, optional
+        If True, will also get entry points which target a
+        submodule of the given module. By default True.
+    flatten : bool, optional
+        If True, will return a flat list of entry points. If
+        False, will return a dict arranged by target group. By
+        default True.
+    """
+    # start off with a blank list/dict
+    entryPointsList = []
+    entryPointsDict = {}
+    # iterate through groups
+    for group, points in importlib.metadata.entry_points().items():
+        # does this group correspond to the requested module?
+        if submodules:
+            targeted = group.startswith(module)
+        else:
+            targeted = group == module
+        # if group is targeted, add entry points
+        if targeted:
+            entryPointsList += points
+            entryPointsDict[group] = points
+    # return list or dict according to flatten arg
+    if flatten:
+        return entryPointsList
+    else:
+        return entryPointsDict

psychopy/preferences/Darwin.spec

@@ -56,7 +56,7 @@
     # display tips when starting PsychoPy
     showStartupTips = boolean(default='True')
     # what windows to display when PsychoPy starts
-    defaultView = option('builder', 'coder', 'runner', 'all', default='all')
+    defaultView = option('last', 'builder', 'coder', 'runner', 'all', default='last')
     # reset preferences to defaults on next restart of PsychoPy
     resetPrefs = boolean(default='False') # default must be False!
     # save any unsaved preferences before closing the window
@@ -149,8 +149,10 @@
     forceWindowed = boolean(default=True)
     # What window size to use when forced to windowed mode
     forcedWindowSize = list(default=list(800, 600))
-    # How much output to include in the log files when piloting ('error' is fewest messages, 'debug' is most)
+    # How much output to include in the log file when piloting ('error' is fewest messages, 'debug' is most)
     pilotLoggingLevel = option('error', 'warning', 'data', 'exp', 'info', 'debug', default='debug')
+    # How much output to display in the console / app when piloting ('error' is fewest messages, 'debug' is most).
+    pilotConsoleLoggingLevel = option('error', 'warning', 'data', 'exp', 'info', 'debug', default='warning')
     # Show an orange border around the window when in piloting mode
     showPilotingIndicator = boolean(default=True)
     # Prevent experiment from enabling rush mode when piloting

psychopy/preferences/FreeBSD.spec

@@ -56,7 +56,7 @@
     # display tips when starting PsychoPy
     showStartupTips = boolean(default='True')
     # what windows to display when PsychoPy starts
-    defaultView = option('builder', 'coder', 'runner', 'all', default='all')
+    defaultView = option('last', 'builder', 'coder', 'runner', 'all', default='last')
     # reset preferences to defaults on next restart of PsychoPy
     resetPrefs = boolean(default='False') # default must be False!
     # save any unsaved preferences before closing the window
@@ -149,8 +149,10 @@
     forceWindowed = boolean(default=True)
     # What window size to use when forced to windowed mode
     forcedWindowSize = list(default=list(800, 600))
-    # How much output to include in the log files when piloting ('error' is fewest messages, 'debug' is most)
+    # How much output to include in the log file when piloting ('error' is fewest messages, 'debug' is most)
     pilotLoggingLevel = option('error', 'warning', 'data', 'exp', 'info', 'debug', default='debug')
+    # How much output to display in the console / app when piloting ('error' is fewest messages, 'debug' is most).
+    pilotConsoleLoggingLevel = option('error', 'warning', 'data', 'exp', 'info', 'debug', default='warning')
     # Show an orange border around the window when in piloting mode
     showPilotingIndicator = boolean(default=True)
     # Prevent experiment from enabling rush mode when piloting

psychopy/preferences/Linux.spec

@@ -56,7 +56,7 @@
     # display tips when starting PsychoPy
     showStartupTips = boolean(default='True')
     # what windows to display when PsychoPy starts
-    defaultView = option('builder', 'coder', 'runner', 'all', default='all')
+    defaultView = option('last', 'builder', 'coder', 'runner', 'all', default='last')
     # reset preferences to defaults on next restart of PsychoPy
     resetPrefs = boolean(default='False') # default must be False!
     # save any unsaved preferences before closing the window
@@ -149,8 +149,10 @@
     forceWindowed = boolean(default=True)
     # What window size to use when forced to windowed mode
     forcedWindowSize = list(default=list(800, 600))
-    # How much output to include in the log files when piloting ('error' is fewest messages, 'debug' is most)
+    # How much output to include in the log file when piloting ('error' is fewest messages, 'debug' is most)
     pilotLoggingLevel = option('error', 'warning', 'data', 'exp', 'info', 'debug', default='debug')
+    # How much output to display in the console / app when piloting ('error' is fewest messages, 'debug' is most).
+    pilotConsoleLoggingLevel = option('error', 'warning', 'data', 'exp', 'info', 'debug', default='warning')
     # Show an orange border around the window when in piloting mode
     showPilotingIndicator = boolean(default=True)
     # Prevent experiment from enabling rush mode when piloting