CreativePython 1.1.3__py3-none-any.whl → 1.1.5__py3-none-any.whl

CreativePython/GuiHandler.py

@@ -66,37 +66,58 @@ def _createEvent(eventType, target, args=None):
 # Child process entry point
 #######################################################################################
 
-def _launchRenderer(childConn, adminChildConn, adminParentConn):
+def _launchRenderer(childCommandConnection, childPriorityConnection, parentPriorityConnection):
    """
    Entry point for the GuiRenderer child process.
    Defined here so GuiHandler can reference it without importing from GuiRenderer
    globally (which would also import Qt/PySide6 in the parent process).
 
-   adminChildConn is the child end of the duplex admin pipe; the child watches it
+   childPriorityConnection is the child end of the duplex admin pipe; the child watches it
    with QSocketNotifier.  Admin commands (setRate, getRate) arrive here, bypassing
-   the command buffer.  When the parent closes its end (adminParentConn), the child
+   the command buffer.  When the parent closes its end (parentPriorityConnection), the child
    receives EOF and initiates shutdown.
 
-   adminParentConn is the parent's end; the child closes it immediately so that
+   parentPriorityConnection is the parent's end; the child closes it immediately so that
    only the parent holds it — ensuring the child sees EOF when the parent closes.
 
    At runtime this function only executes in the child process.
    """
-   import sys, os
-
-   adminParentConn.close()   # child must not hold the parent end open
-
-   # Suppress macOS system noise that would confuse students.
-   # Redirect at the OS level (fd 2) so that
-   # C-level libraries (Cocoa, XPC) are also silenced.
-   _devnull = os.open(os.devnull, os.O_WRONLY)
-   os.dup2(_devnull, 2)
-   os.close(_devnull)
-   sys.stderr = open(os.devnull, 'w')
-
-   from CreativePython.GuiRenderer import GuiRenderer
-   renderer = GuiRenderer(childConn, adminChildConn)
-   renderer.run()
+   import sys, os, traceback
+
+   parentPriorityConnection.close()   # child must not hold the parent end open
+
+   # Set to True to redirect stderr to PENCIL_debug.log for diagnostics.
+   # When False, stderr is silenced (sent to /dev/null) to suppress Qt/Cocoa noise.
+   _DEBUG_LOG = False
+
+   if _DEBUG_LOG:
+      # Redirect stderr (fd 2) to a log file so both Python tracebacks and C-level
+      # output from Qt/Cocoa/XPC are captured for diagnostics.
+      # The log is removed on clean exit if nothing was written to it.
+      _logPath = os.path.join(os.getcwd(), "PENCIL_debug.log")
+      _logFile = open(_logPath, "w")
+   else:
+      _logPath = None
+      _logFile = open(os.devnull, "w")
+
+   os.dup2(_logFile.fileno(), 2)
+   sys.stderr = _logFile
+
+   try:
+      from CreativePython.GuiRenderer import GuiRenderer
+      renderer = GuiRenderer(childCommandConnection, childPriorityConnection)
+      renderer.run()
+   except Exception:
+      traceback.print_exc()
+      raise
+   finally:
+      _logFile.flush()
+      if _DEBUG_LOG and _logPath and os.path.getsize(_logPath) == 0:
+         try:
+            _logFile.close()
+            os.unlink(_logPath)
+         except OSError:
+            pass
 
 
 #######################################################################################
@@ -119,8 +140,8 @@ class GuiHandler:
       Registers an atexit handler so the child is always cleaned up when
       the parent process exits — no cleanup code required in gui.py.
       """
-      parentConn, childConn = multiprocessing.Pipe(duplex=True)
-      self.connection = parentConn
+      parentCommandConnection, childCommandConnection = multiprocessing.Pipe(duplex=True)
+      self.connection = parentCommandConnection
 
       # Choose the spawn context based on the runtime environment:
       #
@@ -157,13 +178,13 @@ class GuiHandler:
       else:
          ctx = multiprocessing.get_context('fork')
 
-      # Dedicated duplex admin pipe.  The parent holds adminParentConn; the child
-      # holds adminChildConn.  Admin commands (setRate, getRate) travel here,
-      # bypassing the command buffer entirely.  Closing adminParentConn sends EOF
+      # Dedicated duplex admin pipe.  The parent holds parentPriorityConnection; the child
+      # holds childPriorityConnection.  Admin commands (setRate, getRate) travel here,
+      # bypassing the command buffer entirely.  Closing parentPriorityConnection sends EOF
       # to the child, which Qt detects via QSocketNotifier and treats as shutdown —
       # independent of the command queue and independent of whether atexit runs.
-      adminChildConn, adminParentConn = multiprocessing.Pipe(duplex=True)
-      self._adminConn = adminParentConn
+      childPriorityConnection, parentPriorityConnection = multiprocessing.Pipe(duplex=True)
+      self._adminConn = parentPriorityConnection
 
       # With 'spawn' on POSIX (fork+exec), the forked helper calls
       # get_preparation_data() which reads sys.modules['__main__'].__file__.
@@ -184,7 +205,7 @@ class GuiHandler:
       try:
          self.childProcess = ctx.Process(
             target = _launchRenderer,
-            args   = (childConn, adminChildConn, adminParentConn),
+            args   = (childCommandConnection, childPriorityConnection, parentPriorityConnection),
             daemon = True   # child is killed automatically if parent dies unexpectedly
          )
          self.childProcess.start()
@@ -194,8 +215,8 @@ class GuiHandler:
                _main_mod.__file__ = _saved_file
             if _saved_spec is not _UNSET:
                _main_mod.__spec__ = _saved_spec
-      childConn.close()      # parent no longer needs the child end of the command pipe
-      adminChildConn.close() # parent no longer needs the child end of the admin pipe
+      childCommandConnection.close()      # parent no longer needs the child end of the command pipe
+      childPriorityConnection.close() # parent no longer needs the child end of the admin pipe
 
       # responseId counter — each sendQuery() call gets a unique ID so the
       # listener thread can route the response back to the correct caller