CreativePython 1.1.1__tar.gz → 1.1.2__tar.gz

{creativepython-1.1.1/src/CreativePython.egg-info → creativepython-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CreativePython
-Version: 1.1.1
+Version: 1.1.2
 Summary: A Python-based software environment for developing algorithmic art projects.
 Author-email: "Dr. Bill Manaris" <manaris@cofc.edu>, Taj Ballinger <ballingertj@g.cofc.edu>, Trevor Ritchie <ritchiets@g.cofc.edu>
 License: MIT License

{creativepython-1.1.1 → creativepython-1.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "CreativePython"
-version = "1.1.1"
+version = "1.1.2"
 description = "A Python-based software environment for developing algorithmic art projects."
 readme = "README.md"
 license = { file = "LICENSE" }

{creativepython-1.1.1 → creativepython-1.1.2}/src/CreativePython/GuiHandler.py

@@ -61,16 +61,25 @@ def _createEvent(eventType, target, args=None):
 # Child process entry point
 #######################################################################################
 
-def _launchRenderer(childConn):
+def _launchRenderer(childConn, shutdownReadConn, shutdownWriteConn):
    """
    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).
 
+   shutdownReadConn is the read end of the dedicated shutdown pipe; the child
+   watches it with QSocketNotifier and shuts down when it becomes readable (EOF).
+   shutdownWriteConn is the write end inherited from the parent (fork) or passed
+   via pickling (forkserver/spawn); it is closed immediately so that only the
+   parent's copy of the write end remains open — ensuring the child sees EOF when
+   the parent closes its copy.
+
    At runtime this function only executes in the child process.
    """
    import sys, os
 
+   shutdownWriteConn.close()   # child must not hold the write end open
+
    # Suppress macOS system noise (stale XPC connections inherited via fork)
    # that would confuse students.  Redirect at the OS level (fd 2) so that
    # C-level libraries (Cocoa, XPC) are also silenced.
@@ -80,7 +89,7 @@ def _launchRenderer(childConn):
    sys.stderr = open(os.devnull, 'w')
 
    from CreativePython.GuiRenderer import GuiRenderer
-   renderer = GuiRenderer(childConn)
+   renderer = GuiRenderer(childConn, shutdownReadConn)
    renderer.run()
 
 
@@ -140,6 +149,15 @@ class GuiHandler:
          ctx = multiprocessing.get_context('forkserver')
       else:
          ctx = multiprocessing.get_context('fork')
+
+      # Dedicated one-directional shutdown pipe.  The parent holds the write
+      # end; the child holds the read end.  Closing the write end in the parent
+      # sends EOF to the child's read end, which Qt detects immediately via
+      # QSocketNotifier — independent of the command queue and independent of
+      # whether atexit runs (the OS closes the fd automatically on process death).
+      shutdownReadConn, shutdownWriteConn = multiprocessing.Pipe(duplex=False)
+      self._shutdownPipe = shutdownWriteConn
+
       # With 'spawn' on POSIX (fork+exec), the forked helper calls
       # get_preparation_data() which reads sys.modules['__main__'].__file__.
       # When a user script is running in PENCIL's subprocess, __main__.__file__
@@ -159,7 +177,7 @@ class GuiHandler:
       try:
          self.childProcess = ctx.Process(
             target = _launchRenderer,
-            args   = (childConn,),
+            args   = (childConn, shutdownReadConn, shutdownWriteConn),
             daemon = True   # child is killed automatically if parent dies unexpectedly
          )
          self.childProcess.start()
@@ -169,7 +187,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 Pipe
+      childConn.close()        # parent no longer needs the child end of the command pipe
+      shutdownReadConn.close() # parent no longer needs the read end of the shutdown pipe
 
       # responseId counter — each sendQuery() call gets a unique ID so the
       # listener thread can route the response back to the correct caller
@@ -214,11 +233,10 @@ class GuiHandler:
 
    def _listenForMessages(self):
       """
-      Background thread.  Reads all incoming messages from GuiRenderer and
-      routes each one based on its type:
-        - 'responseId' key present → response for a waiting sendQuery() call
-        - 'type' key present       → event for a registered callback
-      Exits when the pipe is closed (EOFError).
+      Background thread.  Reads incoming messages from GuiRenderer and routes
+      each one: responses unblock waiting sendQuery() callers; events invoke
+      registered callbacks.  Exits when the child closes the pipe (EOFError)
+      and releases any sendQuery() callers still waiting for a response.
       """
       while True:
          try:
@@ -228,7 +246,11 @@ class GuiHandler:
             elif 'type' in message:
                self._dispatchEvent(message)
          except EOFError:
-            break   # pipe closed; thread exits cleanly
+            break
+      with self._pendingLock:
+         for slot in self._pendingResponses.values():
+            slot['values'] = ['shutdown']
+            slot['event'].set()
 
    def _handleResponse(self, responseDict):
       """
@@ -334,23 +356,14 @@ class GuiHandler:
 
    def _shutdown(self):
       """
-      Kills the child process immediately and closes the pipe.
+      Signals the child to shut down and waits for it to exit.
+      Closing the shutdown pipe delivers EOF to the child's QSocketNotifier,
+      which fires _onShutdownSignal on Qt's main thread immediately — even if
+      atexit does not run, since the OS closes the pipe fd on process death.
       Called automatically via atexit when the parent process exits.
-      The child is killed with SIGKILL so it does not drain its event queue —
-      exit() in the parent should return promptly.
       """
-      if self.childProcess.is_alive():
-         # SIGTERM is overridden in the child to call os._exit(0) immediately,
-         # bypassing Qt's graceful shutdown (which drains the event queue).
-         # Python delivers SIGTERM between bytecodes, so it fires within one
-         # iteration of the child's _pollPipe loop — far faster than SIGKILL,
-         # which macOS may defer while a Metal/GPU operation is in flight.
-         self.childProcess.terminate()
-         self.childProcess.join(timeout=0.5)   # should die in < 1 ms
-      if self.childProcess.is_alive():
-         self.childProcess.kill()              # backup: SIGKILL
-         self.childProcess.join(timeout=2.0)
-      self.connection.close()
+      self._shutdownPipe.close()
+      self.childProcess.join(timeout=1.0)
 
 
 #######################################################################################

{creativepython-1.1.1 → creativepython-1.1.2}/src/CreativePython/GuiRenderer.py

@@ -75,30 +75,20 @@ class GuiRenderer:
    Unknown targets and unknown actions are silently ignored.
    """
 
-   def __init__(self, childConn):
+   def __init__(self, childConn, shutdownReadConn):
       """
       Creates the QApplication and initializes all registries.
       """
-      self.connection = childConn
+      self.connection      = childConn
+      self._shutdownConn   = shutdownReadConn
 
       # QApplication must be created first; it owns the Qt event loop.
       self._app = QtWidgets.QApplication([])
 
-      # Do not quit when the last window is closed.  The default behaviour
-      # (quitOnLastWindowClosed = True) would exit the child process the
-      # moment the user closes a Display, breaking the IPC pipe and making
-      # it impossible to open new Displays without restarting Python.
-      # The child only exits when the parent sends a 'shutdown' command or
-      # kills the process directly.
+      # Do not quit when the last window is closed — the child stays alive
+      # until the parent closes the shutdown pipe, triggering _onShutdownSignal.
       self._app.setQuitOnLastWindowClosed(False)
 
-      # Qt installs a SIGTERM handler that drains the event queue before
-      # exiting (graceful shutdown).  When the parent kills this process,
-      # we want immediate exit — override Qt's handler after QApplication
-      # is constructed so ours takes precedence.
-      import signal, os as _os
-      signal.signal(signal.SIGTERM, lambda sig, frame: _os._exit(0))
-
       # maps objectId (int) -> mirror object (e.g. DisplayMirror, RectangleMirror)
       self._objectRegistry = {}
 
@@ -108,87 +98,58 @@ class GuiRenderer:
 
    def run(self):
       """
-      Starts the pipe-polling timer and enters Qt's event loop.
-      The QTimer fires _pollPipe() every 8ms (~120 Hz), draining any pending
-      commands without blocking the Qt event loop between frames.
+      Wires up the command-polling timer and the shutdown notifier, then enters
+      Qt's event loop.
+      _pollPipe fires every 8ms to process incoming commands in fixed batches.
+      _shutdownNotifier watches the dedicated shutdown pipe fd; when the parent
+      closes its write end (via _shutdown() or process death), Qt fires
+      _onShutdownSignal on the main thread immediately — independent of the
+      command queue and of whether atexit runs in the parent.
       """
       self._timer = QtCore.QTimer()
       self._timer.timeout.connect(self._pollPipe)
       self._timer.start(8)
-      self._app.exec()
 
-   _polling = False  # reentrancy guard
+      self._shutdownNotifier = QtCore.QSocketNotifier(
+         self._shutdownConn.fileno(),
+         QtCore.QSocketNotifier.Type.Read
+      )
+      self._shutdownNotifier.activated.connect(self._onShutdownSignal)
+
+      self._app.exec()
 
-   # # ── Option A: no batching (drain entire queue before rendering) ─────────
-   # def _pollPipe(self):
-   #    """
-   #    Drains all pending commands before returning to Qt's event loop.
-   #    """
-   #    while self.connection.poll():
-   #       message     = self.connection.recv()
-   #       keepRunning = self._routeCommand(message)
-   #       if not keepRunning:
-   #          break
+   # ── Command polling ───────────────────────────────────────────────────────
 
-   # ── Option B: fixed batch (let Qt render every N commands) ──────────────
    _BATCH_SIZE = 10
-   
+
    def _pollPipe(self):
       """
-      Drains pending commands, letting Qt process events every _BATCH_SIZE
-      commands so the display updates incrementally during large batches.
-      """
-      if self._polling:
-         return   # processEvents() fired the timer again — skip
-      self._polling = True
-      try:
-         count = 0
-         while self.connection.poll():
-            message     = self.connection.recv()
-            keepRunning = self._routeCommand(message)
-            if not keepRunning:
-               break
-            count += 1
-            if count % self._BATCH_SIZE == 0:
-               self._app.processEvents()
-      finally:
-         self._polling = False
-
-   # # ── Option C: adaptive batch (scales with scene complexity) ─────────────
-   # _BATCH_MIN = 10    # batch size when scene is empty
-   # _BATCH_MAX = 1000  # batch size ceiling
-   # _BATCH_PER = 25    # add this many to the batch per 1000 objects in scene
-
-   # def _pollPipe(self):
-   #    """
-   #    Drains pending commands, letting Qt process events at adaptive
-   #    intervals.  Small scenes get frequent updates (responsive feel);
-   #    large scenes batch more commands between repaints (less overhead
-   #    from increasingly expensive repaints).
-   #    """
-   #    if self._polling:
-   #       return   # processEvents() fired the timer again — skip
-   #    self._polling = True
-   #    try:
-   #       objectCount = len(self._objectRegistry)
-   #       batchSize   = min(self._BATCH_MAX,
-   #                         self._BATCH_MIN + objectCount * self._BATCH_PER)
-   #       count = 0
-   #       while self.connection.poll():
-   #          message     = self.connection.recv()
-   #          keepRunning = self._routeCommand(message)
-   #          if not keepRunning:
-   #             break
-   #          count += 1
-   #          if count % batchSize == 0:
-   #             self._app.processEvents()
-   #    finally:
-   #       self._polling = False
+      Processes up to _BATCH_SIZE pending commands per timer tick, then returns
+      control to Qt's event loop.  Keeping batches small lets Qt handle input
+      events and repaints between each batch, keeping the UI responsive during
+      heavy animation.
+      """
+      count = 0
+      while count < self._BATCH_SIZE and self.connection.poll():
+         try:
+            message = self.connection.recv()
+         except (EOFError, OSError):
+            # Command pipe closed — parent process died without sending a shutdown
+            # signal (e.g. killed by SIGTERM/SIGKILL, atexit didn't run).
+            # _onShutdownSignal may also fire if the OS released the shutdown pipe
+            # write end, but _app.quit() is safe to call from either path.
+            self._timer.stop()
+            self._shutdownNotifier.setEnabled(False)
+            self._app.quit()
+            return
+         self._routeCommand(message)
+         count += 1
 
    def _routeCommand(self, commandDict):
       """
       Routes an incoming command to the appropriate handler.
-      Returns False if the renderer should shut down, True otherwise.
+      Shutdown is handled out-of-band by _onShutdownSignal; unknown actions are
+      silently ignored.
       """
       action     = commandDict.get('action')
       target     = commandDict.get('target')
@@ -196,11 +157,7 @@ class GuiRenderer:
       responseId = commandDict.get('responseId')
 
       # ── Built-in actions ──────────────────────────────────────────────────
-      if action == 'shutdown':
-         self._handleShutdown()
-         return False
-
-      elif action == 'ping':
+      if action == 'ping':
          response = _createResponse(responseId, ['pong'])
          self.connection.send(response)
 
@@ -356,9 +313,32 @@ class GuiRenderer:
       event = _createEvent(eventType, objectId, args)
       self.connection.send(event)
 
-   def _handleShutdown(self):
-      """Stops the polling timer and quits the Qt event loop."""
+   def _onShutdownSignal(self):
+      """
+      Called by Qt when the shutdown pipe becomes readable — meaning the parent
+      has closed its write end (via _shutdown() or process death).
+      Fires immediately on the Qt main thread, independent of the command queue.
+      Drains any remaining commands from the command pipe, sending 'shutdown'
+      responses to release any sendQuery() callers blocking in the parent.
+      Fire-and-forget commands are discarded.  Then quits Qt's event loop
+      normally so Qt can clean up its own resources.
+      """
+      self._shutdownNotifier.setEnabled(False)
       self._timer.stop()
+
+      # Drain remaining commands.  Queries get a 'shutdown' response so that
+      # any sendQuery() call blocking in the parent is released immediately.
+      # Fire-and-forget commands are discarded.
+      # If the command pipe is already closed, the drain is skipped gracefully.
+      try:
+         while self.connection.poll():
+            message    = self.connection.recv()
+            responseId = message.get('responseId')
+            if responseId is not None:
+               self.connection.send(_createResponse(responseId, ['shutdown']))
+      except (EOFError, OSError):
+         pass  # command pipe already closed; listener releases pending queries
+
       self._app.quit()
 
 

{creativepython-1.1.1 → creativepython-1.1.2/src/CreativePython.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CreativePython
-Version: 1.1.1
+Version: 1.1.2
 Summary: A Python-based software environment for developing algorithmic art projects.
 Author-email: "Dr. Bill Manaris" <manaris@cofc.edu>, Taj Ballinger <ballingertj@g.cofc.edu>, Trevor Ritchie <ritchiets@g.cofc.edu>
 License: MIT License

{creativepython-1.1.1 → creativepython-1.1.2}/src/gui.py

@@ -933,19 +933,19 @@ class Display(_Interactable):
          raise TypeError(f'{type(self).__name__}.addPopupMenu(): menu should be a Menu object (it was {type(menu).__name__})')
       _handler().sendCommand('addPopupMenu', self._objectId, {'menuId': menu._objectId})
 
-   def write(self, filename, width=None, height=None):
+   def save(self, filename, width=None, height=None):
       """
       Saves the display's currently visible canvas to an image file.
       The file format is determined by the filename extension (e.g. .png, .jpg).
       Optional width and height resize the saved image; omitting one preserves the aspect ratio.
-      Prints whether the write succeeded and the resolved file path.
+      Prints whether the save succeeded and the resolved file path.
       """
       result = _handler().sendQuery('write', self._objectId, {'filename': filename, 'width': width, 'height': height})
       success, resolvedPath = result[0], result[1]
       if success:
-         print(f'{type(self).__name__}.write(): saved to "{resolvedPath}"')
+         print(f'{type(self).__name__}.save(): saved canvas to "{resolvedPath}"')
       else:
-         print(f'{type(self).__name__}.write(): failed to save "{resolvedPath}"')
+         print(f'{type(self).__name__}.save(): failed to save to "{resolvedPath}"')
 
    def onClose(self, action):
       """
@@ -2296,9 +2296,9 @@ class Icon(_Graphics):
       rotation      = self.getRotation()
       return f'Icon(filename = "{filename}", width = {width}, height = {height}, rotation = {rotation})'
 
-   # ── Write ────────────────────────────────────────────────────────────────
+   # ── Save ────────────────────────────────────────────────────────────────
 
-   def write(self, filename, width=None, height=None):
+   def save(self, filename, width=None, height=None):
       """
       Saves the icon to an image file.
       The file format is determined by the filename extension (e.g. .png, .jpg).
@@ -2308,9 +2308,9 @@ class Icon(_Graphics):
       result = _handler().sendQuery('write', self._objectId, {'filename': filename, 'width': width, 'height': height})
       success, resolvedPath = result[0], result[1]
       if success:
-         print(f'{type(self).__name__}.write(): saved to "{resolvedPath}"')
+         print(f'{type(self).__name__}.save(): saved canvas to "{resolvedPath}"')
       else:
-         print(f'{type(self).__name__}.write(): failed to save "{resolvedPath}"')
+         print(f'{type(self).__name__}.save(): failed to save "{resolvedPath}"')
 
    # ── Crop ────────────────────────────────────────────────────────────────
 

creativepython-1.1.2/src/image.py

@@ -0,0 +1,123 @@
+################################################################################
+# image.py       Version 1.0     30-Jan-2025
+# Taj Ballinger, Trevor Ritchie, and Bill Manaris
+#
+##############################################################
+##################
+
+from gui import Display, Icon
+
+class Image:
+   """
+   Display window for rendering images.
+   """
+   def __init__(self, arg1, arg2=None):
+      """
+      Creates a new image display.
+      """
+      # JythonMusic's Image class has overloaded constructors,
+      # but Python doesn't allow that.  We replicate an overload based on the
+      # data types of arg1 and arg2.
+      #
+      # (str, None) -> a filename for an image to load
+      # (str, int)  -> a filename for an image to load, scaled to a width
+      # (int, None) -> the width of a square, blank canvas
+      # (int, int)  -> the width and height of a blank canvas
+
+      self._display = Display()  # create a new, blank Display
+      self.read(arg1, arg2)      # read() handles loading the icon, plus setting the title and size of the Display
+
+   def show(self):
+      """
+      Shows the display window.
+      """
+      self._display.show()
+
+   def hide(self):
+      """
+      Hides the display window.
+      """
+      self._display.hide()
+
+   def getWidth(self):
+      """
+      Returns the display's canvas width (in pixels).
+      """
+      return self._display.getWidth()
+
+   def getHeight(self):
+      """
+      Returns the display's canvas height (in pixels).
+      """
+      return self._display.getHeight()
+
+   # pixel manipulation wrappers
+
+   def getPixel(self, col, row):
+      """
+      Returns the [r, g, b] color of a given pixel in the image.
+      """
+      return self._icon.getPixel(col, row)
+
+   def setPixel(self, col, row, RGBList):
+      """
+      Sets the [r, g, b] color of a given pixel in the image.
+      """
+      self._icon.setPixel(col, row, RGBList)
+
+   def getPixels(self):
+      """
+      Returns the [r, g, b] color of all pixels in the icon as a 2-dimensional array.
+      """
+      return self._icon.getPixels()
+
+   def setPixels(self, pixels):
+      """
+      Sets the [r, g, b] color of all pixels in the icon from a 2-dimensional array.
+      """
+      self._icon.setPixels(pixels)
+
+   def write(self, filename):
+      """
+      Saves the display's currently visible canvas to an image file.
+      The file format is determined by the filename extension (e.g. .png, .jpg).
+      """
+      self._display.save(filename)
+
+   def read(self, arg1, arg2=None):
+      """
+      Updates the image with a new filename.
+      arg1 and arg2 have the same overloaded behavior as Image's constructor.
+      (str, None) -> a filename for an image to load
+      (str, int)  -> a filename for an image to load, scaled to a width
+      (int, None) -> the width of a square, blank canvas
+      (int, int)  -> the width and height of a blank canvas
+      """
+      # first, load the icon
+      if isinstance(arg1, str):
+         # arg1 is a filename
+         title = arg1
+         icon  = Icon(arg1, arg2)  # load icon with optional resizing
+      else:
+         # arg1 is a image size
+         title = "Image"
+         icon  = Icon("", arg1, arg2)  # load blank icon, sized to given dimensions
+
+      # remove the previous icon, if needed
+      if self._icon is not None:
+         self._display.remove(self._icon)
+
+      # next, update the Display
+      width, height = icon.getSize()
+      self._display.setSize(width, height)
+      self._display.setTitle(title)
+
+      # finally, add new icon to the display
+      self._icon = icon
+      self._display.add(icon)
+
+
+###### Unit Tests ###################################
+
+if __name__ == "__main__":
+   pass

creativepython-1.1.1/src/image.py

@@ -1,70 +0,0 @@
-################################################################################
-# image.py       Version 1.0     30-Jan-2025
-# Taj Ballinger, Trevor Ritchie, and Bill Manaris
-#
-##############################################################
-##################
-
-from gui import Display, Icon
-
-class Image(Display):
-   """
-   Display window for rendering images.
-   """
-   def __init__(self, arg1, arg2=None):
-      """
-      Creates a new image display.
-      """
-      # JythonMusic's Image class has overloaded constructors,
-      # but Python doesn't allow that.  We replicate an overload based on the
-      # data types of arg1 and arg2.
-      #
-      # (str, None) -> a filename for an image to load
-      # (str, int)  -> a filename for an image to load, scaled to a width
-      # (int, None) -> the width of a square, blank canvas
-      # (int, int)  -> the width and height of a blank canvas
-
-      if isinstance(arg1, str):
-         # this is a filename
-         title = arg1
-         self._icon = Icon(arg1, arg2)  # load icon with optional parameter
-
-      else:
-         title = "Image"
-         self._icon = Icon("", arg1, arg2)  # load blank icon with given dimensions
-
-      width, height = self._icon.getSize()
-
-      Display.__init__(self, title, width, height)
-      self.add(self._icon)
-
-   # pixel manipulation wrappers
-
-   def getPixel(self, col, row):
-      """
-      Returns the [r, g, b] color of a given pixel in the image.
-      """
-      return self._icon.getPixel(col, row)
-
-   def setPixel(self, col, row, RGBList):
-      """
-      Sets the [r, g, b] color of a given pixel in the image.
-      """
-      self._icon.setPixel(col, row, RGBList)
-
-   def getPixels(self):
-      """
-      Returns the [r, g, b] color of all pixels in the icon as a 2-dimensional array.
-      """
-      return self._icon.getPixels()
-
-   def setPixels(self, pixels):
-      """
-      Sets the [r, g, b] color of all pixels in the icon from a 2-dimensional array.
-      """
-      self._icon.setPixels(pixels)
-
-###### Unit Tests ###################################
-
-if __name__ == "__main__":
-   pass