psychopy 2024.2.1__py3-none-any.whl → 2024.2.4__py3-none-any.whl

psychopy/iohub/devices/mouse/darwin.py.orig

@@ -0,0 +1,427 @@
+# -*- coding: utf-8 -*-
+# Part of the PsychoPy library
+# Copyright (C) 2012-2020 iSolver Software Solutions (C) 2021 Open Science Tools Ltd.
+# Distributed under the terms of the GNU General Public License (GPL).
+from copy import copy
+import Quartz as Qz
+from AppKit import NSEvent
+
+from . import MouseDevice
+from .. import Keyboard, Computer, Device
+from ...errors import print2err, printExceptionDetailsToStdErr
+from ...constants import EventConstants, MouseConstants
+
+currentSec = Computer.getTime
+
+pressID = [
+    None,
+    Qz.kCGEventLeftMouseDown,
+    Qz.kCGEventRightMouseDown,
+    Qz.kCGEventOtherMouseDown]
+releaseID = [
+    None,
+    Qz.kCGEventLeftMouseUp,
+    Qz.kCGEventRightMouseUp,
+    Qz.kCGEventOtherMouseUp]
+dragID = [
+    None,
+    Qz.kCGEventLeftMouseDragged,
+    Qz.kCGEventRightMouseDragged,
+    Qz.kCGEventOtherMouseDragged]
+
+
+class Mouse(MouseDevice):
+    """The Mouse class and related events represent a standard computer mouse
+    device and the events a standard mouse can produce.
+
+    Mouse position data is mapped to the coordinate space defined in the
+    ioHub configuration file for the Display.
+
+    Examples:
+
+        A. Print all mouse events received for 5 seconds::
+    
+            from psychopy.iohub import launchHubServer
+            from psychopy.core import getTime
+            
+            # Start the ioHub process. 'io' can now be used during the
+            # experiment to access iohub devices and read iohub device events.
+            io = launchHubServer()
+            
+            mouse = io.devices.mouse
+                    
+            # Check for and print any Mouse events received for 5 seconds.
+            stime = getTime()
+            while getTime()-stime < 5.0:
+                for e in mouse.getEvents():
+                    print(e)
+            
+            # Stop the ioHub Server
+            io.quit()
+            
+        B. Print current mouse position for 5 seconds::
+    
+            from psychopy.iohub import launchHubServer
+            from psychopy.core import getTime
+            
+            # Start the ioHub process. 'io' can now be used during the
+            # experiment to access iohub devices and read iohub device events.
+            io = launchHubServer()
+            
+            mouse = io.devices.mouse
+                    
+            # Check for and print any Mouse events received for 5 seconds.
+            stime = getTime()
+            while getTime()-stime < 5.0:
+                print(mouse.getPosition())
+            
+            # Stop the ioHub Server
+            io.quit()
+                
+    """
+    __slots__ = ['_loop_source', '_tap', '_device_loop', '_CGEventTapEnable',
+                 '_loop_mode', '_scrollPositionX']
+
+    _IOHUB_BUTTON_ID_MAPPINGS = {
+        Qz.kCGEventLeftMouseDown: MouseConstants.MOUSE_BUTTON_LEFT,
+        Qz.kCGEventRightMouseDown: MouseConstants.MOUSE_BUTTON_RIGHT,
+        Qz.kCGEventOtherMouseDown: MouseConstants.MOUSE_BUTTON_MIDDLE,
+        Qz.kCGEventLeftMouseUp: MouseConstants.MOUSE_BUTTON_LEFT,
+        Qz.kCGEventRightMouseUp: MouseConstants.MOUSE_BUTTON_RIGHT,
+        Qz.kCGEventOtherMouseUp: MouseConstants.MOUSE_BUTTON_MIDDLE
+    }
+
+    DEVICE_TIME_TO_SECONDS = 0.000000001
+
+    _EVENT_TEMPLATE_LIST = [0,  # experiment id
+                            0,  # session id
+                            0,  # device id
+                            0,  # Device._getNextEventID(),
+                            0,  # ioHub Event type
+                            0.0,  # event device time,
+                            0.0,  # event logged_time,
+                            0.0,  # event iohub Time,
+                            0.0,  # confidence_interval,
+                            0.0,  # delay,
+                            0,  # filtered by ID (always 0 right now)
+                            0,  # Display Index,
+                            0,  # ioHub Button State,
+                            0,  # ioHub Button ID,
+                            0,  # Active Buttons,
+                            0.0,  # x position of mouse in Display device coord's
+                            0.0,  # y position of mouse in Display device coord's
+                            0,  # Wheel dx
+                            0,  # Wheel Absolute x
+                            0,  # Wheel dy
+                            0,  # Wheel Absolute y
+                            0,  # modifiers
+                            0]  # event.Window]
+
+    def __init__(self, *args, **kwargs):
+        MouseDevice.__init__(self, *args, **kwargs['dconfig'])
+
+        self._tap = Qz.CGEventTapCreate(
+            Qz.kCGSessionEventTap,
+            Qz.kCGHeadInsertEventTap,
+            Qz.kCGEventTapOptionDefault,
+            Qz.CGEventMaskBit(Qz.kCGEventMouseMoved) |
+            Qz.CGEventMaskBit(Qz.kCGEventLeftMouseDown) |
+            Qz.CGEventMaskBit(Qz.kCGEventLeftMouseUp) |
+            Qz.CGEventMaskBit(Qz.kCGEventRightMouseDown) |
+            Qz.CGEventMaskBit(Qz.kCGEventRightMouseUp) |
+            Qz.CGEventMaskBit(Qz.kCGEventLeftMouseDragged) |
+            Qz.CGEventMaskBit(Qz.kCGEventRightMouseDragged) |
+            Qz.CGEventMaskBit(Qz.kCGEventOtherMouseDragged) |
+            Qz.CGEventMaskBit(Qz.kCGEventOtherMouseDown) |
+            Qz.CGEventMaskBit(Qz.kCGEventScrollWheel) |
+            Qz.CGEventMaskBit(Qz.kCGEventOtherMouseUp),
+            self._nativeEventCallback,
+            None)
+
+        self._scrollPositionX = 0
+        self._CGEventTapEnable = Qz.CGEventTapEnable
+        self._loop_source = Qz.CFMachPortCreateRunLoopSource(
+            None, self._tap, 0)
+        self._device_loop = Qz.CFRunLoopGetCurrent()
+        self._loop_mode = Qz.kCFRunLoopDefaultMode
+
+        Qz.CFRunLoopAddSource(
+            self._device_loop,
+            self._loop_source,
+            self._loop_mode)
+
+
+    def _initialMousePos(self):
+        """If getPosition is called prior to any mouse events being received,
+        this method gets the current system cursor pos.
+        TODO: Implement OS X version
+        """
+        if self._position is None:
+            self._position = 0.0, 0.0
+            self._lastPosition = 0.0, 0.0
+
+    def _nativeSetMousePos(self, px, py):
+        result = Qz.CGWarpMouseCursorPosition(
+            Qz.CGPointMake(float(px), float(py)))
+        #print2err('_nativeSetMousePos result: ',result)
+
+    #def _nativeGetSystemCursorVisibility(self):
+    #    return Qz.CGCursorIsVisible()
+    #
+    # def _nativeSetSystemCursorVisibility(self, v):
+    #     if v and not Qz.CGCursorIsVisible():
+    #         Qz.CGDisplayShowCursor(Qz.CGMainDisplayID())
+    #     elif not v and Qz.CGCursorIsVisible():
+    #         Qz.CGDisplayHideCursor(Qz.CGMainDisplayID())
+
+    #def _nativeLimitCursorToBoundingRect(self, clip_rect):
+    #    print2err(
+    #        'WARNING: Mouse._nativeLimitCursorToBoundingRect not implemented on OSX yet.')
+    #    native_clip_rect = None
+    #    return native_clip_rect
+
+    def getScroll(self):
+        """
+        TODO: Update docs for OSX
+        Args: None
+        Returns
+        """
+        return self._scrollPositionX, self._scrollPositionY
+
+    def setScroll(self, sp):
+        """
+        TODO: Update docs for OSX
+        """
+        self._scrollPositionX, self._scrollPositionY = sp
+        return self._scrollPositionX, self._scrollPositionY
+
+    def _poll(self):
+        self._last_poll_time = currentSec()
+        while Qz.CFRunLoopRunInMode(self._loop_mode, 0.0, True) == Qz.kCFRunLoopRunHandledSource:
+            pass
+
+    def _nativeEventCallback(self, *args):
+        try:
+            proxy, etype, event, refcon = args
+            if self.isReportingEvents():
+                logged_time = currentSec()
+
+                if etype == Qz.kCGEventTapDisabledByTimeout:
+                    print2err('** WARNING: Mouse Tap Disabled due to timeout. Re-enabling....: ', etype)
+                    Qz.CGEventTapEnable(self._tap, True)
+                    return event
+                else:
+                    confidence_interval = 0.0
+                    delay = 0.0
+                    iohub_time = logged_time
+                    device_time = Qz.CGEventGetTimestamp(event) * self.DEVICE_TIME_TO_SECONDS
+                    ioe_type = EventConstants.UNDEFINED
+                    px, py = Qz.CGEventGetLocation(event)
+                    multi_click_count = Qz.CGEventGetIntegerValueField(event, Qz.kCGMouseEventClickState)
+                    mouse_event = NSEvent.eventWithCGEvent_(event)
+
+                    # TODO: window_handle seems to always be 0.
+                    window_handle = mouse_event.windowNumber()
+
+                    display_index = self.getDisplayIndexForMousePosition((px, py))
+                    if display_index == -1:
+                        if self._last_display_index is not None:
+                            display_index = self._last_display_index
+                        else:
+                            # Do not report event to iohub if it does not map to a display
+                            # ?? Can this ever actually happen ??
+                            return event
+
+<<<<<<< HEAD
+                    enable_multi_window = self.getConfiguration().get('enable_multi_window', False)
+                    if enable_multi_window is False:
+                        px, py = self._display_device._pixel2DisplayCoord(px, py, display_index)
+                    else:
+                        wid, wx, wy = self._desktopToWindowPos((px, py))
+                        if wid:
+                            px, py = self._pix2windowUnits(wid, (wx, wy))
+                            window_handle = wid
+                        else:
+                            window_handle = 0
+
+=======
+#                    result=self._validateMousePosition((px,py),display_index)
+#                    if result != True:
+#                        #print2err("!!! _validateMousePosition made adjustment: {0} to {1}".format((px,py),result))
+#                        nx,ny=result
+#                        display_index=self.getDisplayIndexForMousePosition((nx,ny))
+#                        #print2err("Going to Update mousePosition: {0} => {1} on D {2}".format((px,py),(ny,ny),display_index))
+#                        px,py=nx,ny
+#                        self._nativeSetMousePos(px,py)
+
+                    px, py = self._display_device._pixel2DisplayCoord(
+                        px, py, display_index)
+>>>>>>> release
+                    self._lastPosition = self._position
+                    self._position = px, py
+                    self._last_display_index = self._display_index
+                    self._display_index = display_index
+
+                    # TO DO: Supported reporting scroll x info for OSX.
+                    # This also suggests not having scroll up and down events and
+                    # just having the one scroll event type, regardless of
+                    # direction / dimension
+                    scroll_dx = 0
+                    scroll_dy = 0
+                    button_state = 0
+                    if etype in pressID:
+                        button_state = MouseConstants.MOUSE_BUTTON_STATE_PRESSED
+                        if multi_click_count > 1:
+                            ioe_type = EventConstants.MOUSE_MULTI_CLICK
+                        else:
+                            ioe_type = EventConstants.MOUSE_BUTTON_PRESS
+                    elif etype in releaseID:
+                        button_state = MouseConstants.MOUSE_BUTTON_STATE_RELEASED
+                        ioe_type = EventConstants.MOUSE_BUTTON_RELEASE
+                    elif etype in dragID:
+                        ioe_type = EventConstants.MOUSE_DRAG
+                    elif etype == Qz.kCGEventMouseMoved:
+                        ioe_type = EventConstants.MOUSE_MOVE
+                    elif etype == Qz.kCGEventScrollWheel:
+                        ioe_type = EventConstants.MOUSE_SCROLL
+                        scroll_dy = Qz.CGEventGetIntegerValueField(event, Qz.kCGScrollWheelEventPointDeltaAxis1)
+                        scroll_dx = Qz.CGEventGetIntegerValueField(event, Qz.kCGScrollWheelEventPointDeltaAxis2)
+                        self._scrollPositionX += scroll_dx
+                        self._scrollPositionY += scroll_dy
+
+                    iohub_button_id = self._IOHUB_BUTTON_ID_MAPPINGS.get(etype, 0)
+
+                    if iohub_button_id in self.activeButtons:
+                        abuttons = int(button_state == MouseConstants.MOUSE_BUTTON_STATE_PRESSED)
+                        self.activeButtons[iohub_button_id] = abuttons
+
+                    pressed_buttons = 0
+                    for k, v in self.activeButtons.items():
+                        pressed_buttons += k * v
+
+                    # Create Event List
+                    # index 0 and 1 are session and exp. ID's
+                    # index 2 is (yet to be used) device_id
+                    ioe = self._EVENT_TEMPLATE_LIST
+                    ioe[3] = Device._getNextEventID()
+                    ioe[4] = ioe_type  # event type code
+                    ioe[5] = device_time
+                    ioe[6] = logged_time
+                    ioe[7] = iohub_time
+                    ioe[8] = confidence_interval
+                    ioe[9] = delay
+                    # index 10 is filter id, not used at this time
+                    ioe[11] = display_index
+                    ioe[12] = button_state
+                    ioe[13] = iohub_button_id
+                    ioe[14] = pressed_buttons
+                    ioe[15] = px
+                    ioe[16] = py
+                    ioe[17] = int(scroll_dx)
+                    ioe[18] = int(self._scrollPositionX)
+                    ioe[19] = int(scroll_dy)
+                    ioe[20] = int(self._scrollPositionY)
+                    ioe[21] = Keyboard._modifier_value
+                    ioe[22] = window_handle
+
+                    self._addNativeEventToBuffer(copy(ioe))
+
+                self._last_callback_time = logged_time
+        except Exception:
+            printExceptionDetailsToStdErr()
+            Qz.CGEventTapEnable(self._tap, False)
+
+        # Must return original event or no mouse events will get to OSX!
+        return event
+
+    def _getIOHubEventObject(self, native_event_data):
+        #ioHub.print2err('Event: ',native_event_data)
+        return native_event_data
+
+    def _close(self):
+        #try:
+        #    self._nativeSetSystemCursorVisibility(True)
+        #except Exception:
+        #    pass
+
+        try:
+            Qz.CGEventTapEnable(self._tap, False)
+        except Exception:
+            pass
+
+        try:
+            if Qz.CFRunLoopContainsSource(
+                    self._device_loop,
+                    self._loop_source,
+                    self._loop_mode) is True:
+                Qz.CFRunLoopRemoveSource(
+                    self._device_loop, self._loop_source, self._loop_mode)
+        finally:
+            self._loop_source = None
+            self._tap = None
+            self._device_loop = None
+            self._loop_mode = None
+
+        MouseDevice._close(self)
+# END OF OSX MOUSE CLASS
+
+    """
+    CGEventTapInformation
+    Defines the structure used to report information about event taps.
+    typedef struct CGEventTapInformation
+       {
+       uint32_t            eventTapID;
+       CGEventTapLocation  tapPoint;
+       CGEventTapOptions   options;
+       CGEventMask         eventsOfInterest;
+       pid_t               tappingProcess;
+       pid_t               processBeingTapped;
+       bool                enabled;
+       float               minUsecLatency;
+       float               avgUsecLatency;
+       float               maxUsecLatency;
+    } CGEventTapInformation;
+    Fields
+
+    eventTapID
+    The unique identifier for the event tap.
+
+    tapPoint
+    The location of the event tap. See "Event Tap Locations."
+
+    options
+    The type of event tap (passive listener or active filter).
+
+    eventsOfInterest
+    The mask that identifies the set of events to be observed.
+
+    tappingProcess
+    The process ID of the application that created the event tap.
+
+    processBeingTapped
+    The process ID of the target application (non-zero only if the
+    event tap was created using the function CGEventTapCreateForPSN.
+
+    enabled
+    TRUE if the event tap is currently enabled; otherwise FALSE.
+
+    minUsecLatency
+    Minimum latency in microseconds. In this data structure,
+    latency is defined as the time in microseconds it takes
+    for an event tap to process and respond to an event passed to it.
+
+    avgUsecLatency
+    Average latency in microseconds. This is a weighted average
+    that gives greater weight to more recent events.
+
+    maxUsecLatency
+    Maximum latency in microseconds.
+
+    Discussion
+    To learn how to obtain information about event taps, see the
+    function CGGetEventTapList.
+    Availability
+    Available in OS X v10.4 and later.
+    Declared In
+    CGEventTypes.h
+    """

psychopy/iohub/devices/mouse/linux2.py.orig

@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+# Part of the PsychoPy library
+# Copyright (C) 2012-2020 iSolver Software Solutions (C) 2021 Open Science Tools Ltd.
+# Distributed under the terms of the GNU General Public License (GPL).
+
+from ctypes import cdll
+
+from . import MouseDevice
+from .. import Keyboard, Computer, Device, xlib
+from ...constants import MouseConstants
+from ...errors import print2err, printExceptionDetailsToStdErr
+
+currentSec = Computer.getTime
+
+
+class Mouse(MouseDevice):
+    """The Mouse class and related events represent a standard computer mouse
+    device and the events a standard mouse can produce.
+
+    Mouse position data is mapped to the coordinate space defined in the
+    ioHub configuration file for the Display.
+
+    """
+
+    _xdll = None
+    _xfixsdll = None
+    _xdisplay = None
+    _xscreen_count = None
+
+    __slots__ = ['_cursorVisible']
+
+    def __init__(self, *args, **kwargs):
+        MouseDevice.__init__(self, *args, **kwargs['dconfig'])
+
+        self._cursorVisible = True
+
+        if Mouse._xdll is None:
+            try:
+                Mouse._xdll = cdll.LoadLibrary('libX11.so')
+                try:
+                    # should use linux cmd:
+                    # find /usr/lib -name libXfixes.so\*
+                    # to find full path to the lib (if it exists)
+                    #
+                    Mouse._xfixsdll = cdll.LoadLibrary('libXfixes.so')
+                except Exception:
+                    try:
+                        Mouse._xfixsdll = cdll.LoadLibrary(
+                            'libXfixes.so.3.1.0')
+                    except Exception:
+                        print2err(
+                            'ERROR: Mouse._xfixsdll is None. libXfixes.so could not be found')
+            except Exception:
+                print2err(
+                    'ERROR: Mouse._xdll is None. libX11.so could not be found')
+
+        Mouse._xdisplay = xlib.XOpenDisplay(None)
+        Mouse._xscreen_count = xlib.XScreenCount(Mouse._xdisplay)
+
+        if Mouse._xfixsdll and self._xdll and self._display_device and self._display_device._xwindow is None:
+            self._display_device._xwindow = self._xdll.XRootWindow(
+                Mouse._xdisplay, self._display_device.getIndex())
+
+
+    def _initialMousePos(self):
+        """If getPosition is called prior to any mouse events being received,
+        this method gets the current system cursor pos.
+        TODO: Implement Linux version
+        """
+        if self._position is None:
+            self._position = 0.0, 0.0
+            self._lastPosition = 0.0, 0.0
+
+    def _nativeSetMousePos(self, px, py):
+        Mouse._xdll.XWarpPointer(
+            Mouse._xdisplay,
+            None,
+            self._display_device._xwindow,
+            0,
+            0,
+            0,
+            0,
+            int(px),
+            int(py))
+        Mouse._xdll.XFlush(Mouse._xdisplay)
+
+<<<<<<< HEAD
+=======
+    #def _nativeGetSystemCursorVisibility(self):
+    #    return self._cursorVisible
+
+    # def _nativeSetSystemCursorVisibility(self, v):
+    #     if Mouse._xfixsdll is None:
+    #         print2err(
+    #             'Xfixes DLL could not be loaded. Cursor visibility support is unavailable.')
+    #         return True
+    #
+    #     if v is True and self._nativeGetSystemCursorVisibility() is False:
+    #         Mouse._xfixsdll.XFixesShowCursor(
+    #             Mouse._xdisplay, self._display_device._xwindow)
+    #         Mouse._xfixsdll.XFlush(Mouse._xdisplay)
+    #         self._cursorVisible = True
+    #     elif v is False and self._nativeGetSystemCursorVisibility() is True:
+    #         Mouse._xfixsdll.XFixesHideCursor(
+    #             Mouse._xdisplay, self._display_device._xwindow)
+    #         Mouse._xfixsdll.XFlush(Mouse._xdisplay)
+    #         self._cursorVisible = False
+    #
+    #     return self._nativeGetSystemCursorVisibility()
+
+    #def _nativeLimitCursorToBoundingRect(self, clip_rect):
+    #    print2err(
+    #        'WARNING: Mouse._nativeLimitCursorToBoundingRect not implemented on Linux yet.')
+    #    native_clip_rect = None
+    #    return native_clip_rect
+
+>>>>>>> release
+    def _nativeEventCallback(self, event):
+        try:
+            if self.isReportingEvents():
+                logged_time = currentSec()
+                event_array = event[0]
+
+                psychowins = self._iohub_server._psychopy_windows.keys()
+                report_all = self.getConfiguration().get('report_system_wide_events', True)
+                if report_all is False and psychowins and event_array[-1] not in psychowins:
+                    return True
+
+                event_array[3] = Device._getNextEventID()
+
+                display_index = self.getDisplayIndexForMousePosition((event_array[15], event_array[16]))
+                if display_index == -1:
+                    if self._last_display_index is not None:
+                        display_index = self._last_display_index
+                    else:
+                        # Do not report event to iohub if it does not map to a display
+                        # ?? Can this ever actually happen ??
+                        return True
+
+                enable_multi_window = self.getConfiguration().get('enable_multi_window', False)
+                if enable_multi_window is False:
+                    # convert mouse position to psychopy window coord space
+                    display_index = self._display_device.getIndex()
+                    x, y = self._display_device._pixel2DisplayCoord(event_array[15], event_array[16], display_index)
+                    event_array[15] = x
+                    event_array[16] = y
+                else:
+                    wid, wx, wy = self._desktopToWindowPos((event_array[15], event_array[16]))
+                    if wid:
+                        wx, wy = self._pix2windowUnits(wid, (wx, wy))
+                        event_array[15], event_array[16] = x, y = wx, wy
+                        event_array[-1] = wid
+                    else:
+                        event_array[-1] = 0
+                        x = event_array[15]
+                        y = event_array[16]
+
+                event_array[-2] = Keyboard._modifier_value
+                self._lastPosition = self._position
+                self._position = x, y
+
+                event_array[11] = display_index
+                self._last_display_index = self._display_index
+                self._display_index = display_index
+
+                bstate = event_array[-11]
+                bnum = event_array[-10]
+
+                if bnum is not MouseConstants.MOUSE_BUTTON_NONE:
+                    self.activeButtons[bnum] = int(bstate)
+
+                self._scrollPositionY = event_array[-3]
+
+                self._addNativeEventToBuffer(event_array)
+
+                self._last_callback_time = logged_time
+        except Exception:
+            printExceptionDetailsToStdErr()
+        return True
+
+    def _getIOHubEventObject(self, native_event_data):
+        return native_event_data
+
+    def _close(self):
+        if Mouse._xdll:
+            #if Mouse._xfixsdll and self._nativeGetSystemCursorVisibility() is False:
+            #    Mouse._xfixsdll.XFixesShowCursor(
+            #        Mouse._xdisplay, self._display_device._xwindow)
+            Mouse._xdll.XCloseDisplay(Mouse._xdisplay)
+            Mouse._xdll = None
+            Mouse._xfixsdll = None
+            Mouse._xdisplay = None
+            Mouse._xscreen_count = None
+
+            try:
+                self._display_device._xwindow = None
+            except Exception:
+                pass

psychopy/projects/pavlovia.py

@@ -1208,12 +1208,19 @@ class PavloviaProject(dict):
         None
         """
         localConfig = self.repo.git.config(l=True, local=True)  # list local
-        if self.session.user['email'] in localConfig:
-            return  # we already have it set up so can return
         # set the local config
-        with self.repo.config_writer() as config:
+        config = self.repo.config_writer()
+        # set config values if the user hasn't set them already
+        # the -100 hack is because ConfigParser.get_value allows setting a default
+        # but doing try...except on its custom errors is annoying!
+        if config.get_value("user", "email", default=-100) == -100:
             config.set_value("user", "email", self.session.user['email'])
             config.set_value("user", "name", self.session.user['name'])
+        if config.get_value("pull", "rebase", default=-100) == -100:
+            config.set_value("pull", "rebase", False)
+        if config.get_value("http", "postBuffer", default=-100) == -100:
+            config.set_value("http", "postBuffer", 524288000)
+        config.release()  # saves the changes (not needed if using `with config_writer() as config`)
 
     def fork(self, to=None):
         # Sub in current user if none given